Functions

Returns an array of row adapters that split a row according to the input number of columns.

For example:

let sql = "SELECT 1, 2,3,4, 5,6, 7,8"
//               <.><. . .><. .><. .>
let adapters = splittingRowAdapters([1, 3, 2])
let adapter = ScopeAdapter([
    "a": adapters[0],
    "b": adapters[1],
    "c": adapters[2],
    "d": adapters[3]])
let row = try Row.fetchOne(db, sql: sql, adapter: adapter)
row.scopes["a"] // [1]
row.scopes["b"] // [2, 3, 4]
row.scopes["c"] // [5, 6]
row.scopes["d"] // [7, 8]

Returns a logically negated aggregate.

For example:

Author.having(!Author.books.isEmpty)

Groups two aggregates with the AND SQL operator.

For example:

Author.having(Author.books.isEmpty && Author.paintings.isEmpty)

Groups two aggregates with the OR SQL operator.

For example:

Author.having(!Author.books.isEmpty || !Author.paintings.isEmpty)

Returns an aggregate that compares two aggregates with the = SQL operator.

For example:

Author.having(Author.books.count == Author.paintings.count)

Returns an aggregate that compares an aggregate with the = SQL operator.

For example:

Author.having(Author.books.count == 3)

Returns an aggregate that compares an aggregate with the = SQL operator.

For example:

Author.having(3 == Author.books.count)

Returns an aggregate that checks the boolean value of an aggregate.

For example:

Author.having(Author.books.isEmpty == false)

Returns an aggregate that checks the boolean value of an aggregate.

For example:

Author.having(false == Author.books.isEmpty)

Returns an aggregate that compares two aggregates with the <> SQL operator.

For example:

Author.having(Author.books.count != Author.paintings.count)

Returns an aggregate that compares an aggregate with the <> SQL operator.

For example:

Author.having(Author.books.count != 3)

Returns an aggregate that compares an aggregate with the <> SQL operator.

For example:

Author.having(3 != Author.books.count)

Returns an aggregate that checks the boolean value of an aggregate.

For example:

Author.having(Author.books.isEmpty != true)

Returns an aggregate that checks the boolean value of an aggregate.

For example:

Author.having(true != Author.books.isEmpty)

Returns an aggregate that compares two aggregates with the IS SQL operator.

For example:

Author.having(Author.books.count === Author.paintings.count)

Returns an aggregate that compares an aggregate with the IS SQL operator.

For example:

Author.having(Author.books.count === 3)

Returns an aggregate that compares an aggregate with the IS SQL operator.

For example:

Author.having(3 === Author.books.count)

Returns an aggregate that compares two aggregates with the IS NOT SQL operator.

For example:

Author.having(Author.books.count !== Author.paintings.count)

Returns an aggregate that compares an aggregate with the IS NOT SQL operator.

For example:

Author.having(Author.books.count !== 3)

Returns an aggregate that compares an aggregate with the IS NOT SQL operator.

For example:

Author.having(3 !== Author.books.count)

Returns an aggregate that compares two aggregates with the <= SQL operator.

For example:

Author.having(Author.books.count <= Author.paintings.count)

Returns an aggregate that compares an aggregate with the <= SQL operator.

For example:

Author.having(Author.books.count <= 3)

Returns an aggregate that compares an aggregate with the <= SQL operator.

For example:

Author.having(3 <= Author.books.count)

Returns an aggregate that compares two aggregates with the < SQL operator.

For example:

Author.having(Author.books.count < Author.paintings.count)

Returns an aggregate that compares an aggregate with the < SQL operator.

For example:

Author.having(Author.books.count < 3)

Returns an aggregate that compares an aggregate with the < SQL operator.

For example:

Author.having(3 < Author.books.count)

Returns an aggregate that compares two aggregates with the > SQL operator.

For example:

Author.having(Author.books.count > Author.paintings.count)

Returns an aggregate that compares an aggregate with the > SQL operator.

For example:

Author.having(Author.books.count > 3)

Returns an aggregate that compares an aggregate with the > SQL operator.

For example:

Author.having(3 > Author.books.count)

Returns an aggregate that compares two aggregates with the >= SQL operator.

For example:

Author.having(Author.books.count >= Author.paintings.count)

Returns an aggregate that compares an aggregate with the >= SQL operator.

For example:

Author.having(Author.books.count >= 3)

Returns an aggregate that compares an aggregate with the >= SQL operator.

For example:

Author.having(3 >= Author.books.count)

Returns an arithmetically negated aggregate.

For example:

Author.annotated(with: -Author.books.count)

Returns an aggregate that sums two aggregates with the + SQL operator.

For example:

Author.annotated(with: Author.books.count + Author.paintings.count)

Returns an aggregate that sums an aggregate with the + SQL operator.

For example:

Author.annotated(with: Author.books.count + 1)

Returns an aggregate that sums an aggregate with the + SQL operator.

For example:

Author.annotated(with: 1 + Author.books.count)

Returns an aggregate that substracts two aggregates with the - SQL operator.

For example:

Author.annotated(with: Author.books.count - Author.paintings.count)

Returns an aggregate that substracts an aggregate with the - SQL operator.

For example:

Author.annotated(with: Author.books.count - 1)

Returns an aggregate that substracts an aggregate with the - SQL operator.

For example:

Author.annotated(with: 1 - Author.books.count)

Returns an aggregate that multiplies two aggregates with the * SQL operator.

For example:

Author.annotated(with: Author.books.count * Author.paintings.count)

Returns an aggregate that substracts an aggregate with the * SQL operator.

For example:

Author.annotated(with: Author.books.count * 2)

Returns an aggregate that substracts an aggregate with the * SQL operator.

For example:

Author.annotated(with: 2 * Author.books.count)

Returns an aggregate that multiplies two aggregates with the / SQL operator.

For example:

Author.annotated(with: Author.books.count / Author.paintings.count)

Returns an aggregate that substracts an aggregate with the / SQL operator.

For example:

Author.annotated(with: Author.books.count / 2)

Returns an aggregate that substracts an aggregate with the / SQL operator.

For example:

Author.annotated(with: 2 / Author.books.count)

Returns an aggregate that evaluates the IFNULL SQL function.

Team.annotated(with: Team.players.min(Column("score")) ?? 0)

Returns an aggregate that evaluates to the absolute value of the input aggregate.

Returns an aggregate that evaluates the LENGTH SQL function on the input aggregate.

Creates an assignment that adds a value

Column("score") += 1
Column("score") += Column("bonus")

try dbQueue.write { db in
    // UPDATE player SET score = score + 1
    try Player.updateAll(db, Column("score") += 1)
}

Creates an assignment that subtracts a value

Column("score") -= 1
Column("score") -= Column("bonus")

try dbQueue.write { db in
    // UPDATE player SET score = score - 1
    try Player.updateAll(db, Column("score") -= 1)
}

Creates an assignment that multiplies by a value

Column("score") *= 2
Column("score") *= Column("factor")

try dbQueue.write { db in
    // UPDATE player SET score = score * 2
    try Player.updateAll(db, Column("score") *= 2)
}

Creates an assignment that divides by a value

Column("score") /= 2
Column("score") /= Column("factor")

try dbQueue.write { db in
    // UPDATE player SET score = score / 2
    try Player.updateAll(db, Column("score") /= 2)
}

Returns an expression that evaluates the ABS SQL function.

// ABS(amount)
abs(Column("amount"))

Returns an expression that evaluates the AVG SQL function.

// AVG(length)
average(Column("length"))

Returns an expression that evaluates the COUNT SQL function.

// COUNT(email)
count(Column("email"))

Returns an expression that evaluates the COUNT(DISTINCT) SQL function.

// COUNT(DISTINCT email)
count(distinct: Column("email"))

Returns an expression that evaluates the IFNULL SQL function.

// IFNULL(name, 'Anonymous')
Column("name") ?? "Anonymous"

Returns an expression that evaluates the LENGTH SQL function.

// LENGTH(name)
length(Column("name"))

Returns an expression that evaluates the MAX SQL function.

// MAX(score)
max(Column("score"))

Returns an expression that evaluates the MIN SQL function.

// MIN(score)
min(Column("score"))

Returns an expression that evaluates the SUM SQL function.

See https://www.sqlite.org/lang_aggfunc.html#sumunc.

See also total(_:).

// SUM(amount)
sum(Column("amount"))

Returns an expression that evaluates the TOTAL SQL function.

See https://www.sqlite.org/lang_aggfunc.html#sumunc.

See also sum(_:).

// TOTAL(amount)
total(Column("amount"))

Returns an expression that evaluates the JULIANDAY SQL function.

// JULIANDAY(date)
julianDay(Column("date"))

// JULIANDAY(date, '1 days')
julianDay(Column("date"), .day(1))

For more information, see https://www.sqlite.org/lang_datefunc.html

Returns an expression that evaluates the DATETIME SQL function.

// DATETIME(date)
dateTime(Column("date"))

// DATETIME(date, '1 days')
dateTime(Column("date"), .day(1))

For more information, see https://www.sqlite.org/lang_datefunc.html

An SQL expression that compares two expressions with the = SQL operator.

// name = 'Arthur'
Column("name") == "Arthur"

When the right operand is nil, IS NULL is used instead.

// name IS NULL
Column("name") == nil

An SQL expression that checks the boolean value of an expression.

The comparison is done with the built-in boolean evaluation of SQLite:

// validated
Column("validated") == true

// NOT validated
Column("validated") == false

An SQL expression that compares two expressions with the = SQL operator.

// 'Arthur' = name
"Arthur" == Column("name")

When the left operand is nil, IS NULL is used instead.

// name IS NULL
nil == Column("name")

An SQL expression that checks the boolean value of an expression.

The comparison is done with the built-in boolean evaluation of SQLite:

// validated
true == Column("validated")

// NOT validated
false == Column("validated")

An SQL expression that compares two expressions with the = SQL operator.

// email = login
Column("email") == Column("login")

An SQL expression that compares two expressions with the <> SQL operator.

// name <> 'Arthur'
Column("name") != "Arthur"

When the right operand is nil, IS NOT NULL is used instead.

// name IS NOT NULL
Column("name") != nil

An SQL expression that checks the boolean value of an expression.

The comparison is done with the built-in boolean evaluation of SQLite:

// NOT validated
Column("validated") != true

// validated
Column("validated") != false

An SQL expression that compares two expressions with the <> SQL operator.

// 'Arthur' <> name
"Arthur" != Column("name")

When the left operand is nil, IS NOT NULL is used instead.

// name IS NOT NULL
nil != Column("name")

An SQL expression that checks the boolean value of an expression.

The comparison is done with the built-in boolean evaluation of SQLite:

// NOT validated
true != Column("validated")

// validated
false != Column("validated")

An SQL expression that compares two expressions with the <> SQL operator.

// email <> login
Column("email") != Column("login")

An SQL expression that compares two expressions with the IS SQL operator.

// name IS 'Arthur'
Column("name") === "Arthur"

An SQL expression that compares two expressions with the IS SQL operator.

// name IS 'Arthur'
"Arthur" === Column("name")

An SQL expression that compares two expressions with the IS SQL operator.

// email IS login
Column("email") === Column("login")

An SQL expression that compares two expressions with the IS NOT SQL operator.

// name IS NOT 'Arthur'
Column("name") !== "Arthur"

An SQL expression that compares two expressions with the IS NOT SQL operator.

// name IS NOT 'Arthur'
"Arthur" !== Column("name")

An SQL expression that compares two expressions with the IS NOT SQL operator.

// email IS NOT login
Column("email") !== Column("login")

An SQL expression that compares two expressions with the < SQL operator.

// score < 18
Column("score") < 18

An SQL expression that compares two expressions with the < SQL operator.

// 18 < score
18 < Column("score")

An SQL expression that compares two expressions with the < SQL operator.

// width < height
Column("width") < Column("height")

An SQL expression that compares two expressions with the <= SQL operator.

// score <= 18
Column("score") <= 18

An SQL expression that compares two expressions with the <= SQL operator.

// 18 <= score
18 <= Column("score")

An SQL expression that compares two expressions with the <= SQL operator.

// width <= height
Column("width") <= Column("height")

An SQL expression that compares two expressions with the > SQL operator.

// score > 18
Column("score") > 18

An SQL expression that compares two expressions with the > SQL operator.

// 18 > score
18 > Column("score")

An SQL expression that compares two expressions with the > SQL operator.

// width > height
Column("width") > Column("height")

An SQL expression that compares two expressions with the >= SQL operator.

// score >= 18
Column("score") >= 18

An SQL expression that compares two expressions with the >= SQL operator.

// 18 >= score
18 >= Column("score")

An SQL expression that compares two expressions with the >= SQL operator.

// width >= height
Column("width") >= Column("height")

An SQL arithmetic multiplication.

// width * 2
Column("width") * 2

An SQL arithmetic multiplication.

// 2 * width
2 * Column("width")

An SQL arithmetic multiplication.

// width * height
Column("width") * Column("height")

An SQL arithmetic division.

// width / 2
Column("width") / 2

An SQL arithmetic division.

// 2 / width
2 / Column("width")

An SQL arithmetic division.

// width / height
Column("width") / Column("height")

An SQL arithmetic addition.

// width + 2
Column("width") + 2

An SQL arithmetic addition.

// 2 + width
2 + Column("width")

An SQL arithmetic addition.

// width + height
Column("width") + Column("height")

A negated SQL arithmetic expression.

// -width
-Column("width")

An SQL arithmetic substraction.

// width - 2
Column("width") - 2

An SQL arithmetic substraction.

// 2 - width
2 - Column("width")

An SQL arithmetic substraction.

// width - height
Column("width") - Column("height")

A logical SQL expression with the AND SQL operator.

// favorite AND 0
Column("favorite") && false

A logical SQL expression with the AND SQL operator.

// 0 AND favorite
false && Column("favorite")

A logical SQL expression with the AND SQL operator.

// email IS NOT NULL AND favorite
Column("email") != nil && Column("favorite")

A logical SQL expression with the OR SQL operator.

// favorite OR 1
Column("favorite") || true

A logical SQL expression with the OR SQL operator.

// 0 OR favorite
true || Column("favorite")

A logical SQL expression with the OR SQL operator.

// email IS NULL OR hidden
Column("email") == nil || Column("hidden")

A negated logical SQL expression with the NOT SQL operator.

// NOT hidden
!Column("hidden")

Some expressions may be negated with specific SQL operators:

// id NOT BETWEEN 1 AND 10
!((1...10).contains(Column("id")))

Return as many question marks separated with commas as the count argument.

databaseQuestionMarks(count: 3) // "?,?,?"