mirror of
https://github.com/groue/GRDB.swift
synced 2026-11-22 04:00:39 +00:00
551 lines
21 KiB
Swift
551 lines
21 KiB
Swift
/// SQLQueryGenerator is able to generate an SQL SELECT query.
|
|
struct SQLQueryGenerator {
|
|
fileprivate let relation: SQLQualifiedRelation
|
|
private let isDistinct: Bool
|
|
private let groupPromise: DatabasePromise<[SQLExpression]>?
|
|
private let havingExpressions: [SQLExpression]
|
|
private let limit: SQLLimit?
|
|
|
|
init(_ query: SQLQuery) {
|
|
// To generate SQL, we need a "qualified" relation, where all tables,
|
|
// expressions, etc, are identified with table aliases.
|
|
//
|
|
// All those aliases let us disambiguate tables at the SQL level, and
|
|
// prefix columns names. For example, the following request...
|
|
//
|
|
// Book.filter(Column("kind") == Book.Kind.novel)
|
|
// .including(optional: Book.author)
|
|
// .including(optional: Book.translator)
|
|
// .annotated(with: Book.awards.count)
|
|
//
|
|
// ... generates the following SQL, where all identifiers are correctly
|
|
// disambiguated and qualified:
|
|
//
|
|
// SELECT book.*, person1.*, person2.*, COUNT(DISTINCT award.id)
|
|
// FROM book
|
|
// LEFT JOIN person person1 ON person1.id = book.authorId
|
|
// LEFT JOIN person person2 ON person2.id = book.translatorId
|
|
// LEFT JOIN award ON award.bookId = book.id
|
|
// GROUP BY book.id
|
|
// WHERE book.kind = 'novel'
|
|
relation = SQLQualifiedRelation(query.relation)
|
|
|
|
// Qualify group expressions and having clause with the relation alias.
|
|
//
|
|
// This turns `GROUP BY id` INTO `GROUP BY book.id`, and
|
|
// `HAVING MAX(year) < 2000` INTO `HAVING MAX(book.year) < 2000`.
|
|
let alias = relation.alias
|
|
groupPromise = query.groupPromise?.map { [alias] in $0.map { $0.qualifiedExpression(with: alias) } }
|
|
havingExpressions = query.havingExpressions.map { $0.qualifiedExpression(with: alias) }
|
|
|
|
// Preserve other flags
|
|
isDistinct = query.isDistinct
|
|
limit = query.limit
|
|
}
|
|
|
|
func sql(_ db: Database, _ context: inout SQLGenerationContext) throws -> String {
|
|
var sql = "SELECT"
|
|
|
|
if isDistinct {
|
|
sql += " DISTINCT"
|
|
}
|
|
|
|
let selection = relation.selection
|
|
GRDBPrecondition(!selection.isEmpty, "Can't generate SQL with empty selection")
|
|
sql += " " + selection.map { $0.resultColumnSQL(&context) }.joined(separator: ", ")
|
|
|
|
sql += " FROM "
|
|
sql += try relation.source.sql(db, &context)
|
|
|
|
for (_, join) in relation.joins {
|
|
sql += " "
|
|
sql += try join.sql(db, &context, leftAlias: relation.alias)
|
|
}
|
|
|
|
let filters = try relation.filtersPromise.resolve(db)
|
|
if filters.isEmpty == false {
|
|
sql += " WHERE "
|
|
sql += SQLExpressionAnd(filters).expressionSQL(&context, wrappedInParenthesis: false)
|
|
}
|
|
|
|
if let groupExpressions = try groupPromise?.resolve(db), !groupExpressions.isEmpty {
|
|
sql += " GROUP BY "
|
|
sql += groupExpressions
|
|
.map { $0.expressionSQL(&context, wrappedInParenthesis: false) }
|
|
.joined(separator: ", ")
|
|
}
|
|
|
|
if havingExpressions.isEmpty == false {
|
|
sql += " HAVING "
|
|
sql += SQLExpressionAnd(havingExpressions).expressionSQL(&context, wrappedInParenthesis: false)
|
|
}
|
|
|
|
let orderings = try relation.ordering.resolve(db)
|
|
if !orderings.isEmpty {
|
|
sql += " ORDER BY "
|
|
sql += orderings
|
|
.map { $0.orderingTermSQL(&context) }
|
|
.joined(separator: ", ")
|
|
}
|
|
|
|
if let limit = limit {
|
|
sql += " LIMIT "
|
|
sql += limit.sql
|
|
}
|
|
|
|
return sql
|
|
}
|
|
|
|
func prepare(_ db: Database) throws -> (SelectStatement, RowAdapter?) {
|
|
return try (makeSelectStatement(db), rowAdapter(db))
|
|
}
|
|
|
|
private func optimizedDatabaseRegion(_ db: Database, _ databaseRegion: DatabaseRegion) throws -> DatabaseRegion {
|
|
// Can we intersect the region with rowIds?
|
|
//
|
|
// Give up unless request feeds from a single database table
|
|
guard case .table(tableName: let tableName, alias: _) = relation.source else {
|
|
// TODO: try harder
|
|
return databaseRegion
|
|
}
|
|
|
|
// Give up unless primary key is rowId
|
|
let primaryKeyInfo = try db.primaryKey(tableName)
|
|
guard primaryKeyInfo.isRowID else {
|
|
return databaseRegion
|
|
}
|
|
|
|
// The filters knows better
|
|
let filters = try relation.filtersPromise.resolve(db)
|
|
guard let rowIds = SQLExpressionAnd(filters).matchedRowIds(rowIdName: primaryKeyInfo.rowIDColumn) else {
|
|
return databaseRegion
|
|
}
|
|
|
|
// Database regions are case-insensitive: use the canonical table name
|
|
let canonicalTableName = try db.canonicalTableName(tableName)
|
|
return databaseRegion.tableIntersection(canonicalTableName, rowIds: rowIds)
|
|
}
|
|
|
|
func makeDeleteStatement(_ db: Database) throws -> UpdateStatement {
|
|
if let groupExpressions = try groupPromise?.resolve(db), !groupExpressions.isEmpty {
|
|
// Programmer error
|
|
fatalError("Can't delete query with GROUP BY clause")
|
|
}
|
|
|
|
guard havingExpressions.isEmpty else {
|
|
// Programmer error
|
|
fatalError("Can't delete query with HAVING clause")
|
|
}
|
|
|
|
guard relation.joins.isEmpty else {
|
|
// Programmer error
|
|
fatalError("Can't delete query with JOIN clause")
|
|
}
|
|
|
|
guard case .table = relation.source else {
|
|
// Programmer error
|
|
fatalError("Can't delete without any database table")
|
|
}
|
|
|
|
var context = SQLGenerationContext.queryGenerationContext(aliases: relation.allAliases)
|
|
|
|
var sql = try "DELETE FROM " + relation.source.sql(db, &context)
|
|
|
|
let filters = try relation.filtersPromise.resolve(db)
|
|
if filters.isEmpty == false {
|
|
sql += " WHERE " + SQLExpressionAnd(filters).expressionSQL(&context, wrappedInParenthesis: false)
|
|
}
|
|
|
|
if let limit = limit {
|
|
let orderings = try relation.ordering.resolve(db)
|
|
if !orderings.isEmpty {
|
|
sql += " ORDER BY " + orderings.map { $0.orderingTermSQL(&context) }.joined(separator: ", ")
|
|
}
|
|
sql += " LIMIT " + limit.sql
|
|
}
|
|
|
|
let statement = try db.makeUpdateStatement(sql: sql)
|
|
statement.arguments = context.arguments!
|
|
return statement
|
|
}
|
|
|
|
/// Returns nil if assignments is empty
|
|
func makeUpdateStatement(_ db: Database, _ assignments: [ColumnAssignment]) throws -> UpdateStatement? {
|
|
if let groupExpressions = try groupPromise?.resolve(db), !groupExpressions.isEmpty {
|
|
// Programmer error
|
|
fatalError("Can't update query with GROUP BY clause")
|
|
}
|
|
|
|
guard havingExpressions.isEmpty else {
|
|
// Programmer error
|
|
fatalError("Can't update query with HAVING clause")
|
|
}
|
|
|
|
guard relation.joins.isEmpty else {
|
|
// Programmer error
|
|
fatalError("Can't update query with JOIN clause")
|
|
}
|
|
|
|
guard case .table = relation.source else {
|
|
// Programmer error
|
|
fatalError("Can't update without any database table")
|
|
}
|
|
|
|
if assignments.isEmpty {
|
|
return nil
|
|
}
|
|
|
|
var context = SQLGenerationContext.queryGenerationContext(aliases: relation.allAliases)
|
|
|
|
var sql = try "UPDATE " + relation.source.sql(db, &context)
|
|
|
|
let assignmentsSQL = assignments
|
|
.map({ assignment in
|
|
assignment.column.expressionSQL(&context, wrappedInParenthesis: false) +
|
|
" = " +
|
|
assignment.value.sqlExpression.expressionSQL(&context, wrappedInParenthesis: false)
|
|
})
|
|
.joined(separator: ", ")
|
|
sql += " SET " + assignmentsSQL
|
|
|
|
let filters = try relation.filtersPromise.resolve(db)
|
|
if filters.isEmpty == false {
|
|
sql += " WHERE " + SQLExpressionAnd(filters).expressionSQL(&context, wrappedInParenthesis: false)
|
|
}
|
|
|
|
if let limit = limit {
|
|
let orderings = try relation.ordering.resolve(db)
|
|
if !orderings.isEmpty {
|
|
sql += " ORDER BY " + orderings.map { $0.orderingTermSQL(&context) }.joined(separator: ", ")
|
|
}
|
|
sql += " LIMIT " + limit.sql
|
|
}
|
|
|
|
let statement = try db.makeUpdateStatement(sql: sql)
|
|
statement.arguments = context.arguments!
|
|
return statement
|
|
}
|
|
|
|
/// Returns a select statement
|
|
func makeSelectStatement(_ db: Database) throws -> SelectStatement {
|
|
// Build an SQK generation context with all aliases found in the query,
|
|
// so that we can disambiguate tables that are used several times with
|
|
// SQL aliases.
|
|
var context = SQLGenerationContext.queryGenerationContext(aliases: relation.allAliases)
|
|
|
|
// Generate SQL
|
|
let sql = try self.sql(db, &context)
|
|
|
|
// Compile & set arguments
|
|
let statement = try db.makeSelectStatement(sql: sql)
|
|
statement.arguments = context.arguments! // not nil for this kind of context
|
|
|
|
// Optimize databaseRegion
|
|
statement.databaseRegion = try optimizedDatabaseRegion(db, statement.databaseRegion)
|
|
return statement
|
|
}
|
|
|
|
/// Returns the row adapter which presents the fetched rows according to the
|
|
/// tree of joined relations.
|
|
///
|
|
/// The adapter is nil for queries without any included relation,
|
|
/// because the fetched rows don't need any processing:
|
|
///
|
|
/// // SELECT * FROM book
|
|
/// let request = Book.all()
|
|
/// for row in try Row.fetchAll(db, request) {
|
|
/// row // [id:1, title:"Moby-Dick"]
|
|
/// let book = Book(row: row)
|
|
/// }
|
|
///
|
|
/// But as soon as the selection includes columns of a included relation,
|
|
/// we need an adapter:
|
|
///
|
|
/// // SELECT book.*, author.* FROM book JOIN author ON author.id = book.authorId
|
|
/// let request = Book.including(required: Book.author)
|
|
/// for row in try Row.fetchAll(db, request) {
|
|
/// row // [id:1, title:"Moby-Dick"]
|
|
/// let book = Book(row: row)
|
|
///
|
|
/// row.scopes["author"] // [id:12, name:"Herman Melville"]
|
|
/// let author: Author = row["author"]
|
|
/// }
|
|
private func rowAdapter(_ db: Database) throws -> RowAdapter? {
|
|
return try relation.rowAdapter(db, fromIndex: 0)?.adapter
|
|
}
|
|
}
|
|
|
|
/// A "qualified" relation, where all tables are identified with a table alias.
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// | | | | | |
|
|
/// | | | | | • ordering
|
|
/// | | | | • filterPromise
|
|
/// | | | • joins
|
|
/// | | • alias
|
|
/// | • source
|
|
/// • fullSelection
|
|
private struct SQLQualifiedRelation {
|
|
/// The alias for the relation
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// |
|
|
/// • alias
|
|
let alias: TableAlias
|
|
|
|
/// All aliases, including aliases of joined relations
|
|
var allAliases: [TableAlias] {
|
|
var aliases = [alias]
|
|
for join in joins.values {
|
|
aliases.append(contentsOf: join.relation.allAliases)
|
|
}
|
|
aliases.append(contentsOf: source.allAliases)
|
|
return aliases
|
|
}
|
|
|
|
/// The source
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// |
|
|
/// • source
|
|
let source: SQLQualifiedSource
|
|
|
|
/// The selection, not including selection of joined relations
|
|
private let ownSelection: [SQLSelectable]
|
|
|
|
/// The full selection, including selection of joined relations
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// |
|
|
/// • fullSelection
|
|
var selection: [SQLSelectable] {
|
|
return joins.reduce(into: ownSelection) {
|
|
$0.append(contentsOf: $1.value.relation.selection)
|
|
}
|
|
}
|
|
|
|
/// The filtering clause
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// |
|
|
/// • filtersPromise
|
|
let filtersPromise: DatabasePromise<[SQLExpression]>
|
|
|
|
/// The ordering, not including ordering of joined relations
|
|
private let ownOrdering: SQLRelation.Ordering
|
|
|
|
/// The full ordering, including orderings of joined relations
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// |
|
|
/// • ordering
|
|
var ordering: SQLRelation.Ordering {
|
|
return joins.reduce(ownOrdering) {
|
|
$0.appending($1.value.relation.ordering)
|
|
}
|
|
}
|
|
|
|
/// The joins
|
|
///
|
|
/// SELECT ... FROM ... AS ... JOIN ... WHERE ... ORDER BY ...
|
|
/// |
|
|
/// • joins
|
|
let joins: OrderedDictionary<String, SQLQualifiedJoin>
|
|
|
|
init(_ relation: SQLRelation) {
|
|
// Qualify the source, so that it be disambiguated with an SQL alias
|
|
// if needed (when a select query uses the same table several times).
|
|
// This disambiguation job will be actually performed by
|
|
// SQLGenerationContext, when the SQLSelectQueryGenerator which owns
|
|
// this SQLQualifiedRelation generates SQL.
|
|
source = SQLQualifiedSource(relation.source)
|
|
let alias = source.alias
|
|
self.alias = alias
|
|
|
|
// Qualify all joins, selection, filter, and ordering, so that all
|
|
// identifiers can be correctly disambiguated and qualified.
|
|
joins = relation.children.compactMapValues { child -> SQLQualifiedJoin? in
|
|
let kind: SQLQualifiedJoin.Kind
|
|
switch child.kind {
|
|
case .oneRequired:
|
|
kind = .innerJoin
|
|
case .oneOptional:
|
|
kind = .leftJoin
|
|
case .allPrefetched, .allNotPrefetched:
|
|
// This relation child is not fetched with an SQL join.
|
|
return nil
|
|
}
|
|
|
|
return SQLQualifiedJoin(
|
|
kind: kind,
|
|
condition: child.condition,
|
|
relation: SQLQualifiedRelation(child.relation))
|
|
}
|
|
ownSelection = relation.selection.map { $0.qualifiedSelectable(with: alias) }
|
|
filtersPromise = relation.filtersPromise.map { [alias] in $0.map { $0.qualifiedExpression(with: alias) } }
|
|
ownOrdering = relation.ordering.qualified(with: alias)
|
|
}
|
|
|
|
/// See SQLQueryGenerator.rowAdapter(_:)
|
|
///
|
|
/// - parameter db: A database connection.
|
|
/// - parameter startIndex: The index of the leftmost selected column of
|
|
/// this relation in a full SQL query. `startIndex` is 0 for the relation
|
|
/// at the root of a SQLQueryGenerator (as opposed to the
|
|
/// joined relations).
|
|
/// - returns: An optional tuple made of a RowAdapter and the index past the
|
|
/// rightmost selected column of this relation. Nil is returned if this
|
|
/// relations does not need any row adapter.
|
|
func rowAdapter(_ db: Database, fromIndex startIndex: Int) throws -> (adapter: RowAdapter, endIndex: Int)? {
|
|
// Root relation && no join => no need for any adapter
|
|
if startIndex == 0 && joins.isEmpty {
|
|
return nil
|
|
}
|
|
|
|
// The number of columns in own selection. Columns selected by joined
|
|
// relations are appended after.
|
|
let selectionWidth = try ownSelection
|
|
.map { try $0.columnCount(db) }
|
|
.reduce(0, +)
|
|
|
|
// Recursively build adapters for each joined relation with a selection.
|
|
// Name them according to the join keys.
|
|
var endIndex = startIndex + selectionWidth
|
|
var scopes: [String: RowAdapter] = [:]
|
|
for (key, join) in joins {
|
|
if let (joinAdapter, joinEndIndex) = try join.relation.rowAdapter(db, fromIndex: endIndex) {
|
|
scopes[key] = joinAdapter
|
|
endIndex = joinEndIndex
|
|
}
|
|
}
|
|
|
|
// (Root relation || empty selection) && no included relation => no need for any adapter
|
|
if (startIndex == 0 || selectionWidth == 0) && scopes.isEmpty {
|
|
return nil
|
|
}
|
|
|
|
// Build a RangeRowAdapter extended with the adapters of joined relations.
|
|
//
|
|
// // SELECT book.*, author.* FROM book JOIN author ON author.id = book.authorId
|
|
// let request = Book.including(required: Book.author)
|
|
// for row in try Row.fetchAll(db, request) {
|
|
//
|
|
// The RangeRowAdapter hides the columns appended by joined relations:
|
|
//
|
|
// row // [id:1, title:"Moby-Dick"]
|
|
// let book = Book(row: row)
|
|
//
|
|
// Scopes give access to those joined relations:
|
|
//
|
|
// row.scopes["author"] // [id:12, name:"Herman Melville"]
|
|
// let author: Author = row["author"]
|
|
// }
|
|
let rangeAdapter = RangeRowAdapter(startIndex ..< (startIndex + selectionWidth))
|
|
let adapter = rangeAdapter.addingScopes(scopes)
|
|
|
|
return (adapter: adapter, endIndex: endIndex)
|
|
}
|
|
}
|
|
|
|
/// A "qualified" source, where all tables are identified with a table alias.
|
|
private enum SQLQualifiedSource {
|
|
case table(tableName: String, alias: TableAlias)
|
|
indirect case query(SQLQueryGenerator)
|
|
|
|
var alias: TableAlias {
|
|
switch self {
|
|
case .table(_, let alias):
|
|
return alias
|
|
case .query(let query):
|
|
return query.relation.alias
|
|
}
|
|
}
|
|
|
|
var allAliases: [TableAlias] {
|
|
switch self {
|
|
case .table(_, let alias):
|
|
return [alias]
|
|
case .query(let query):
|
|
return query.relation.allAliases
|
|
}
|
|
}
|
|
|
|
init(_ source: SQLSource) {
|
|
switch source {
|
|
case let .table(tableName, alias):
|
|
let alias = alias ?? TableAlias(tableName: tableName)
|
|
self = .table(tableName: tableName, alias: alias)
|
|
case let .query(query):
|
|
self = .query(SQLQueryGenerator(query))
|
|
}
|
|
}
|
|
|
|
func sql(_ db: Database, _ context: inout SQLGenerationContext) throws -> String {
|
|
switch self {
|
|
case let .table(tableName, alias):
|
|
if let aliasName = context.aliasName(for: alias) {
|
|
return "\(tableName.quotedDatabaseIdentifier) \(aliasName.quotedDatabaseIdentifier)"
|
|
} else {
|
|
return "\(tableName.quotedDatabaseIdentifier)"
|
|
}
|
|
case let .query(query):
|
|
return try "(\(query.sql(db, &context)))"
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A "qualified" join, where all tables are identified with a table alias.
|
|
private struct SQLQualifiedJoin {
|
|
enum Kind: String {
|
|
case leftJoin = "LEFT JOIN"
|
|
case innerJoin = "JOIN"
|
|
}
|
|
|
|
let kind: Kind
|
|
let condition: SQLAssociationCondition
|
|
let relation: SQLQualifiedRelation
|
|
|
|
func sql(_ db: Database, _ context: inout SQLGenerationContext, leftAlias: TableAlias) throws -> String {
|
|
return try sql(db, &context, leftAlias: leftAlias, allowingInnerJoin: true)
|
|
}
|
|
|
|
private func sql(
|
|
_ db: Database,
|
|
_ context: inout SQLGenerationContext,
|
|
leftAlias: TableAlias,
|
|
allowingInnerJoin allowsInnerJoin: Bool)
|
|
throws -> String
|
|
{
|
|
var allowsInnerJoin = allowsInnerJoin
|
|
var sql = ""
|
|
|
|
switch self.kind {
|
|
case .innerJoin:
|
|
guard allowsInnerJoin else {
|
|
// TODO: chainOptionalRequired
|
|
//
|
|
// When we eventually implement this, make sure we both support:
|
|
// - joining(optional: assoc.joining(required: ...))
|
|
// - having(assoc.joining(required: ...).isEmpty)
|
|
fatalError("Not implemented: chaining a required association behind an optional association")
|
|
}
|
|
case .leftJoin:
|
|
allowsInnerJoin = false
|
|
}
|
|
sql += try "\(kind.rawValue) \(relation.source.sql(db, &context))"
|
|
|
|
let rightAlias = relation.alias
|
|
let filters = try condition.expressions(db, leftAlias: leftAlias, rightAlias: rightAlias)
|
|
+ relation.filtersPromise.resolve(db)
|
|
if filters.isEmpty == false {
|
|
sql += " ON \(SQLExpressionAnd(filters).expressionSQL(&context, wrappedInParenthesis: false))"
|
|
}
|
|
|
|
for (_, join) in relation.joins {
|
|
sql += try " \(join.sql(db, &context, leftAlias: rightAlias, allowingInnerJoin: allowsInnerJoin))"
|
|
}
|
|
|
|
return sql
|
|
}
|
|
}
|