Track triggers and indices in schema

Author: wickwirew

Sources/Compiler/Driver.swift

@@ -10,7 +10,7 @@ import Foundation
 public actor Driver {
     private let fileSystem: FileSystem
     private var results: [Path: Output] = [:]
-    private var currentSchema: Schema = [:]
+    private var currentSchema = Schema()
 
     public typealias Path = String
 

Sources/Compiler/Gen/Language.swift

@@ -65,7 +65,7 @@ extension Language {
         tables: [GeneratedModel],
         queries: [(String?, [GeneratedQuery])]
     ) {
-        let tables = schema.mapValues(model(for:))
+        let tables = schema.tables.mapValues(model(for:))
         let queries = queries.map { ($0.map { "\($0)Queries" }, $1.map{ query(for: $0, tables: tables) }) }
         return (Array(tables.values), queries)
     }

Sources/Compiler/Schema.swift

@@ -7,7 +7,26 @@
 
 import OrderedCollections
 
-public typealias Schema = OrderedDictionary<Substring, Table>
+public struct Schema {
+    public var tables: OrderedDictionary<Substring, Table> = [:]
+    public var triggers: OrderedDictionary<Substring, Trigger> = [:]
+    public var indices: OrderedDictionary<Substring, Index> = [:]
+    
+    public subscript(tableName: Substring) -> Table? {
+        _read { yield tables[tableName] }
+        _modify { yield &tables[tableName] }
+    }
+    
+    public subscript(trigger triggerName: Substring) -> Trigger? {
+        _read { yield triggers[triggerName] }
+        _modify { yield &triggers[triggerName] }
+    }
+    
+    public subscript(index indexName: Substring) -> Index? {
+        _read { yield indices[indexName] }
+        _modify { yield &indices[indexName] }
+    }
+}
 
 // TODO: An ordered dictionary may not be the best representation of the
 // TODO: columns. Since this is used even in selects, the user could
@@ -39,3 +58,17 @@ public struct Table: Sendable {
         return .row(.named(columns))
     }
 }
+
+public struct Trigger {
+    /// The name of the trigger
+    public let name: Substring
+    /// The table the trigger is watching
+    public let targetTable: Substring
+    /// Any table accessed in the `BEGIN/END`
+    public let usedTables: Set<Substring>
+}
+
+public struct Index {
+    public let name: Substring
+    public let table: Substring
+}

Sources/Compiler/Sema/StmtTypeChecker.swift

@@ -169,18 +169,24 @@ extension StmtTypeChecker: StmtSyntaxVisitor {
             _ = typeCheck(whereExpr)
         }
 
+        schema[index: stmt.name.value] = Index(
+            name: stmt.name.value,
+            table: table.name
+        )
+        
         return .empty
     }
 
     mutating func visit(_ stmt: borrowing DropIndexStmtSyntax) -> ResultColumns {
-        // Indices are not stored at the moment, so there is nothign to do.
+        if !stmt.ifExists, schema[index: stmt.name.value] == nil {
+            diagnostics.add(.init("Index does not exist", at: stmt.name.location))
+        }
+        
+        schema[index: stmt.name.value] = nil
         return .empty
     }
 
     mutating func visit(_ stmt: borrowing ReindexStmtSyntax) -> ResultColumns {
-        // Indices are not stored at the moment, so there is nothign to do.
-        // We cant really even validate the name since it can be the
-        // index name and not just the table
         return .empty
     }
 
@@ -246,6 +252,13 @@ extension StmtTypeChecker: StmtSyntaxVisitor {
             return .empty
         }
 
+        if !stmt.ifNotExists, schema[trigger: stmt.triggerName.value] != nil {
+            diagnostics.add(.init(
+                "Trigger with name already exists",
+                at: stmt.triggerName.location
+            ))
+        }
+        
         switch stmt.action {
         case .delete:
             insertTableAndColumnsIntoEnv(table, as: "old", globallyAddColumns: false)
@@ -279,11 +292,21 @@ extension StmtTypeChecker: StmtSyntaxVisitor {
             }
         }
 
+        schema[trigger: stmt.triggerName.value] = Trigger(
+            name: stmt.triggerName.value,
+            targetTable: table.name,
+            usedTables: usedTableNames
+        )
+        
         return .empty
     }
 
-    func visit(_ stmt: borrowing DropTriggerStmtSyntax) -> ResultColumns {
-        // TODO: Track triggers
+    mutating func visit(_ stmt: borrowing DropTriggerStmtSyntax) -> ResultColumns {
+        if !stmt.ifExists, schema[trigger: stmt.triggerName.value] == nil {
+            diagnostics.add(.init("Trigger with name does not exist", at: stmt.triggerName.location))
+        }
+        
+        schema[trigger: stmt.triggerName.value] = nil
         return .empty
     }
 }
@@ -942,6 +965,24 @@ extension StmtTypeChecker {
             diagnostics.add(.tableDoesNotExist(dropTable.tableName.name))
         }
 
+        for trigger in schema.triggers.values {
+            if trigger.targetTable == dropTable.tableName.name.value {
+                // Dropping a table automatically removes any trigger its the target of.
+                schema[trigger: trigger.name] = nil
+            } else {
+                guard !trigger.usedTables.contains(dropTable.tableName.name.value) else { continue }
+                
+                // SQLite seemingly from my tests will allow this to happen but I swear I've
+                // had errors from it before. But error if the table is used in a trigger.
+                // Any trigger where its the target table will automatically be deleted
+                // so those dont matter
+                diagnostics.add(.init(
+                    "Table referenced in statements of trigger '\(trigger.name)'",
+                    at: dropTable.location
+                ))
+            }
+        }
+        
         schema[dropTable.tableName.name.value] = nil
     }
 

Tests/CompilerTests/Compiler/CompileTriggers.sql

@@ -0,0 +1,28 @@
+CREATE TABLE foo (bar INTEGER);
+CREATE TABLE baz (qux INTEGER);
+
+CREATE TRIGGER fooUpdate
+AFTER UPDATE ON foo
+BEGIN
+INSERT INTO baz (qux) VALUES (1);
+END;
+
+-- CHECK-ERROR: Trigger with name already exists
+CREATE TRIGGER fooUpdate
+AFTER UPDATE ON foo
+BEGIN
+INSERT INTO baz (qux) VALUES (1);
+END;
+
+-- CHECK-ERROR: Trigger with name does not exist
+DROP TRIGGER doesNotExist;
+
+DROP TRIGGER IF EXISTS doesNotExistButItDoesntMatter;
+
+-- CHECK-ERROR: Table referenced in statements of trigger 'fooUpdate'
+DROP TABLE baz;
+
+DROP TABLE foo;
+
+-- CHECK-ERROR: Trigger with name does not exist
+DROP TRIGGER fooUpdate;

Tests/CompilerTests/CompilerTests.swift

@@ -64,6 +64,10 @@ class CompilerTests: XCTestCase {
             }
         )
     }
+    
+    func testTriggers() throws {
+        try checkErrors(compile: "CompileTriggers", dump: true)
+    }
 }
 
 struct CheckSignature: Checkable {
@@ -105,7 +109,7 @@ func checkSchema(
                 validator: IsAlwaysValid(),
                 context: "tests"
             )
-            return (Array(compiler.schema.values), diags)
+            return (Array(compiler.schema.tables.values), diags)
         },
         prefix: prefix,
         dump: dump,
@@ -178,3 +182,29 @@ func checkWithErrors<Output>(
         line: line
     )
 }
+
+func checkErrors(
+    compile sqlFile: String,
+    prefix: String = "CHECK-ERROR",
+    dump: Bool = false,
+    file: StaticString = #filePath,
+    line: UInt = #line
+) throws {
+    try check(
+        sqlFile: sqlFile,
+        parse: { contents in
+            var compiler = Compiler()
+            let (_, d) = compiler.compile(
+                source: contents,
+                validator: IsAlwaysValid(),
+                context: "tests"
+            )
+            
+            return d.map(\.message)
+        },
+        prefix: prefix,
+        dump: dump,
+        file: file,
+        line: line
+    )
+}