Crate rusqlite 

Rusqlite is an ergonomic wrapper for using SQLite from Rust.

Historically, the API was based on the one from rust-postgres. However, the two have diverged in many ways, and no compatibility between the two is intended.

use rusqlite::{params, Connection, Result};

#[derive(Debug)]
struct Person {
    id: i32,
    name: String,
    data: Option<Vec<u8>>,
}

fn main() -> Result<()> {
    let conn = Connection::open_in_memory()?;

    conn.execute(
        "CREATE TABLE person (
            id   INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            data BLOB
        )",
        (), // empty list of parameters.
    )?;
    let me = Person {
        id: 0,
        name: "Steven".to_string(),
        data: None,
    };
    conn.execute(
        "INSERT INTO person (name, data) VALUES (?1, ?2)",
        (&me.name, &me.data),
    )?;

    let mut stmt = conn.prepare("SELECT id, name, data FROM person")?;
    let person_iter = stmt.query_map([], |row| {
        Ok(Person {
            id: row.get(0)?,
            name: row.get(1)?,
            data: row.get(2)?,
        })
    })?;

    for person in person_iter {
        println!("Found person {:?}", person?);
    }
    Ok(())
}

Re-exports

pub use crate::types::ToSql;

pub use fallible_iterator;

pub use fallible_streaming_iterator;

pub use libsqlite3_sys as ffi;

Modules

auto_extension

Automatic extension loading

bind 🔒

busy 🔒

Busy handler (when the database is locked)

cache 🔒

Prepared statements cache for faster execution.

column 🔒

config

Configure database connections

error 🔒

inner_connection 🔒

params 🔒

pragma 🔒

Pragma helpers

raw_statement 🔒

row 🔒

statement 🔒

transaction 🔒

types

Traits dealing with SQLite data types.

util 🔒

version 🔒

Macros

named_params

A macro making it more convenient to pass lists of named parameters as a &[(&str, &dyn ToSql)].

params

A macro making it more convenient to pass longer lists of parameters as a &[&dyn ToSql].

Structs

AndThenRows

An iterator over the mapped resulting rows of a query, with an Error type unifying with Error.

Batch

Batch fallible iterator

CachedStatement

Cacheable statement.

Connection

A connection to a SQLite database.

InterruptHandle

Allows interrupting a long-running computation.

Map

F is used to transform the streaming iterator into a fallible iterator.

MappedRows

An iterator over the mapped resulting rows of a query.

OpenFlags

Flags for opening SQLite database connections. See sqlite3_open_v2 for details.

ParamsFromIter

Adapter type which allows any iterator over ToSql values to implement Params.

PrepFlags

Prepare flags. See sqlite3_prepare_v3 for details.

Row

A single result row of a query.

Rows

A handle (lazy fallible streaming iterator) for the resulting rows of a query.

Savepoint

Represents a savepoint on a database connection.

Statement

A prepared statement.

Transaction

Represents a transaction on a database connection.

Enums

DropBehavior

Options for how a Transaction or Savepoint should behave when it is dropped.

Error

Enum listing possible errors from rusqlite.

ErrorCode

Error Codes

StatementStatus

Prepared statement status counters.

TransactionBehavior

Options for transaction behavior. See BEGIN TRANSACTION for details.

TransactionState

Transaction state of a database

Constants

MAIN_DB

Shorthand for Main database.

STATEMENT_CACHE_DEFAULT_CAPACITY 🔒

TEMP_DB

Shorthand for Temp database.

Traits

BindIndex

A trait implemented by types that can index into parameters of a statement.

Name

Database, table, column, collation, function, module, vfs name

OptionalExtension

See the method documentation.

Params

Trait used for sets of parameter passed into SQL statements/queries.

RowIndex

A trait implemented by types that can index into columns of a row.

Functions

errmsg_to_string 🔒 ^⚠

len_as_c_int 🔒

params_from_iter

Constructor function for a ParamsFromIter. See its documentation for more.

path_to_cstring 🔒

str_for_sqlite 🔒

Returns Ok((string ptr, len as c_int, SQLITE_STATIC | SQLITE_TRANSIENT)) normally. Returns error if the string is too large for sqlite. The sqlite3_destructor_type item is always SQLITE_TRANSIENT unless the string was empty (in which case it’s SQLITE_STATIC, and the ptr is static).

to_sqlite_error^⚠

Transform Rust error to SQLite error (message and code).

version

Returns the SQLite version as a string; e.g., "3.16.2" for version 3.16.2.

version_number

Returns the SQLite version as an integer; e.g., 3016002 for version 3.16.2.

Type Aliases

Result

A typedef of the result returned by many methods.