http://www.sqlite.org/c3ref/open.html

http://www.sqlite.org/c3ref/close.html

Execute zero or more SQL statements delimited by semicolons.

Like exec, but print result rows to stdout.

This is mainly for convenience when experimenting in GHCi. The output format may change in the future.

Like exec, but invoke the callback for each result row.

http://www.sqlite.org/c3ref/prepare.html

Unlike exec, prepare only executes the first statement, and ignores subsequent statements.

If the query string contains no SQL statements, this fails.

http://www.sqlite.org/c3ref/prepare.html

It can help to avoid redundant Utf8 to Text conversion if you already have Utf8

If the query string contains no SQL statements, this fails.

http://www.sqlite.org/c3ref/step.html

http://www.sqlite.org/c3ref/reset.html

Note that in the C API, sqlite3_reset returns an error code if the most recent sqlite3_step indicated an error. We do not replicate that behavior here. reset never throws an exception.

http://www.sqlite.org/c3ref/finalize.html

Like reset, finalize never throws an exception.

http://www.sqlite.org/c3ref/clear_bindings.html

Set all parameters in the prepared statement to null.

http://www.sqlite.org/c3ref/bind_parameter_count.html

This returns the index of the largest (rightmost) parameter. Note that this is not necessarily the number of parameters. If numbered parameters like ?5 are used, there may be gaps in the list.

See ParamIndex for more information.

http://www.sqlite.org/c3ref/bind_parameter_name.html

Return the N-th SQL parameter name.

Named parameters are returned as-is. E.g. ":v" is returned as Just ":v". Unnamed parameters, however, are converted to Nothing.

Note that the parameter index starts at 1, not 0.

http://www.sqlite.org/c3ref/column_count.html

http://www.sqlite.org/c3ref/column_name.html

Return the name of a result column. If the column index is out of range, return Nothing.

If the index is not between 1 and bindParameterCount inclusive, this fails with ErrorRange. Otherwise, it succeeds, even if the query skips this index by using numbered parameters.

Example:

> stmt <- prepare conn "SELECT ?1, ?3, ?5"
> bindSQLData stmt 1 (SQLInteger 1)
> bindSQLData stmt 2 (SQLInteger 2)
> bindSQLData stmt 6 (SQLInteger 6)
*** Exception: SQLite3 returned ErrorRange while attempting to perform bind int64.
> step stmt >> columns stmt
[SQLInteger 1,SQLNull,SQLNull]

Convenience function for binding values to all parameters. This will fail if the list has the wrong number of parameters.

Convenience function for binding named values to all parameters. This will fail if the list has the wrong number of parameters or if an unknown name is used.

Example:

stmt <- prepare conn "SELECT :foo + :bar"
bindNamed stmt [(":foo", SQLInteger 1), (":bar", SQLInteger 2)]

This avoids extra API calls using the list of column types. If passed types do not correspond to the actual types, the values will be converted according to the rules at http://www.sqlite.org/c3ref/column_blob.html. If the list contains more items that number of columns, the result is undefined.

This will throw a DecodeError if the datum contains invalid UTF-8. If this behavior is undesirable, you can use columnText from Database.SQLite3.Direct, which does not perform conversion to Text.

http://www.sqlite.org/c3ref/last_insert_rowid.html

http://www.sqlite.org/c3ref/changes.html

Return the number of rows that were changed, inserted, or deleted by the most recent INSERT, DELETE, or UPDATE statement.

http://sqlite.org/c3ref/create_function.html

Create a custom SQL function or redefine the behavior of an existing function. If the function is deterministic, i.e. if it always returns the same result given the same input, you can set the boolean flag to let sqlite perform additional optimizations.

Like createFunction except that it creates an aggregate function.

Delete an SQL function (scalar or aggregate).

https://www.sqlite.org/c3ref/context_db_handle.html

http://www.sqlite.org/c3ref/create_collation.html

Delete a collation.

http://www.sqlite.org/c3ref/interrupt.html

Cause any pending operation on the Database handle to stop at its earliest opportunity. This simply sets a flag and returns immediately. It does not wait for the pending operation to finish.

You'll need to compile with -threaded for this to do any good. Without -threaded, FFI calls block the whole RTS, meaning interrupt would never run at the same time as step.

Make it possible to interrupt the given database operation with an asynchronous exception. This only works if the program is compiled with base >= 4.3 and -threaded.

It works by running the callback in a forked thread. If interrupted, it uses interrupt to try to stop the operation.

https://www.sqlite.org/c3ref/blob_open.html

Open a blob for incremental I/O.

https://www.sqlite.org/c3ref/blob_close.html

https://www.sqlite.org/c3ref/blob_reopen.html

https://www.sqlite.org/c3ref/blob_bytes.html

https://www.sqlite.org/c3ref/blob_read.html

https://www.sqlite.org/c3ref/blob_write.html

Exception thrown when SQLite3 reports an error.

direct-sqlite may throw other types of exceptions if you misuse the API.

The context in which a custom SQL function is executed.

The arguments of a custom SQL function.

The type of blob handles used for incremental blob I/O

A handle for an online backup process.

Index of a parameter in a parameterized query. Parameter indices start from 1.

When a query is prepared, SQLite allocates an array indexed from 1 to the highest parameter index. For example:

>Right stmt <- prepare conn "SELECT ?1, ?5, ?3, ?"
>bindParameterCount stmt
ParamIndex 6

This will allocate an array indexed from 1 to 6 (? takes the highest preceding index plus one). The array is initialized with null values. When you bind a parameter with bindSQLData, it assigns a new value to one of these indices.

See http://www.sqlite.org/lang_expr.html#varparam for the syntax of parameter placeholders, and how parameter indices are assigned.

Index of a column in a result set. Column indices start from 0.

Number of columns in a result set.

Number of arguments of a user defined SQL function.

Index of an argument to a custom function. Indices start from 0.