StatementArguments
public struct StatementArguments
StatementArguments provide values to argument placeholders in raw SQL queries.
Placeholders can take several forms (see https://www.sqlite.org/lang_expr.html#varparam for more information):
?NNN
(e.g.?2
): the NNN-th argument (starts at 1)?
: the N-th argument, where N is one greater than the largest argument number already assigned:AAAA
(e.g.:name
): named argument$AAAA
(e.g.$name
): named argument
Positional Arguments
To fill question marks placeholders, feed StatementArguments with an array:
db.execute(
"INSERT ... (?, ?)",
arguments: StatementArguments(["Arthur", 41]))
// Array literals are automatically converted:
db.execute(
"INSERT ... (?, ?)",
arguments: ["Arthur", 41])
Named Arguments
To fill named arguments, feed StatementArguments with a dictionary:
db.execute(
"INSERT ... (:name, :age)",
arguments: StatementArguments(["name": "Arthur", "age": 41]))
// Dictionary literals are automatically converted:
db.execute(
"INSERT ... (:name, :age)",
arguments: ["name": "Arthur", "age": 41])
Concatenating Arguments
Several arguments can be concatenated and mixed with the
append(contentsOf:)
method and the +
, &+
, +=
operators:
var arguments: StatementArguments = ["Arthur"]
arguments += [41]
db.execute("INSERT ... (?, ?)", arguments: arguments)
+
and +=
operators consider that overriding named arguments is a
programmer error:
var arguments: StatementArguments = ["name": "Arthur"]
arguments += ["name": "Barbara"]
// fatal error: already defined statement argument: name
&+
and append(contentsOf:)
allow overriding named arguments:
var arguments: StatementArguments = ["name": "Arthur"]
arguments = arguments &+ ["name": "Barbara"]
print(arguments)
// Prints ["name": "Barbara"]
Mixed Arguments
When a statement consumes a mix of named and positional arguments, it prefers named arguments over positional ones. For example:
let sql = "SELECT ?2 AS two, :foo AS foo, ?1 AS one, :foo AS foo2, :bar AS bar"
let row = try Row.fetchOne(db, sql, arguments: [1, 2, "bar"] + ["foo": "foo"])!
print(row)
// Prints <Row two:2 foo:"foo" one:1 foo2:"foo" bar:"bar">
-
Undocumented
Declaration
Swift
public struct StatementArguments
-
Initializes arguments from a sequence of optional values.
let values: [DatabaseValueConvertible?] = ["foo", 1, nil] db.execute("INSERT ... (?,?,?)", arguments: StatementArguments(values))
Declaration
Swift
public init<Sequence: Swift.Sequence>(_ sequence: Sequence) where Sequence.Iterator.Element == DatabaseValueConvertible?
Parameters
sequence
A sequence of DatabaseValueConvertible values.
Return Value
A StatementArguments.
-
Initializes arguments from a sequence of optional values.
let values: [String] = ["foo", "bar"] db.execute("INSERT ... (?,?)", arguments: StatementArguments(values))
Declaration
Swift
public init<Sequence: Swift.Sequence>(_ sequence: Sequence) where Sequence.Iterator.Element: DatabaseValueConvertible
Parameters
sequence
A sequence of DatabaseValueConvertible values.
Return Value
A StatementArguments.
-
Initializes arguments from [Any].
The result is nil unless all objects adopt DatabaseValueConvertible.
Declaration
Swift
public init?(_ array: [Any])
Parameters
array
An array
Return Value
A StatementArguments.
-
Initializes arguments from a sequence of (key, value) dictionary, such as a dictionary.
let values: [String: DatabaseValueConvertible?] = ["firstName": nil, "lastName": "Miller"] db.execute("INSERT ... (:firstName, :lastName)", arguments: StatementArguments(values))
Declaration
Swift
public init(_ dictionary: [String: DatabaseValueConvertible?])
Parameters
sequence
A sequence of (key, value) pairs
Return Value
A StatementArguments.
-
Initializes arguments from a sequence of (key, value) pairs, such as a dictionary.
let values: [String: DatabaseValueConvertible?] = ["firstName": nil, "lastName": "Miller"] db.execute("INSERT ... (:firstName, :lastName)", arguments: StatementArguments(values))
Declaration
Swift
public init<Sequence: Swift.Sequence>(_ sequence: Sequence) where Sequence.Iterator.Element == (String, DatabaseValueConvertible?)
Parameters
sequence
A sequence of (key, value) pairs
Return Value
A StatementArguments.
-
Initializes arguments from [AnyHashable: Any].
The result is nil unless all dictionary keys are strings, and values adopt DatabaseValueConvertible.
Declaration
Swift
public init?(_ dictionary: [AnyHashable: Any])
Parameters
dictionary
A dictionary.
Return Value
A StatementArguments.
-
Extends statement arguments with other arguments.
Positional arguments (provided as arrays) are concatenated:
var arguments: StatementArguments = [1] arguments.append(contentsOf: [2, 3]) print(arguments) // Prints [1, 2, 3]
Named arguments (provided as dictionaries) are updated:
var arguments: StatementArguments = ["foo": 1] arguments.append(contentsOf: ["bar": 2]) print(arguments) // Prints ["foo": 1, "bar": 2]
Arguments that were replaced, if any, are returned:
var arguments: StatementArguments = ["foo": 1, "bar": 2] let replacedValues = arguments.append(contentsOf: ["foo": 3]) print(arguments) // Prints ["foo": 3, "bar": 2] print(replacedValues) // Prints ["foo": 1]
You can mix named and positional arguments (see documentation of the StatementArguments type for more information about mixed arguments):
var arguments: StatementArguments = ["foo": 1] arguments.append(contentsOf: [2, 3]) print(arguments) // Prints ["foo": 1, 2, 3]
Declaration
Swift
public mutating func append(contentsOf arguments: StatementArguments) -> [String: DatabaseValue]
-
Creates a new StatementArguments by extending the left-hand size arguments with the right-hand side arguments.
Positional arguments (provided as arrays) are concatenated:
let arguments: StatementArguments = [1] + [2, 3] print(arguments) // Prints [1, 2, 3]
Named arguments (provided as dictionaries) are updated:
let arguments: StatementArguments = ["foo": 1] + ["bar": 2] print(arguments) // Prints ["foo": 1, "bar": 2]
You can mix named and positional arguments (see documentation of the StatementArguments type for more information about mixed arguments):
let arguments: StatementArguments = ["foo": 1] + [2, 3] print(arguments) // Prints ["foo": 1, 2, 3]
If the arguments on the right-hand side has named parameters that are already defined on the left, a fatal error is raised:
let arguments: StatementArguments = ["foo": 1] + ["foo": 2] // fatal error: already defined statement argument: foo
This fatal error can be avoided with the &+ operator, or the append(contentsOf:) method.
Declaration
Swift
public static func + (lhs: StatementArguments, rhs: StatementArguments) -> StatementArguments
-
Creates a new StatementArguments by extending the left-hand size arguments with the right-hand side arguments.
Positional arguments (provided as arrays) are concatenated:
let arguments: StatementArguments = [1] &+ [2, 3] print(arguments) // Prints [1, 2, 3]
Named arguments (provided as dictionaries) are updated:
let arguments: StatementArguments = ["foo": 1] &+ ["bar": 2] print(arguments) // Prints ["foo": 1, "bar": 2]
You can mix named and positional arguments (see documentation of the StatementArguments type for more information about mixed arguments):
let arguments: StatementArguments = ["foo": 1] &+ [2, 3] print(arguments) // Prints ["foo": 1, 2, 3]
If a named arguments is defined in both arguments, the right-hand side wins:
let arguments: StatementArguments = ["foo": 1] &+ ["foo": 2] print(arguments) // Prints ["foo": 2]
Declaration
Swift
public static func &+ (lhs: StatementArguments, rhs: StatementArguments) -> StatementArguments
-
Extends the left-hand size arguments with the right-hand side arguments.
Positional arguments (provided as arrays) are concatenated:
var arguments: StatementArguments = [1] arguments += [2, 3] print(arguments) // Prints [1, 2, 3]
Named arguments (provided as dictionaries) are updated:
var arguments: StatementArguments = ["foo": 1] arguments += ["bar": 2] print(arguments) // Prints ["foo": 1, "bar": 2]
You can mix named and positional arguments (see documentation of the StatementArguments type for more information about mixed arguments):
var arguments: StatementArguments = ["foo": 1] arguments.append(contentsOf: [2, 3]) print(arguments) // Prints ["foo": 1, 2, 3]
If the arguments on the right-hand side has named parameters that are already defined on the left, a fatal error is raised:
var arguments: StatementArguments = ["foo": 1] arguments += ["foo": 2] // fatal error: already defined statement argument: foo
This fatal error can be avoided with the &+ operator, or the append(contentsOf:) method.
Declaration
Swift
public static func += (lhs: inout StatementArguments, rhs: StatementArguments)
-
Returns a StatementArguments from an array literal:
db.selectRows("SELECT ...", arguments: ["Arthur", 41])
Declaration
Swift
public init(arrayLiteral elements: DatabaseValueConvertible?...)
-
Returns a StatementArguments from a dictionary literal:
db.selectRows("SELECT ...", arguments: ["name": "Arthur", "age": 41])
Declaration
Swift
public init(dictionaryLiteral elements: (String, DatabaseValueConvertible?)...)
-
A textual representation of
self
.Declaration
Swift
public var description: String