Rename Expression to SQLExpression to avoid Swift 6 name conflicts

Author: marcprux

Sources/SQLiteDB/Extensions/FTS4.swift

@@ -51,15 +51,15 @@ extension VirtualTable {
     ///
     /// - Returns: An expression appended with a `MATCH` query against the given
     ///   pattern.
-    public func match(_ pattern: String) -> Expression<Bool> {
+    public func match(_ pattern: String) -> SQLExpression<Bool> {
         "MATCH".infix(tableName(), pattern)
     }
 
-    public func match(_ pattern: Expression<String>) -> Expression<Bool> {
+    public func match(_ pattern: SQLExpression<String>) -> SQLExpression<Bool> {
         "MATCH".infix(tableName(), pattern)
     }
 
-    public func match(_ pattern: Expression<String?>) -> Expression<Bool?> {
+    public func match(_ pattern: SQLExpression<String?>) -> SQLExpression<Bool?> {
         "MATCH".infix(tableName(), pattern)
     }
 
@@ -77,11 +77,11 @@ extension VirtualTable {
         filter(match(pattern))
     }
 
-    public func match(_ pattern: Expression<String>) -> QueryType {
+    public func match(_ pattern: SQLExpression<String>) -> QueryType {
         filter(match(pattern))
     }
 
-    public func match(_ pattern: Expression<String?>) -> QueryType {
+    public func match(_ pattern: SQLExpression<String?>) -> QueryType {
         filter(match(pattern))
     }
 
@@ -209,7 +209,7 @@ open class FTSConfig {
         var options = Options()
         options.append(formatColumnDefinitions())
         if let tokenizer {
-            options.append("tokenize", value: Expression<Void>(literal: tokenizer.description))
+            options.append("tokenize", value: SQLExpression<Void>(literal: tokenizer.description))
         }
         options.appendCommaSeparated("prefix", values: prefixes.sorted().map { String($0) })
         if isContentless {
@@ -237,11 +237,11 @@ open class FTSConfig {
         }
 
         @discardableResult mutating func append(_ key: String, value: String) -> Options {
-            append(key, value: Expression<String>(value))
+            append(key, value: SQLExpression<String>(value))
         }
 
         @discardableResult mutating func append(_ key: String, value: Expressible) -> Options {
-            arguments.append("=".join([Expression<Void>(literal: key), value]))
+            arguments.append("=".join([SQLExpression<Void>(literal: key), value]))
             return self
         }
     }

Sources/SQLiteDB/Extensions/FTS5.swift

@@ -73,7 +73,7 @@ open class FTS5Config: FTSConfig {
             options.append("content_rowid", value: contentRowId)
         }
         if let columnSize {
-            options.append("columnsize", value: Expression<Int>(value: columnSize))
+            options.append("columnsize", value: SQLExpression<Int>(value: columnSize))
         }
         if let detail {
             options.append("detail", value: detail.rawValue)
@@ -84,7 +84,7 @@ open class FTS5Config: FTSConfig {
     override func formatColumnDefinitions() -> [Expressible] {
         columnDefinitions.map { definition in
             if definition.options.contains(.unindexed) {
-                return " ".join([definition.0, Expression<Void>(literal: "UNINDEXED")])
+                return " ".join([definition.0, SQLExpression<Void>(literal: "UNINDEXED")])
             } else {
                 return definition.0
             }

Sources/SQLiteDB/Extensions/RTree.swift

@@ -23,8 +23,8 @@
 //
 
 extension Module {
-    public static func RTree<T: Value, U: Value>(_ primaryKey: Expression<T>,
-                                                 _ pairs: (Expression<U>, Expression<U>)...)
+    public static func RTree<T: Value, U: Value>(_ primaryKey: SQLExpression<T>,
+                                                 _ pairs: (SQLExpression<U>, SQLExpression<U>)...)
                     -> Module where T.Datatype == Int64, U.Datatype == Double {
         var arguments: [Expressible] = [primaryKey]
 

Sources/SQLiteDB/Helpers.swift

@@ -32,10 +32,10 @@ import CSQLite
 import SQLite3
 #endif
 
-public typealias Star = (Expression<Binding>?, Expression<Binding>?) -> Expression<Void>
+public typealias Star = (SQLExpression<Binding>?, SQLExpression<Binding>?) -> SQLExpression<Void>
 
-public func *(_: Expression<Binding>?, _: Expression<Binding>?) -> Expression<Void> {
-    Expression(literal: "*")
+public func *(_: SQLExpression<Binding>?, _: SQLExpression<Binding>?) -> SQLExpression<Void> {
+    SQLExpression(literal: "*")
 }
 
 // swiftlint:disable:next type_name
@@ -75,34 +75,34 @@ extension String {
             template.append(expression.template)
             bindings.append(contentsOf: expression.bindings)
         }
-        return Expression<Void>(template.joined(separator: self), bindings)
+        return SQLExpression<Void>(template.joined(separator: self), bindings)
     }
 
-    func infix<T>(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true) -> Expression<T> {
+    func infix<T>(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true) -> SQLExpression<T> {
         infix([lhs, rhs], wrap: wrap)
     }
 
-    func infix<T>(_ terms: [Expressible], wrap: Bool = true) -> Expression<T> {
-        let expression = Expression<T>(" \(self) ".join(terms).expression)
+    func infix<T>(_ terms: [Expressible], wrap: Bool = true) -> SQLExpression<T> {
+        let expression = SQLExpression<T>(" \(self) ".join(terms).expression)
         guard wrap else {
             return expression
         }
         return "".wrap(expression)
     }
 
     func prefix(_ expressions: Expressible) -> Expressible {
-        "\(self) ".wrap(expressions) as Expression<Void>
+        "\(self) ".wrap(expressions) as SQLExpression<Void>
     }
 
     func prefix(_ expressions: [Expressible]) -> Expressible {
-        "\(self) ".wrap(expressions) as Expression<Void>
+        "\(self) ".wrap(expressions) as SQLExpression<Void>
     }
 
-    func wrap<T>(_ expression: Expressible) -> Expression<T> {
-        Expression("\(self)(\(expression.expression.template))", expression.expression.bindings)
+    func wrap<T>(_ expression: Expressible) -> SQLExpression<T> {
+        SQLExpression("\(self)(\(expression.expression.template))", expression.expression.bindings)
     }
 
-    func wrap<T>(_ expressions: [Expressible]) -> Expression<T> {
+    func wrap<T>(_ expressions: [Expressible]) -> SQLExpression<T> {
         wrap(", ".join(expressions))
     }
 

Sources/SQLiteDB/Schema/SchemaReader.swift

@@ -141,54 +141,54 @@ private enum SchemaTable {
     }
 
     // columns
-    static let typeColumn = Expression<String>("type")
-    static let nameColumn = Expression<String>("name")
-    static let tableNameColumn = Expression<String>("tbl_name")
-    static let rootPageColumn = Expression<Int64?>("rootpage")
-    static let sqlColumn = Expression<String?>("sql")
+    static let typeColumn = SQLExpression<String>("type")
+    static let nameColumn = SQLExpression<String>("name")
+    static let tableNameColumn = SQLExpression<String>("tbl_name")
+    static let rootPageColumn = SQLExpression<Int64?>("rootpage")
+    static let sqlColumn = SQLExpression<String?>("sql")
 }
 
 private enum TableInfoTable {
-    static let idColumn = Expression<Int64>("cid")
-    static let nameColumn = Expression<String>("name")
-    static let typeColumn = Expression<String>("type")
-    static let notNullColumn = Expression<Int64>("notnull")
-    static let defaultValueColumn = Expression<String?>("dflt_value")
-    static let primaryKeyColumn = Expression<Int64?>("pk")
+    static let idColumn = SQLExpression<Int64>("cid")
+    static let nameColumn = SQLExpression<String>("name")
+    static let typeColumn = SQLExpression<String>("type")
+    static let notNullColumn = SQLExpression<Int64>("notnull")
+    static let defaultValueColumn = SQLExpression<String?>("dflt_value")
+    static let primaryKeyColumn = SQLExpression<Int64?>("pk")
 }
 
 private enum IndexInfoTable {
     // The rank of the column within the index. (0 means left-most.)
-    static let seqnoColumn = Expression<Int64>("seqno")
+    static let seqnoColumn = SQLExpression<Int64>("seqno")
     // The rank of the column within the table being indexed.
     // A value of -1 means rowid and a value of -2 means that an expression is being used.
-    static let cidColumn = Expression<Int64>("cid")
+    static let cidColumn = SQLExpression<Int64>("cid")
     // The name of the column being indexed. This columns is NULL if the column is the rowid or an expression.
-    static let nameColumn = Expression<String?>("name")
+    static let nameColumn = SQLExpression<String?>("name")
 }
 
 private enum IndexListTable {
     // A sequence number assigned to each index for internal tracking purposes.
-    static let seqColumn = Expression<Int64>("seq")
+    static let seqColumn = SQLExpression<Int64>("seq")
     // The name of the index
-    static let nameColumn = Expression<String>("name")
+    static let nameColumn = SQLExpression<String>("name")
     // "1" if the index is UNIQUE and "0" if not.
-    static let uniqueColumn = Expression<Int64>("unique")
+    static let uniqueColumn = SQLExpression<Int64>("unique")
     // "c" if the index was created by a CREATE INDEX statement,
     // "u" if the index was created by a UNIQUE constraint, or
     // "pk" if the index was created by a PRIMARY KEY constraint.
-    static let originColumn = Expression<String>("origin")
+    static let originColumn = SQLExpression<String>("origin")
     // "1" if the index is a partial index and "0" if not.
-    static let partialColumn = Expression<Int64>("partial")
+    static let partialColumn = SQLExpression<Int64>("partial")
 }
 
 private enum ForeignKeyListTable {
-    static let idColumn = Expression<Int64>("id")
-    static let seqColumn = Expression<Int64>("seq")
-    static let tableColumn = Expression<String>("table")
-    static let fromColumn = Expression<String>("from")
-    static let toColumn = Expression<String?>("to") // when null, use primary key
-    static let onUpdateColumn = Expression<String>("on_update")
-    static let onDeleteColumn = Expression<String>("on_delete")
-    static let matchColumn = Expression<String>("match")
+    static let idColumn = SQLExpression<Int64>("id")
+    static let seqColumn = SQLExpression<Int64>("seq")
+    static let tableColumn = SQLExpression<String>("table")
+    static let fromColumn = SQLExpression<String>("from")
+    static let toColumn = SQLExpression<String?>("to") // when null, use primary key
+    static let onUpdateColumn = SQLExpression<String>("on_update")
+    static let onDeleteColumn = SQLExpression<String>("on_delete")
+    static let matchColumn = SQLExpression<String>("match")
 }