small fixes

wickwirew · wickwirew · commit 3aa22c987f35 · 2025-06-19T23:07:20.000-04:00
diff --git a/.swiftformat b/.swiftformat
@@ -1,2 +1,3 @@
 --swiftversion 60.
 --disable unusedArguments, opaqueGenericParameters, redundantSelf, trailingSpace, redundantReturn, spaceAroundOperators
+--ifdef no-indent
diff --git a/Sources/Compiler/Driver.swift b/Sources/Compiler/Driver.swift
@@ -109,8 +109,12 @@ public actor Driver {
                 // The output path contains the file we are writing too
                 // so removing the last component gives us just the directory.
                 var directory = path.split(separator: "/")
-                directory.removeLast()
-                try fileSystem.create(directory: directory.joined(separator: "/"))
+                
+                if directory.count > 1 {
+                    directory.removeLast()
+                    try fileSystem.create(directory: directory.joined(separator: "/"))
+                }
+                
                 try file.write(toFile: path, atomically: true, encoding: .utf8)
             } else {
                 // No output path, default to stdout.
diff --git a/Sources/Compiler/Sema/Builtins.swift b/Sources/Compiler/Sema/Builtins.swift
@@ -117,6 +117,7 @@ enum Builtins {
             returning: .text,
             overloads: [Function.Overload(.text, .integer, .integer, returning: .text)]
         ),
+        "sqrt": Function(.var(.integer(0)), returning: .var(.integer(0))),
         "trim": Function(
             .text,
             returning: .text,
diff --git a/Sources/Compiler/Sema/CardinalityInferrer.swift b/Sources/Compiler/Sema/CardinalityInferrer.swift
@@ -27,6 +27,7 @@ struct CardinalityInferrer {
         _ expr: any ExprSyntax,
         for table: Table
     ) -> Cardinality {
+        guard !table.primaryKey.isEmpty else { return .many }
         let filteredPrimaryKeys = expr.accept(visitor: &self)
         let didFilterByPrimaryKey = !table.primaryKey.contains{ !filteredPrimaryKeys.contains($0) }
         return didFilterByPrimaryKey ? .single : .many
diff --git a/Sources/Compiler/Sema/InferenceState.swift b/Sources/Compiler/Sema/InferenceState.swift
@@ -135,7 +135,11 @@ struct InferenceState {
         case let .alias(ty, alias):
             return .alias(solution(for: ty, defaultIfTyVar: true), alias)
         case let .row(row):
-            return .row(row.mapTypes { solution(for: $0, defaultIfTyVar: true) })
+            if let type = row.first, row.count == 1, !row.isUnknown {
+                return solution(for: type, defaultIfTyVar: true)
+            } else {
+                return .row(row.mapTypes { solution(for: $0, defaultIfTyVar: true) })
+            }
         default:
             return result
         }
diff --git a/Sources/Compiler/Sema/StmtTypeChecker.swift b/Sources/Compiler/Sema/StmtTypeChecker.swift
@@ -446,7 +446,9 @@ extension StmtTypeChecker {
         // Type check limit before since it does not have access
         // to any selected columns
         if let limit = select.limit {
-            _ = typeCheck(limit.expr)
+            let (type, name) = typeCheck(limit.expr)
+            nameInferrer.suggest(name: "limit", for: name)
+            inferenceState.unify(type, with: .integer, at: limit.expr.location)
         }
         
         let resultColumns = typeCheck(
diff --git a/Sources/Compiler/Sema/Type.swift b/Sources/Compiler/Sema/Type.swift
@@ -77,6 +77,11 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
             }
         }
         
+        var isUnknown: Bool {
+            guard case .unknown = self else { return false }
+            return true
+        }
+        
         func apply(_ s: Substitution) -> Row {
             return switch self {
             case let .fixed(v): .fixed(v.map { $0.apply(s) })
diff --git a/Tests/CompilerTests/Compiler/CompileIsSingleResult.sql b/Tests/CompilerTests/Compiler/CompileIsSingleResult.sql
@@ -9,6 +9,8 @@ CREATE TABLE employee (
     PRIMARY KEY(companyId, userId)
 );
 
+CREATE TABLE noPk (value INTEGER);
+
 -- CHECK: SINGLE
 SELECT * FROM user WHERE id = 1;
 
@@ -29,3 +31,6 @@ SELECT * FROM employee WHERE companyId = 1 AND userId = 1;
 
 -- CHECK: MANY
 SELECT * FROM employee WHERE companyId = 1 OR userId = 1;
+
+-- CHECK: MANY
+SELECT * FROM noPk WHERE value = ?;
diff --git a/Tests/CompilerTests/Compiler/CompileSimpleSelects.sql b/Tests/CompilerTests/Compiler/CompileSimpleSelects.sql
@@ -184,9 +184,9 @@ SELECT id, ? AS value FROM bar;
 -- CHECK:     CHUNK
 -- CHECK:       OUTPUT
 -- CHECK:         id INTEGER
--- CHECK:         bestValue (INTEGER)
--- CHECK:         secondBestValue (INTEGER)
--- CHECK:         thirdBestValue (INTEGER)
+-- CHECK:         bestValue INTEGER
+-- CHECK:         secondBestValue INTEGER
+-- CHECK:         thirdBestValue INTEGER
 -- CHECK:   TABLES
 -- CHECK:     bar
 SELECT id,
@@ -234,11 +234,17 @@ SELECT -1 AS value FROM foo
 WHERE value = 1 AND value NOTNULL AND value NOT NULL AND value ISNULL ORDER BY value;
 
 -- CHECK: SIGNATURE
+-- CHECK:   PARAMETERS
+-- CHECK:     PARAMETER
+-- CHECK:       TYPE INTEGER
+-- CHECK:       INDEX 1
+-- CHECK:       NAME limit
 -- CHECK:   OUTPUT_CHUNKS
 -- CHECK:     CHUNK
 -- CHECK:       OUTPUT
 -- CHECK:         value INTEGER
 -- CHECK:   TABLES
 -- CHECK:     foo
 SELECT 1 AS value FROM foo
-WHERE EXISTS (SELECT * FROM foo) value;
+WHERE EXISTS (SELECT * FROM foo)
+LIMIT ?;
diff --git a/Tests/CompilerTests/TypeCheckerTests.swift b/Tests/CompilerTests/TypeCheckerTests.swift
@@ -192,7 +192,7 @@ class TypeCheckerTests: XCTestCase {
     }
     
     func testExprInParens() {
-        XCTAssertEqual(.row(.fixed([.integer])), try check("(1 + 1) + 1"))
+        XCTAssertEqual(.integer, try check("(1 + 1) + 1"))
     }
     
     func scope(table: String, schema: String) throws -> Environment {
diff --git a/Tests/FeatherTests/QueryPublisherTests.swift b/Tests/FeatherTests/QueryPublisherTests.swift
@@ -0,0 +1,137 @@
+//
+//  QueryPublisherTests.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 2/18/25.
+//
+
+#if canImport(Combine)
+@testable import Feather
+import Testing
+import Combine
+import Foundation
+
+@Suite
+struct QueryPublisherTests {
+    @Test func demandOfMaxOnlyReturnsASingleValue() async throws {
+        let db = try TestDB.inMemory()
+
+        try await db.insertFoo.execute(with: 1)
+        
+        let subscriber = TestSubscriber<[TestDB.Foo]>()
+        db.selectFoos.publisher().subscribe(subscriber)
+        subscriber.request(.max(.max))
+        
+        let values1 = await first(from: subscriber.received)
+        #expect(values1 == [TestDB.Foo(bar: 1)])
+        
+        try await db.insertFoo.execute(with: 2)
+        let values2 = await first(from: subscriber.received)
+        #expect(values2 == [TestDB.Foo(bar: 1), TestDB.Foo(bar: 2)])
+        
+        try await db.insertFoo.execute(with: 3)
+        let values3 = await first(from: subscriber.received)
+        #expect(values3 == [TestDB.Foo(bar: 1), TestDB.Foo(bar: 2), TestDB.Foo(bar: 3)])
+        
+        subscriber.subscription?.cancel()
+    }
+    
+    @Test func demandOfOneOnlyReturnsASingleValue() async throws {
+        let db = try TestDB.inMemory()
+
+        try await db.insertFoo.execute(with: 1)
+        
+        let subscriber = TestSubscriber<[TestDB.Foo]>()
+        db.selectFoos.publisher().subscribe(subscriber)
+        subscriber.request(.max(1))
+        
+        let value = await first(from: subscriber.received)
+        #expect(value == [TestDB.Foo(bar: 1)])
+        
+        try await db.insertFoo.execute(with: 2)
+        let nextValue = await first(from: subscriber.received, timeout: .milliseconds(100))
+        #expect(nextValue == nil)
+        
+        subscriber.subscription?.cancel()
+    }
+    
+    @Test func demandOfNoneOnlyReturnsASingleValue() async throws {
+        let db = try TestDB.inMemory()
+
+        try await db.insertFoo.execute(with: 1)
+        
+        let subscriber = TestSubscriber<[TestDB.Foo]>()
+        db.selectFoos.publisher().subscribe(subscriber)
+        subscriber.request(.none)
+
+        let value = await first(from: subscriber.received, timeout: .milliseconds(100))
+        #expect(value == nil)
+        
+        subscriber.subscription?.cancel()
+    }
+    
+    final class TestSubscriber<Input: Sendable>: Subscriber {
+        typealias Failure = Error
+        var subscription: Subscription?
+        var (received, receivedCont) = AsyncStream<Input>.makeStream()
+        
+        func request(_ demand: Subscribers.Demand) {
+            guard let subscription else {
+                Issue.record("Subscription not started")
+                return
+            }
+            
+            subscription.request(demand)
+        }
+        
+        func receive(subscription: any Subscription) {
+            self.subscription = subscription
+        }
+        
+        func receive(_ input: Input) -> Subscribers.Demand {
+            receivedCont.yield(input)
+            return .none
+        }
+        
+        func receive(completion: Subscribers.Completion<any Failure>) {}
+    }
+    
+    private func first<T>(from stream: AsyncStream<T>) async -> T? {
+        for await value in stream {
+            return value
+        }
+        
+        return nil
+    }
+    
+    private func first<T: Sendable>(from stream: AsyncStream<T>, timeout: Duration) async -> T? {
+        let lock = NSLock()
+        nonisolated(unsafe) var didReturn = false
+        
+        let shouldReturn: @Sendable () -> Bool = {
+            lock.withLock {
+                guard !didReturn else { return false }
+                didReturn = true
+                return true
+            }
+        }
+        
+        return await withCheckedContinuation { cont in
+            let task1 = Task {
+                for await value in stream {
+                    guard shouldReturn() else { return }
+                    cont.resume(returning: value)
+                    return
+                }
+            }
+            
+            Task {
+                try await Task.sleep(for: timeout)
+                guard shouldReturn() else { return }
+                cont.resume(returning: nil)
+                task1.cancel()
+            }
+        }
+    }
+}
+#endif
diff --git a/Tests/FeatherTests/TestDatabase.swift b/Tests/FeatherTests/TestDatabase.swift
@@ -22,7 +22,7 @@ struct TestDB {
     
     static var migrations: [String] {
         return [
-            "CREATE TABLE foo (bar INTEGER);"
+            "CREATE TABLE foo (bar INTEGER PRIMARY KEY);"
         ]
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
`1`	`1`	`--swiftversion 60.`
`2`	`2`	`--disable unusedArguments, opaqueGenericParameters, redundantSelf, trailingSpace, redundantReturn, spaceAroundOperators`
	`3`	`+--ifdef no-indent`
Original file line number	Diff line number	Diff line change
`@@ -77,6 +77,11 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
	`80`	`+ var isUnknown: Bool {`
	`81`	`+ guard case .unknown = self else { return false }`
	`82`	`+ return true`
	`83`	`+ }`
	`84`	`+`
`80`	`85`	`func apply(_ s: Substitution) -> Row {`
`81`	`86`	`return switch self {`
`82`	`87`	`case let .fixed(v): .fixed(v.map { $0.apply(s) })`
Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ class TypeCheckerTests: XCTestCase {`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`func testExprInParens() {`
`195`		`- XCTAssertEqual(.row(.fixed([.integer])), try check("(1 + 1) + 1"))`
	`195`	`+ XCTAssertEqual(.integer, try check("(1 + 1) + 1"))`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`func scope(table: String, schema: String) throws -> Environment {`