Updates pods

Delta.xcodeproj/project.pbxproj

@@ -957,7 +957,7 @@
 			files = (
 			);
 			inputPaths = (
-				"${SRCROOT}/Pods/Target Support Files/Pods-Delta/Pods-Delta-frameworks.sh",
+				"${PODS_ROOT}/Target Support Files/Pods-Delta/Pods-Delta-frameworks.sh",
 				"${BUILT_PRODUCTS_DIR}/SDWebImage/SDWebImage.framework",
 				"${BUILT_PRODUCTS_DIR}/SMCalloutView/SMCalloutView.framework",
 				"${BUILT_PRODUCTS_DIR}/SQLite.swift/SQLite.framework",
@@ -970,7 +970,7 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
-			shellScript = "\"${SRCROOT}/Pods/Target Support Files/Pods-Delta/Pods-Delta-frameworks.sh\"\n";
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Delta/Pods-Delta-frameworks.sh\"\n";
 			showEnvVarsInLog = 0;
 		};
 		BF14D8981DE7A519002CA1BE /* mogenerator */ = {
@@ -1316,6 +1316,7 @@
 				INFOPLIST_FILE = "Delta/Supporting Files/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" -DDEBUG";
+				PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.Delta;
 				PROVISIONING_PROFILE = "";
 				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_OBJC_BRIDGING_HEADER = "Delta/Supporting Files/Delta-Bridging-Header.h";
@@ -1337,6 +1338,7 @@
 				INFOPLIST_FILE = "Delta/Supporting Files/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" -DIMPACTOR";
+				PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.Delta;
 				PROVISIONING_PROFILE = "";
 				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_OBJC_BRIDGING_HEADER = "Delta/Supporting Files/Delta-Bridging-Header.h";

Podfile.lock

@@ -2,13 +2,13 @@ PODS:
   - Crashlytics (3.8.6):
     - Fabric (~> 1.6.3)
   - Fabric (1.6.13)
-  - SDWebImage (3.8.2):
+  - SDWebImage (3.8.3):
-    - SDWebImage/Core (= 3.8.2)
+    - SDWebImage/Core (= 3.8.3)
-  - SDWebImage/Core (3.8.2)
+  - SDWebImage/Core (3.8.3)
   - SMCalloutView (2.1.5)
-  - SQLite.swift (0.11.4):
+  - SQLite.swift (0.11.6):
-    - SQLite.swift/standard (= 0.11.4)
+    - SQLite.swift/standard (= 0.11.6)
-  - SQLite.swift/standard (0.11.4)
+  - SQLite.swift/standard (0.11.6)
 
 DEPENDENCIES:
   - Crashlytics (~> 3.8.0)
@@ -28,10 +28,10 @@ SPEC REPOS:
 SPEC CHECKSUMS:
   Crashlytics: 95d05f4e4c19a771250c4bd9ce344d996de32bbf
   Fabric: 2fb5676bc811af011a04513451f463dac6803206
-  SDWebImage: 098e97e6176540799c27e804c96653ee0833d13c
+  SDWebImage: a72e880a8fe0f7fc31efe15aaed443c074d2a80c
   SMCalloutView: 5c0ee363dc8e7204b2fda17dfad38c93e9e23481
-  SQLite.swift: 3e3bee21da701b5b9f87c4a672cb54f233505692
+  SQLite.swift: 46d890be8601964454bd3392527f863d1b802d45
 
 PODFILE CHECKSUM: 1d7f9ff69da571c7991621312e07aa4b16a0a074
 
-COCOAPODS: 1.5.3
+COCOAPODS: 1.6.1

Pods/Manifest.lock

@@ -2,13 +2,13 @@ PODS:
   - Crashlytics (3.8.6):
     - Fabric (~> 1.6.3)
   - Fabric (1.6.13)
-  - SDWebImage (3.8.2):
+  - SDWebImage (3.8.3):
-    - SDWebImage/Core (= 3.8.2)
+    - SDWebImage/Core (= 3.8.3)
-  - SDWebImage/Core (3.8.2)
+  - SDWebImage/Core (3.8.3)
   - SMCalloutView (2.1.5)
-  - SQLite.swift (0.11.4):
+  - SQLite.swift (0.11.6):
-    - SQLite.swift/standard (= 0.11.4)
+    - SQLite.swift/standard (= 0.11.6)
-  - SQLite.swift/standard (0.11.4)
+  - SQLite.swift/standard (0.11.6)
 
 DEPENDENCIES:
   - Crashlytics (~> 3.8.0)
@@ -28,10 +28,10 @@ SPEC REPOS:
 SPEC CHECKSUMS:
   Crashlytics: 95d05f4e4c19a771250c4bd9ce344d996de32bbf
   Fabric: 2fb5676bc811af011a04513451f463dac6803206
-  SDWebImage: 098e97e6176540799c27e804c96653ee0833d13c
+  SDWebImage: a72e880a8fe0f7fc31efe15aaed443c074d2a80c
   SMCalloutView: 5c0ee363dc8e7204b2fda17dfad38c93e9e23481
-  SQLite.swift: 3e3bee21da701b5b9f87c4a672cb54f233505692
+  SQLite.swift: 46d890be8601964454bd3392527f863d1b802d45
 
 PODFILE CHECKSUM: 1d7f9ff69da571c7991621312e07aa4b16a0a074
 
-COCOAPODS: 1.5.3
+COCOAPODS: 1.6.1

Pods/SDWebImage/SDWebImage/UIImageView+WebCache.m

@@ -164,7 +164,7 @@ static char TAG_ACTIVITY_SHOW;
 }
 
 - (void)setIndicatorStyle:(UIActivityIndicatorViewStyle)style{
-    objc_setAssociatedObject(self, &TAG_ACTIVITY_STYLE, [NSNumber numberWithInt:style], OBJC_ASSOCIATION_RETAIN);
+    objc_setAssociatedObject(self, &TAG_ACTIVITY_STYLE, [NSNumber numberWithInteger:style], OBJC_ASSOCIATION_RETAIN);
 }
 
 - (int)getIndicatorStyle{

Pods/SQLite.swift/README.md

@@ -112,7 +112,7 @@ and the [companion repository][SQLiteDataAccessLayer2].
 
 ## Installation
 
-> _Note:_ SQLite.swift requires Swift 4 (and [Xcode][] 9).
+> _Note:_ SQLite.swift requires Swift 4.2 (and [Xcode][] 10.2).
 
 ### Carthage
 
@@ -124,7 +124,7 @@ install SQLite.swift with Carthage:
  2. Update your Cartfile to include the following:
 
     ```ruby
-    github "stephencelis/SQLite.swift" ~> 0.11.4
+    github "stephencelis/SQLite.swift" ~> 0.11.6
     ```
 
  3. Run `carthage update` and
@@ -156,7 +156,7 @@ SQLite.swift with CocoaPods:
     use_frameworks!
 
     target 'YourAppTargetName' do
-        pod 'SQLite.swift', '~> 0.11.4'
+        pod 'SQLite.swift', '~> 0.11.6'
     end
     ```
 
@@ -174,7 +174,7 @@ Swift code.
 
   ```swift
   dependencies: [
-      .package(url: "https://github.com/stephencelis/SQLite.swift.git", from: "0.11.4")
+      .package(url: "https://github.com/stephencelis/SQLite.swift.git", from: "0.11.6")
   ]
   ```
 
@@ -285,7 +285,7 @@ Looking for something else? Try another Swift wrapper (or [FMDB][]):
 [GitterBadge]: https://badges.gitter.im/stephencelis/SQLite.swift.svg
 [GitterLink]: https://gitter.im/stephencelis/SQLite.swift
 
-[Swift4Badge]: https://img.shields.io/badge/swift-4-orange.svg?style=flat
+[Swift4Badge]: https://img.shields.io/badge/swift-4.2-orange.svg?style=flat
 [Swift4Link]: https://developer.apple.com/swift/
 
 [SQLiteMigrationManager.swift]: https://github.com/garriguv/SQLiteMigrationManager.swift

Pods/SQLite.swift/Sources/SQLite/Core/Connection.swift

@@ -577,7 +577,7 @@ public final class Connection {
             } else if let result = result as? Int64 {
                 sqlite3_result_int64(context, result)
             } else if let result = result as? String {
-                sqlite3_result_text(context, result, Int32(result.characters.count), SQLITE_TRANSIENT)
+                sqlite3_result_text(context, result, Int32(result.count), SQLITE_TRANSIENT)
             } else if result == nil {
                 sqlite3_result_null(context)
             } else {

Pods/SQLite.swift/Sources/SQLite/Foundation.swift

@@ -31,12 +31,12 @@ extension Data : Value {
     }
 
     public static func fromDatatypeValue(_ dataValue: Blob) -> Data {
-        return Data(bytes: dataValue.bytes)
+        return Data(dataValue.bytes)
     }
 
     public var datatypeValue: Blob {
-        return withUnsafeBytes { (pointer: UnsafePointer<UInt8>) -> Blob in
+        return withUnsafeBytes { (pointer: UnsafeRawBufferPointer) -> Blob in
-            return Blob(bytes: pointer, length: count)
+            return Blob(bytes: pointer.baseAddress!, length: count)
         }
     }
 

Pods/SQLite.swift/Sources/SQLite/Helpers.swift

@@ -56,7 +56,7 @@ let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 extension String {
 
     func quote(_ mark: Character = "\"") -> String {
-        let escaped = characters.reduce("") { string, character in
+        let escaped = reduce("") { string, character in
             string + (character == mark ? "\(mark)\(mark)" : "\(character)")
         }
         return "\(mark)\(escaped)\(mark)"
@@ -98,18 +98,6 @@ extension String {
 
 }
 
-func infix<T>(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true, function: String = #function) -> Expression<T> {
-    return function.infix(lhs, rhs, wrap: wrap)
-}
-
-func wrap<T>(_ expression: Expressible, function: String = #function) -> Expression<T> {
-    return function.wrap(expression)
-}
-
-func wrap<T>(_ expressions: [Expressible], function: String = #function) -> Expression<T> {
-    return function.wrap(", ".join(expressions))
-}
-
 func transcode(_ literal: Binding?) -> String {
     guard let literal = literal else { return "NULL" }
 

Pods/SQLite.swift/Sources/SQLite/Typed/AggregateFunctions.swift

@@ -22,6 +22,19 @@
 // THE SOFTWARE.
 //
 
+private enum Function: String {
+    case count
+    case max
+    case min
+    case avg
+    case sum
+    case total
+    
+    func wrap<T>(_ expression: Expressible) -> Expression<T> {
+        return self.rawValue.wrap(expression)
+    }
+}
+
 extension ExpressionType where UnderlyingType : Value {
 
     /// Builds a copy of the expression prefixed with the `DISTINCT` keyword.
@@ -48,7 +61,7 @@ extension ExpressionType where UnderlyingType : Value {
     /// - Returns: A copy of the expression wrapped with the `count` aggregate
     ///   function.
     public var count: Expression<Int> {
-        return wrap(self)
+        return Function.count.wrap(self)
     }
 
 }
@@ -79,7 +92,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `count` aggregate
     ///   function.
     public var count: Expression<Int> {
-        return wrap(self)
+        return Function.count.wrap(self)
     }
 
 }
@@ -96,7 +109,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `max` aggregate
     ///   function.
     public var max: Expression<UnderlyingType?> {
-        return wrap(self)
+        return Function.max.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `min` aggregate
@@ -109,7 +122,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var min: Expression<UnderlyingType?> {
-        return wrap(self)
+        return Function.min.wrap(self)
     }
 
 }
@@ -126,7 +139,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `max` aggregate
     ///   function.
     public var max: Expression<UnderlyingType> {
-        return wrap(self)
+        return Function.max.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `min` aggregate
@@ -139,7 +152,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var min: Expression<UnderlyingType> {
-        return wrap(self)
+        return Function.min.wrap(self)
     }
 
 }
@@ -156,7 +169,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var average: Expression<Double?> {
-        return "avg".wrap(self)
+        return Function.avg.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `sum` aggregate
@@ -169,7 +182,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var sum: Expression<UnderlyingType?> {
-        return wrap(self)
+        return Function.sum.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `total` aggregate
@@ -182,7 +195,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var total: Expression<Double> {
-        return wrap(self)
+        return Function.total.wrap(self)
     }
 
 }
@@ -199,7 +212,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var average: Expression<Double?> {
-        return "avg".wrap(self)
+        return Function.avg.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `sum` aggregate
@@ -212,7 +225,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var sum: Expression<UnderlyingType> {
-        return wrap(self)
+        return Function.sum.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `total` aggregate
@@ -225,7 +238,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var total: Expression<Double> {
-        return wrap(self)
+        return Function.total.wrap(self)
     }
 
 }
@@ -233,7 +246,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
 extension ExpressionType where UnderlyingType == Int {
 
     static func count(_ star: Star) -> Expression<UnderlyingType> {
-        return wrap(star(nil, nil))
+        return Function.count.wrap(star(nil, nil))
     }
 
 }

Pods/SQLite.swift/Sources/SQLite/Typed/Coding.swift

@@ -184,7 +184,7 @@ fileprivate class SQLiteEncoder: Encoder {
         }
     }
 
-    fileprivate var setters: [SQLite.Setter] = []
+    fileprivate var setters: [Setter] = []
     let codingPath: [CodingKey] = []
     let userInfo: [CodingUserInfoKey: Any]
 
@@ -217,7 +217,7 @@ fileprivate class SQLiteDecoder : Decoder {
         }
 
         var allKeys: [Key] {
-            return self.row.columnNames.keys.flatMap({Key(stringValue: $0)})
+            return self.row.columnNames.keys.compactMap({Key(stringValue: $0)})
         }
 
         func contains(_ key: Key) -> Bool {

Pods/SQLite.swift/Sources/SQLite/Typed/CoreFunctions.swift

@@ -24,6 +24,40 @@
 
 import Foundation
 
+private enum Function: String {
+    case abs
+    case round
+    case random
+    case randomblob
+    case zeroblob
+    case length
+    case lower
+    case upper
+    case ltrim
+    case rtrim
+    case trim
+    case replace
+    case substr
+    case like = "LIKE"
+    case `in` = "IN"
+    case glob = "GLOB"
+    case match = "MATCH"
+    case regexp = "REGEXP"
+    case collate = "COLLATE"
+    case ifnull
+    
+    func infix<T>(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true) -> Expression<T> {
+        return self.rawValue.infix(lhs, rhs, wrap: wrap)
+    }
+    
+    func wrap<T>(_ expression: Expressible) -> Expression<T> {
+        return self.rawValue.wrap(expression)
+    }
+    
+    func wrap<T>(_ expressions: [Expressible]) -> Expression<T> {
+        return self.rawValue.wrap(", ".join(expressions))
+    }
+}
 
 extension ExpressionType where UnderlyingType : Number {
 
@@ -35,7 +69,7 @@ extension ExpressionType where UnderlyingType : Number {
     ///
     /// - Returns: A copy of the expression wrapped with the `abs` function.
     public var absoluteValue : Expression<UnderlyingType> {
-        return "abs".wrap(self)
+        return Function.abs.wrap(self)
     }
 
 }
@@ -50,7 +84,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     ///
     /// - Returns: A copy of the expression wrapped with the `abs` function.
     public var absoluteValue : Expression<UnderlyingType> {
-        return "abs".wrap(self)
+        return Function.abs.wrap(self)
     }
 
 }
@@ -68,9 +102,9 @@ extension ExpressionType where UnderlyingType == Double {
     /// - Returns: A copy of the expression wrapped with the `round` function.
     public func round(_ precision: Int? = nil) -> Expression<UnderlyingType> {
         guard let precision = precision else {
-            return wrap([self])
+            return Function.round.wrap([self])
         }
-        return wrap([self, Int(precision)])
+        return Function.round.wrap([self, Int(precision)])
     }
 
 }
@@ -88,9 +122,9 @@ extension ExpressionType where UnderlyingType == Double? {
     /// - Returns: A copy of the expression wrapped with the `round` function.
     public func round(_ precision: Int? = nil) -> Expression<UnderlyingType> {
         guard let precision = precision else {
-            return wrap(self)
+            return Function.round.wrap(self)
         }
-        return wrap([self, Int(precision)])
+        return Function.round.wrap([self, Int(precision)])
     }
 
 }
@@ -104,7 +138,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype =
     ///
     /// - Returns: An expression calling the `random` function.
     public static func random() -> Expression<UnderlyingType> {
-        return "random".wrap([])
+        return Function.random.wrap([])
     }
 
 }
@@ -120,7 +154,7 @@ extension ExpressionType where UnderlyingType == Data {
     ///
     /// - Returns: An expression calling the `randomblob` function.
     public static func random(_ length: Int) -> Expression<UnderlyingType> {
-        return "randomblob".wrap([])
+        return Function.randomblob.wrap([])
     }
 
     /// Builds an expression representing the `zeroblob` function.
@@ -132,7 +166,7 @@ extension ExpressionType where UnderlyingType == Data {
     ///
     /// - Returns: An expression calling the `zeroblob` function.
     public static func allZeros(_ length: Int) -> Expression<UnderlyingType> {
-        return "zeroblob".wrap([])
+        return Function.zeroblob.wrap([])
     }
 
     /// Builds a copy of the expression wrapped with the `length` function.
@@ -143,7 +177,7 @@ extension ExpressionType where UnderlyingType == Data {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int> {
-        return wrap(self)
+        return Function.length.wrap(self)
     }
 
 }
@@ -158,7 +192,7 @@ extension ExpressionType where UnderlyingType == Data? {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int?> {
-        return wrap(self)
+        return Function.length.wrap(self)
     }
 
 }
@@ -173,7 +207,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int> {
-        return wrap(self)
+        return Function.length.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `lower` function.
@@ -184,7 +218,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `lower` function.
     public var lowercaseString: Expression<UnderlyingType> {
-        return "lower".wrap(self)
+        return Function.lower.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `upper` function.
@@ -195,7 +229,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `upper` function.
     public var uppercaseString: Expression<UnderlyingType> {
-        return "upper".wrap(self)
+        return Function.upper.wrap(self)
     }
 
     /// Builds a copy of the expression appended with a `LIKE` query against the
@@ -242,9 +276,9 @@ extension ExpressionType where UnderlyingType == String {
     ///   the given pattern.
     public func like(_ pattern: Expression<String>, escape character: Character? = nil) -> Expression<Bool> {
         guard let character = character else {
-            return "LIKE".infix(self, pattern)
+            return Function.like.infix(self, pattern)
         }
-        let like: Expression<Bool> = "LIKE".infix(self, pattern, wrap: false)
+        let like: Expression<Bool> =  Function.like.infix(self, pattern, wrap: false)
         return Expression("(\(like.template) ESCAPE ?)", like.bindings + [String(character)])
     }
 
@@ -260,7 +294,7 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression appended with a `GLOB` query against
     ///   the given pattern.
     public func glob(_ pattern: String) -> Expression<Bool> {
-        return "GLOB".infix(self, pattern)
+        return Function.glob.infix(self, pattern)
     }
 
     /// Builds a copy of the expression appended with a `MATCH` query against
@@ -275,7 +309,7 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression appended with a `MATCH` query
     ///   against the given pattern.
     public func match(_ pattern: String) -> Expression<Bool> {
-        return "MATCH".infix(self, pattern)
+        return Function.match.infix(self, pattern)
     }
 
     /// Builds a copy of the expression appended with a `REGEXP` query against
@@ -286,7 +320,7 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression appended with a `REGEXP` query
     ///   against the given pattern.
     public func regexp(_ pattern: String) -> Expression<Bool> {
-        return "REGEXP".infix(self, pattern)
+        return Function.regexp.infix(self, pattern)
     }
 
     /// Builds a copy of the expression appended with a `COLLATE` clause with
@@ -301,7 +335,7 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression appended with a `COLLATE` clause
     ///   with the given sequence.
     public func collate(_ collation: Collation) -> Expression<UnderlyingType> {
-        return "COLLATE".infix(self, collation)
+        return Function.collate.infix(self, collation)
     }
 
     /// Builds a copy of the expression wrapped with the `ltrim` function.
@@ -317,9 +351,9 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression wrapped with the `ltrim` function.
     public func ltrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
         guard let characters = characters else {
-            return wrap(self)
+            return Function.ltrim.wrap(self)
         }
-        return wrap([self, String(characters)])
+        return Function.ltrim.wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `rtrim` function.
@@ -335,9 +369,9 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression wrapped with the `rtrim` function.
     public func rtrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
         guard let characters = characters else {
-            return wrap(self)
+            return Function.rtrim.wrap(self)
         }
-        return wrap([self, String(characters)])
+        return Function.rtrim.wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `trim` function.
@@ -353,9 +387,9 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression wrapped with the `trim` function.
     public func trim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
         guard let characters = characters else {
-            return wrap([self])
+            return Function.trim.wrap([self])
         }
-        return wrap([self, String(characters)])
+        return Function.trim.wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `replace` function.
@@ -372,14 +406,14 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `replace` function.
     public func replace(_ pattern: String, with replacement: String) -> Expression<UnderlyingType> {
-        return "replace".wrap([self, pattern, replacement])
+        return Function.replace.wrap([self, pattern, replacement])
     }
 
     public func substring(_ location: Int, length: Int? = nil) -> Expression<UnderlyingType> {
         guard let length = length else {
-            return "substr".wrap([self, location])
+            return Function.substr.wrap([self, location])
         }
-        return "substr".wrap([self, location, length])
+        return Function.substr.wrap([self, location, length])
     }
 
     public subscript(range: Range<Int>) -> Expression<UnderlyingType> {
@@ -398,7 +432,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int?> {
-        return wrap(self)
+        return Function.length.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `lower` function.
@@ -409,7 +443,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `lower` function.
     public var lowercaseString: Expression<UnderlyingType> {
-        return "lower".wrap(self)
+        return Function.lower.wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `upper` function.
@@ -420,7 +454,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `upper` function.
     public var uppercaseString: Expression<UnderlyingType> {
-        return "upper".wrap(self)
+        return Function.upper.wrap(self)
     }
 
     /// Builds a copy of the expression appended with a `LIKE` query against the
@@ -443,7 +477,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///   the given pattern.
     public func like(_ pattern: String, escape character: Character? = nil) -> Expression<Bool?> {
         guard let character = character else {
-            return "LIKE".infix(self, pattern)
+            return Function.like.infix(self, pattern)
         }
         return Expression("(\(template) LIKE ? ESCAPE ?)", bindings + [pattern, String(character)])
     }
@@ -467,9 +501,9 @@ extension ExpressionType where UnderlyingType == String? {
     ///   the given pattern.
     public func like(_ pattern: Expression<String>, escape character: Character? = nil) -> Expression<Bool?> {
         guard let character = character else {
-            return "LIKE".infix(self, pattern)
+            return Function.like.infix(self, pattern)
         }
-        let like: Expression<Bool> = "LIKE".infix(self, pattern, wrap: false)
+        let like: Expression<Bool> = Function.like.infix(self, pattern, wrap: false)
         return Expression("(\(like.template) ESCAPE ?)", like.bindings + [String(character)])
     }
 
@@ -485,7 +519,7 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression appended with a `GLOB` query against
     ///   the given pattern.
     public func glob(_ pattern: String) -> Expression<Bool?> {
-        return "GLOB".infix(self, pattern)
+        return Function.glob.infix(self, pattern)
     }
 
     /// Builds a copy of the expression appended with a `MATCH` query against
@@ -500,7 +534,7 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression appended with a `MATCH` query
     ///   against the given pattern.
     public func match(_ pattern: String) -> Expression<Bool> {
-        return "MATCH".infix(self, pattern)
+        return Function.match.infix(self, pattern)
     }
 
     /// Builds a copy of the expression appended with a `REGEXP` query against
@@ -511,7 +545,7 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression appended with a `REGEXP` query
     ///   against the given pattern.
     public func regexp(_ pattern: String) -> Expression<Bool?> {
-        return "REGEXP".infix(self, pattern)
+        return Function.regexp.infix(self, pattern)
     }
 
     /// Builds a copy of the expression appended with a `COLLATE` clause with
@@ -526,7 +560,7 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression appended with a `COLLATE` clause
     ///   with the given sequence.
     public func collate(_ collation: Collation) -> Expression<UnderlyingType> {
-        return "COLLATE".infix(self, collation)
+        return Function.collate.infix(self, collation)
     }
 
     /// Builds a copy of the expression wrapped with the `ltrim` function.
@@ -542,9 +576,9 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression wrapped with the `ltrim` function.
     public func ltrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
         guard let characters = characters else {
-            return wrap(self)
+            return Function.ltrim.wrap(self)
         }
-        return wrap([self, String(characters)])
+        return Function.ltrim.wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `rtrim` function.
@@ -560,9 +594,9 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression wrapped with the `rtrim` function.
     public func rtrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
         guard let characters = characters else {
-            return wrap(self)
+            return Function.rtrim.wrap(self)
         }
-        return wrap([self, String(characters)])
+        return Function.rtrim.wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `trim` function.
@@ -578,9 +612,9 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression wrapped with the `trim` function.
     public func trim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
         guard let characters = characters else {
-            return wrap(self)
+            return Function.trim.wrap(self)
         }
-        return wrap([self, String(characters)])
+        return Function.trim.wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `replace` function.
@@ -597,7 +631,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `replace` function.
     public func replace(_ pattern: String, with replacement: String) -> Expression<UnderlyingType> {
-        return "replace".wrap([self, pattern, replacement])
+        return Function.replace.wrap([self, pattern, replacement])
     }
 
     /// Builds a copy of the expression wrapped with the `substr` function.
@@ -617,9 +651,9 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression wrapped with the `substr` function.
     public func substring(_ location: Int, length: Int? = nil) -> Expression<UnderlyingType> {
         guard let length = length else {
-            return "substr".wrap([self, location])
+            return Function.substr.wrap([self, location])
         }
-        return "substr".wrap([self, location, length])
+        return Function.substr.wrap([self, location, length])
     }
 
     /// Builds a copy of the expression wrapped with the `substr` function.
@@ -637,7 +671,7 @@ extension ExpressionType where UnderlyingType == String? {
 
 }
 
-extension Collection where Iterator.Element : Value, IndexDistance == Int {
+extension Collection where Iterator.Element : Value {
 
     /// Builds a copy of the expression prepended with an `IN` check against the
     /// collection.
@@ -652,7 +686,7 @@ extension Collection where Iterator.Element : Value, IndexDistance == Int {
     ///   the collection.
     public func contains(_ expression: Expression<Iterator.Element>) -> Expression<Bool> {
         let templates = [String](repeating: "?", count: count).joined(separator: ", ")
-        return "IN".infix(expression, Expression<Void>("(\(templates))", map { $0.datatypeValue }))
+        return Function.in.infix(expression, Expression<Void>("(\(templates))", map { $0.datatypeValue }))
     }
 
     /// Builds a copy of the expression prepended with an `IN` check against the
@@ -668,7 +702,7 @@ extension Collection where Iterator.Element : Value, IndexDistance == Int {
     ///   the collection.
     public func contains(_ expression: Expression<Iterator.Element?>) -> Expression<Bool?> {
         let templates = [String](repeating: "?", count: count).joined(separator: ", ")
-        return "IN".infix(expression, Expression<Void>("(\(templates))", map { $0.datatypeValue }))
+        return Function.in.infix(expression, Expression<Void>("(\(templates))", map { $0.datatypeValue }))
     }
 
 }
@@ -694,9 +728,9 @@ extension String {
     ///   the given pattern.
     public func like(_ pattern: Expression<String>, escape character: Character? = nil) -> Expression<Bool> {
         guard let character = character else {
-            return "LIKE".infix(self, pattern)
+            return Function.like.infix(self, pattern)
         }
-        let like: Expression<Bool> = "LIKE".infix(self, pattern, wrap: false)
+        let like: Expression<Bool> = Function.like.infix(self, pattern, wrap: false)
         return Expression("(\(like.template) ESCAPE ?)", like.bindings + [String(character)])
     }
 
@@ -718,7 +752,7 @@ extension String {
 /// - Returns: A copy of the given expressions wrapped with the `ifnull`
 ///   function.
 public func ??<V : Value>(optional: Expression<V?>, defaultValue: V) -> Expression<V> {
-    return "ifnull".wrap([optional, defaultValue])
+    return Function.ifnull.wrap([optional, defaultValue])
 }
 
 /// Builds a copy of the given expressions wrapped with the `ifnull` function.
@@ -738,7 +772,7 @@ public func ??<V : Value>(optional: Expression<V?>, defaultValue: V) -> Expressi
 /// - Returns: A copy of the given expressions wrapped with the `ifnull`
 ///   function.
 public func ??<V : Value>(optional: Expression<V?>, defaultValue: Expression<V>) -> Expression<V> {
-    return "ifnull".wrap([optional, defaultValue])
+    return Function.ifnull.wrap([optional, defaultValue])
 }
 
 /// Builds a copy of the given expressions wrapped with the `ifnull` function.
@@ -758,5 +792,5 @@ public func ??<V : Value>(optional: Expression<V?>, defaultValue: Expression<V>)
 /// - Returns: A copy of the given expressions wrapped with the `ifnull`
 ///   function.
 public func ??<V : Value>(optional: Expression<V?>, defaultValue: Expression<V?>) -> Expression<V> {
-    return "ifnull".wrap([optional, defaultValue])
+    return Function.ifnull.wrap([optional, defaultValue])
 }

Pods/SQLite.swift/Sources/SQLite/Typed/CustomFunctions.swift

@@ -39,76 +39,76 @@ public extension Connection {
     ///     The assigned types must be explicit.
     ///
     /// - Returns: A closure returning an SQL expression to call the function.
-    public func createFunction<Z : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping () -> Z) throws -> (() -> Expression<Z>) {
+    func createFunction<Z : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping () -> Z) throws -> (() -> Expression<Z>) {
         let fn = try createFunction(function, 0, deterministic) { _ in block() }
         return { fn([]) }
     }
 
-    public func createFunction<Z : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping () -> Z?) throws -> (() -> Expression<Z?>) {
+    func createFunction<Z : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping () -> Z?) throws -> (() -> Expression<Z?>) {
         let fn = try createFunction(function, 0, deterministic) { _ in block() }
         return { fn([]) }
     }
 
     // MARK: -
 
-    public func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A) -> Z) throws -> ((Expression<A>) -> Expression<Z>) {
+    func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A) -> Z) throws -> ((Expression<A>) -> Expression<Z>) {
         let fn = try createFunction(function, 1, deterministic) { args in block(value(args[0])) }
         return { arg in fn([arg]) }
     }
 
-    public func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?) -> Z) throws -> ((Expression<A?>) -> Expression<Z>) {
+    func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?) -> Z) throws -> ((Expression<A?>) -> Expression<Z>) {
         let fn = try createFunction(function, 1, deterministic) { args in block(args[0].map(value)) }
         return { arg in fn([arg]) }
     }
 
-    public func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A) -> Z?) throws -> ((Expression<A>) -> Expression<Z?>) {
+    func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A) -> Z?) throws -> ((Expression<A>) -> Expression<Z?>) {
         let fn = try createFunction(function, 1, deterministic) { args in block(value(args[0])) }
         return { arg in fn([arg]) }
     }
 
-    public func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?) -> Z?) throws -> ((Expression<A?>) -> Expression<Z?>) {
+    func createFunction<Z : Value, A : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?) -> Z?) throws -> ((Expression<A?>) -> Expression<Z?>) {
         let fn = try createFunction(function, 1, deterministic) { args in block(args[0].map(value)) }
         return { arg in fn([arg]) }
     }
 
     // MARK: -
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B) -> Z) throws -> (Expression<A>, Expression<B>) -> Expression<Z> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B) -> Z) throws -> (Expression<A>, Expression<B>) -> Expression<Z> {
         let fn = try createFunction(function, 2, deterministic) { args in block(value(args[0]), value(args[1])) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B) -> Z) throws -> (Expression<A?>, Expression<B>) -> Expression<Z> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B) -> Z) throws -> (Expression<A?>, Expression<B>) -> Expression<Z> {
         let fn = try createFunction(function, 2, deterministic) { args in block(args[0].map(value), value(args[1])) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B?) -> Z) throws -> (Expression<A>, Expression<B?>) -> Expression<Z> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B?) -> Z) throws -> (Expression<A>, Expression<B?>) -> Expression<Z> {
         let fn = try createFunction(function, 2, deterministic) { args in block(value(args[0]), args[1].map(value)) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B) -> Z?) throws -> (Expression<A>, Expression<B>) -> Expression<Z?> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B) -> Z?) throws -> (Expression<A>, Expression<B>) -> Expression<Z?> {
         let fn = try createFunction(function, 2, deterministic) { args in block(value(args[0]), value(args[1])) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B?) -> Z) throws -> (Expression<A?>, Expression<B?>) -> Expression<Z> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B?) -> Z) throws -> (Expression<A?>, Expression<B?>) -> Expression<Z> {
         let fn = try createFunction(function, 2, deterministic) { args in block(args[0].map(value), args[1].map(value)) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B) -> Z?) throws -> (Expression<A?>, Expression<B>) -> Expression<Z?> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B) -> Z?) throws -> (Expression<A?>, Expression<B>) -> Expression<Z?> {
         let fn = try createFunction(function, 2, deterministic) { args in block(args[0].map(value), value(args[1])) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B?) -> Z?) throws -> (Expression<A>, Expression<B?>) -> Expression<Z?> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A, B?) -> Z?) throws -> (Expression<A>, Expression<B?>) -> Expression<Z?> {
         let fn = try createFunction(function, 2, deterministic) { args in block(value(args[0]), args[1].map(value)) }
         return { a, b in fn([a, b]) }
     }
 
-    public func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B?) -> Z?) throws -> (Expression<A?>, Expression<B?>) -> Expression<Z?> {
+    func createFunction<Z : Value, A : Value, B : Value>(_ function: String, deterministic: Bool = false, _ block: @escaping (A?, B?) -> Z?) throws -> (Expression<A?>, Expression<B?>) -> Expression<Z?> {
         let fn = try createFunction(function, 2, deterministic) { args in block(args[0].map(value), args[1].map(value)) }
         return { a, b in fn([a, b]) }
     }

Pods/SQLite.swift/Sources/SQLite/Typed/Expression.swift

@@ -77,7 +77,7 @@ extension Expressible {
     public func asSQL() -> String {
         let expressed = expression
         var idx = 0
-        return expressed.template.characters.reduce("") { template, character in
+        return expressed.template.reduce("") { template, character in
             let transcoded: String
             
             if character == "?" {

Pods/SQLite.swift/Sources/SQLite/Typed/Operators.swift

@@ -24,266 +24,297 @@
 
 // TODO: use `@warn_unused_result` by the time operator functions support it
 
+private enum Operator: String {
+    case plus = "+"
+    case minus = "-"
+    case or = "OR"
+    case and = "AND"
+    case not = "NOT "
+    case mul = "*"
+    case div = "/"
+    case mod = "%"
+    case bitwiseLeft = "<<"
+    case bitwiseRight = ">>"
+    case bitwiseAnd = "&"
+    case bitwiseOr = "|"
+    case bitwiseXor = "~"
+    case eq = "="
+    case neq = "!="
+    case gt = ">"
+    case lt = "<"
+    case gte = ">="
+    case lte = "<="
+    case concatenate = "||"
+    
+    func infix<T>(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true) -> Expression<T> {
+        return self.rawValue.infix(lhs, rhs, wrap: wrap)
+    }
+    
+    func wrap<T>(_ expression: Expressible) -> Expression<T> {
+        return self.rawValue.wrap(expression)
+    }
+}
+
 public func +(lhs: Expression<String>, rhs: Expression<String>) -> Expression<String> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 
 public func +(lhs: Expression<String>, rhs: Expression<String?>) -> Expression<String?> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 public func +(lhs: Expression<String?>, rhs: Expression<String>) -> Expression<String?> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 public func +(lhs: Expression<String?>, rhs: Expression<String?>) -> Expression<String?> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 public func +(lhs: Expression<String>, rhs: String) -> Expression<String> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 public func +(lhs: Expression<String?>, rhs: String) -> Expression<String?> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 public func +(lhs: String, rhs: Expression<String>) -> Expression<String> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 public func +(lhs: String, rhs: Expression<String?>) -> Expression<String?> {
-    return "||".infix(lhs, rhs)
+    return Operator.concatenate.infix(lhs, rhs)
 }
 
 // MARK: -
 
 public func +<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 public func +<V: Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.plus.infix(lhs, rhs)
 }
 
 public func -<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 public func -<V: Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.minus.infix(lhs, rhs)
 }
 
 public func *<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 public func *<V: Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.mul.infix(lhs, rhs)
 }
 
 public func /<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 public func /<V: Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return infix(lhs, rhs)
+    return Operator.div.infix(lhs, rhs)
 }
 
 public prefix func -<V : Value>(rhs: Expression<V>) -> Expression<V> where V.Datatype : Number {
-    return wrap(rhs)
+    return Operator.minus.wrap(rhs)
 }
 public prefix func -<V : Value>(rhs: Expression<V?>) -> Expression<V?> where V.Datatype : Number {
-    return wrap(rhs)
+    return Operator.minus.wrap(rhs)
 }
 
 // MARK: -
 
 public func %<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 public func %<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.mod.infix(lhs, rhs)
 }
 
 public func <<<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 public func <<<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseLeft.infix(lhs, rhs)
 }
 
 public func >><V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 public func >><V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseRight.infix(lhs, rhs)
 }
 
 public func &<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 public func &<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseAnd.infix(lhs, rhs)
 }
 
 public func |<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 public func |<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return infix(lhs, rhs)
+    return Operator.bitwiseOr.infix(lhs, rhs)
 }
 
 public func ^<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
@@ -312,166 +343,166 @@ public func ^<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<V?> where V.
 }
 
 public prefix func ~<V : Value>(rhs: Expression<V>) -> Expression<V> where V.Datatype == Int64 {
-    return wrap(rhs)
+    return Operator.bitwiseXor.wrap(rhs)
 }
 public prefix func ~<V : Value>(rhs: Expression<V?>) -> Expression<V?> where V.Datatype == Int64 {
-    return wrap(rhs)
+    return Operator.bitwiseXor.wrap(rhs)
 }
 
 // MARK: -
 
 public func ==<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Equatable {
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Equatable {
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<Bool?> where V.Datatype : Equatable {
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Equatable {
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<Bool> where V.Datatype : Equatable {
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: Expression<V?>, rhs: V?) -> Expression<Bool?> where V.Datatype : Equatable {
     guard let rhs = rhs else { return "IS".infix(lhs, Expression<V?>(value: nil)) }
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Equatable {
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 public func ==<V : Value>(lhs: V?, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Equatable {
     guard let lhs = lhs else { return "IS".infix(Expression<V?>(value: nil), rhs) }
-    return "=".infix(lhs, rhs)
+    return Operator.eq.infix(lhs, rhs)
 }
 
 public func !=<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Equatable {
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Equatable {
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<Bool?> where V.Datatype : Equatable {
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Equatable {
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<Bool> where V.Datatype : Equatable {
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: Expression<V?>, rhs: V?) -> Expression<Bool?> where V.Datatype : Equatable {
     guard let rhs = rhs else { return "IS NOT".infix(lhs, Expression<V?>(value: nil)) }
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Equatable {
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 public func !=<V : Value>(lhs: V?, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Equatable {
     guard let lhs = lhs else { return "IS NOT".infix(Expression<V?>(value: nil), rhs) }
-    return infix(lhs, rhs)
+    return Operator.neq.infix(lhs, rhs)
 }
 
 public func ><V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: Expression<V>, rhs: V) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: V, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 public func ><V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gt.infix(lhs, rhs)
 }
 
 public func >=<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 public func >=<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.gte.infix(lhs, rhs)
 }
 
 public func <<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 public func <<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lt.infix(lhs, rhs)
 }
 
 public func <=<V : Value>(lhs: Expression<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: Expression<V>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: Expression<V?>, rhs: Expression<V>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: Expression<V?>, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: Expression<V>, rhs: V) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: Expression<V?>, rhs: V) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: V, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 public func <=<V : Value>(lhs: V, rhs: Expression<V?>) -> Expression<Bool?> where V.Datatype : Comparable {
-    return infix(lhs, rhs)
+    return Operator.lte.infix(lhs, rhs)
 }
 
 public func ~=<V : Value>(lhs: ClosedRange<V>, rhs: Expression<V>) -> Expression<Bool> where V.Datatype : Comparable & Value {
@@ -517,58 +548,58 @@ public func ~=<V : Value>(lhs: PartialRangeFrom<V>, rhs: Expression<V?>) -> Expr
 // MARK: -
 
 public func &&(lhs: Expression<Bool>, rhs: Expression<Bool>) -> Expression<Bool> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Expression<Bool>, rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Expression<Bool?>, rhs: Expression<Bool>) -> Expression<Bool?> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Expression<Bool?>, rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Expression<Bool>, rhs: Bool) -> Expression<Bool> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Expression<Bool?>, rhs: Bool) -> Expression<Bool?> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Bool, rhs: Expression<Bool>) -> Expression<Bool> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 public func &&(lhs: Bool, rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "AND".infix(lhs, rhs)
+    return Operator.and.infix(lhs, rhs)
 }
 
 public func ||(lhs: Expression<Bool>, rhs: Expression<Bool>) -> Expression<Bool> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Expression<Bool>, rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Expression<Bool?>, rhs: Expression<Bool>) -> Expression<Bool?> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Expression<Bool?>, rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Expression<Bool>, rhs: Bool) -> Expression<Bool> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Expression<Bool?>, rhs: Bool) -> Expression<Bool?> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Bool, rhs: Expression<Bool>) -> Expression<Bool> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 public func ||(lhs: Bool, rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "OR".infix(lhs, rhs)
+    return Operator.or.infix(lhs, rhs)
 }
 
 public prefix func !(rhs: Expression<Bool>) -> Expression<Bool> {
-    return "NOT ".wrap(rhs)
+    return Operator.not.wrap(rhs)
 }
 public prefix func !(rhs: Expression<Bool?>) -> Expression<Bool?> {
-    return "NOT ".wrap(rhs)
+    return Operator.not.wrap(rhs)
 }

Pods/SQLite.swift/Sources/SQLite/Typed/Query.swift

@@ -647,7 +647,7 @@ extension QueryType {
             whereClause
         ]
 
-        return Insert(" ".join(clauses.flatMap { $0 }).expression)
+        return Insert(" ".join(clauses.compactMap { $0 }).expression)
     }
 
     /// Runs an `INSERT` statement against the query with `DEFAULT VALUES`.
@@ -690,7 +690,7 @@ extension QueryType {
             limitOffsetClause
         ]
 
-        return Update(" ".join(clauses.flatMap { $0 }).expression)
+        return Update(" ".join(clauses.compactMap { $0 }).expression)
     }
 
     // MARK: DELETE
@@ -704,7 +704,7 @@ extension QueryType {
             limitOffsetClause
         ]
 
-        return Delete(" ".join(clauses.flatMap { $0 }).expression)
+        return Delete(" ".join(clauses.compactMap { $0 }).expression)
     }
 
     // MARK: EXISTS
@@ -789,7 +789,7 @@ extension QueryType {
             limitOffsetClause
         ]
 
-        return " ".join(clauses.flatMap { $0 }).expression
+        return " ".join(clauses.compactMap { $0 }).expression
     }
 
 }
@@ -938,7 +938,7 @@ extension Connection {
     private func columnNamesForQuery(_ query: QueryType) throws -> [String: Int] {
         var (columnNames, idx) = ([String: Int](), 0)
         column: for each in query.clauses.select.columns {
-            var names = each.expression.template.characters.split { $0 == "." }.map(String.init)
+            var names = each.expression.template.split { $0 == "." }.map(String.init)
             let column = names.removeLast()
             let namespace = names.joined(separator: ".")
             

Pods/SQLite.swift/Sources/SQLite/Typed/Schema.swift

@@ -47,7 +47,7 @@ extension Table {
             withoutRowid ? Expression<Void>(literal: "WITHOUT ROWID") : nil
         ]
 
-        return " ".join(clauses.flatMap { $0 }).asSQL()
+        return " ".join(clauses.compactMap { $0 }).asSQL()
     }
 
     public func create(_ query: QueryType, temporary: Bool = false, ifNotExists: Bool = false) -> String {
@@ -57,7 +57,7 @@ extension Table {
             query
         ]
 
-        return " ".join(clauses.flatMap { $0 }).asSQL()
+        return " ".join(clauses.compactMap { $0 }).asSQL()
     }
 
     // MARK: - ALTER TABLE … ADD COLUMN
@@ -135,7 +135,7 @@ extension Table {
             "".wrap(columns) as Expression<Void>
         ]
 
-        return " ".join(clauses.flatMap { $0 }).asSQL()
+        return " ".join(clauses.compactMap { $0 }).asSQL()
     }
 
     // MARK: - DROP INDEX
@@ -148,7 +148,7 @@ extension Table {
     fileprivate func indexName(_ columns: [Expressible]) -> Expressible {
         let string = (["index", clauses.from.name, "on"] + columns.map { $0.expression.template }).joined(separator: " ").lowercased()
 
-        let index = string.characters.reduce("") { underscored, character in
+        let index = string.reduce("") { underscored, character in
             guard character != "\"" else {
                 return underscored
             }
@@ -174,7 +174,7 @@ extension View {
             query
         ]
 
-        return " ".join(clauses.flatMap { $0 }).asSQL()
+        return " ".join(clauses.compactMap { $0 }).asSQL()
     }
 
     // MARK: - DROP VIEW
@@ -196,7 +196,7 @@ extension VirtualTable {
             using
         ]
 
-        return " ".join(clauses.flatMap { $0 }).asSQL()
+        return " ".join(clauses.compactMap { $0 }).asSQL()
     }
 
     // MARK: - ALTER TABLE … RENAME TO
@@ -405,7 +405,7 @@ public final class TableBuilder {
             delete.map { Expression<Void>(literal: "ON DELETE \($0.rawValue)") }
         ]
 
-        definitions.append(" ".join(clauses.flatMap { $0 }))
+        definitions.append(" ".join(clauses.compactMap { $0 }))
     }
 
 }
@@ -456,7 +456,7 @@ private extension QueryType {
             name
         ]
 
-        return " ".join(clauses.flatMap { $0 })
+        return " ".join(clauses.compactMap { $0 })
     }
 
     func rename(to: Self) -> String {
@@ -475,7 +475,7 @@ private extension QueryType {
             name
         ]
 
-        return " ".join(clauses.flatMap { $0 }).asSQL()
+        return " ".join(clauses.compactMap { $0 }).asSQL()
     }
 
 }
@@ -493,7 +493,7 @@ private func definition(_ column: Expressible, _ datatype: String, _ primaryKey:
         collate.map { " ".join([Expression<Void>(literal: "COLLATE"), $0]) }
     ]
 
-    return " ".join(clauses.flatMap { $0 })
+    return " ".join(clauses.compactMap { $0 })
 }
 
 private func reference(_ primary: (QueryType, Expressible)) -> Expressible {

Pods/SQLite.swift/Sources/SQLiteObjc/include/SQLite-Bridging.h

@@ -23,8 +23,7 @@
 //
 
 @import Foundation;
-
+@import SQLite3;
-#import "sqlite3.h"
 
 NS_ASSUME_NONNULL_BEGIN
 typedef NSString * _Nullable (^_SQLiteTokenizerNextCallback)(const char *input, int *inputOffset, int *inputLength);

Pods/Target Support Files/Crashlytics/Crashlytics.xcconfig

@@ -0,0 +1,10 @@
+CONFIGURATION_BUILD_DIR = ${PODS_CONFIGURATION_BUILD_DIR}/Crashlytics
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_ROOT}/Crashlytics/iOS" "${PODS_ROOT}/Fabric/iOS"
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+OTHER_LDFLAGS = $(inherited) -l"c++" -l"z" -framework "Security" -framework "SystemConfiguration"
+PODS_BUILD_DIR = ${BUILD_DIR}
+PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
+PODS_ROOT = ${SRCROOT}
+PODS_TARGET_SRCROOT = ${PODS_ROOT}/Crashlytics
+PRODUCT_BUNDLE_IDENTIFIER = org.cocoapods.${PRODUCT_NAME:rfc1034identifier}
+SKIP_INSTALL = YES

Pods/Target Support Files/Fabric/Fabric.xcconfig

@@ -0,0 +1,10 @@
+CONFIGURATION_BUILD_DIR = ${PODS_CONFIGURATION_BUILD_DIR}/Fabric
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_ROOT}/Fabric/iOS"
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+OTHER_LDFLAGS = $(inherited) -framework "UIKit"
+PODS_BUILD_DIR = ${BUILD_DIR}
+PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
+PODS_ROOT = ${SRCROOT}
+PODS_TARGET_SRCROOT = ${PODS_ROOT}/Fabric
+PRODUCT_BUNDLE_IDENTIFIER = org.cocoapods.${PRODUCT_NAME:rfc1034identifier}
+SKIP_INSTALL = YES

Pods/Target Support Files/Pods-Delta/Pods-Delta-Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>${EXECUTABLE_NAME}</string>
+  <key>CFBundleIdentifier</key>
+  <string>${PRODUCT_BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>${CURRENT_PROJECT_VERSION}</string>
+  <key>NSPrincipalClass</key>
+  <string></string>
+</dict>
+</plist>

Pods/Target Support Files/Pods-Delta/Pods-Delta-frameworks.sh

@@ -3,10 +3,15 @@ set -e
 set -u
 set -o pipefail
 
+function on_error {
+  echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
+}
+trap 'on_error $LINENO' ERR
+
 if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
-    # If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
+  # If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
-    # frameworks to, so exit 0 (signalling the script phase was successful).
+  # frameworks to, so exit 0 (signalling the script phase was successful).
-    exit 0
+  exit 0
 fi
 
 echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
@@ -36,8 +41,8 @@ install_framework()
   local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
 
   if [ -L "${source}" ]; then
-      echo "Symlinked..."
+    echo "Symlinked..."
-      source="$(readlink "${source}")"
+    source="$(readlink "${source}")"
   fi
 
   # Use filter instead of exclude so missing patterns don't throw errors.
@@ -47,8 +52,13 @@ install_framework()
   local basename
   basename="$(basename -s .framework "$1")"
   binary="${destination}/${basename}.framework/${basename}"
+
   if ! [ -r "$binary" ]; then
     binary="${destination}/${basename}"
+  elif [ -L "${binary}" ]; then
+    echo "Destination binary is symlinked..."
+    dirname="$(dirname "${binary}")"
+    binary="${dirname}/$(readlink "${binary}")"
   fi
 
   # Strip invalid architectures so "fat" simulator / device frameworks work on device
@@ -62,7 +72,7 @@ install_framework()
   # Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
   if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
     local swift_runtime_libs
-    swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u  && exit ${PIPESTATUS[0]})
+    swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u)
     for lib in $swift_runtime_libs; do
       echo "rsync -auv \"${SWIFT_STDLIB_PATH}/${lib}\" \"${destination}\""
       rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
@@ -101,8 +111,8 @@ install_dsym() {
 
 # Signs a framework with the provided identity
 code_sign_if_enabled() {
-  if [ -n "${EXPANDED_CODE_SIGN_IDENTITY}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
+  if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
-    # Use the current code_sign_identitiy
+    # Use the current code_sign_identity
     echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
     local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
 
@@ -131,7 +141,7 @@ strip_invalid_archs() {
   for arch in $binary_archs; do
     if ! [[ "${ARCHS}" == *"$arch"* ]]; then
       # Strip non-valid architectures in-place
-      lipo -remove "$arch" -output "$binary" "$binary" || exit 1
+      lipo -remove "$arch" -output "$binary" "$binary"
       stripped="$stripped $arch"
     fi
   done

Pods/Target Support Files/Pods-Delta/Pods-Delta.debug.xcconfig

@@ -1,10 +1,11 @@
 ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES
 FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage" "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView" "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift" "${PODS_ROOT}/Crashlytics/iOS" "${PODS_ROOT}/Fabric/iOS"
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage/SDWebImage.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView/SMCalloutView.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift/SQLite.framework/Headers"
 LD_RUNPATH_SEARCH_PATHS = $(inherited) '@executable_path/Frameworks' '@loader_path/Frameworks'
-OTHER_CFLAGS = $(inherited) -iquote "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage/SDWebImage.framework/Headers" -iquote "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView/SMCalloutView.framework/Headers" -iquote "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift/SQLite.framework/Headers"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage/SDWebImage.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView/SMCalloutView.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift/SQLite.framework/Headers" -iframework "${PODS_ROOT}/Crashlytics/iOS" -iframework "${PODS_ROOT}/Fabric/iOS" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift"
-OTHER_LDFLAGS = $(inherited) -ObjC -l"c++" -l"z" -framework "Crashlytics" -framework "Fabric" -framework "SDWebImage" -framework "SMCalloutView" -framework "SQLite" -framework "Security" -framework "SystemConfiguration" -framework "UIKit"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"c++" -l"sqlite3" -l"z" -framework "Crashlytics" -framework "Fabric" -framework "ImageIO" -framework "SDWebImage" -framework "SMCalloutView" -framework "SQLite" -framework "Security" -framework "SystemConfiguration" -framework "UIKit"
-OTHER_SWIFT_FLAGS = $(inherited) "-D" "COCOAPODS"
+OTHER_SWIFT_FLAGS = $(inherited) -D COCOAPODS
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_PODFILE_DIR_PATH = ${SRCROOT}/.

Pods/Target Support Files/Pods-Delta/Pods-Delta.release.xcconfig

@@ -1,10 +1,11 @@
 ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES
 FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage" "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView" "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift" "${PODS_ROOT}/Crashlytics/iOS" "${PODS_ROOT}/Fabric/iOS"
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage/SDWebImage.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView/SMCalloutView.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift/SQLite.framework/Headers"
 LD_RUNPATH_SEARCH_PATHS = $(inherited) '@executable_path/Frameworks' '@loader_path/Frameworks'
-OTHER_CFLAGS = $(inherited) -iquote "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage/SDWebImage.framework/Headers" -iquote "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView/SMCalloutView.framework/Headers" -iquote "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift/SQLite.framework/Headers"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage/SDWebImage.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView/SMCalloutView.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift/SQLite.framework/Headers" -iframework "${PODS_ROOT}/Crashlytics/iOS" -iframework "${PODS_ROOT}/Fabric/iOS" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/SMCalloutView" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift"
-OTHER_LDFLAGS = $(inherited) -ObjC -l"c++" -l"z" -framework "Crashlytics" -framework "Fabric" -framework "SDWebImage" -framework "SMCalloutView" -framework "SQLite" -framework "Security" -framework "SystemConfiguration" -framework "UIKit"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"c++" -l"sqlite3" -l"z" -framework "Crashlytics" -framework "Fabric" -framework "ImageIO" -framework "SDWebImage" -framework "SMCalloutView" -framework "SQLite" -framework "Security" -framework "SystemConfiguration" -framework "UIKit"
-OTHER_SWIFT_FLAGS = $(inherited) "-D" "COCOAPODS"
+OTHER_SWIFT_FLAGS = $(inherited) -D COCOAPODS
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_PODFILE_DIR_PATH = ${SRCROOT}/.

Pods/Target Support Files/SDWebImage/SDWebImage-Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>${EXECUTABLE_NAME}</string>
+  <key>CFBundleIdentifier</key>
+  <string>${PRODUCT_BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>3.8.3</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>${CURRENT_PROJECT_VERSION}</string>
+  <key>NSPrincipalClass</key>
+  <string></string>
+</dict>
+</plist>

Pods/Target Support Files/SDWebImage/SDWebImage.xcconfig

@@ -1,6 +1,6 @@
 CONFIGURATION_BUILD_DIR = ${PODS_CONFIGURATION_BUILD_DIR}/SDWebImage
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
-OTHER_LDFLAGS = -framework "ImageIO"
+OTHER_LDFLAGS = $(inherited) -framework "ImageIO"
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_ROOT = ${SRCROOT}

Pods/Target Support Files/SMCalloutView/SMCalloutView-Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>${EXECUTABLE_NAME}</string>
+  <key>CFBundleIdentifier</key>
+  <string>${PRODUCT_BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>2.1.5</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>${CURRENT_PROJECT_VERSION}</string>
+  <key>NSPrincipalClass</key>
+  <string></string>
+</dict>
+</plist>

Pods/Target Support Files/SQLite.swift/SQLite.swift-Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>${EXECUTABLE_NAME}</string>
+  <key>CFBundleIdentifier</key>
+  <string>${PRODUCT_BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>0.11.6</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>${CURRENT_PROJECT_VERSION}</string>
+  <key>NSPrincipalClass</key>
+  <string></string>
+</dict>
+</plist>

Pods/Target Support Files/SQLite.swift/SQLite.swift.xcconfig

@@ -1,11 +1,11 @@
 CONFIGURATION_BUILD_DIR = ${PODS_CONFIGURATION_BUILD_DIR}/SQLite.swift
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
-OTHER_LDFLAGS = -l"sqlite3"
+OTHER_LDFLAGS = $(inherited) -l"sqlite3"
-OTHER_SWIFT_FLAGS = $(inherited) "-D" "COCOAPODS" "-suppress-warnings"
+OTHER_SWIFT_FLAGS = $(inherited) -D COCOAPODS -suppress-warnings
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_ROOT = ${SRCROOT}
 PODS_TARGET_SRCROOT = ${PODS_ROOT}/SQLite.swift
 PRODUCT_BUNDLE_IDENTIFIER = org.cocoapods.${PRODUCT_NAME:rfc1034identifier}
 SKIP_INSTALL = YES
-SWIFT_VERSION = 4.0
+SWIFT_VERSION = 4.2