From c518400ba4ee180ac824004277fc7d4ec2155c59 Mon Sep 17 00:00:00 2001 From: Arjav Lad Date: Tue, 26 Mar 2019 23:08:33 +0530 Subject: [PATCH] Syntaxt error in Xcode 10.2 fixed --- Sources/SQLite/Helpers.swift | 12 - Sources/SQLite/Typed/AggregateFunctions.swift | 22 +- Sources/SQLite/Typed/Coding.swift | 0 Sources/SQLite/Typed/Collation.swift | 0 Sources/SQLite/Typed/CoreFunctions.swift | 40 +-- Sources/SQLite/Typed/CustomFunctions.swift | 0 .../SQLite/Typed/DateAndTimeFunctions.swift | 0 Sources/SQLite/Typed/Expression.swift | 0 Sources/SQLite/Typed/Operators.swift | 232 +++++++++--------- Sources/SQLite/Typed/Query.swift | 0 Sources/SQLite/Typed/Schema.swift | 0 Sources/SQLite/Typed/Setter.swift | 0 12 files changed, 147 insertions(+), 159 deletions(-) mode change 100644 => 100755 Sources/SQLite/Helpers.swift mode change 100644 => 100755 Sources/SQLite/Typed/AggregateFunctions.swift mode change 100644 => 100755 Sources/SQLite/Typed/Coding.swift mode change 100644 => 100755 Sources/SQLite/Typed/Collation.swift mode change 100644 => 100755 Sources/SQLite/Typed/CoreFunctions.swift mode change 100644 => 100755 Sources/SQLite/Typed/CustomFunctions.swift mode change 100644 => 100755 Sources/SQLite/Typed/DateAndTimeFunctions.swift mode change 100644 => 100755 Sources/SQLite/Typed/Expression.swift mode change 100644 => 100755 Sources/SQLite/Typed/Operators.swift mode change 100644 => 100755 Sources/SQLite/Typed/Query.swift mode change 100644 => 100755 Sources/SQLite/Typed/Schema.swift mode change 100644 => 100755 Sources/SQLite/Typed/Setter.swift diff --git a/Sources/SQLite/Helpers.swift b/Sources/SQLite/Helpers.swift old mode 100644 new mode 100755 index ac831667..115ea5c6 --- a/Sources/SQLite/Helpers.swift +++ b/Sources/SQLite/Helpers.swift @@ -98,18 +98,6 @@ extension String { } -func infix(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true, function: String = #function) -> Expression { - return function.infix(lhs, rhs, wrap: wrap) -} - -func wrap(_ expression: Expressible, function: String = #function) -> Expression { - return function.wrap(expression) -} - -func wrap(_ expressions: [Expressible], function: String = #function) -> Expression { - return function.wrap(", ".join(expressions)) -} - func transcode(_ literal: Binding?) -> String { guard let literal = literal else { return "NULL" } diff --git a/Sources/SQLite/Typed/AggregateFunctions.swift b/Sources/SQLite/Typed/AggregateFunctions.swift old mode 100644 new mode 100755 index 249bbe60..bb1157fe --- a/Sources/SQLite/Typed/AggregateFunctions.swift +++ b/Sources/SQLite/Typed/AggregateFunctions.swift @@ -48,7 +48,7 @@ extension ExpressionType where UnderlyingType : Value { /// - Returns: A copy of the expression wrapped with the `count` aggregate /// function. public var count: Expression { - return wrap(self) + return "count".wrap(self) } } @@ -79,7 +79,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr /// - Returns: A copy of the expression wrapped with the `count` aggregate /// function. public var count: Expression { - return wrap(self) + return "count".wrap(self) } } @@ -96,7 +96,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype : /// - Returns: A copy of the expression wrapped with the `max` aggregate /// function. public var max: Expression { - return wrap(self) + return "max".wrap(self) } /// Builds a copy of the expression wrapped with the `min` aggregate @@ -109,7 +109,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype : /// - Returns: A copy of the expression wrapped with the `min` aggregate /// function. public var min: Expression { - return wrap(self) + return "min".wrap(self) } } @@ -126,7 +126,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr /// - Returns: A copy of the expression wrapped with the `max` aggregate /// function. public var max: Expression { - return wrap(self) + return "max".wrap(self) } /// Builds a copy of the expression wrapped with the `min` aggregate @@ -139,7 +139,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr /// - Returns: A copy of the expression wrapped with the `min` aggregate /// function. public var min: Expression { - return wrap(self) + return "min".wrap(self) } } @@ -169,7 +169,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype : /// - Returns: A copy of the expression wrapped with the `min` aggregate /// function. public var sum: Expression { - return wrap(self) + return "sum".wrap(self) } /// Builds a copy of the expression wrapped with the `total` aggregate @@ -182,7 +182,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype : /// - Returns: A copy of the expression wrapped with the `min` aggregate /// function. public var total: Expression { - return wrap(self) + return "total".wrap(self) } } @@ -212,7 +212,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr /// - Returns: A copy of the expression wrapped with the `min` aggregate /// function. public var sum: Expression { - return wrap(self) + return "sum".wrap(self) } /// Builds a copy of the expression wrapped with the `total` aggregate @@ -225,7 +225,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr /// - Returns: A copy of the expression wrapped with the `min` aggregate /// function. public var total: Expression { - return wrap(self) + return "total".wrap(self) } } @@ -233,7 +233,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr extension ExpressionType where UnderlyingType == Int { static func count(_ star: Star) -> Expression { - return wrap(star(nil, nil)) + return "count".wrap(star(nil, nil)) } } diff --git a/Sources/SQLite/Typed/Coding.swift b/Sources/SQLite/Typed/Coding.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/Collation.swift b/Sources/SQLite/Typed/Collation.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/CoreFunctions.swift b/Sources/SQLite/Typed/CoreFunctions.swift old mode 100644 new mode 100755 index d7995b95..b7b53c71 --- a/Sources/SQLite/Typed/CoreFunctions.swift +++ b/Sources/SQLite/Typed/CoreFunctions.swift @@ -68,9 +68,9 @@ extension ExpressionType where UnderlyingType == Double { /// - Returns: A copy of the expression wrapped with the `round` function. public func round(_ precision: Int? = nil) -> Expression { guard let precision = precision else { - return wrap([self]) + return "round".wrap([self]) } - return wrap([self, Int(precision)]) + return "round".wrap([self, Int(precision)]) } } @@ -88,9 +88,9 @@ extension ExpressionType where UnderlyingType == Double? { /// - Returns: A copy of the expression wrapped with the `round` function. public func round(_ precision: Int? = nil) -> Expression { guard let precision = precision else { - return wrap(self) + return "round".wrap(self) } - return wrap([self, Int(precision)]) + return "round".wrap([self, Int(precision)]) } } @@ -143,7 +143,7 @@ extension ExpressionType where UnderlyingType == Data { /// /// - Returns: A copy of the expression wrapped with the `length` function. public var length: Expression { - return wrap(self) + return "length".wrap(self) } } @@ -158,7 +158,7 @@ extension ExpressionType where UnderlyingType == Data? { /// /// - Returns: A copy of the expression wrapped with the `length` function. public var length: Expression { - return wrap(self) + return "length".wrap(self) } } @@ -173,7 +173,7 @@ extension ExpressionType where UnderlyingType == String { /// /// - Returns: A copy of the expression wrapped with the `length` function. public var length: Expression { - return wrap(self) + return "length".wrap(self) } /// Builds a copy of the expression wrapped with the `lower` function. @@ -317,9 +317,9 @@ extension ExpressionType where UnderlyingType == String { /// - Returns: A copy of the expression wrapped with the `ltrim` function. public func ltrim(_ characters: Set? = nil) -> Expression { guard let characters = characters else { - return wrap(self) + return "ltrim".wrap(self) } - return wrap([self, String(characters)]) + return "ltrim".wrap([self, String(characters)]) } /// Builds a copy of the expression wrapped with the `rtrim` function. @@ -335,9 +335,9 @@ extension ExpressionType where UnderlyingType == String { /// - Returns: A copy of the expression wrapped with the `rtrim` function. public func rtrim(_ characters: Set? = nil) -> Expression { guard let characters = characters else { - return wrap(self) + return "rtrim".wrap(self) } - return wrap([self, String(characters)]) + return "rtrim".wrap([self, String(characters)]) } /// Builds a copy of the expression wrapped with the `trim` function. @@ -353,9 +353,9 @@ extension ExpressionType where UnderlyingType == String { /// - Returns: A copy of the expression wrapped with the `trim` function. public func trim(_ characters: Set? = nil) -> Expression { guard let characters = characters else { - return wrap([self]) + return "trim".wrap([self]) } - return wrap([self, String(characters)]) + return "trim".wrap([self, String(characters)]) } /// Builds a copy of the expression wrapped with the `replace` function. @@ -398,7 +398,7 @@ extension ExpressionType where UnderlyingType == String? { /// /// - Returns: A copy of the expression wrapped with the `length` function. public var length: Expression { - return wrap(self) + return "length".wrap(self) } /// Builds a copy of the expression wrapped with the `lower` function. @@ -542,9 +542,9 @@ extension ExpressionType where UnderlyingType == String? { /// - Returns: A copy of the expression wrapped with the `ltrim` function. public func ltrim(_ characters: Set? = nil) -> Expression { guard let characters = characters else { - return wrap(self) + return "ltrim".wrap(self) } - return wrap([self, String(characters)]) + return "ltrim".wrap([self, String(characters)]) } /// Builds a copy of the expression wrapped with the `rtrim` function. @@ -560,9 +560,9 @@ extension ExpressionType where UnderlyingType == String? { /// - Returns: A copy of the expression wrapped with the `rtrim` function. public func rtrim(_ characters: Set? = nil) -> Expression { guard let characters = characters else { - return wrap(self) + return "rtrim".wrap(self) } - return wrap([self, String(characters)]) + return "rtrim".wrap([self, String(characters)]) } /// Builds a copy of the expression wrapped with the `trim` function. @@ -578,9 +578,9 @@ extension ExpressionType where UnderlyingType == String? { /// - Returns: A copy of the expression wrapped with the `trim` function. public func trim(_ characters: Set? = nil) -> Expression { guard let characters = characters else { - return wrap(self) + return "trim".wrap(self) } - return wrap([self, String(characters)]) + return "trim".wrap([self, String(characters)]) } /// Builds a copy of the expression wrapped with the `replace` function. diff --git a/Sources/SQLite/Typed/CustomFunctions.swift b/Sources/SQLite/Typed/CustomFunctions.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/DateAndTimeFunctions.swift b/Sources/SQLite/Typed/DateAndTimeFunctions.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/Expression.swift b/Sources/SQLite/Typed/Expression.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/Operators.swift b/Sources/SQLite/Typed/Operators.swift old mode 100644 new mode 100755 index d97e52b9..5f8be14b --- a/Sources/SQLite/Typed/Operators.swift +++ b/Sources/SQLite/Typed/Operators.swift @@ -53,237 +53,237 @@ public func +(lhs: String, rhs: Expression) -> Expression { // MARK: - public func +(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func +(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "+".infix(lhs, rhs) } public func -(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func -(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "-".infix(lhs, rhs) } public func *(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func *(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "*".infix(lhs, rhs) } public func /(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: Expression, rhs: V) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public func /(lhs: V, rhs: Expression) -> Expression where V.Datatype : Number { - return infix(lhs, rhs) + return "/".infix(lhs, rhs) } public prefix func -(rhs: Expression) -> Expression where V.Datatype : Number { - return wrap(rhs) + return "-".wrap(rhs) } public prefix func -(rhs: Expression) -> Expression where V.Datatype : Number { - return wrap(rhs) + return "-".wrap(rhs) } // MARK: - public func %(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func %(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "%".infix(lhs, rhs) } public func <<(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func <<(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "<<".infix(lhs, rhs) } public func >>(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func >>(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return ">>".infix(lhs, rhs) } public func &(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func &(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "&".infix(lhs, rhs) } public func |(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: Expression, rhs: V) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func |(lhs: V, rhs: Expression) -> Expression where V.Datatype == Int64 { - return infix(lhs, rhs) + return "|".infix(lhs, rhs) } public func ^(lhs: Expression, rhs: Expression) -> Expression where V.Datatype == Int64 { @@ -312,10 +312,10 @@ public func ^(lhs: V, rhs: Expression) -> Expression where V. } public prefix func ~(rhs: Expression) -> Expression where V.Datatype == Int64 { - return wrap(rhs) + return "~".wrap(rhs) } public prefix func ~(rhs: Expression) -> Expression where V.Datatype == Int64 { - return wrap(rhs) + return "~".wrap(rhs) } // MARK: - @@ -348,130 +348,130 @@ public func ==(lhs: V?, rhs: Expression) -> Expression whe } public func !=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Equatable { - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Equatable { - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Equatable { - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Equatable { - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: Expression, rhs: V) -> Expression where V.Datatype : Equatable { - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: Expression, rhs: V?) -> Expression where V.Datatype : Equatable { guard let rhs = rhs else { return "IS NOT".infix(lhs, Expression(value: nil)) } - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: V, rhs: Expression) -> Expression where V.Datatype : Equatable { - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func !=(lhs: V?, rhs: Expression) -> Expression where V.Datatype : Equatable { guard let lhs = lhs else { return "IS NOT".infix(Expression(value: nil), rhs) } - return infix(lhs, rhs) + return "!=".infix(lhs, rhs) } public func >(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">".infix(lhs, rhs) } public func >=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func >=(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return ">=".infix(lhs, rhs) } public func <(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<".infix(lhs, rhs) } public func <=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: Expression, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: Expression, rhs: V) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func <=(lhs: V, rhs: Expression) -> Expression where V.Datatype : Comparable { - return infix(lhs, rhs) + return "<=".infix(lhs, rhs) } public func ~=(lhs: ClosedRange, rhs: Expression) -> Expression where V.Datatype : Comparable & Value { diff --git a/Sources/SQLite/Typed/Query.swift b/Sources/SQLite/Typed/Query.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/Schema.swift b/Sources/SQLite/Typed/Schema.swift old mode 100644 new mode 100755 diff --git a/Sources/SQLite/Typed/Setter.swift b/Sources/SQLite/Typed/Setter.swift old mode 100644 new mode 100755