Classes

A type-erased cursor of Element.

This cursor forwards its next() method to an arbitrary underlying cursor having the same Element type, hiding the specifics of the underlying cursor.

An enumeration of the elements of a cursor.

To create an instance of EnumeratedCursor, call the enumerated() method on a cursor:

let cursor = try String.fetchCursor(db, "SELECT 'foo' UNION ALL SELECT 'bar'")
let c = cursor.enumerated()
while let (n, x) = c.next() {
    print("\(n): \(x)")
}
// Prints: "0: foo"
// Prints: "1: bar"

A cursor whose elements consist of the elements of some base cursor that also satisfy a given predicate.

A cursor consisting of all the elements contained in each segment contained in some Base cursor.

See Cursor.joined(), Cursor.flatMap(:), Sequence.flatMap(:)

A Cursor whose elements consist of those in a Base Cursor passed through a transform function returning Element.

See Cursor.map(_:)

A Cursor whose elements are those of a sequence iterator.

A Database connection.

You don’t create a database directly. Instead, you use a DatabaseQueue, or a DatabasePool:

let dbQueue = DatabaseQueue(...)

// The Database is the `db` in the closure:
try dbQueue.inDatabase { db in
    try db.execute(...)
}

A Collation is a string comparison function used by SQLite.

An SQL function or aggregate.

A DatabasePool grants concurrent accesses to an SQLite database.

A DatabaseQueue serializes access to an SQLite database.

A type-erased DatabaseReader

Instances of AnyDatabaseReader forward their methods to an arbitrary underlying database reader.

A cursor of database values extracted from a single column. For example:

try dbQueue.inDatabase { db in
    let urls: DatabaseValueCursor<URL> = try URL.fetchCursor(db, "SELECT url FROM links")
    while let url = urls.next() { // URL
        print(url)
    }
}

A cursor of optional database values extracted from a single column. For example:

try dbQueue.inDatabase { db in
    let urls: NullableDatabaseValueCursor<URL> = try Optional<URL>.fetchCursor(db, "SELECT url FROM links")
    while let url = urls.next() { // URL?
        print(url)
    }
}

A type-erased DatabaseWriter

Instances of AnyDatabaseWriter forward their methods to an arbitrary underlying database writer.

You use FetchedRecordsController to track changes in the results of an SQLite request.

See https://github.com/groue/GRDB.swift#fetchedrecordscontroller for more information.

The FTS3TableDefinition class lets you define columns of a FTS3 virtual table.

You don’t create instances of this class. Instead, you use the Database create(virtualTable:using:) method:

try db.create(virtualTable: "documents", using: FTS3()) { t in // t is FTS3TableDefinition
    t.column("content")
}

The FTS4TableDefinition class lets you define columns of a FTS4 virtual table.

You don’t create instances of this class. Instead, you use the Database create(virtualTable:using:) method:

try db.create(virtualTable: "documents", using: FTS4()) { t in // t is FTS4TableDefinition
    t.column("content")
}

See https://www.sqlite.org/fts3.html

The FTS4ColumnDefinition class lets you refine a column of an FTS4 virtual table.

You get instances of this class when you create an FTS4 table:

try db.create(virtualTable: "documents", using: FTS4()) { t in
    t.column("content")      // FTS4ColumnDefinition
}

See https://www.sqlite.org/fts3.html

The FTS5TableDefinition class lets you define columns of a FTS5 virtual table.

You don’t create instances of this class. Instead, you use the Database create(virtualTable:using:) method:

try db.create(virtualTable: "documents", using: FTS5()) { t in // t is FTS5TableDefinition
    t.column("content")
}

See https://www.sqlite.org/fts5.html

The FTS5ColumnDefinition class lets you refine a column of an FTS5 virtual table.

You get instances of this class when you create an FTS5 table:

try db.create(virtualTable: "documents", using: FTS5()) { t in
    t.column("content")      // FTS5ColumnDefinition
}

See https://www.sqlite.org/fts5.html

Record is a class that wraps a table row, or the result of any query. It is designed to be subclassed.

RecordBox is a subclass of Record that aims at giving any record type the changes tracking provided by the Record class.

// A Regular record struct
struct Player: RowConvertible, MutablePersistable, Codable {
    static let databaseTableName = "players"
    var id: Int64?
    var name: String
    var score: Int
    mutating func didInsert(with rowID: Int64, for column: String?) {
        id = rowID
    }
}

try dbQueue.inDatabase { db in
    // Fetch a player record
    let playerRecord = try RecordBox<Player>.fetchOne(db, key: 1)!

    // Profit from changes tracking
    playerRecord.value.score = 300
    playerRecord.hasPersistentChangedValues         // true
    playerRecord.persistentChangedValues["score"]   // 100 (the old value)
}

A database row.

A cursor of database rows. For example:

try dbQueue.inDatabase { db in
    let rows: RowCursor = try Row.fetchCursor(db, "SELECT * FROM players")
}

A cursor of records. For example:

struct Player : RowConvertible { ... }
try dbQueue.inDatabase { db in
    let players: RecordCursor<Player> = try Player.fetchCursor(db, "SELECT * FROM players")
}

A statement represents an SQL query.

It is the base class of UpdateStatement that executes update statements, and SelectStatement that fetches rows.

A subclass of Statement that fetches database rows.

You create SelectStatement with the Database.makeSelectStatement() method:

try dbQueue.inDatabase { db in
    let statement = try db.makeSelectStatement("SELECT COUNT(*) FROM players WHERE score > ?")
    let moreThanTwentyCount = try Int.fetchOne(statement, arguments: [20])!
    let moreThanThirtyCount = try Int.fetchOne(statement, arguments: [30])!
}

A cursor that iterates a database statement without producing any value. For example:

try dbQueue.inDatabase { db in
    let statement = db.makeSelectStatement("SELECT * FROM players")
    let cursor: StatementCursor = statement.cursor()
}

A subclass of Statement that executes SQL queries.

You create UpdateStatement with the Database.makeUpdateStatement() method:

try dbQueue.inTransaction { db in
    let statement = try db.makeUpdateStatement("INSERT INTO players (name) VALUES (?)")
    try statement.execute(arguments: ["Arthur"])
    try statement.execute(arguments: ["Barbara"])
    return .commit
}

A cursor of database values extracted from a single column. For example:

try dbQueue.inDatabase { db in
    let names: ColumnCursor<String> = try String.fetchCursor(db, "SELECT name FROM players")
    while let name = names.next() { // String
        print(name)
    }
}

A cursor of optional database values extracted from a single column. For example:

try dbQueue.inDatabase { db in
    let emails: NullableColumnCursor<String> = try Optional<String>.fetchCursor(db, "SELECT email FROM players")
    while let email = emails.next() { // String?
        print(email ?? "<NULL>")
    }
}

The TableDefinition class lets you define table columns and constraints.

You don’t create instances of this class. Instead, you use the Database create(table:) method:

try db.create(table: "players") { t in // t is TableDefinition
    t.column(...)
}

See https://www.sqlite.org/lang_createtable.html

The TableAlteration class lets you alter database tables.

You don’t create instances of this class. Instead, you use the Database alter(table:) method:

try db.alter(table: "players") { t in // t is TableAlteration
    t.add(column: ...)
}

See https://www.sqlite.org/lang_altertable.html

The ColumnDefinition class lets you refine a table column.

You get instances of this class when you create or alter a database table:

try db.create(table: "players") { t in
    t.column(...)      // ColumnDefinition
}

try db.alter(table: "players") { t in
    t.add(column: ...) // ColumnDefinition
}

See https://www.sqlite.org/lang_createtable.html and https://www.sqlite.org/lang_altertable.html