wip

Author: stephencelis

Sources/StructuredQueriesCore/Operators.swift

@@ -192,7 +192,7 @@ public func == <QueryValue: _OptionalProtocol>(
   lhs: any QueryExpression<QueryValue>,
   rhs: some QueryExpression<QueryValue.Wrapped>
 ) -> some QueryExpression<Bool> {
-  BinaryOperator(lhs: lhs, operator: isNull(lhs) ? "IS" : "=", rhs: rhs)
+  BinaryOperator(lhs: lhs, operator: "IS", rhs: rhs)
 }
 
 // NB: This overload is required due to an overload resolution bug of 'Updates[dynamicMember:]'.
@@ -202,7 +202,7 @@ public func != <QueryValue: _OptionalProtocol>(
   lhs: any QueryExpression<QueryValue>,
   rhs: some QueryExpression<QueryValue.Wrapped>
 ) -> some QueryExpression<Bool> {
-  BinaryOperator(lhs: lhs, operator: isNull(lhs) ? "IS NOT" : "<>", rhs: rhs)
+  BinaryOperator(lhs: lhs, operator: "IS NOT", rhs: rhs)
 }
 
 // NB: This overload is required due to an overload resolution bug of 'Updates[dynamicMember:]'.
@@ -211,7 +211,7 @@ public func == <QueryValue: _OptionalProtocol>(
   lhs: any QueryExpression<QueryValue>,
   rhs: some QueryExpression<QueryValue>
 ) -> some QueryExpression<Bool> {
-  BinaryOperator(lhs: lhs, operator: isNull(lhs) || isNull(rhs) ? "IS" : "=", rhs: rhs)
+  BinaryOperator(lhs: lhs, operator: "IS", rhs: rhs)
 }
 
 // NB: This overload is required due to an overload resolution bug of 'Updates[dynamicMember:]'.
@@ -220,7 +220,7 @@ public func != <QueryValue: _OptionalProtocol>(
   lhs: any QueryExpression<QueryValue>,
   rhs: some QueryExpression<QueryValue>
 ) -> some QueryExpression<Bool> {
-  BinaryOperator(lhs: lhs, operator: isNull(lhs) || isNull(rhs) ? "IS NOT" : "<>", rhs: rhs)
+  BinaryOperator(lhs: lhs, operator: "IS NOT", rhs: rhs)
 }
 
 // NB: This overload is required due to an overload resolution bug of 'Updates[dynamicMember:]'.

Sources/StructuredQueriesCore/PrimaryKeyed.swift

@@ -23,6 +23,18 @@ public protocol TableDraft: Table {
 }
 
 extension TableDraft {
+  public static subscript(
+    dynamicMember keyPath: KeyPath<PrimaryTable.Type, some Statement<PrimaryTable>>
+  ) -> some Statement<Self> {
+    SQLQueryExpression("\(PrimaryTable.self[keyPath: keyPath])")
+  }
+
+  public static subscript(
+    dynamicMember keyPath: KeyPath<PrimaryTable.Type, some SelectStatementOf<PrimaryTable>>
+  ) -> SelectOf<Self> {
+    unsafeBitCast(PrimaryTable.self[keyPath: keyPath].asSelect(), to: SelectOf<Self>.self)
+  }
+
   public static var all: SelectOf<Self> {
     unsafeBitCast(PrimaryTable.all.asSelect(), to: SelectOf<Self>.self)
   }
@@ -44,6 +56,14 @@ where QueryValue: PrimaryKeyedTable {
   var primaryKey: TableColumn<QueryValue, PrimaryKey> { get }
 }
 
+extension TableDefinition where QueryValue: TableDraft {
+  public subscript<Member>(
+    dynamicMember keyPath: KeyPath<QueryValue.PrimaryTable.TableColumns, Member>
+  ) -> Member {
+    QueryValue.PrimaryTable.columns[keyPath: keyPath]
+  }
+}
+
 extension PrimaryKeyedTableDefinition {
   /// A query expression representing the number of rows in this table.
   ///

Sources/StructuredQueriesCore/Statements/Where.swift

@@ -80,6 +80,13 @@ public struct Where<From: Table> {
     public subscript(dynamicMember keyPath: KeyPath<From.Type, Self>) -> Self {
       self + From.self[keyPath: keyPath]
     }
+
+    public subscript(
+      dynamicMember keyPath: KeyPath<From.PrimaryTable.Type, Where<From.PrimaryTable>>
+    ) -> Self
+    where From: TableDraft {
+      self + unsafeBitCast(From.PrimaryTable.self[keyPath: keyPath], to: Self.self)
+    }
   #endif
 }
 

Sources/StructuredQueriesCore/TableDefinition.swift

@@ -2,6 +2,7 @@
 ///
 /// Don't conform to this protocol directly. Instead, use the `@Table` and `@Column` macros to
 /// generate a conformance.
+@dynamicMemberLookup
 public protocol TableDefinition<QueryValue>: QueryExpression where QueryValue: Table {
   /// An array of this table's columns.
   static var allColumns: [any TableColumnExpression] { get }

Tests/StructuredQueriesTests/OperatorsTests.swift

@@ -24,12 +24,12 @@ extension SnapshotTests {
       }
       assertInlineSnapshot(of: Row.columns.a == Row.columns.c, as: .sql) {
         """
-        ("rows"."a" = "rows"."c")
+        ("rows"."a" IS "rows"."c")
         """
       }
       assertInlineSnapshot(of: Row.columns.a == Row.columns.a, as: .sql) {
         """
-        ("rows"."a" = "rows"."a")
+        ("rows"."a" IS "rows"."a")
         """
       }
       assertInlineSnapshot(of: Row.columns.a == nil as Int?, as: .sql) {
@@ -64,12 +64,12 @@ extension SnapshotTests {
       }
       assertInlineSnapshot(of: Row.columns.a != Row.columns.c, as: .sql) {
         """
-        ("rows"."a" <> "rows"."c")
+        ("rows"."a" IS NOT "rows"."c")
         """
       }
       assertInlineSnapshot(of: Row.columns.a != Row.columns.a, as: .sql) {
         """
-        ("rows"."a" <> "rows"."a")
+        ("rows"."a" IS NOT "rows"."a")
         """
       }
       assertInlineSnapshot(of: Row.columns.a != nil as Int?, as: .sql) {

Tests/StructuredQueriesTests/SelectTests.swift

@@ -1126,7 +1126,7 @@ extension SnapshotTests {
         SELECT "remindersLists"."id", "remindersLists"."color", "remindersLists"."title", "reminders"."id", "reminders"."assignedUserID", "reminders"."dueDate", "reminders"."isCompleted", "reminders"."isFlagged", "reminders"."notes", "reminders"."priority", "reminders"."remindersListID", "reminders"."title"
         FROM "remindersLists"
         LEFT JOIN "reminders" ON ("remindersLists"."id" = "reminders"."remindersListID")
-        WHERE ifnull(("reminders"."priority" = 3), 0)
+        WHERE ifnull(("reminders"."priority" IS 3), 0)
         """
       } results: {
         """
@@ -1171,6 +1171,81 @@ extension SnapshotTests {
       }
     }
 
+    @Test func reusableStaticHelperOnDraft() {
+      assertQuery(
+        Reminder.Draft.incomplete.select(\.id)
+      ) {
+        """
+        SELECT "reminders"."id"
+        FROM "reminders"
+        WHERE NOT ("reminders"."isCompleted")
+        """
+      } results: {
+        """
+        ┌───┐
+        │ 1 │
+        │ 2 │
+        │ 3 │
+        │ 5 │
+        │ 6 │
+        │ 8 │
+        │ 9 │
+        └───┘
+        """
+      }
+      assertQuery(
+        Reminder.Draft.where { _ in true }.incomplete.select(\.id)
+      ) {
+        """
+        SELECT "reminders"."id"
+        FROM "reminders"
+        WHERE 1 AND NOT ("reminders"."isCompleted")
+        """
+      } results: {
+        """
+        ┌───┐
+        │ 1 │
+        │ 2 │
+        │ 3 │
+        │ 5 │
+        │ 6 │
+        │ 8 │
+        │ 9 │
+        └───┘
+        """
+      }
+      // TODO: Compile
+      // assertQuery(
+      //   Reminder.Draft.select(\.id).incomplete
+      // )
+    }
+
+    @Test func reusableColumnHelperOnDraft() {
+      assertQuery(
+        Reminder.Draft.select(\.isHighPriority)
+      ) {
+        """
+        SELECT ("reminders"."priority" IS 3)
+        FROM "reminders"
+        """
+      } results: {
+        """
+        ┌───────┐
+        │ false │
+        │ false │
+        │ true  │
+        │ false │
+        │ false │
+        │ true  │
+        │ false │
+        │ true  │
+        │ false │
+        │ false │
+        └───────┘
+        """
+      }
+    }
+
     @Test func optionalMapAndFlatMap() {
       do {
         let query: some Statement<Bool?> = Reminder.select {