Crate rusqlite[][src]

Expand description

Rusqlite is an ergonomic wrapper for using SQLite from Rust. It attempts to expose an interface similar to rust-postgres.

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
                  )",
        [],
    )?;
    let me = Person {
        id: 0,
        name: "Steven".to_string(),
        data: None,
    };
    conn.execute(
        "INSERT INTO person (name, data) VALUES (?1, ?2)",
        params![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.unwrap());
    }
    Ok(())
}

Re-exports

pub use libsqlite3_sys as ffi;

Modules

feature = "backup" Online SQLite backup API.

feature = "blob" Incremental BLOB I/O.

Configure database connections

feature = "functions" Create or redefine SQL functions.

feature = "limits" Run-Time Limits

feature = "trace" Tracing and profiling functions. Error and warning log.

Traits dealing with SQLite data types.

feature = "vtab" Create virtual tables.

Macros

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

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

Structs

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

Batch iterator

Cacheable statement.

Information about a column of a SQLite query.

A connection to a SQLite database.

Allows interrupting a long-running computation.

feature = "load_extension" RAII guard temporarily enabling SQLite extensions to be loaded.

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

An iterator over the mapped resulting rows of a query.

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

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

A single result row of a query.

An handle for the resulting rows of a query.

Represents a savepoint on a database connection.

A prepared statement.

Represents a transaction on a database connection.

Enums

Name for a database within a SQLite connection.

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

Enum listing possible errors from rusqlite.

Error Codes

Prepared statement status counters.

Options for transaction behavior. See BEGIN TRANSACTION for details.

Constants

NO_PARAMSDeprecated

To be used when your statement has no parameter.

Traits

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

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

A trait for types that can be converted into SQLite values. Returns Error::ToSqlConversionFailure if the conversion fails.

Functions

rusqlite’s check for a safe SQLite threading mode requires SQLite 3.7.0 or later. If you are running against a SQLite older than that, rusqlite attempts to ensure safety by performing configuration and initialization of SQLite itself the first time you attempt to open a connection. By default, rusqlite panics if that initialization fails, since that could mean SQLite has been initialized in single-thread mode.

rusqlite performs a one-time check that the runtime SQLite version is at least as new as the version of SQLite found when rusqlite was built. Bypassing this check may be dangerous; e.g., if you use features of SQLite that are not present in the runtime version.

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

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

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

Type Definitions

A typedef of the result returned by many methods.