Structuregrdb 7.3.0GRDB
ScopesView
A view on the scopes defined by row adapters.
struct ScopesViewScopesView is a Collection of (name: String, row: Row) pairs.
See scopes for more information.
A view on the scopes defined by row adapters.
struct ScopesViewScopesView is a Collection of (name: String, row: Row) pairs.
See scopes for more information.
import GRDBA toolkit for SQLite databases, with a focus on application development
final class RowA database row.
var scopes: ScopesView { get }A view on the scopes defined by row adapters.
var prefetchedRows: Row.PrefetchedRowsView { get }A view on the prefetched associated rows.
var scopesTree: ScopesTreeView { get }A view on the scopes tree defined by row adapters.
var unadapted: Row { get }The raw row fetched from the database.
var unscoped: Row { get }The row, without any scope of prefetched rows.
subscript<Record>(scope: String) -> Record? where Record : FetchableRecord { get } The eventual record associated to the given scope.
subscript<Record>(scope: String) -> Record where Record : FetchableRecord { get } The record associated to the given scope.
subscript<Records>(key: String) -> Records where Records : RangeReplaceableCollection, Records.Element : FetchableRecord { get } A collection of prefetched records associated to the given association key.
subscript<Record>(key: String) -> Set<Record> where Record : FetchableRecord, Record : Hashable { get } A set prefetched records associated to the given association key.
struct PrefetchedRowsViewA view on the prefetched associated rows.
struct ScopesTreeViewA view on the scopes tree defined by row adapters.
convenience init() Creates an empty row.
convenience init(_ dictionary: [String : (any DatabaseValueConvertible)?]) Creates a row from a dictionary of database values.
convenience init?(_ dictionary: [AnyHashable : Any]) Creates a row from a dictionary.
convenience init(dictionaryLiteral elements: (String, (any DatabaseValueConvertible)?)...) Creates a row initialized with elements. Column order is preserved, and duplicated columns names are allowed.
static func fetchAll(_ db: Database, _ request: some FetchRequest) throws -> [Row] Returns an array of rows fetched from a fetch request.
static func fetchAll(_ statement: Statement, arguments: StatementArguments? = nil, adapter: (any RowAdapter)? = nil) throws -> [Row] Returns an array of rows fetched from a prepared statement.
static func fetchAll(_ db: Database, sql: String, arguments: StatementArguments = StatementArguments(), adapter: (any RowAdapter)? = nil) throws -> [Row] Returns an array of rows fetched from an SQL query.
static func fetchCursor(_ db: Database, _ request: some FetchRequest) throws -> RowCursor Returns a cursor over rows fetched from a fetch request.
static func fetchCursor(_ statement: Statement, arguments: StatementArguments? = nil, adapter: (any RowAdapter)? = nil) throws -> RowCursor Returns a cursor over rows fetched from a prepared statement.
static func fetchCursor(_ db: Database, sql: String, arguments: StatementArguments = StatementArguments(), adapter: (any RowAdapter)? = nil) throws -> RowCursor Returns a cursor over rows fetched from an SQL query.
static func fetchOne(_ db: Database, _ request: some FetchRequest) throws -> Row? Returns a single row fetched from a fetch request.
static func fetchOne(_ statement: Statement, arguments: StatementArguments? = nil, adapter: (any RowAdapter)? = nil) throws -> Row? Returns a single row fetched from a prepared statement.
static func fetchOne(_ db: Database, sql: String, arguments: StatementArguments = StatementArguments(), adapter: (any RowAdapter)? = nil) throws -> Row? Returns a single row fetched from an SQL query.
static func fetchSet(_ db: Database, _ request: some FetchRequest) throws -> Set<Row> Returns a set of rows fetched from a fetch request.
static func fetchSet(_ statement: Statement, arguments: StatementArguments? = nil, adapter: (any RowAdapter)? = nil) throws -> Set<Row> Returns a set of rows fetched from a prepared statement.
static func fetchSet(_ db: Database, sql: String, arguments: StatementArguments = StatementArguments(), adapter: (any RowAdapter)? = nil) throws -> Set<Row> Returns a set of rows fetched from an SQL query.
var columnNames: LazyMapCollection<Row, String> { get }The names of columns in the row, from left to right.
var containsNonNullValue: Bool { get }Returns a boolean value indicating if the row contains one value this is not NULL.
let count: IntThe number of columns in the row.
var databaseValues: LazyMapCollection<Row, DatabaseValue> { get }The database values in the row, from left to right.
var debugDescription: String { get }var description: String { get }var endIndex: Index { get }var startIndex: Index { get }subscript(columnName: String) -> (any DatabaseValueConvertible)? { get } Returns Int64, Double, String, Data or nil, depending on the value stored at the given column.
subscript(index: Int) -> (any DatabaseValueConvertible)? { get } Returns Int64, Double, String, Data or nil, depending on the value stored at the given index.
subscript(column: some ColumnExpression) -> (any DatabaseValueConvertible)? { get } Returns Int64, Double, String, Data or nil, depending on the value stored at the given column.
subscript(position: Index) -> (String, DatabaseValue) { get } Returns the (column, value) pair at given index.
subscript<Value>(columnName: String) -> Value where Value : DatabaseValueConvertible, Value : StatementColumnConvertible { get } Returns the value at given column, converted to the requested type.
subscript<Value>(columnName: String) -> Value where Value : DatabaseValueConvertible { get } Returns the value at given column, converted to the requested type.
subscript<Value>(index: Int) -> Value where Value : DatabaseValueConvertible, Value : StatementColumnConvertible { get } Returns the value at given index, converted to the requested type.
subscript<Value>(index: Int) -> Value where Value : DatabaseValueConvertible { get } Returns the value at given index, converted to the requested type.
subscript<Value>(column: some ColumnExpression) -> Value where Value : DatabaseValueConvertible, Value : StatementColumnConvertible { get } Returns the value at given column, converted to the requested type.
subscript<Value>(column: some ColumnExpression) -> Value where Value : DatabaseValueConvertible { get } Returns the value at given column, converted to the requested type.
static func == (lhs: Row, rhs: Row) -> Bool 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.
func coalesce<T>(_ columns: some Collection<any ColumnExpression>) -> T? where T : DatabaseValueConvertible Returns the first non-null value, if any. Identical to SQL COALESCE function.
func coalesce<T>(_ columns: some Collection<String>) -> T? where T : DatabaseValueConvertible Returns the first non-null value, if any. Identical to SQL COALESCE function.
func copy() -> Row Returns an immutable copy of the row.
func hasColumn(_ columnName: String) -> Bool Returns whether the row has one column with the given name (case-insensitive).
func hasNull(atIndex index: Int) -> Bool Returns whether the row has a NULL value at given index.
func hash(into hasher: inout Hasher) func withUnsafeData<T>(at column: some ColumnExpression, _ body: (Data?) throws -> T) throws -> T Calls the given closure with the Data at the given column.
func withUnsafeData<T>(atIndex index: Int, _ body: (Data?) throws -> T) throws -> T Calls the given closure with the Data at given index.
func withUnsafeData<T>(named columnName: String, _ body: (Data?) throws -> T) throws -> T Calls the given closure with the Data at the given column.
struct IndexAn index to a (column, value) pair in a Row.
func dataNoCopy(_ column: some ColumnExpression) -> Data? Returns the optional Data at given column.
func dataNoCopy(atIndex index: Int) -> Data? Returns the optional Data at given index.
func dataNoCopy(named columnName: String) -> Data? Returns the optional Data at given column.
protocol Collection<Element> : SequenceA sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.
protocol CopyableA type whose values can be implicitly or explicitly copied.
protocol Escapableprotocol Sequence<Element>A type that provides sequential, iterated access to its elements.
var endIndex: Index { get }var names: Dictionary<String, any _LayoutedRowAdapter>.Keys { get }The available scopes in this row.
var startIndex: Index { get }subscript(name: String) -> Row? { get } The row associated with the given scope, or nil if the scope is not available.
subscript(position: Index) -> (name: String, row: Row) { get } func index(after i: Index) -> Index typealias Index = Dictionary<String, any _LayoutedRowAdapter>.Indexvar count: Int { get }The number of elements in the collection.
var first: Self.Element? { get }The first element of the collection.
var indices: DefaultIndices<Self> { get }The indices that are valid for subscripting the collection, in ascending order.
var isEmpty: Bool { get }A Boolean value indicating whether the collection is empty.
var lazy: LazySequence<Self> { get }A sequence containing the same elements as this sequence, but on which some operations, such as map and filter, are implemented lazily.
var underestimatedCount: Int { get }A value less than or equal to the number of elements in the collection.
subscript<R>(r: R) -> Self.SubSequence where R : RangeExpression, Self.Index == R.Bound { get } Accesses the contiguous subrange of the collection’s elements specified by a range expression.
subscript(x: (UnboundedRange_) -> ()) -> Self.SubSequence { get } subscript(subranges: RangeSet<Self.Index>) -> DiscontiguousSlice<Self> { get } Accesses a view of this collection with the elements at the given indices.
subscript(bounds: Range<Self.Index>) -> Slice<Self> { get } Accesses a contiguous subrange of the collection’s elements.
func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.
func compactMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.
func compare<Comparator>(_ lhs: Comparator.Compared, _ rhs: Comparator.Compared) -> ComparisonResult where Comparator : SortComparator, Comparator == Self.Element If lhs is ordered before rhs in the ordering described by the given sequence of SortComparators
func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
func count<E>(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error Returns the number of elements in the sequence that satisfy the given predicate.
func distance(from start: Self.Index, to end: Self.Index) -> Int Returns the distance between two indices.
func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence Returns a subsequence by skipping elements while predicate returns true and returning the remaining elements.
func dropFirst(_ k: Int = 1) -> Self.SubSequence Returns a subsequence containing all but the given number of initial elements.
func dropLast(_ k: Int = 1) -> Self.SubSequence Returns a subsequence containing all but the specified number of final elements.
func elementsEqual<OtherSequence>(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.
func enumerated() -> EnumeratedSequence<Self> Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero and x represents an element of the sequence.
func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> [Self.Element] Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.
func filter(_ predicate: Predicate<Self.Element>) throws -> [Self.Element] func first(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the first element of the sequence that satisfies the given predicate.
func firstIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index? Returns the first index in which an element of the collection satisfies the given predicate.
func flatMap<SegmentOfResult>(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.
func flatMap<SegmentOfResult>(_ transform: @escaping (Iterator.Element) throws -> SegmentOfResult) -> FlattenCursor<MapCursor<AnyCursor<Iterator.Element>, SegmentOfResult>> where SegmentOfResult : Cursor Returns a cursor over the concatenated results of mapping transform over self.
func forEach(_ body: (Self.Element) throws -> Void) rethrows Calls the given closure on each element in the sequence in the same order as a for-in loop.
func formIndex(_ i: inout Self.Index, offsetBy distance: Int) Offsets the given index by the specified distance.
func formIndex(_ i: inout Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Bool Offsets the given index by the specified distance, or so that it equals the given limiting index.
func formIndex(after i: inout Self.Index) Replaces the given index with its successor.
func formatted<S>(_ style: S) -> S.FormatOutput where Self == S.FormatInput, S : FormatStyle func index(_ i: Self.Index, offsetBy distance: Int) -> Self.Index Returns an index that is the specified distance from the given index.
func index(_ i: Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Self.Index? Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.
func indices(where predicate: (Self.Element) throws -> Bool) rethrows -> RangeSet<Self.Index> Returns the indices of all the elements that match the given predicate.
func lexicographicallyPrecedes<OtherSequence>(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.
func makeIterator() -> IndexingIterator<Self> Returns an iterator over the elements of the collection.
func map<T, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error Returns an array containing the results of mapping the given closure over the sequence’s elements.
func map<T, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error Returns an array containing the results of mapping the given closure over the sequence’s elements.
@warn_unqualified_access func max(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the maximum element in the sequence, using the given predicate as the comparison between elements.
@warn_unqualified_access func min(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the minimum element in the sequence, using the given predicate as the comparison between elements.
func prefix(_ maxLength: Int) -> Self.SubSequence Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.
func prefix(through position: Self.Index) -> Self.SubSequence Returns a subsequence from the start of the collection through the specified position.
func prefix(upTo end: Self.Index) -> Self.SubSequence Returns a subsequence from the start of the collection up to, but not including, the specified position.
func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence Returns a subsequence containing the initial elements until predicate returns false and skipping the remaining elements.
func randomElement() -> Self.Element? Returns a random element of the collection.
func randomElement<T>(using generator: inout T) -> Self.Element? where T : RandomNumberGenerator Returns a random element of the collection, using the given generator as a source for randomness.
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result Returns the result of combining the elements of the sequence using the given closure.
func reduce<Result>(into initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result Returns the result of combining the elements of the sequence using the given closure.
func removingSubranges(_ subranges: RangeSet<Self.Index>) -> DiscontiguousSlice<Self> Returns a collection of the elements in this collection that are not represented by the given range set.
func reversed() -> [Self.Element] Returns an array containing the elements of this sequence in reverse order.
func shuffled() -> [Self.Element] Returns the elements of the sequence, shuffled.
func shuffled<T>(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator Returns the elements of the sequence, shuffled using the given generator as a source for randomness.
func sorted(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element] Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.
func sorted<Comparator>(using comparator: Comparator) -> [Self.Element] where Comparator : SortComparator, Self.Element == Comparator.Compared Returns the elements of the sequence, sorted using the given comparator to compare elements.
func sorted<S, Comparator>(using comparators: S) -> [Self.Element] where S : Sequence, Comparator : SortComparator, Comparator == S.Element, Self.Element == Comparator.Compared Returns the elements of the sequence, sorted using the given array of SortComparators to compare elements.
func split(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence] Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.
func suffix(_ maxLength: Int) -> Self.SubSequence Returns a subsequence, up to the given maximum length, containing the final elements of the collection.
func suffix(from start: Self.Index) -> Self.SubSequence Returns a subsequence from the specified position to the end of the collection.
func trimmingPrefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R? func flatMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]