 
 // SELECT a.`firstname`, b.`comment` from `test1` as a INNER JOIN `test2` as b USING('id') WHERE a.`firstname` == "Daniel";
 
-pool.select(from: "test1").zip(with: pool.select(from: "test2"), .natural)/* { t1, t2 in
+pool.select(from: "test1").zip(with: pool.select(from: "test2")) { t1, t2 in
     t1["id"] == t2["id"]
-}*/.map { t1, t2 in
+}.map { t1, t2 in
     [t1["firstname"], t2["comment"]]
 }/*.filter { t1, t2 in
     t1["firstname"] == "Daniel"

        case .inner(left: let left, right: let right, condition: .using(let columns)):
            let using = columns.map {"`\($0)`"}.joined(separator: ", ")
            return left.render(dialect: self, aliases: aliases) + " INNER JOIN " + right.render(dialect: self, aliases: aliases) + " USING(\(using))"
        default:
            fatalError("Not implemented")
        }

}

extension Predicate {
    func render(dialect:Dialect, aliases:[String: String]) -> SQL? {
        switch self {
        case .null:
            return nil
        case .bool(let bool):
            return dialect.render(value: bool)
        case .comparison(op: let op, a: let a, b: let b):
            return dialect.render(comparison: op, a, b, aliases: aliases)
        case .compound(op: let op, let a, let b):
            return dialect.render(compound: op, a, b, aliases: aliases)
        }
    }
}

public extension MetaValue {
    public func render(dialect:Dialect, aliases:[String: String]) -> SQL {
        switch self {
        case .column(let column):
            let alias = aliases[column.table.name]!
            let column = dialect.render(column: column.name, table: alias, escape: true)
            return SQL(query: column, parameters: [])
        case .static(let value):
            return dialect.render(value: value)
        }
    }
}

