added where binary conditions

Author: fnc12

Sources/SQLiteORM/AST/BinaryOperator.swift

@@ -0,0 +1,45 @@
+import Foundation
+
+public class BinaryOperator: Expression {
+    var lhs: Expression
+    var rhs: Expression
+    var operatorType: BinaryOperatorType
+    
+    init(lhs: Expression, rhs: Expression, operatorType: BinaryOperatorType) {
+        self.lhs = lhs
+        self.rhs = rhs
+        self.operatorType = operatorType
+    }
+}
+
+extension BinaryOperator: Serializable {
+    public func serialize(with schemaProvider: SchemaProvider) throws -> String {
+        let leftString = try self.lhs.serialize(with: schemaProvider)
+        let rightString = try self.rhs.serialize(with: schemaProvider)
+        return "\(leftString) \(self.operatorType) \(rightString)"
+    }
+}
+
+public func equal(lhs: Expression, rhs: Expression) -> BinaryOperator {
+    return BinaryOperator(lhs: lhs, rhs: rhs, operatorType: .equal)
+}
+
+public func notEqual(lhs: Expression, rhs: Expression) -> BinaryOperator {
+    return BinaryOperator(lhs: lhs, rhs: rhs, operatorType: .notEqual)
+}
+
+public func lesserThan(lhs: Expression, rhs: Expression) -> BinaryOperator {
+    return BinaryOperator(lhs: lhs, rhs: rhs, operatorType: .lesserThan)
+}
+
+public func lesserOrEqual(lhs: Expression, rhs: Expression) -> BinaryOperator {
+    return BinaryOperator(lhs: lhs, rhs: rhs, operatorType: .lesserOrEqual)
+}
+
+public func greaterThan(lhs: Expression, rhs: Expression) -> BinaryOperator {
+    return BinaryOperator(lhs: lhs, rhs: rhs, operatorType: .greaterThan)
+}
+
+public func greaterOrEqual(lhs: Expression, rhs: Expression) -> BinaryOperator {
+    return BinaryOperator(lhs: lhs, rhs: rhs, operatorType: .greaterOrEqual)
+}

Sources/SQLiteORM/AST/BinaryOperatorType.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+enum BinaryOperatorType {
+//    case add
+//    case sub
+//    case mul
+//    case div
+    case equal
+    case notEqual
+    case lesserThan
+    case lesserOrEqual
+    case greaterThan
+    case greaterOrEqual
+}
+
+extension BinaryOperatorType: CustomStringConvertible {
+    var description: String {
+        switch self {
+        case .equal: return "=="
+        case .notEqual: return "!="
+        case .lesserThan: return "<"
+        case .greaterThan: return ">"
+        case .lesserOrEqual: return "<="
+        case .greaterOrEqual: return ">="
+        }
+    }
+}

Sources/SQLiteORM/ConflictClause.swift renamed to Sources/SQLiteORM/AST/ConflictClause.swift

@@ -9,7 +9,7 @@ public enum ConflictClause {
 }
 
 extension ConflictClause: Serializable {
-    func serialize() -> String {
+    public func serialize(with schemaProvider: SchemaProvider) -> String {
         var res = "ON CONFLICT "
         switch self {
         case .rollback: res += "ROLLBACK"

Sources/SQLiteORM/Order.swift renamed to Sources/SQLiteORM/AST/Order.swift

@@ -6,7 +6,7 @@ public enum Order {
 }
 
 extension Order: Serializable {
-    func serialize() -> String {
+    public func serialize(with schemaProvider: SchemaProvider) -> String {
         switch self {
         case .asc: return "ASC"
         case .desc: return "DESC"

Sources/SQLiteORM/AST/SelectConstraint.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+public protocol SelectConstraint: Serializable {
+    
+}

Sources/SQLiteORM/AST/Where.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+public class Where: SelectConstraint {
+    var expression: Expression
+    
+    init(expression: Expression) {
+        self.expression = expression
+    }
+}
+
+extension Where: Serializable {
+    public func serialize(with schemaProvider: SchemaProvider) throws -> String {
+        let expressionString = try self.expression.serialize(with: schemaProvider)
+        return "WHERE \(expressionString)"
+    }
+}
+
+public func where_(_ expression: Expression) -> Where {
+    return Where(expression: expression)
+}

Sources/SQLiteORM/AnyColumn.swift

@@ -77,11 +77,11 @@ public class AnyColumn: NSObject {
 }
 
 extension AnyColumn: Serializable {
-    func serialize() -> String {
+    public func serialize(with schemaProvider: SchemaProvider) -> String {
         let typeString = self.sqliteTypeName
         var res = "\(self.name) \(typeString)"
         for constraint in self.constraints {
-            let constraintString = constraint.serialize()
+            let constraintString = constraint.serialize(with: schemaProvider)
             res += " "
             res += constraintString
         }

Sources/SQLiteORM/ColumnConstraint.swift

@@ -7,17 +7,17 @@ public enum ColumnConstraint {
 }
 
 extension ColumnConstraint: Serializable {
-    func serialize() -> String {
+    public func serialize(with schemaProvider: SchemaProvider) -> String {
         switch self {
         case .primaryKey(let orderMaybe, let conflictClauseMaybe, let autoincrement):
             var res = "PRIMARY KEY"
             if let order = orderMaybe {
-                let orderString = order.serialize()
+                let orderString = order.serialize(with: schemaProvider)
                 res += " "
                 res += orderString
             }
             if let conflictClause = conflictClauseMaybe {
-                let conflictClauseString = conflictClause.serialize()
+                let conflictClauseString = conflictClause.serialize(with: schemaProvider)
                 res += " "
                 res += conflictClauseString
             }
@@ -28,15 +28,15 @@ extension ColumnConstraint: Serializable {
         case .notNull(let conflictClauseMaybe):
             var res = "NOT NULL"
             if let conflictClause = conflictClauseMaybe {
-                let conflictClauseString = conflictClause.serialize()
+                let conflictClauseString = conflictClause.serialize(with: schemaProvider)
                 res += " "
                 res += conflictClauseString
             }
             return res
         case .unique(let conflictClauseMaybe):
             var res = "UNIQUE"
             if let conflictClause = conflictClauseMaybe {
-                let conflictClauseString = conflictClause.serialize()
+                let conflictClauseString = conflictClause.serialize(with: schemaProvider)
                 res += " "
                 res += conflictClauseString
             }

Sources/SQLiteORM/Expression.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-protocol Expression: Any {
+public protocol Expression: Serializable {
 
 }
 
@@ -11,3 +11,11 @@ extension Int: Expression {
 extension Bool: Expression {
 
 }
+
+extension String: Expression {
+    
+}
+
+extension KeyPath: Expression {
+    
+}