     [person["firstname"], person["lastname"], comment["comment"]]
 }/*.filter { t1, _ in
     t1["firstname"] == "Daniel" || t1["lastname"] == "McCartney"
-}*/.filter { person, _ in
-    person["id"] > 0
+}*/.filter { person, comment in
+    person["lastname"] == nil
 }/*.filter { person, comment in
     comment["comment"] == "Musician"// || comment["comment"] == "Cool"
 }*/.execute(on: pool).flatMap{$0}.flatMap { results in


public func ==<T : Equatable>(a:T?, b:T?) -> Predicate {
    return .bool(a == b)
}

public func !=<T : RDBCEquatable>(column:Column, value:T?) -> Predicate {

extension Float : RDBCComparable {
}

/*public struct Null : ExpressibleByNilLiteral {
    public init() {
    }
    
    public init(nilLiteral: ()) {
    }
    
    public static let null = Null()
}

extension Null {
    var meta:MetaValueProtocol? {
        return nil
    }
}

extension Null : Equatable {
}

public func ==<Null>(a:Null, b:Null) -> Bool {
    return true
}*/

extension Null {
    var meta:MetaValueProtocol? {
        return nil
    }
}

public func ==(column:Column, value:Null) -> Predicate {
    return .comparison(op: .eq, a: MetaValue<Any>.column(column), b: value.meta)
}

public func ==(value:Null, column:Column) -> Predicate {
    return .comparison(op: .eq, a: value.meta, b: MetaValue<Any>.column(column))
}

public func ==<T : RDBCEquatable>(column:Column, value:T?) -> Predicate {
    return .comparison(op: .eq, a: MetaValue<Any>.column(column), b: value.map {MetaValue.static($0)})
}
