Row

The number of columns in the row.

Creates an empty row.

Creates a row from a dictionary of values.

Creates a row from [AnyHashable: Any].

The result is nil unless all dictionary keys are strings, and values adopt DatabaseValueConvertible.

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().

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.

Returns true if and only if the row has that column.

This method is case-insensitive.

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.

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.

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).

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.

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).

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.

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.

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).

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.

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).

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.

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.

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).

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.

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).

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.

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.

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.

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.

Returns a scoped row, if the row was fetched along with a row adapter that defines this scope.

// Two adapters
let fooAdapter = ColumnMapping(["value": "foo"])
let barAdapter = ColumnMapping(["value": "bar"])

// Define scopes
let adapter = ScopeAdapter([
    "foo": fooAdapter,
    "bar": barAdapter])

// Fetch
let sql = "SELECT 'foo' AS foo, 'bar' AS bar"
let row = try Row.fetchOne(db, sql, adapter: adapter)!

// Scoped rows:
if let fooRow = row.scoped(on: "foo") {
    fooRow["value"]    // "foo"
}
if let barRow = row.scopeed(on: "bar") {
    barRow["value"]    // "bar"
}

Returns a cursor over rows fetched from a prepared statement.

let statement = try db.makeSelectStatement("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 dispath queue.

Returns an array of rows fetched from a prepared statement.

let statement = try db.makeSelectStatement("SELECT ...")
let rows = try Row.fetchAll(statement)

Returns a single row fetched from a prepared statement.

let statement = try db.makeSelectStatement("SELECT ...")
let row = try Row.fetchOne(statement)

Returns a cursor over rows fetched from a fetch request.

let idColumn = Column("id")
let nameColumn = Column("name")
let request = Player.select(idColumn, nameColumn)
let rows = try Row.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 dispath queue.

Returns an array of rows fetched from a fetch request.

let idColumn = Column("id")
let nameColumn = Column("name")
let request = Player.select(idColumn, nameColumn)
let rows = try Row.fetchAll(db, request)

Returns a single row fetched from a fetch request.

let idColumn = Column("id")
let nameColumn = Column("name")
let request = Player.select(idColumn, nameColumn)
let row = try Row.fetchOne(db, request)

Returns a cursor over rows fetched from an SQL query.

let rows = try Row.fetchCursor(db, "SELECT id, name FROM players") // 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 dispath queue.

Returns an array of rows fetched from an SQL query.

let rows = try Row.fetchAll(db, "SELECT ...")

Returns a single row fetched from an SQL query.

let row = try Row.fetchOne(db, "SELECT ...")

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 <Row foo:1 foo:"bar" baz:NULL>

The index of the first (ColumnName, DatabaseValue) pair.

The past-the-end index, successor of the index of the last (ColumnName, DatabaseValue) pair.

Accesses the (ColumnName, DatabaseValue) pair at given index.

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.

The hash value