Functions Reference


                    
                    
                    splittingRowAdapters(columnCounts:)

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]

Logical Operators (AND, OR, NOT)

!(_:)
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)

Egality and Identity Operators (=, <>, IS, IS NOT)

==(_:_:)
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 two aggregates with the <> SQL operator.

For example:
```
Author.having(Author.books.count != Author.paintings.count)
```
===(_:_:)
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 two aggregates with the IS NOT SQL operator.

For example:
```
Author.having(Author.books.count !== Author.paintings.count)
```

Comparison Operators (<, >, <=, >=)

<=(_:_:)
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 two aggregates with the < SQL operator.

For example:
```
Author.having(Author.books.count < Author.paintings.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 two aggregates with the >= SQL operator.

For example:
```
Author.having(Author.books.count >= Author.paintings.count)
```

Arithmetic Operators (+, -, *, /)

-(_:)
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 substracts two aggregates with the - SQL operator.

For example:
```
Author.annotated(with: Author.books.count - Author.paintings.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 multiplies two aggregates with the / SQL operator.

For example:
```
Author.annotated(with: Author.books.count / Author.paintings.count)
```

IFNULL(…)

??(_:_:)
Returns an aggregate that evaluates the IFNULL SQL function.
```
Team.annotated(with: Team.players.min(Column("score")) ?? 0)
```

ABS(…)

abs(_:)

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

LENGTH(…)

length(_:)

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

ColumnAssignment


                    
                    
                    +=(_:_:)

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

AVG(…)

average(_:)
Returns an expression that evaluates the AVG SQL function.
```
// AVG(length)
average(Column("length"))
```

COUNT(…)

count(_:)
Returns an expression that evaluates the COUNT SQL function.
```
// COUNT(email)
count(Column("email"))
```

COUNT(DISTINCT …)

count(distinct:)
Returns an expression that evaluates the COUNT(DISTINCT) SQL function.
```
// COUNT(DISTINCT email)
count(distinct: Column("email"))
```

MAX(…)

max(_:)
Returns an expression that evaluates the MAX SQL function.
```
// MAX(score)
max(Column("score"))
```

MIN(…)

min(_:)
Returns an expression that evaluates the MIN SQL function.
```
// MIN(score)
min(Column("score"))
```

SUM(…)

sum(_:)
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"))
```

TOTAL(…)

total(_:)
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"))
```

JULIANDAY(…)

julianDay(_:_:)
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

DATETIME(…)

dateTime(_:_:)
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

Public

databaseQuestionMarks(count:)
Return as many question marks separated with commas as the count argument.
```
databaseQuestionMarks(count: 3) // "?,?,?"
```