wip

Author: wickwirew

Sources/Compiler/Parse/Parsers.swift

@@ -1088,7 +1088,7 @@ enum Parsers {
                 location: state.location(from: start)
             )
         case let .identifier(table) where state.peek.kind == .dot && state.peek2.kind == .star:
-            let table = IdentifierSyntax(value: table, location: state.current.location)
+            let table = IdentifierSyntax(id: state.nextId(), value: table, location: state.current.location)
             state.skip()
             state.consume(.dot)
             state.consume(.star)
@@ -2443,10 +2443,10 @@ enum Parsers {
 
         guard case let .identifier(ident) = token.kind else {
             state.diagnostics.add(.init("Expected identifier", at: token.location))
-            return IdentifierSyntax(value: "<<error>>", location: token.location)
+            return IdentifierSyntax(id: state.nextId(), value: "<<error>>", location: token.location)
         }
 
-        return IdentifierSyntax(value: ident, location: token.location)
+        return IdentifierSyntax(id: state.nextId(), value: ident, location: token.location)
     }
 
     /// So this is to handle a weird edge case. SQLite apparently allows keywords
@@ -2457,7 +2457,7 @@ enum Parsers {
         let token = state.take()
 
         if case let .identifier(ident) = token.kind {
-            return IdentifierSyntax(value: ident, location: token.location)
+            return IdentifierSyntax(id: state.nextId(), value: ident, location: token.location)
         }
 
         // Since this is kind of edge casey instead of making all
@@ -2471,10 +2471,10 @@ enum Parsers {
         // should not allow
         guard isKeyword else {
             state.diagnostics.add(.init("Expected identifier", at: token.location))
-            return IdentifierSyntax(value: "<<error>>", location: token.location)
+            return IdentifierSyntax(id: state.nextId(), value: "<<error>>", location: token.location)
         }
 
-        return IdentifierSyntax(value: rawValue, location: token.location)
+        return IdentifierSyntax(id: state.nextId(), value: rawValue, location: token.location)
     }
 
     /// https://www.sqlite.org/syntax/numeric-literal.html

Sources/Compiler/Sema/Builtins.swift

@@ -79,7 +79,11 @@ enum Builtins {
         "likelihood": Function(.var(0), .real, returning: .var(0)),
         "likely": Function(.var(0), returning: .var(0)),
         "lower": Function(.text, returning: .text),
-        "ltrim": Function(.text, .text, returning: .text),
+        "ltrim": Function(
+            .text,
+            returning: .text,
+            overloads: [Function.Overload(.text, .text, returning: .text)]
+        ),
         "max": Function(.var(0), returning: .var(0), variadic: true),
         "min": Function(.var(0), returning: .var(0), variadic: true),
         "nullif": Function(.var(0), .var(0), returning: .optional(.var(0))),
@@ -88,7 +92,11 @@ enum Builtins {
         "randomblob": Function(.integer, returning: .blob),
         "replace": Function(.text, .text, .text, returning: .text),
         "round": Function(.real, .integer, returning: .real),
-        "rtrim": Function(.text, .text, returning: .text),
+        "rtrim": Function(
+            .text,
+            returning: .text,
+            overloads: [Function.Overload(.text, .text, returning: .text)]
+        ),
         "sign": Function(.var(.integer(0)), returning: .integer),
         "soundex": Function(.text, returning: .text),
         "substr": Function(.text, .integer, .integer, returning: .text),

Sources/Compiler/Sema/StmtTypeChecker.swift

@@ -516,7 +516,11 @@ extension StmtTypeChecker {
             var index = 0
             let secondColumns = secondResult.allColumns.values
             return firstResult.mapTypes { type in
-                inferenceState.unify(type, with: secondColumns[index], at: location)
+                inferenceState.unify(
+                    type,
+                    with: inferenceState.solution(for: secondColumns[index]),
+                    at: location
+                )
                 index += 1
                 return type
             }
@@ -691,20 +695,36 @@ extension StmtTypeChecker {
 
         for cte in with.ctes {
             let table = inNewEnvironment { typeChecker in
-                typeChecker.typeCheck(cte: cte)
+                typeChecker.typeCheck(cte: cte, recursive: with.recursive)
             }
 
             ctes[cte.table.value] = table
         }
     }
 
-    private mutating func typeCheck(cte: CommonTableExpressionSyntax) -> Table {
-        let resultColumns = typeCheck(select: cte.select)
-
-        let columns: Columns
+    private mutating func typeCheck(
+        cte: CommonTableExpressionSyntax,
+        recursive: Bool
+    ) -> Table {
+        let cteName = QualifiedName(name: cte.table.value, schema: nil)
+        
         if cte.columns.isEmpty {
-            columns = resultColumns.allColumns
+            let resultColumns = typeCheck(select: cte.select)
+            return Table(name: cteName, columns: resultColumns.allColumns, kind: .cte)
         } else {
+            // CTE's can reference themselves so we need to create a table to
+            // represent this CTE with all columns as type variables.
+            let thisCte = Table(
+                name: cteName,
+                columns: cte.columns.reduce(into: [:]) { columns, name in
+                    columns.append(inferenceState.freshTyVar(for: name), for: name.value)
+                },
+                kind: .cte
+            )
+            
+            ctes[thisCte.name.name] = thisCte
+            
+            let resultColumns = typeCheck(select: cte.select)
             let columnTypes = resultColumns.allColumns.values
             if columnTypes.count != cte.columns.count {
                 diagnostics.add(.init(
@@ -713,16 +733,10 @@ extension StmtTypeChecker {
                 ))
             }
 
-            columns = (0 ..< min(columnTypes.count, cte.columns.count))
-                .reduce(into: [:]) { $0.append(columnTypes[$1], for: cte.columns[$1].value) }
+            // Simply return the table but getting the solution types so the substitution
+            // map retains it's integrity.
+            return thisCte.mapTypes { inferenceState.solution(for: $0) }
         }
-        
-        return Table(
-            name: QualifiedName(name: cte.table.value, schema: nil),
-            columns: columns,
-            primaryKey: [],
-            kind: .cte
-        )
     }
 
     /// Will infer the core part of the select.

Sources/Compiler/Syntax/IdentifierSyntax.swift

@@ -5,7 +5,8 @@
 //  Created by Wes Wickwire on 10/19/24.
 //
 
-struct IdentifierSyntax: Sendable {
+struct IdentifierSyntax: Sendable, Syntax {
+    let id: SyntaxId
     private(set) var value: Substring
     private(set) var location: SourceLocation
 }

Sources/Compiler/Table.swift

@@ -24,6 +24,18 @@ public struct Table: Sendable, Equatable {
         case subquery
     }
 
+    init(
+        name: QualifiedName,
+        columns: Columns,
+        primaryKey: [Substring] = [],
+        kind: Kind
+    ) {
+        self.name = name
+        self.columns = columns
+        self.primaryKey = primaryKey
+        self.kind = kind
+    }
+    
     var type: Type {
         return .row(.fixed(columns.map(\.value)))
     }

Tests/CompilerTests/Compiler/CompileCTE.sql

@@ -0,0 +1,19 @@
+-- CHECK: SIGNATURE
+-- CHECK:   ...
+WITH RECURSIVE
+  xaxis(x) AS (VALUES(-2.0) UNION ALL SELECT x+0.05 FROM xaxis WHERE x<1.2),
+  yaxis(y) AS (VALUES(-1.0) UNION ALL SELECT y+0.1 FROM yaxis WHERE y<1.0),
+  m(iter, cx, cy, x, y) AS (
+    SELECT 0, x, y, 0.0, 0.0 FROM xaxis, yaxis
+    UNION ALL
+    SELECT iter+1, cx, cy, x*x-y*y + cx, 2.0*x*y + cy FROM m
+     WHERE (x*x + y*y) < 4.0 AND iter<28
+  ),
+  m2(iter, cx, cy) AS (
+    SELECT max(iter), cx, cy FROM m GROUP BY cx, cy
+  ),
+  a(t) AS (
+    SELECT group_concat( substr(' .+*#', 1+min(iter/7,4), 1), '')
+    FROM m2 GROUP BY cy
+  )
+SELECT group_concat(rtrim(t),'0a') FROM a;

Tests/CompilerTests/CompilerTests.swift

@@ -80,6 +80,10 @@ class CompilerTests: XCTestCase {
     func testIndex() throws {
         try checkSchema(compile: "CompileIndex")
     }
+    
+    func testCte() throws {
+        try checkQueries(compile: "CompileCTE", dump: true)
+    }
 }
 
 struct CheckSignature: Checkable {