mirror of
https://github.com/groue/GRDB.swift
synced 2026-11-22 04:00:39 +00:00
1922 lines
68 KiB
Swift
1922 lines
68 KiB
Swift
import Foundation
|
|
|
|
/// A database row.
|
|
public final class Row: Equatable, Hashable, RandomAccessCollection,
|
|
ExpressibleByDictionaryLiteral, CustomStringConvertible,
|
|
CustomDebugStringConvertible
|
|
{
|
|
// It is not a violation of the Demeter law when another type uses this
|
|
// property, which is exposed for optimizations.
|
|
let impl: RowImpl
|
|
|
|
/// Unless we are producing a row array, we use a single row when iterating
|
|
/// a statement:
|
|
///
|
|
/// let rows = try Row.fetchCursor(db, sql: "SELECT ...")
|
|
/// let players = try Player.fetchAll(db, sql: "SELECT ...")
|
|
@usableFromInline let statement: SelectStatement?
|
|
@usableFromInline let sqliteStatement: SQLiteStatement?
|
|
|
|
/// The number of columns in the row.
|
|
public let count: Int
|
|
|
|
/// A view on the prefetched associated rows.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Author.including(all: Author.books)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(row)
|
|
/// // Prints [id:1 name:"Herman Melville"]
|
|
///
|
|
/// let bookRows = row.prefetchedRows["books"]
|
|
/// print(bookRows[0])
|
|
/// // Prints [id:42 title:"Moby-Dick"]
|
|
public internal(set) var prefetchedRows = PrefetchedRowsView()
|
|
|
|
// MARK: - Building rows
|
|
|
|
/// Creates an empty row.
|
|
public convenience init() {
|
|
self.init(impl: EmptyRowImpl())
|
|
}
|
|
|
|
/// Creates a row from a dictionary of values.
|
|
public convenience init(_ dictionary: [String: DatabaseValueConvertible?]) {
|
|
self.init(impl: ArrayRowImpl(columns: dictionary.map { ($0, $1?.databaseValue ?? .null) }))
|
|
}
|
|
|
|
/// Creates a row from [AnyHashable: Any].
|
|
///
|
|
/// The result is nil unless all dictionary keys are strings, and values
|
|
/// adopt DatabaseValueConvertible.
|
|
public convenience init?(_ dictionary: [AnyHashable: Any]) {
|
|
var initDictionary = [String: DatabaseValueConvertible?]()
|
|
for (key, value) in dictionary {
|
|
guard let columnName = key as? String else {
|
|
return nil
|
|
}
|
|
guard let dbValue = DatabaseValue(value: value) else {
|
|
return nil
|
|
}
|
|
initDictionary[columnName] = dbValue
|
|
}
|
|
self.init(initDictionary)
|
|
}
|
|
|
|
// ExpressibleByDictionaryLiteral
|
|
/// Creates a row initialized with elements. Column order is preserved, and
|
|
/// duplicated columns names are allowed.
|
|
///
|
|
/// let row: Row = ["foo": 1, "foo": "bar", "baz": nil]
|
|
/// print(row)
|
|
/// // Prints [foo:1 foo:"bar" baz:NULL]
|
|
public convenience init(dictionaryLiteral elements: (String, DatabaseValueConvertible?)...) {
|
|
self.init(impl: ArrayRowImpl(columns: elements.map { ($0, $1?.databaseValue ?? .null) }))
|
|
}
|
|
|
|
/// Returns an immutable copy of the row.
|
|
///
|
|
/// For performance reasons, rows fetched from a cursor are reused during
|
|
/// the iteration of a query: make sure to make a copy of it whenever you
|
|
/// want to keep a specific one: `row.copy()`.
|
|
public func copy() -> Row {
|
|
impl.copiedRow(self)
|
|
}
|
|
|
|
// MARK: - Not Public
|
|
|
|
/// Returns true if and only if the row was fetched from a database.
|
|
var isFetched: Bool { impl.isFetched }
|
|
|
|
/// Creates a row that maps an SQLite statement. Further calls to
|
|
/// sqlite3_step() modify the row.
|
|
///
|
|
/// The row is implemented on top of StatementRowImpl, which grants *direct*
|
|
/// access to the SQLite statement. Iteration of the statement does modify
|
|
/// the row.
|
|
init(statement: SelectStatement) {
|
|
self.statement = statement
|
|
self.sqliteStatement = statement.sqliteStatement
|
|
self.impl = StatementRowImpl(sqliteStatement: statement.sqliteStatement, statement: statement)
|
|
self.count = Int(sqlite3_column_count(sqliteStatement))
|
|
}
|
|
|
|
/// Creates a row that maps an SQLite statement. Further calls to
|
|
/// sqlite3_step() modify the row.
|
|
init(sqliteStatement: SQLiteStatement) {
|
|
self.statement = nil
|
|
self.sqliteStatement = sqliteStatement
|
|
self.impl = SQLiteStatementRowImpl(sqliteStatement: sqliteStatement)
|
|
self.count = Int(sqlite3_column_count(sqliteStatement))
|
|
}
|
|
|
|
/// Creates a row that contain a copy of the current state of the
|
|
/// SQLite statement. Further calls to sqlite3_step() do not modify the row.
|
|
///
|
|
/// The row is implemented on top of StatementCopyRowImpl, which *copies*
|
|
/// the values from the SQLite statement so that further iteration of the
|
|
/// statement does not modify the row.
|
|
convenience init(
|
|
copiedFromSQLiteStatement sqliteStatement: SQLiteStatement,
|
|
statement: SelectStatement)
|
|
{
|
|
self.init(impl: StatementCopyRowImpl(
|
|
sqliteStatement: sqliteStatement,
|
|
columnNames: statement.columnNames))
|
|
}
|
|
|
|
init(impl: RowImpl) {
|
|
self.statement = nil
|
|
self.sqliteStatement = nil
|
|
self.impl = impl
|
|
self.count = impl.count
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Columns
|
|
|
|
/// The names of columns in the row.
|
|
///
|
|
/// Columns appear in the same order as they occur as the `.0` member
|
|
/// of column-value pairs in `self`.
|
|
public var columnNames: LazyMapCollection<Row, String> {
|
|
lazy.map { $0.0 }
|
|
}
|
|
|
|
/// Returns true if and only if the row has that column.
|
|
///
|
|
/// This method is case-insensitive.
|
|
public func hasColumn(_ columnName: String) -> Bool {
|
|
index(forColumn: columnName) != nil
|
|
}
|
|
|
|
@usableFromInline
|
|
func index(forColumn name: String) -> Int? {
|
|
impl.index(forColumn: name)
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Extracting Values
|
|
|
|
/// Fatal errors if index is out of bounds
|
|
@inlinable
|
|
func _checkIndex(_ index: Int, file: StaticString = #file, line: UInt = #line) {
|
|
GRDBPrecondition(index >= 0 && index < count, "row index out of range", file: file, line: line)
|
|
}
|
|
|
|
/// Returns true if and only if one column contains a non-null value, or if
|
|
/// the row was fetched with a row adapter that defines a scoped row that
|
|
/// contains a non-null value.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let row = try Row.fetchOne(db, sql: "SELECT 'foo', 1")!
|
|
/// row.containsNonNullValue // true
|
|
///
|
|
/// let row = try Row.fetchOne(db, sql: "SELECT NULL, NULL")!
|
|
/// row.containsNonNullValue // false
|
|
public var containsNonNullValue: Bool {
|
|
for i in (0..<count) where !impl.hasNull(atUncheckedIndex: i) {
|
|
return true
|
|
}
|
|
|
|
for (_, scopedRow) in scopes where scopedRow.containsNonNullValue {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
/// Returns true if the row contains null at given index.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
///
|
|
/// This method is equivalent to `row[index] == nil`, but may be preferred
|
|
/// in performance-critical code because it can avoid decoding database
|
|
/// values.
|
|
public func hasNull(atIndex index: Int) -> Bool {
|
|
_checkIndex(index)
|
|
return impl.hasNull(atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns Int64, Double, String, Data or nil, depending on the value
|
|
/// stored at the given index.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
public subscript(_ index: Int) -> DatabaseValueConvertible? {
|
|
_checkIndex(index)
|
|
return impl.databaseValue(atUncheckedIndex: index).storage.value
|
|
}
|
|
|
|
/// Returns the value at given index, converted to the requested type.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
///
|
|
/// If the SQLite value is NULL, the result is nil. Otherwise the SQLite
|
|
/// value is converted to the requested type `Value`. Should this conversion
|
|
/// fail, a fatal error is raised.
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible>(_ index: Int) -> Value? {
|
|
_checkIndex(index)
|
|
return Value.decodeIfPresent(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the value at given index, converted to the requested type.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
///
|
|
/// If the SQLite value is NULL, the result is nil. Otherwise the SQLite
|
|
/// value is converted to the requested type `Value`. Should this conversion
|
|
/// fail, a fatal error is raised.
|
|
///
|
|
/// This method exists as an optimization opportunity for types that adopt
|
|
/// StatementColumnConvertible. It *may* trigger SQLite built-in conversions
|
|
/// (see https://www.sqlite.org/datatype3.html).
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible & StatementColumnConvertible>(_ index: Int) -> Value? {
|
|
_checkIndex(index)
|
|
return Value.fastDecodeIfPresent(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the value at given index, converted to the requested type.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
///
|
|
/// This method crashes if the fetched SQLite value is NULL, or if the
|
|
/// SQLite value can not be converted to `Value`.
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible>(_ index: Int) -> Value {
|
|
_checkIndex(index)
|
|
return Value.decode(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the value at given index, converted to the requested type.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
///
|
|
/// This method crashes if the fetched SQLite value is NULL, or if the
|
|
/// SQLite value can not be converted to `Value`.
|
|
///
|
|
/// This method exists as an optimization opportunity for types that adopt
|
|
/// StatementColumnConvertible. It *may* trigger SQLite built-in conversions
|
|
/// (see https://www.sqlite.org/datatype3.html).
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible & StatementColumnConvertible>(_ index: Int) -> Value {
|
|
_checkIndex(index)
|
|
return Value.fastDecode(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns Int64, Double, String, Data or nil, depending on the value
|
|
/// stored at the given column.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// The result is nil if the row does not contain the column.
|
|
public subscript(_ columnName: String) -> DatabaseValueConvertible? {
|
|
// IMPLEMENTATION NOTE
|
|
// This method has a single know use case: checking if the value is nil,
|
|
// as in:
|
|
//
|
|
// if row["foo"] != nil { ... }
|
|
//
|
|
// Without this method, the code above would not compile.
|
|
guard let index = index(forColumn: columnName) else {
|
|
return nil
|
|
}
|
|
return impl.databaseValue(atUncheckedIndex: index).storage.value
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the column is missing or if the SQLite value is NULL, the result is
|
|
/// nil. Otherwise the SQLite value is converted to the requested type
|
|
/// `Value`. Should this conversion fail, a fatal error is raised.
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible>(_ columnName: String) -> Value? {
|
|
guard let index = index(forColumn: columnName) else {
|
|
return nil
|
|
}
|
|
return Value.decodeIfPresent(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the column is missing or if the SQLite value is NULL, the result is
|
|
/// nil. Otherwise the SQLite value is converted to the requested type
|
|
/// `Value`. Should this conversion fail, a fatal error is raised.
|
|
///
|
|
/// This method exists as an optimization opportunity for types that adopt
|
|
/// StatementColumnConvertible. It *may* trigger SQLite built-in conversions
|
|
/// (see https://www.sqlite.org/datatype3.html).
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible & StatementColumnConvertible>(_ columnName: String) -> Value? {
|
|
guard let index = index(forColumn: columnName) else {
|
|
return nil
|
|
}
|
|
return Value.fastDecodeIfPresent(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the row does not contain the column, a fatal error is raised.
|
|
///
|
|
/// This method crashes if the fetched SQLite value is NULL, or if the
|
|
/// SQLite value can not be converted to `Value`.
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible>(_ columnName: String) -> Value {
|
|
guard let index = index(forColumn: columnName) else {
|
|
// No such column
|
|
fatalConversionError(to: Value.self, from: nil, in: self, atColumn: columnName)
|
|
}
|
|
return Value.decode(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the row does not contain the column, a fatal error is raised.
|
|
///
|
|
/// This method crashes if the fetched SQLite value is NULL, or if the
|
|
/// SQLite value can not be converted to `Value`.
|
|
///
|
|
/// This method exists as an optimization opportunity for types that adopt
|
|
/// StatementColumnConvertible. It *may* trigger SQLite built-in conversions
|
|
/// (see https://www.sqlite.org/datatype3.html).
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible & StatementColumnConvertible>(_ columnName: String) -> Value {
|
|
guard let index = index(forColumn: columnName) else {
|
|
// No such column
|
|
fatalConversionError(to: Value.self, from: nil, in: self, atColumn: columnName)
|
|
}
|
|
return Value.fastDecode(from: self, atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns Int64, Double, String, NSData or nil, depending on the value
|
|
/// stored at the given column.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// The result is nil if the row does not contain the column.
|
|
@inlinable
|
|
public subscript<Column: ColumnExpression>(_ column: Column) -> DatabaseValueConvertible? {
|
|
self[column.name]
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the column is missing or if the SQLite value is NULL, the result is
|
|
/// nil. Otherwise the SQLite value is converted to the requested type
|
|
/// `Value`. Should this conversion fail, a fatal error is raised.
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible, Column: ColumnExpression>(_ column: Column) -> Value? {
|
|
self[column.name]
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the column is missing or if the SQLite value is NULL, the result is
|
|
/// nil. Otherwise the SQLite value is converted to the requested type
|
|
/// `Value`. Should this conversion fail, a fatal error is raised.
|
|
///
|
|
/// This method exists as an optimization opportunity for types that adopt
|
|
/// StatementColumnConvertible. It *may* trigger SQLite built-in conversions
|
|
/// (see https://www.sqlite.org/datatype3.html).
|
|
@inlinable
|
|
public subscript<Value, Column>(_ column: Column)
|
|
-> Value?
|
|
where
|
|
Value: DatabaseValueConvertible & StatementColumnConvertible,
|
|
Column: ColumnExpression
|
|
{
|
|
self[column.name]
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the row does not contain the column, a fatal error is raised.
|
|
///
|
|
/// This method crashes if the fetched SQLite value is NULL, or if the
|
|
/// SQLite value can not be converted to `Value`.
|
|
@inlinable
|
|
public subscript<Value: DatabaseValueConvertible, Column: ColumnExpression>(_ column: Column) -> Value {
|
|
self[column.name]
|
|
}
|
|
|
|
/// Returns the value at given column, converted to the requested type.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the row does not contain the column, a fatal error is raised.
|
|
///
|
|
/// This method crashes if the fetched SQLite value is NULL, or if the
|
|
/// SQLite value can not be converted to `Value`.
|
|
///
|
|
/// This method exists as an optimization opportunity for types that adopt
|
|
/// StatementColumnConvertible. It *may* trigger SQLite built-in conversions
|
|
/// (see https://www.sqlite.org/datatype3.html).
|
|
@inlinable
|
|
public subscript<Value, Column>(_ column: Column)
|
|
-> Value
|
|
where
|
|
Value: DatabaseValueConvertible & StatementColumnConvertible,
|
|
Column: ColumnExpression
|
|
{
|
|
self[column.name]
|
|
}
|
|
|
|
/// Returns the optional Data at given index.
|
|
///
|
|
/// Indexes span from 0 for the leftmost column to (row.count - 1) for the
|
|
/// righmost column.
|
|
///
|
|
/// If the SQLite value is NULL, the result is nil. If the SQLite value can
|
|
/// not be converted to Data, a fatal error is raised.
|
|
///
|
|
/// The returned data does not owns its bytes: it must not be used longer
|
|
/// than the row's lifetime.
|
|
public func dataNoCopy(atIndex index: Int) -> Data? {
|
|
_checkIndex(index)
|
|
return impl.dataNoCopy(atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the optional Data at given column.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the column is missing or if the SQLite value is NULL, the result is
|
|
/// nil. If the SQLite value can not be converted to Data, a fatal error
|
|
/// is raised.
|
|
///
|
|
/// The returned data does not owns its bytes: it must not be used longer
|
|
/// than the row's lifetime.
|
|
public func dataNoCopy(named columnName: String) -> Data? {
|
|
guard let index = index(forColumn: columnName) else {
|
|
return nil
|
|
}
|
|
return impl.dataNoCopy(atUncheckedIndex: index)
|
|
}
|
|
|
|
/// Returns the optional `NSData` at given column.
|
|
///
|
|
/// Column name lookup is case-insensitive, and when several columns have
|
|
/// the same name, the leftmost column is considered.
|
|
///
|
|
/// If the column is missing or if the SQLite value is NULL, the result is
|
|
/// nil. If the SQLite value can not be converted to NSData, a fatal error
|
|
/// is raised.
|
|
///
|
|
/// The returned data does not owns its bytes: it must not be used longer
|
|
/// than the row's lifetime.
|
|
public func dataNoCopy<Column: ColumnExpression>(_ column: Column) -> Data? {
|
|
dataNoCopy(named: column.name)
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Extracting DatabaseValue
|
|
|
|
/// The database values in the row.
|
|
///
|
|
/// Values appear in the same order as they occur as the `.1` member
|
|
/// of column-value pairs in `self`.
|
|
public var databaseValues: LazyMapCollection<Row, DatabaseValue> {
|
|
lazy.map { $0.1 }
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Extracting Records
|
|
|
|
/// Returns the record associated with the given scope.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Book.including(required: Book.author)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(Book(row: row).title)
|
|
/// // Prints "Moby-Dick"
|
|
///
|
|
/// let author: Author = row["author"]
|
|
/// print(author.name)
|
|
/// // Prints "Herman Melville"
|
|
///
|
|
/// Associated records stored in nested associations are available, too:
|
|
///
|
|
/// let request = Book.including(required: Book.author.including(required: Author.country))
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(Book(row: row).title)
|
|
/// // Prints "Moby-Dick"
|
|
///
|
|
/// let country: Country = row["country"]
|
|
/// print(country.name)
|
|
/// // Prints "United States"
|
|
///
|
|
/// A fatal error is raised if the scope is not available, or contains only
|
|
/// null values.
|
|
///
|
|
/// See https://github.com/groue/GRDB.swift/blob/master/README.md#joined-queries-support
|
|
/// for more information.
|
|
public subscript<Record: FetchableRecord>(_ scope: String) -> Record {
|
|
guard let scopedRow = scopesTree[scope] else {
|
|
// Programmer error
|
|
let names = scopesTree.names
|
|
if names.isEmpty {
|
|
fatalError("missing scope `\(scope)` (row: \(self))")
|
|
} else {
|
|
fatalError("missing scope `\(scope)` (row: \(self), available scopes: \(names.sorted()))")
|
|
}
|
|
}
|
|
guard scopedRow.containsNonNullValue else {
|
|
// Programmer error
|
|
fatalError("scope `\(scope)` only contains null values (row: \(self))")
|
|
}
|
|
return Record(row: scopedRow)
|
|
}
|
|
|
|
/// Returns the eventual record associated with the given scope.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Book.including(optional: Book.author)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(Book(row: row).title)
|
|
/// // Prints "Moby-Dick"
|
|
///
|
|
/// let author: Author? = row["author"]
|
|
/// print(author.name)
|
|
/// // Prints "Herman Melville"
|
|
///
|
|
/// Associated records stored in nested associations are available, too:
|
|
///
|
|
/// let request = Book.including(optional: Book.author.including(optional: Author.country))
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(Book(row: row).title)
|
|
/// // Prints "Moby-Dick"
|
|
///
|
|
/// let country: Country? = row["country"]
|
|
/// print(country.name)
|
|
/// // Prints "United States"
|
|
///
|
|
/// Nil is returned if the scope is not available, or contains only
|
|
/// null values.
|
|
///
|
|
/// See https://github.com/groue/GRDB.swift/blob/master/README.md#joined-queries-support
|
|
/// for more information.
|
|
public subscript<Record: FetchableRecord>(_ scope: String) -> Record? {
|
|
guard let scopedRow = scopesTree[scope], scopedRow.containsNonNullValue else {
|
|
return nil
|
|
}
|
|
return Record(row: scopedRow)
|
|
}
|
|
|
|
/// Returns the records encoded in the given prefetched rows.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Author.including(all: Author.books)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(Author(row: row).name)
|
|
/// // Prints "Herman Melville"
|
|
///
|
|
/// let books: [Book] = row["books"]
|
|
/// print(books[0].title)
|
|
/// // Prints "Moby-Dick"
|
|
public subscript<Collection>(_ key: String)
|
|
-> Collection
|
|
where
|
|
Collection: RangeReplaceableCollection,
|
|
Collection.Element: FetchableRecord
|
|
{
|
|
guard let rows = prefetchedRows[key] else {
|
|
// Programmer error
|
|
let keys = prefetchedRows.keys
|
|
if keys.isEmpty {
|
|
fatalError("missing key for prefetched rows `\(key)` (row: \(self))")
|
|
} else {
|
|
fatalError("missing key for prefetched rows `\(key)` (row: \(self), available keys: \(keys.sorted()))")
|
|
}
|
|
}
|
|
var collection = Collection()
|
|
collection.reserveCapacity(rows.count)
|
|
for row in rows {
|
|
collection.append(Collection.Element(row: row))
|
|
}
|
|
return collection
|
|
}
|
|
|
|
/// Returns the set of records encoded in the given prefetched rows.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Author.including(all: Author.books)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(Author(row: row).name)
|
|
/// // Prints "Herman Melville"
|
|
///
|
|
/// let books: Set<Book> = row["books"]
|
|
/// print(books.first!.title)
|
|
/// // Prints "Moby-Dick"
|
|
public subscript<Record: FetchableRecord & Hashable>(_ key: String) -> Set<Record> {
|
|
guard let rows = prefetchedRows[key] else {
|
|
// Programmer error
|
|
let keys = prefetchedRows.keys
|
|
if keys.isEmpty {
|
|
fatalError("missing key for prefetched rows `\(key)` (row: \(self))")
|
|
} else {
|
|
fatalError("missing key for prefetched rows `\(key)` (row: \(self), available keys: \(keys.sorted()))")
|
|
}
|
|
}
|
|
var set = Set<Record>(minimumCapacity: rows.count)
|
|
for row in rows {
|
|
set.insert(Record(row: row))
|
|
}
|
|
return set
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Scopes
|
|
|
|
/// Returns a view on the scopes defined by row adapters.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// // Define a tree of nested scopes
|
|
/// let adapter = ScopeAdapter([
|
|
/// "foo": RangeRowAdapter(0..<1),
|
|
/// "bar": RangeRowAdapter(1..<2).addingScopes([
|
|
/// "baz" : RangeRowAdapter(2..<3)])])
|
|
///
|
|
/// // Fetch
|
|
/// let sql = "SELECT 1 AS foo, 2 AS bar, 3 AS baz"
|
|
/// let row = try Row.fetchOne(db, sql: sql, adapter: adapter)!
|
|
///
|
|
/// row.scopes.count // 2
|
|
/// row.scopes.names // ["foo", "bar"]
|
|
///
|
|
/// row.scopes["foo"] // [foo:1]
|
|
/// row.scopes["bar"] // [bar:2]
|
|
/// row.scopes["baz"] // nil
|
|
public var scopes: ScopesView {
|
|
impl.scopes(prefetchedRows: prefetchedRows)
|
|
}
|
|
|
|
/// Returns a view on the scopes tree defined by row adapters.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// // Define a tree of nested scopes
|
|
/// let adapter = ScopeAdapter([
|
|
/// "foo": RangeRowAdapter(0..<1),
|
|
/// "bar": RangeRowAdapter(1..<2).addingScopes([
|
|
/// "baz" : RangeRowAdapter(2..<3)])])
|
|
///
|
|
/// // Fetch
|
|
/// let sql = "SELECT 1 AS foo, 2 AS bar, 3 AS baz"
|
|
/// let row = try Row.fetchOne(db, sql: sql, adapter: adapter)!
|
|
///
|
|
/// row.scopesTree.names // ["foo", "bar", "baz"]
|
|
///
|
|
/// row.scopesTree["foo"] // [foo:1]
|
|
/// row.scopesTree["bar"] // [bar:2]
|
|
/// row.scopesTree["baz"] // [baz:3]
|
|
public var scopesTree: ScopesTreeView {
|
|
ScopesTreeView(scopes: scopes)
|
|
}
|
|
|
|
/// Returns a copy of the row, without any scopes.
|
|
///
|
|
/// This property can turn out useful when you want to test the content of
|
|
/// adapted rows, such as rows fetched from joined requests.
|
|
///
|
|
/// let row = ...
|
|
/// // Failure because row equality tests for row scopes:
|
|
/// XCTAssertEqual(row, ["id": 1, "name": "foo"])
|
|
/// // Success:
|
|
/// XCTAssertEqual(row.unscoped, ["id": 1, "name": "foo"])
|
|
public var unscoped: Row {
|
|
var row = impl.unscopedRow(self)
|
|
|
|
// Remove prefetchedRows
|
|
if row.prefetchedRows.isEmpty == false {
|
|
// Make sure we build another Row instance
|
|
row = Row(impl: row.copy().impl)
|
|
assert(row !== self)
|
|
assert(row.prefetchedRows.isEmpty)
|
|
}
|
|
return row
|
|
}
|
|
|
|
/// Return the raw row fetched from the database.
|
|
///
|
|
/// This property can turn out useful when you debug the consumption of
|
|
/// adapted rows, such as rows fetched from joined requests.
|
|
public var unadapted: Row {
|
|
impl.unadaptedRow(self)
|
|
}
|
|
}
|
|
|
|
// MARK: - RowCursor
|
|
|
|
/// A cursor of database rows. For example:
|
|
///
|
|
/// try dbQueue.read { db in
|
|
/// let rows: RowCursor = try Row.fetchCursor(db, sql: "SELECT * FROM player")
|
|
/// }
|
|
public final class RowCursor: Cursor {
|
|
/// The statement iterated by this cursor
|
|
public let statement: SelectStatement
|
|
@usableFromInline let _sqliteStatement: SQLiteStatement
|
|
@usableFromInline let _row: Row // Reused for performance
|
|
@usableFromInline var _done = false
|
|
|
|
init(statement: SelectStatement, arguments: StatementArguments? = nil, adapter: RowAdapter? = nil) throws {
|
|
self.statement = statement
|
|
self._row = try Row(statement: statement).adapted(with: adapter, layout: statement)
|
|
self._sqliteStatement = statement.sqliteStatement
|
|
statement.reset(withArguments: arguments)
|
|
|
|
// Assume cursor is created for iteration
|
|
try statement.database.selectStatementWillExecute(statement)
|
|
}
|
|
|
|
deinit {
|
|
// Statement reset fails when sqlite3_step has previously failed.
|
|
// Just ignore reset error.
|
|
try? statement.reset()
|
|
}
|
|
|
|
@inlinable
|
|
public func next() throws -> Row? {
|
|
if _done {
|
|
// make sure this instance never yields a value again, even if the
|
|
// statement is reset by another cursor.
|
|
return nil
|
|
}
|
|
switch sqlite3_step(_sqliteStatement) {
|
|
case SQLITE_DONE:
|
|
_done = true
|
|
return nil
|
|
case SQLITE_ROW:
|
|
return _row
|
|
case let code:
|
|
try statement.didFail(withResultCode: code)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Fetching From SelectStatement
|
|
|
|
/// Returns a cursor over rows fetched from a prepared statement.
|
|
///
|
|
/// let statement = try db.makeSelectStatement(sql: "SELECT ...")
|
|
/// let rows = try Row.fetchCursor(statement) // RowCursor
|
|
/// while let row = try rows.next() { // Row
|
|
/// let id: Int64 = row[0]
|
|
/// let name: String = row[1]
|
|
/// }
|
|
///
|
|
/// Fetched rows are reused during the cursor iteration: don't turn a row
|
|
/// cursor into an array with `Array(rows)` or `rows.filter { ... }` since
|
|
/// you would not get the distinct rows you expect. Use `Row.fetchAll(...)`
|
|
/// instead.
|
|
///
|
|
/// For the same reason, make sure you make a copy whenever you extract a
|
|
/// row for later use: `row.copy()`.
|
|
///
|
|
/// If the database is modified during the cursor iteration, the remaining
|
|
/// elements are undefined.
|
|
///
|
|
/// The cursor must be iterated in a protected dispatch queue.
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - sql: An SQL query.
|
|
/// - arguments: Optional statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: A cursor over fetched rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchCursor(
|
|
_ statement: SelectStatement,
|
|
arguments: StatementArguments? = nil,
|
|
adapter: RowAdapter? = nil)
|
|
throws -> RowCursor
|
|
{
|
|
try RowCursor(statement: statement, arguments: arguments, adapter: adapter)
|
|
}
|
|
|
|
/// Returns an array of rows fetched from a prepared statement.
|
|
///
|
|
/// let statement = try db.makeSelectStatement(sql: "SELECT ...")
|
|
/// let rows = try Row.fetchAll(statement)
|
|
///
|
|
/// - parameters:
|
|
/// - statement: The statement to run.
|
|
/// - arguments: Optional statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: An array of rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchAll(
|
|
_ statement: SelectStatement,
|
|
arguments: StatementArguments? = nil,
|
|
adapter: RowAdapter? = nil)
|
|
throws -> [Row]
|
|
{
|
|
// The cursor reuses a single mutable row. Return immutable copies.
|
|
return try Array(fetchCursor(statement, arguments: arguments, adapter: adapter).map { $0.copy() })
|
|
}
|
|
|
|
/// Returns a set of rows fetched from a prepared statement.
|
|
///
|
|
/// let statement = try db.makeSelectStatement(sql: "SELECT ...")
|
|
/// let rows = try Row.fetchSet(statement)
|
|
///
|
|
/// - parameters:
|
|
/// - statement: The statement to run.
|
|
/// - arguments: Optional statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: A set of rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchSet(
|
|
_ statement: SelectStatement,
|
|
arguments: StatementArguments? = nil,
|
|
adapter: RowAdapter? = nil)
|
|
throws -> Set<Row>
|
|
{
|
|
// The cursor reuses a single mutable row. Return immutable copies.
|
|
return try Set(fetchCursor(statement, arguments: arguments, adapter: adapter).map { $0.copy() })
|
|
}
|
|
|
|
/// Returns a single row fetched from a prepared statement.
|
|
///
|
|
/// let statement = try db.makeSelectStatement(sql: "SELECT ...")
|
|
/// let row = try Row.fetchOne(statement)
|
|
///
|
|
/// - parameters:
|
|
/// - statement: The statement to run.
|
|
/// - arguments: Optional statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: An optional row.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchOne(
|
|
_ statement: SelectStatement,
|
|
arguments: StatementArguments? = nil,
|
|
adapter: RowAdapter? = nil)
|
|
throws -> Row?
|
|
{
|
|
let cursor = try fetchCursor(statement, arguments: arguments, adapter: adapter)
|
|
// Keep cursor alive until we can copy the fetched row
|
|
return try withExtendedLifetime(cursor) {
|
|
try cursor.next().map { $0.copy() }
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Fetching From SQL
|
|
|
|
/// Returns a cursor over rows fetched from an SQL query.
|
|
///
|
|
/// let rows = try Row.fetchCursor(db, sql: "SELECT id, name FROM player") // RowCursor
|
|
/// while let row = try rows.next() { // Row
|
|
/// let id: Int64 = row[0]
|
|
/// let name: String = row[1]
|
|
/// }
|
|
///
|
|
/// Fetched rows are reused during the cursor iteration: don't turn a row
|
|
/// cursor into an array with `Array(rows)` or `rows.filter { ... }` since
|
|
/// you would not get the distinct rows you expect. Use `Row.fetchAll(...)`
|
|
/// instead.
|
|
///
|
|
/// For the same reason, make sure you make a copy whenever you extract a
|
|
/// row for later use: `row.copy()`.
|
|
///
|
|
/// If the database is modified during the cursor iteration, the remaining
|
|
/// elements are undefined.
|
|
///
|
|
/// The cursor must be iterated in a protected dispatch queue.
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - sql: An SQL query.
|
|
/// - arguments: Statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: A cursor over fetched rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchCursor(
|
|
_ db: Database,
|
|
sql: String,
|
|
arguments: StatementArguments = StatementArguments(),
|
|
adapter: RowAdapter? = nil)
|
|
throws -> RowCursor
|
|
{
|
|
try fetchCursor(db, SQLRequest<Void>(sql: sql, arguments: arguments, adapter: adapter))
|
|
}
|
|
|
|
/// Returns an array of rows fetched from an SQL query.
|
|
///
|
|
/// let rows = try Row.fetchAll(db, sql: "SELECT id, name FROM player") // [Row]
|
|
/// for row in rows {
|
|
/// let id: Int64 = row[0]
|
|
/// let name: String = row[1]
|
|
/// }
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - sql: An SQL query.
|
|
/// - arguments: Statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: An array of rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchAll(
|
|
_ db: Database,
|
|
sql: String,
|
|
arguments: StatementArguments = StatementArguments(),
|
|
adapter: RowAdapter? = nil)
|
|
throws -> [Row]
|
|
{
|
|
try fetchAll(db, SQLRequest<Void>(sql: sql, arguments: arguments, adapter: adapter))
|
|
}
|
|
|
|
/// Returns a set of rows fetched from an SQL query.
|
|
///
|
|
/// let rows = try Row.fetchSet(db, sql: "SELECT id, name FROM player") // Set<Row>
|
|
/// for row in rows {
|
|
/// let id: Int64 = row[0]
|
|
/// let name: String = row[1]
|
|
/// }
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - sql: An SQL query.
|
|
/// - arguments: Statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: A set of rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchSet(
|
|
_ db: Database,
|
|
sql: String,
|
|
arguments: StatementArguments = StatementArguments(),
|
|
adapter: RowAdapter? = nil)
|
|
throws -> Set<Row>
|
|
{
|
|
try fetchSet(db, SQLRequest<Void>(sql: sql, arguments: arguments, adapter: adapter))
|
|
}
|
|
|
|
/// Returns a single row fetched from an SQL query.
|
|
///
|
|
/// let row = try Row.fetchOne(db, sql: "SELECT id, name FROM player") // Row?
|
|
/// if let row = row {
|
|
/// let id: Int64 = row[0]
|
|
/// let name: String = row[1]
|
|
/// }
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - sql: An SQL query.
|
|
/// - arguments: Statement arguments.
|
|
/// - adapter: Optional RowAdapter
|
|
/// - returns: An optional row.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchOne(
|
|
_ db: Database,
|
|
sql: String,
|
|
arguments: StatementArguments = StatementArguments(),
|
|
adapter: RowAdapter? = nil)
|
|
throws -> Row?
|
|
{
|
|
try fetchOne(db, SQLRequest<Void>(sql: sql, arguments: arguments, adapter: adapter))
|
|
}
|
|
}
|
|
|
|
extension Row {
|
|
|
|
// MARK: - Fetching From FetchRequest
|
|
|
|
/// Returns a cursor over rows fetched from a fetch request.
|
|
///
|
|
/// let request = Player.all()
|
|
/// let rows = try Row.fetchCursor(db, request) // RowCursor
|
|
/// while let row = try rows.next() { // Row
|
|
/// let id: Int64 = row["id"]
|
|
/// let name: String = row["name"]
|
|
/// }
|
|
///
|
|
/// Fetched rows are reused during the cursor iteration: don't turn a row
|
|
/// cursor into an array with `Array(rows)` or `rows.filter { ... }` since
|
|
/// you would not get the distinct rows you expect. Use `Row.fetchAll(...)`
|
|
/// instead.
|
|
///
|
|
/// For the same reason, make sure you make a copy whenever you extract a
|
|
/// row for later use: `row.copy()`.
|
|
///
|
|
/// If the database is modified during the cursor iteration, the remaining
|
|
/// elements are undefined.
|
|
///
|
|
/// The cursor must be iterated in a protected dispatch queue.
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - request: A FetchRequest.
|
|
/// - returns: A cursor over fetched rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchCursor<R: FetchRequest>(_ db: Database, _ request: R) throws -> RowCursor {
|
|
let request = try request.makePreparedRequest(db, forSingleResult: false)
|
|
precondition(request.supplementaryFetch == nil, "Not implemented: fetchCursor with supplementary fetch")
|
|
return try fetchCursor(request.statement, adapter: request.adapter)
|
|
}
|
|
|
|
/// Returns an array of rows fetched from a fetch request.
|
|
///
|
|
/// let request = Player.all()
|
|
/// let rows = try Row.fetchAll(db, request)
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - request: A FetchRequest.
|
|
/// - returns: An array of rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchAll<R: FetchRequest>(_ db: Database, _ request: R) throws -> [Row] {
|
|
let request = try request.makePreparedRequest(db, forSingleResult: false)
|
|
let rows = try fetchAll(request.statement, adapter: request.adapter)
|
|
try request.supplementaryFetch?(db, rows)
|
|
return rows
|
|
}
|
|
|
|
/// Returns a set of rows fetched from a fetch request.
|
|
///
|
|
/// let request = Player.all()
|
|
/// let rows = try Row.fetchSet(db, request)
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - request: A FetchRequest.
|
|
/// - returns: A set of rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchSet<R: FetchRequest>(_ db: Database, _ request: R) throws -> Set<Row> {
|
|
let request = try request.makePreparedRequest(db, forSingleResult: false)
|
|
if let supplementaryFetch = request.supplementaryFetch {
|
|
let rows = try fetchAll(request.statement, adapter: request.adapter)
|
|
try supplementaryFetch(db, rows)
|
|
return Set(rows)
|
|
} else {
|
|
return try fetchSet(request.statement, adapter: request.adapter)
|
|
}
|
|
}
|
|
|
|
/// Returns a single row fetched from a fetch request.
|
|
///
|
|
/// let request = Player.filter(key: 1)
|
|
/// let row = try Row.fetchOne(db, request)
|
|
///
|
|
/// - parameters:
|
|
/// - db: A database connection.
|
|
/// - request: A FetchRequest.
|
|
/// - returns: An optional row.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public static func fetchOne<R: FetchRequest>(_ db: Database, _ request: R) throws -> Row? {
|
|
let request = try request.makePreparedRequest(db, forSingleResult: true)
|
|
guard let row = try fetchOne(request.statement, adapter: request.adapter) else {
|
|
return nil
|
|
}
|
|
try request.supplementaryFetch?(db, [row])
|
|
return row
|
|
}
|
|
}
|
|
|
|
extension FetchRequest where RowDecoder == Row {
|
|
|
|
// MARK: Fetching Rows
|
|
|
|
/// A cursor over fetched rows.
|
|
///
|
|
/// let request: ... // Some FetchRequest that fetches Row
|
|
/// let rows = try request.fetchCursor(db) // RowCursor
|
|
/// while let row = try rows.next() { // Row
|
|
/// let id: Int64 = row[0]
|
|
/// let name: String = row[1]
|
|
/// }
|
|
///
|
|
/// Fetched rows are reused during the cursor iteration: don't turn a row
|
|
/// cursor into an array with `Array(rows)` or `rows.filter { ... }` since
|
|
/// you would not get the distinct rows you expect. Use `Row.fetchAll(...)`
|
|
/// instead.
|
|
///
|
|
/// For the same reason, make sure you make a copy whenever you extract a
|
|
/// row for later use: `row.copy()`.
|
|
///
|
|
/// If the database is modified during the cursor iteration, the remaining
|
|
/// elements are undefined.
|
|
///
|
|
/// The cursor must be iterated in a protected dispatch queue.
|
|
///
|
|
/// - parameter db: A database connection.
|
|
/// - returns: A cursor over fetched rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public func fetchCursor(_ db: Database) throws -> RowCursor {
|
|
try Row.fetchCursor(db, self)
|
|
}
|
|
|
|
/// An array of fetched rows.
|
|
///
|
|
/// let request: ... // Some FetchRequest that fetches Row
|
|
/// let rows = try request.fetchAll(db)
|
|
///
|
|
/// - parameter db: A database connection.
|
|
/// - returns: An array of fetched rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public func fetchAll(_ db: Database) throws -> [Row] {
|
|
try Row.fetchAll(db, self)
|
|
}
|
|
|
|
/// A set of fetched rows.
|
|
///
|
|
/// let request: ... // Some FetchRequest that fetches Row
|
|
/// let rows = try request.fetchSet(db)
|
|
///
|
|
/// - parameter db: A database connection.
|
|
/// - returns: A set of fetched rows.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public func fetchSet(_ db: Database) throws -> Set<Row> {
|
|
try Row.fetchSet(db, self)
|
|
}
|
|
|
|
/// The first fetched row.
|
|
///
|
|
/// let request: ... // Some FetchRequest that fetches Row
|
|
/// let row = try request.fetchOne(db)
|
|
///
|
|
/// - parameter db: A database connection.
|
|
/// - returns: An optional row.
|
|
/// - throws: A DatabaseError is thrown whenever an SQLite error occurs.
|
|
public func fetchOne(_ db: Database) throws -> Row? {
|
|
try Row.fetchOne(db, self)
|
|
}
|
|
}
|
|
|
|
// RandomAccessCollection
|
|
extension Row {
|
|
|
|
// MARK: - Row as a Collection of (ColumnName, DatabaseValue) Pairs
|
|
|
|
/// The index of the first (ColumnName, DatabaseValue) pair.
|
|
/// :nodoc:
|
|
public var startIndex: RowIndex { RowIndex(0) }
|
|
|
|
/// The "past-the-end" index, successor of the index of the last
|
|
/// (ColumnName, DatabaseValue) pair.
|
|
/// :nodoc:
|
|
public var endIndex: RowIndex { RowIndex(count) }
|
|
|
|
/// Accesses the (ColumnName, DatabaseValue) pair at given index.
|
|
public subscript(position: RowIndex) -> (String, DatabaseValue) {
|
|
let index = position.index
|
|
_checkIndex(index)
|
|
return (
|
|
impl.columnName(atUncheckedIndex: index),
|
|
impl.databaseValue(atUncheckedIndex: index))
|
|
}
|
|
}
|
|
|
|
// Equatable
|
|
extension Row {
|
|
|
|
/// Returns true if and only if both rows have the same columns and values,
|
|
/// in the same order. Columns are compared in a case-sensitive way.
|
|
/// :nodoc:
|
|
public static func == (lhs: Row, rhs: Row) -> Bool {
|
|
if lhs === rhs {
|
|
return true
|
|
}
|
|
|
|
guard lhs.count == rhs.count else {
|
|
return false
|
|
}
|
|
|
|
for ((lcol, lval), (rcol, rval)) in zip(lhs, rhs) {
|
|
guard lcol == rcol else {
|
|
return false
|
|
}
|
|
guard lval == rval else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
let lscopeNames = lhs.scopes.names
|
|
let rscopeNames = rhs.scopes.names
|
|
guard lscopeNames == rscopeNames else {
|
|
return false
|
|
}
|
|
|
|
for name in lscopeNames {
|
|
let lscope = lhs.scopes[name]
|
|
let rscope = rhs.scopes[name]
|
|
guard lscope == rscope else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
guard lhs.prefetchedRows == rhs.prefetchedRows else {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
}
|
|
|
|
// Hashable
|
|
extension Row {
|
|
/// :nodoc:
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(count)
|
|
for (column, dbValue) in self {
|
|
hasher.combine(column)
|
|
hasher.combine(dbValue)
|
|
}
|
|
}
|
|
}
|
|
|
|
// CustomStringConvertible & CustomDebugStringConvertible
|
|
extension Row {
|
|
/// :nodoc:
|
|
public var description: String {
|
|
"["
|
|
+ map { (column, dbValue) in "\(column):\(dbValue)" }.joined(separator: " ")
|
|
+ "]"
|
|
}
|
|
|
|
/// :nodoc:
|
|
public var debugDescription: String {
|
|
debugDescription(level: 0)
|
|
}
|
|
|
|
private func debugDescription(level: Int) -> String {
|
|
if level == 0 && self == self.unadapted && prefetchedRows.prefetches.isEmpty {
|
|
return description
|
|
}
|
|
let prefix = repeatElement(" ", count: level + 1).joined()
|
|
var str = ""
|
|
if level == 0 {
|
|
str = "▿ " + description
|
|
let unadapted = self.unadapted
|
|
if self != unadapted {
|
|
str += "\n" + prefix + "unadapted: " + unadapted.description
|
|
}
|
|
} else {
|
|
str = description
|
|
}
|
|
for (name, scopedRow) in scopes.sorted(by: { $0.name < $1.name }) {
|
|
str += "\n" + prefix + "- " + name + ": " + scopedRow.debugDescription(level: level + 1)
|
|
}
|
|
for key in prefetchedRows.keys.sorted() {
|
|
let rows = prefetchedRows[key]!
|
|
let prefetchedRowsDescription: String
|
|
switch rows.count {
|
|
case 0:
|
|
prefetchedRowsDescription = "0 row"
|
|
case 1:
|
|
prefetchedRowsDescription = "1 row"
|
|
case let count:
|
|
prefetchedRowsDescription = "\(count) rows"
|
|
}
|
|
str += "\n" + prefix + "+ " + key + ": \(prefetchedRowsDescription)"
|
|
}
|
|
|
|
return str
|
|
}
|
|
}
|
|
|
|
|
|
// MARK: - RowIndex
|
|
|
|
/// Indexes to (ColumnName, DatabaseValue) pairs in a database row.
|
|
public struct RowIndex: Comparable, Strideable {
|
|
let index: Int
|
|
init(_ index: Int) { self.index = index }
|
|
}
|
|
|
|
// Comparable
|
|
extension RowIndex {
|
|
/// :nodoc:
|
|
public static func == (lhs: RowIndex, rhs: RowIndex) -> Bool {
|
|
lhs.index == rhs.index
|
|
}
|
|
|
|
/// :nodoc:
|
|
public static func < (lhs: RowIndex, rhs: RowIndex) -> Bool {
|
|
lhs.index < rhs.index
|
|
}
|
|
}
|
|
|
|
// Strideable: support for Row: RandomAccessCollection
|
|
extension RowIndex {
|
|
/// :nodoc:
|
|
public func distance(to other: RowIndex) -> Int {
|
|
other.index - index
|
|
}
|
|
|
|
/// :nodoc:
|
|
public func advanced(by n: Int) -> RowIndex {
|
|
RowIndex(index + n)
|
|
}
|
|
}
|
|
|
|
// MARK: - Row.ScopesView
|
|
|
|
extension Row {
|
|
/// A view of the scopes defined by row adapters. It is a collection of
|
|
/// tuples made of a scope name and a scoped row, which behaves like a
|
|
/// dictionary.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// // Define a tree of nested scopes
|
|
/// let adapter = ScopeAdapter([
|
|
/// "foo": RangeRowAdapter(0..<1),
|
|
/// "bar": RangeRowAdapter(1..<2).addingScopes([
|
|
/// "baz" : RangeRowAdapter(2..<3)])])
|
|
///
|
|
/// // Fetch
|
|
/// let sql = "SELECT 1 AS foo, 2 AS bar, 3 AS baz"
|
|
/// let row = try Row.fetchOne(db, sql: sql, adapter: adapter)!
|
|
///
|
|
/// row.scopes.count // 2
|
|
/// row.scopes.names // ["foo", "bar"]
|
|
///
|
|
/// row.scopes["foo"] // [foo:1]
|
|
/// row.scopes["bar"] // [bar:2]
|
|
/// row.scopes["baz"] // nil
|
|
public struct ScopesView: Collection {
|
|
public typealias Index = Dictionary<String, _LayoutedRowAdapter>.Index
|
|
private let row: Row
|
|
private let scopes: [String: _LayoutedRowAdapter]
|
|
private let prefetchedRows: Row.PrefetchedRowsView
|
|
|
|
/// The scopes defined on this row.
|
|
public var names: Dictionary<String, _LayoutedRowAdapter>.Keys {
|
|
scopes.keys
|
|
}
|
|
|
|
init() {
|
|
self.init(row: Row(), scopes: [:], prefetchedRows: Row.PrefetchedRowsView())
|
|
}
|
|
|
|
init(row: Row, scopes: [String: _LayoutedRowAdapter], prefetchedRows: Row.PrefetchedRowsView) {
|
|
self.row = row
|
|
self.scopes = scopes
|
|
self.prefetchedRows = prefetchedRows
|
|
}
|
|
|
|
/// :nodoc:
|
|
public var startIndex: Index {
|
|
scopes.startIndex
|
|
}
|
|
|
|
/// :nodoc:
|
|
public var endIndex: Index {
|
|
scopes.endIndex
|
|
}
|
|
|
|
/// :nodoc:
|
|
public func index(after i: Index) -> Index {
|
|
scopes.index(after: i)
|
|
}
|
|
|
|
/// :nodoc:
|
|
public subscript(position: Index) -> (name: String, row: Row) {
|
|
let (name, adapter) = scopes[position]
|
|
let adaptedRow = Row(base: row, adapter: adapter)
|
|
if let prefetch = prefetchedRows.prefetches[name] {
|
|
// Let the adapted row access its own prefetched rows.
|
|
// Use case:
|
|
//
|
|
// let request = A.including(required: A.b.including(all: B.c))
|
|
// let row = try Row.fetchOne(db, request)!
|
|
// row.prefetchedRows["cs"] // Some array
|
|
// row.scopes["b"]!.prefetchedRows["cs"] // The same array
|
|
adaptedRow.prefetchedRows = Row.PrefetchedRowsView(prefetches: prefetch.prefetches)
|
|
}
|
|
return (name: name, row: adaptedRow)
|
|
}
|
|
|
|
/// Returns the row associated with the given scope, or nil if the
|
|
/// scope is not defined.
|
|
public subscript(_ name: String) -> Row? {
|
|
scopes.index(forKey: name).map { self[$0].row }
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Row.ScopesTreeView
|
|
|
|
extension Row {
|
|
|
|
/// A view on the scopes tree defined by row adapters.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// // Define a tree of nested scopes
|
|
/// let adapter = ScopeAdapter([
|
|
/// "foo": RangeRowAdapter(0..<1),
|
|
/// "bar": RangeRowAdapter(1..<2).addingScopes([
|
|
/// "baz" : RangeRowAdapter(2..<3)])])
|
|
///
|
|
/// // Fetch
|
|
/// let sql = "SELECT 1 AS foo, 2 AS bar, 3 AS baz"
|
|
/// let row = try Row.fetchOne(db, sql: sql, adapter: adapter)!
|
|
///
|
|
/// row.scopesTree.names // ["foo", "bar", "baz"]
|
|
///
|
|
/// row.scopesTree["foo"] // [foo:1]
|
|
/// row.scopesTree["bar"] // [bar:2]
|
|
/// row.scopesTree["baz"] // [baz:3]
|
|
public struct ScopesTreeView {
|
|
let scopes: ScopesView
|
|
|
|
/// The scopes defined on this row, recursively.
|
|
public var names: Set<String> {
|
|
var names = Set<String>()
|
|
for (name, row) in scopes {
|
|
names.insert(name)
|
|
names.formUnion(row.scopesTree.names)
|
|
}
|
|
return names
|
|
}
|
|
|
|
/// Returns the row associated with the given scope.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Book.including(required: Book.author)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(row)
|
|
/// // Prints [id:42 title:"Moby-Dick"]
|
|
///
|
|
/// let authorRow = row.scopesTree["author"]
|
|
/// print(authorRow)
|
|
/// // Prints [id:1 name:"Herman Melville"]
|
|
///
|
|
/// Associated rows stored in nested associations are available, too:
|
|
///
|
|
/// let request = Book.including(required: Book.author.including(required: Author.country))
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(row)
|
|
/// // Prints [id:42 title:"Moby-Dick"]
|
|
///
|
|
/// let countryRow = row.scopesTree["country"]
|
|
/// print(countryRow)
|
|
/// // Prints [code:"US" name:"United States"]
|
|
///
|
|
/// Nil is returned if the scope is not available.
|
|
public subscript(_ name: String) -> Row? {
|
|
var fifo = Array(scopes)
|
|
while !fifo.isEmpty {
|
|
let scope = fifo.removeFirst()
|
|
if scope.name == name {
|
|
return scope.row
|
|
}
|
|
fifo.append(contentsOf: scope.row.scopes)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Row.PrefetchedRowsView
|
|
|
|
extension Row {
|
|
fileprivate struct Prefetch: Equatable {
|
|
// Nil for intermediate associations
|
|
var rows: [Row]?
|
|
// OrderedDictionary so that breadth-first search gives a consistent result
|
|
// (we preserve the ordering of associations in the request)
|
|
var prefetches: OrderedDictionary<String, Prefetch>
|
|
}
|
|
|
|
/// A view on the prefetched associated rows.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Author.including(all: Author.books)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(row)
|
|
/// // Prints [id:1 name:"Herman Melville"]
|
|
///
|
|
/// let bookRows = row.prefetchedRows["books"]
|
|
/// print(bookRows[0])
|
|
/// // Prints [id:42 title:"Moby-Dick"]
|
|
public struct PrefetchedRowsView: Equatable {
|
|
// OrderedDictionary so that breadth-first search gives a consistent result
|
|
// (we preserve the ordering of associations in the request)
|
|
fileprivate var prefetches: OrderedDictionary<String, Prefetch> = [:]
|
|
|
|
/// True if there is no prefetched associated rows.
|
|
public var isEmpty: Bool {
|
|
prefetches.isEmpty
|
|
}
|
|
|
|
/// The keys for available prefetched rows
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Author.including(all: Author.books)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(row.prefetchedRows.keys)
|
|
/// // Prints ["books"]
|
|
public var keys: Set<String> {
|
|
var result: Set<String> = []
|
|
var fifo = Array(prefetches)
|
|
while !fifo.isEmpty {
|
|
let (prefetchKey, prefetch) = fifo.removeFirst()
|
|
if prefetch.rows != nil {
|
|
result.insert(prefetchKey)
|
|
}
|
|
fifo.append(contentsOf: prefetch.prefetches)
|
|
}
|
|
return result
|
|
}
|
|
|
|
/// Returns the prefetched rows associated with the given key.
|
|
///
|
|
/// For example:
|
|
///
|
|
/// let request = Author.including(all: Author.books)
|
|
/// let row = try Row.fetchOne(db, request)!
|
|
///
|
|
/// print(row)
|
|
/// // Prints [id:1 name:"Herman Melville"]
|
|
///
|
|
/// let bookRows = row.prefetchedRows["books"]
|
|
/// print(bookRows[0])
|
|
/// // Prints [id:42 title:"Moby-Dick"]
|
|
///
|
|
/// Prefetched rows stored in nested "to-one" associations are
|
|
/// available, too.
|
|
///
|
|
/// Nil is returned if the key is not available.
|
|
public subscript(_ key: String) -> [Row]? {
|
|
var fifo = Array(prefetches)
|
|
while !fifo.isEmpty {
|
|
let (prefetchKey, prefetch) = fifo.removeFirst()
|
|
if prefetchKey == key {
|
|
return prefetch.rows
|
|
}
|
|
fifo.append(contentsOf: prefetch.prefetches)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
mutating func setRows(_ rows: [Row], forKeyPath keyPath: [String]) {
|
|
prefetches.setRows(rows, forKeyPath: keyPath)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension OrderedDictionary where Key == String, Value == Row.Prefetch {
|
|
fileprivate mutating func setRows(_ rows: [Row], forKeyPath keyPath: [String]) {
|
|
var keyPath = keyPath
|
|
let key = keyPath.removeFirst()
|
|
if keyPath.isEmpty {
|
|
self[key, default: Row.Prefetch(rows: nil, prefetches: [:])].rows = rows
|
|
} else {
|
|
self[key, default: Row.Prefetch(rows: nil, prefetches: [:])].prefetches.setRows(rows, forKeyPath: keyPath)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - RowImpl
|
|
|
|
// The protocol for Row underlying implementation
|
|
protocol RowImpl {
|
|
var count: Int { get }
|
|
var isFetched: Bool { get }
|
|
|
|
func scopes(prefetchedRows: Row.PrefetchedRowsView) -> Row.ScopesView
|
|
func columnName(atUncheckedIndex index: Int) -> String
|
|
func hasNull(atUncheckedIndex index: Int) -> Bool
|
|
func databaseValue(atUncheckedIndex index: Int) -> DatabaseValue
|
|
func fastDecode<Value: DatabaseValueConvertible & StatementColumnConvertible>(
|
|
_ type: Value.Type,
|
|
atUncheckedIndex index: Int)
|
|
-> Value
|
|
func fastDecodeIfPresent<Value: DatabaseValueConvertible & StatementColumnConvertible>(
|
|
_ type: Value.Type,
|
|
atUncheckedIndex index: Int)
|
|
-> Value?
|
|
func dataNoCopy(atUncheckedIndex index: Int) -> Data?
|
|
|
|
/// Returns the index of the leftmost column that matches *name* (case-insensitive)
|
|
func index(forColumn name: String) -> Int?
|
|
|
|
// row.impl is guaranteed to be self.
|
|
func unscopedRow(_ row: Row) -> Row
|
|
func unadaptedRow(_ row: Row) -> Row
|
|
func copiedRow(_ row: Row) -> Row
|
|
}
|
|
|
|
extension RowImpl {
|
|
func copiedRow(_ row: Row) -> Row {
|
|
// unless customized, assume unsafe and unadapted row
|
|
return Row(impl: ArrayRowImpl(columns: Array(row)))
|
|
}
|
|
|
|
func unscopedRow(_ row: Row) -> Row {
|
|
// unless customized, assume unadapted row (see AdaptedRowImpl for customization)
|
|
return row
|
|
}
|
|
|
|
func unadaptedRow(_ row: Row) -> Row {
|
|
// unless customized, assume unadapted row (see AdaptedRowImpl for customization)
|
|
return row
|
|
}
|
|
|
|
func scopes(prefetchedRows: Row.PrefetchedRowsView) -> Row.ScopesView {
|
|
// unless customized, assume unuscoped row (see AdaptedRowImpl for customization)
|
|
return Row.ScopesView()
|
|
}
|
|
|
|
func hasNull(atUncheckedIndex index: Int) -> Bool {
|
|
// unless customized, use slow check (see StatementRowImpl and AdaptedRowImpl for customization)
|
|
return databaseValue(atUncheckedIndex: index).isNull
|
|
}
|
|
|
|
func fastDecode<Value: DatabaseValueConvertible & StatementColumnConvertible>(
|
|
_ type: Value.Type,
|
|
atUncheckedIndex index: Int) -> Value
|
|
{
|
|
// unless customized, use slow decoding (see StatementRowImpl and AdaptedRowImpl for customization)
|
|
return Value.decode(
|
|
from: databaseValue(atUncheckedIndex: index),
|
|
conversionContext: ValueConversionContext(Row(impl: self)).atColumn(index))
|
|
}
|
|
|
|
func fastDecodeIfPresent<Value: DatabaseValueConvertible & StatementColumnConvertible>(
|
|
_ type: Value.Type,
|
|
atUncheckedIndex index: Int) -> Value?
|
|
{
|
|
// unless customized, use slow decoding (see StatementRowImpl and AdaptedRowImpl for customization)
|
|
return Value.decodeIfPresent(
|
|
from: databaseValue(atUncheckedIndex: index),
|
|
conversionContext: ValueConversionContext(Row(impl: self)).atColumn(index))
|
|
}
|
|
|
|
func dataNoCopy(atUncheckedIndex index: Int) -> Data? {
|
|
// unless customized, copy data (see StatementRowImpl and AdaptedRowImpl for customization)
|
|
return Data.decodeIfPresent(
|
|
from: databaseValue(atUncheckedIndex: index),
|
|
conversionContext: ValueConversionContext(Row(impl: self)).atColumn(index))
|
|
}
|
|
}
|
|
|
|
// TODO: merge with StatementCopyRowImpl eventually?
|
|
/// See Row.init(dictionary:)
|
|
private struct ArrayRowImpl: RowImpl {
|
|
let columns: [(String, DatabaseValue)]
|
|
|
|
init(columns: [(String, DatabaseValue)]) {
|
|
self.columns = columns
|
|
}
|
|
|
|
var count: Int { columns.count }
|
|
|
|
var isFetched: Bool { false }
|
|
|
|
func databaseValue(atUncheckedIndex index: Int) -> DatabaseValue {
|
|
columns[index].1
|
|
}
|
|
|
|
func columnName(atUncheckedIndex index: Int) -> String {
|
|
columns[index].0
|
|
}
|
|
|
|
func index(forColumn name: String) -> Int? {
|
|
let lowercaseName = name.lowercased()
|
|
return columns.firstIndex { (column, _) in column.lowercased() == lowercaseName }
|
|
}
|
|
|
|
func copiedRow(_ row: Row) -> Row {
|
|
row
|
|
}
|
|
}
|
|
|
|
|
|
// TODO: merge with ArrayRowImpl eventually?
|
|
/// See Row.init(copiedFromStatementRef:sqliteStatement:)
|
|
private struct StatementCopyRowImpl: RowImpl {
|
|
let dbValues: ContiguousArray<DatabaseValue>
|
|
let columnNames: [String]
|
|
|
|
init(sqliteStatement: SQLiteStatement, columnNames: [String]) {
|
|
let sqliteStatement = sqliteStatement
|
|
self.dbValues = ContiguousArray(
|
|
(0..<sqlite3_column_count(sqliteStatement))
|
|
.map { DatabaseValue(sqliteStatement: sqliteStatement, index: $0) }
|
|
as [DatabaseValue])
|
|
self.columnNames = columnNames
|
|
}
|
|
|
|
var count: Int { columnNames.count }
|
|
|
|
var isFetched: Bool { true }
|
|
|
|
func databaseValue(atUncheckedIndex index: Int) -> DatabaseValue {
|
|
dbValues[index]
|
|
}
|
|
|
|
func columnName(atUncheckedIndex index: Int) -> String {
|
|
columnNames[index]
|
|
}
|
|
|
|
func index(forColumn name: String) -> Int? {
|
|
let lowercaseName = name.lowercased()
|
|
return columnNames.firstIndex { $0.lowercased() == lowercaseName }
|
|
}
|
|
|
|
func copiedRow(_ row: Row) -> Row {
|
|
row
|
|
}
|
|
}
|
|
|
|
|
|
/// See Row.init(statement:)
|
|
private struct StatementRowImpl: RowImpl {
|
|
let statement: SelectStatement
|
|
let sqliteStatement: SQLiteStatement
|
|
let lowercaseColumnIndexes: [String: Int]
|
|
|
|
init(sqliteStatement: SQLiteStatement, statement: SelectStatement) {
|
|
self.statement = statement
|
|
self.sqliteStatement = sqliteStatement
|
|
// Optimize row[columnName]
|
|
let lowercaseColumnNames = (0..<sqlite3_column_count(sqliteStatement))
|
|
.map { String(cString: sqlite3_column_name(sqliteStatement, Int32($0))).lowercased() }
|
|
self.lowercaseColumnIndexes = Dictionary(
|
|
lowercaseColumnNames
|
|
.enumerated()
|
|
.map { ($0.element, $0.offset) },
|
|
uniquingKeysWith: { (left, _) in left }) // keep leftmost indexes
|
|
}
|
|
|
|
var count: Int {
|
|
Int(sqlite3_column_count(sqliteStatement))
|
|
}
|
|
|
|
var isFetched: Bool { true }
|
|
|
|
func hasNull(atUncheckedIndex index: Int) -> Bool {
|
|
// Avoid extracting values, because this modifies the SQLite statement.
|
|
return sqlite3_column_type(sqliteStatement, Int32(index)) == SQLITE_NULL
|
|
}
|
|
|
|
func dataNoCopy(atUncheckedIndex index: Int) -> Data? {
|
|
guard sqlite3_column_type(sqliteStatement, Int32(index)) != SQLITE_NULL else {
|
|
return nil
|
|
}
|
|
guard let bytes = sqlite3_column_blob(sqliteStatement, Int32(index)) else {
|
|
return Data()
|
|
}
|
|
let count = Int(sqlite3_column_bytes(sqliteStatement, Int32(index)))
|
|
return Data(bytesNoCopy: UnsafeMutableRawPointer(mutating: bytes), count: count, deallocator: .none)
|
|
}
|
|
|
|
func databaseValue(atUncheckedIndex index: Int) -> DatabaseValue {
|
|
DatabaseValue(sqliteStatement: sqliteStatement, index: Int32(index))
|
|
}
|
|
|
|
func fastDecode<Value: DatabaseValueConvertible & StatementColumnConvertible>(
|
|
_ type: Value.Type,
|
|
atUncheckedIndex index: Int) -> Value
|
|
{
|
|
Value.fastDecode(from: sqliteStatement, atUncheckedIndex: Int32(index))
|
|
}
|
|
|
|
func fastDecodeIfPresent<Value: DatabaseValueConvertible & StatementColumnConvertible>(
|
|
_ type: Value.Type,
|
|
atUncheckedIndex index: Int) -> Value?
|
|
{
|
|
Value.fastDecodeIfPresent(from: sqliteStatement, atUncheckedIndex: Int32(index))
|
|
}
|
|
|
|
func columnName(atUncheckedIndex index: Int) -> String {
|
|
statement.columnNames[index]
|
|
}
|
|
|
|
func index(forColumn name: String) -> Int? {
|
|
if let index = lowercaseColumnIndexes[name] {
|
|
return index
|
|
}
|
|
return lowercaseColumnIndexes[name.lowercased()]
|
|
}
|
|
|
|
func copiedRow(_ row: Row) -> Row {
|
|
Row(copiedFromSQLiteStatement: sqliteStatement, statement: statement)
|
|
}
|
|
}
|
|
|
|
// This one is not optimized at all, since it is only used in fatal conversion errors, so far
|
|
private struct SQLiteStatementRowImpl: RowImpl {
|
|
let sqliteStatement: SQLiteStatement
|
|
var count: Int { Int(sqlite3_column_count(sqliteStatement)) }
|
|
var isFetched: Bool { true }
|
|
|
|
func columnName(atUncheckedIndex index: Int) -> String {
|
|
String(cString: sqlite3_column_name(sqliteStatement, Int32(index)))
|
|
}
|
|
|
|
func databaseValue(atUncheckedIndex index: Int) -> DatabaseValue {
|
|
DatabaseValue(sqliteStatement: sqliteStatement, index: Int32(index))
|
|
}
|
|
|
|
func dataNoCopy(atUncheckedIndex index: Int) -> Data? {
|
|
guard sqlite3_column_type(sqliteStatement, Int32(index)) != SQLITE_NULL else {
|
|
return nil
|
|
}
|
|
guard let bytes = sqlite3_column_blob(sqliteStatement, Int32(index)) else {
|
|
return Data()
|
|
}
|
|
let count = Int(sqlite3_column_bytes(sqliteStatement, Int32(index)))
|
|
return Data(bytesNoCopy: UnsafeMutableRawPointer(mutating: bytes), count: count, deallocator: .none)
|
|
}
|
|
|
|
func index(forColumn name: String) -> Int? {
|
|
let name = name.lowercased()
|
|
for index in 0..<count where columnName(atUncheckedIndex: index).lowercased() == name {
|
|
return index
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
/// See Row.init()
|
|
private struct EmptyRowImpl: RowImpl {
|
|
var count: Int { 0 }
|
|
|
|
var isFetched: Bool { false }
|
|
|
|
func databaseValue(atUncheckedIndex index: Int) -> DatabaseValue {
|
|
// Programmer error
|
|
fatalError("row index out of range")
|
|
}
|
|
|
|
func columnName(atUncheckedIndex index: Int) -> String {
|
|
// Programmer error
|
|
fatalError("row index out of range")
|
|
}
|
|
|
|
func index(forColumn name: String) -> Int? { nil }
|
|
|
|
func copiedRow(_ row: Row) -> Row { row }
|
|
}
|