1276 lines
64 KiB
Swift
1276 lines
64 KiB
Swift
import XCTest
|
|
import GRDB
|
|
|
|
// A -> B <- C -> D
|
|
private struct A: TableRecord, EncodableRecord {
|
|
static let databaseTableName = "a"
|
|
static let b = belongsTo(B.self)
|
|
static let c = hasOne(C.self, through: b, using: B.c)
|
|
func encode(to container: inout PersistenceContainer) {
|
|
container["bid"] = 1
|
|
}
|
|
}
|
|
|
|
private struct B: TableRecord {
|
|
static let c = hasOne(C.self)
|
|
static let d = hasOne(D.self, through: c, using: C.d)
|
|
static let databaseTableName = "b"
|
|
}
|
|
|
|
private struct C: TableRecord {
|
|
static let databaseTableName = "c"
|
|
static let b = belongsTo(B.self)
|
|
static let d = belongsTo(D.self)
|
|
}
|
|
|
|
private struct D: TableRecord {
|
|
static let databaseTableName = "d"
|
|
}
|
|
|
|
/// Test SQL generation
|
|
class AssociationChainSQLTests: GRDBTestCase {
|
|
|
|
override func setup(_ dbWriter: some DatabaseWriter) throws {
|
|
try dbWriter.write { db in
|
|
try db.create(table: "b") { t in
|
|
t.primaryKey("id", .integer)
|
|
}
|
|
try db.create(table: "d") { t in
|
|
t.primaryKey("id", .integer)
|
|
}
|
|
try db.create(table: "a") { t in
|
|
t.primaryKey("id", .integer)
|
|
t.column("bid", .integer).references("b")
|
|
}
|
|
try db.create(table: "c") { t in
|
|
t.primaryKey("id", .integer)
|
|
t.column("bid", .integer).references("b")
|
|
t.column("did", .integer).references("d")
|
|
}
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoRequestForIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
// Direct, Direct
|
|
try assertEqualSQL(db, A().request(for: A.b.including(required: B.c)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.b.including(optional: B.c)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
|
|
// Direct, Through
|
|
try assertEqualSQL(db, A().request(for: A.b.including(required: B.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.b.including(optional: B.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
|
|
// Through, Through
|
|
try assertEqualSQL(db, A().request(for: A.c.including(required: C.d)), """
|
|
SELECT "c".*, "d".* \
|
|
FROM "c" \
|
|
JOIN "d" ON "d"."id" = "c"."did" \
|
|
JOIN "b" ON ("b"."id" = "c"."bid") AND ("b"."id" = 1)
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.c.including(optional: C.d)), """
|
|
SELECT "c".*, "d".* \
|
|
FROM "c" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did" \
|
|
JOIN "b" ON ("b"."id" = "c"."bid") AND ("b"."id" = 1)
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoIncludingIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.including(optional: B.c.including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoIncludingIncludingIncludingSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c).including(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c).including(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c).including(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(required: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(required: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(optional: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(required: C.d).including(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(required: C.d).including(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(optional: C.d).including(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.including(optional: B.c.including(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoIncludingIncludingJoiningSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c).joining(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c).joining(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c).joining(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c).joining(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c).joining(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(required: C.d).joining(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(required: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(optional: C.d).joining(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.including(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(required: C.d).joining(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(required: C.d).joining(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.including(optional: C.d).joining(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.including(optional: B.c.including(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoRequestForJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
// Direct, Direct
|
|
try assertEqualSQL(db, A().request(for: A.b.joining(required: B.c)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.b.joining(optional: B.c)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
|
|
// Direct, Through
|
|
try assertEqualSQL(db, A().request(for: A.b.joining(required: B.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.b.joining(optional: B.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
|
|
// Through, Through
|
|
try assertEqualSQL(db, A().request(for: A.c.joining(required: C.d)), """
|
|
SELECT "c".* \
|
|
FROM "c" \
|
|
JOIN "d" ON "d"."id" = "c"."did" \
|
|
JOIN "b" ON ("b"."id" = "c"."bid") AND ("b"."id" = 1)
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.c.joining(optional: C.d)), """
|
|
SELECT "c".* \
|
|
FROM "c" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did" \
|
|
JOIN "b" ON ("b"."id" = "c"."bid") AND ("b"."id" = 1)
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoIncludingJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c)), "")
|
|
try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(required: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(optional: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.including(optional: B.c.joining(optional: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoIncludingJoiningIncludingSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c).including(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c).including(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c).including(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(required: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(required: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(optional: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(required: C.d).including(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(required: C.d).including(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(optional: C.d).including(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.including(optional: B.c.joining(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoIncludingJoiningJoiningSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c).joining(required: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c).joining(required: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c).joining(required: B.c)), "")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c).joining(optional: B.c)), "")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c).joining(required: B.c)), "")
|
|
try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(required: C.d).joining(required: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(required: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(optional: C.d).joining(required: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.including(required: B.c.joining(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(required: C.d).joining(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(required: C.d).joining(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.including(optional: B.c.joining(optional: C.d).joining(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.including(optional: B.c.joining(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "c".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoJoiningIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.joining(optional: B.c.including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoJoiningIncludingIncludingSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c).including(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c).including(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c).including(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(required: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(required: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(optional: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(required: C.d).including(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(required: C.d).including(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(optional: C.d).including(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.joining(optional: B.c.including(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoJoiningIncludingJoiningSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c).joining(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c).joining(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c).joining(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c).joining(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c).joining(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(required: C.d).joining(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(required: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(optional: C.d).joining(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.including(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(required: C.d).joining(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(required: C.d).joining(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.including(optional: C.d).joining(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.joining(optional: B.c.including(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoJoiningJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(required: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(optional: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.joining(optional: B.c.joining(optional: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoJoiningJoiningIncludingSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c).including(required: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c).including(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c).including(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c).including(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c).including(optional: B.c)), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(required: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(required: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(optional: C.d).including(required: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(required: C.d).including(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(required: C.d).including(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(optional: C.d).including(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.joining(optional: B.c.joining(optional: C.d).including(optional: C.d)), """
|
|
SELECT "b".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfTwoJoiningJoiningJoiningSameAssociation() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c).joining(required: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c).joining(optional: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c).joining(required: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c).joining(required: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c).joining(optional: B.c)), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c).joining(required: B.c)), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c).joining(optional: B.c)), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(required: C.d).joining(required: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(required: C.d).joining(optional: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(optional: C.d).joining(required: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, B.joining(required: B.c.joining(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(required: C.d).joining(required: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(required: C.d).joining(optional: C.d)), "TODO")
|
|
// try assertEqualSQL(db, B.joining(optional: B.c.joining(optional: C.d).joining(required: C.d)), "TODO")
|
|
try assertEqualSQL(db, B.joining(optional: B.c.joining(optional: C.d).joining(optional: C.d)), """
|
|
SELECT "b".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeRequestForIncludingIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A().request(for: A.b.including(required: B.c.including(required: C.d))), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
try assertEqualSQL(db, A().request(for: A.b.including(required: B.c.including(optional: C.d))), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A().request(for: A.b.including(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A().request(for: A.b.including(optional: B.c.including(optional: C.d))), """
|
|
SELECT "b".*, "c".*, "d".* \
|
|
FROM "b" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did" \
|
|
WHERE "b"."id" = 1
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeIncludingIncludingIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c.including(required: C.d))), """
|
|
SELECT "a".*, "b".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c.including(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c.including(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeIncludingIncludingJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c.joining(required: C.d))), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(required: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(required: A.b.including(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c.joining(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(required: B.c.joining(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.including(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeIncludingJoiningIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c.including(required: C.d))), """
|
|
SELECT "a".*, "b".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c.including(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c.including(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "b".*, "d".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeIncludingJoiningJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c.joining(required: C.d))), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(required: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(required: A.b.joining(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c.joining(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(required: B.c.joining(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.including(optional: A.b.joining(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "b".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeJoiningIncludingIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c.including(required: C.d))), """
|
|
SELECT "a".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c.including(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c.including(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "c".*, "d".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeJoiningIncludingJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c.joining(required: C.d))), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(required: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(required: A.b.including(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c.joining(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(required: B.c.joining(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.including(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".*, "c".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeJoiningJoiningIncluding() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c.including(required: C.d))), """
|
|
SELECT "a".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "d".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c.including(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c.including(optional: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c.including(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c.including(optional: C.d))), """
|
|
SELECT "a".*, "d".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
|
|
func testChainOfThreeJoiningJoiningJoining() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.inDatabase { db in
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c.joining(required: C.d))), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(required: B.c.joining(optional: C.d))), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(required: A.b.joining(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
// TODO: chainOptionalRequired
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c.joining(required: C.d))), "TODO")
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(required: B.c.joining(optional: C.d))), "TODO)
|
|
// try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c.joining(required: C.d))), "TODO")
|
|
try assertEqualSQL(db, A.joining(optional: A.b.joining(optional: B.c.joining(optional: C.d))), """
|
|
SELECT "a".* \
|
|
FROM "a" \
|
|
LEFT JOIN "b" ON "b"."id" = "a"."bid" \
|
|
LEFT JOIN "c" ON "c"."bid" = "b"."id" \
|
|
LEFT JOIN "d" ON "d"."id" = "c"."did"
|
|
""")
|
|
}
|
|
}
|
|
}
|