Allow values from parent env to be overwritten

Author: wickwirew

Sources/Compiler/Environment.swift

@@ -33,37 +33,64 @@ struct Environment {
         /// during a query. However if they do a `SELECT *` it should
         /// not be included into the result columns
         let explicitAccessOnly: Bool
+        /// Whether or not this value is inherited from a parent environment.
+        /// In a subquery we inherit the values from the parent environment
+        /// but with the caveat that they are overridable and won't be consider
+        /// ambiguous if something was inserted with the same name.
+        let isFromParent: Bool
     }
 
     init() {}
+    
+    private init(identifiers: OrderedDictionary<Substring, TypeContainer>) {
+        self.identifiers = identifiers
+    }
 
     /// Inserts or updates the type for the given name
     mutating func upsert(_ name: Substring, ty: Type, explicitAccessOnly: Bool = false) {
         identifiers[name] = TypeContainer(
             type: ty,
             isAmbiguous: false,
-            explicitAccessOnly: explicitAccessOnly
+            explicitAccessOnly: explicitAccessOnly,
+            isFromParent: false
         )
     }
 
     /// Inserts the type for the given name. If the name
     /// already exists it will be marked as ambiguous
     mutating func insert(_ name: Substring, ty: Type, explicitAccessOnly: Bool = false) {
-        if let existing = identifiers[name] {
+        // If it already exists, mark it as ambiguous except for the case
+        // where its from a parent environment.
+        if let existing = identifiers[name], !existing.isFromParent {
             identifiers[name] = TypeContainer(
                 type: existing.type,
                 isAmbiguous: true,
-                explicitAccessOnly: explicitAccessOnly
+                explicitAccessOnly: explicitAccessOnly,
+                isFromParent: false
             )
         } else {
             identifiers[name] = TypeContainer(
                 type: ty,
                 isAmbiguous: false,
-                explicitAccessOnly: explicitAccessOnly
+                explicitAccessOnly: explicitAccessOnly,
+                isFromParent: false
             )
         }
     }
 
+    /// Returns a copy of `self` but with all identifiers in the environment
+    /// as overridable since they are from a parent environment.
+    func asParent() -> Environment {
+        return Environment(identifiers: identifiers.mapValues { container in
+            TypeContainer(
+                type: container.type,
+                isAmbiguous: container.isAmbiguous,
+                explicitAccessOnly: container.explicitAccessOnly,
+                isFromParent: true
+            )
+        })
+    }
+    
     mutating func rename(_ key: Substring, to newValue: Substring) {
         guard let value = identifiers[key] else { return }
         identifiers[key] = nil

Sources/Compiler/Sema/Builtins.swift

@@ -25,7 +25,20 @@ enum Builtins {
     static let regexp = TypeScheme(typeVariables: [], type: .fn(params: [.text, .text], ret: .integer))
     static let glob = TypeScheme(typeVariables: [], type: .fn(params: [.text, .text], ret: .integer))
 
-    static let functions: OrderedDictionary<Substring, TypeScheme> = [
+    static let functions: OrderedDictionary<Substring, TypeScheme> = {
+        // TODO: Clean this up. SQLite isnt casing dependant but we are at the moment.
+        // TODO: So insert each function twice, under the lower and upper cased name.
+        
+        var functions = baseFunctions
+        
+        for (name, fn) in baseFunctions {
+            functions[name.uppercased()[...]] = fn
+        }
+        
+        return functions
+    }()
+    
+    private static let baseFunctions: OrderedDictionary<Substring, TypeScheme> = [
         // Scalar functions
         "abs": TypeScheme(typeVariables: [.integer(0)], type: .fn(params: [.var(.integer(0))], ret: .var(.integer(0)))),
         "changes": TypeScheme(typeVariables: [], type: .fn(params: [], ret: .integer)),

Sources/Compiler/Sema/ExprTypeChecker.swift

@@ -18,6 +18,8 @@ struct ExprTypeChecker {
     private let schema: Schema
     /// Any diagnostics that are emitted during compilation
     private(set) var diagnostics = Diagnostics()
+    /// Any table that is used
+    private(set) var usedTableNames: Set<Substring> = []
 
     private let pragmas: FeatherPragmas
 
@@ -245,7 +247,12 @@ extension ExprTypeChecker: ExprSyntaxVisitor {
     }
 
     mutating func visit(_ expr: borrowing SelectExprSyntax) -> Type {
-        var typeChecker = StmtTypeChecker(env: env, schema: schema, inferenceState: inferenceState, pragmas: pragmas)
+        var typeChecker = StmtTypeChecker(
+            env: env.asParent(),
+            schema: schema,
+            inferenceState: inferenceState,
+            pragmas: pragmas
+        )
         let signature = typeChecker.signature(for: expr.select)
         let type: Type = .row(.named(signature.output.allColumns))
         // Make sure to update our inference state
@@ -255,6 +262,7 @@ extension ExprTypeChecker: ExprSyntaxVisitor {
         diagnostics.merge(typeChecker.diagnostics)
         // Record the result type in the state
         inferenceState.record(type: type, for: expr)
+        usedTableNames = typeChecker.usedTableNames
         return type
     }
 

Sources/Compiler/Sema/StmtTypeChecker.swift

@@ -68,6 +68,7 @@ struct StmtTypeChecker {
         diagnostics.merge(exprTypeChecker.diagnostics)
         // Collect the updated inference state.
         inferenceState = exprTypeChecker.inferenceState
+        usedTableNames.formUnion(exprTypeChecker.usedTableNames)
         return (type, name)
     }
 
@@ -287,6 +288,7 @@ extension StmtTypeChecker: StmtSyntaxVisitor {
         }
 
         for statement in stmt.statements {
+            // Extending the current environment to include new/old
             _ = inNewEnvironment(extendCurrentEnv: true) { typeChecker in
                 statement.accept(visitor: &typeChecker)
             }

Tests/CompilerTests/Compiler/CompileSimpleSelects.sql

@@ -194,3 +194,17 @@ SELECT id,
     (bar.id) + (1 - 12) * (unixepoch()) AS secondBestValue,
     (bar.id) + (bar.id + 1) AS thirdBestValue
 FROM bar;
+
+-- CHECK: SIGNATURE
+-- CHECK:   OUTPUT_CHUNKS
+-- CHECK:     CHUNK
+-- CHECK:       OUTPUT
+-- CHECK:         id INTEGER
+-- CHECK:         bar (INTEGER AS Bool)?
+-- CHECK:         baz TEXT
+-- CHECK:       OUTPUT_TABLE foo
+-- CHECK:   TABLES
+-- CHECK:     bar
+-- CHECK:     foo
+SELECT * FROM foo
+WHERE id IN (SELECT qux FROM bar WHERE qux > foo.id);