Rusqlite

https://docs.rs/rusqlite/latest/rusqlite/
Admin
Rusqlite is a Rust library providing an ergonomic interface to SQLite for Rust applications.
Tokens:635,960
Snippets:5,488
Trust Score:9.1
Update:1 week ago
Show doc for...
Tokens:
Raw
### partition_point basic example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows how to use partition_point to find the index where the predicate changes from true to false. The example uses a slice of integers and checks the partitions.

```rust
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);

assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

--------------------------------

### Rusqlite Example: Create Table, Insert, and Query

Source: https://docs.rs/rusqlite/latest/rusqlite/index.html?search=

This example shows how to use Rusqlite to open an in-memory SQLite database, create a table, insert a row with parameters, and query the data using a prepared statement. It demonstrates the use of the Connection, params, and Result types. The example prints each found person to the console.

```rust
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(())
}
```

--------------------------------

### Option::is_none_or example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Demonstrates is_none_or, which returns true if the option is None or the value matches a predicate. Includes examples with ownership and as_ref.

```rust
let x: Option<u32> = Some(2);
assert_eq!(x.is_none_or(|x| x > 1), true);

let x: Option<u32> = Some(0);
assert_eq!(x.is_none_or(|x| x > 1), false);

let x: Option<u32> = None;
assert_eq!(x.is_none_or(|x| x > 1), true);

let x: Option<String> = Some("ownership".to_string());
assert_eq!(x.as_ref().is_none_or(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### Example for Result::is_ok_and

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html

Example for the is_ok_and method on Result<T, E>, which returns true if the result is Ok and the value matches a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### Option::is_some_and example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Demonstrates is_some_and, which returns true if the option is Some and the value matches a predicate. Includes examples with ownership and as_ref.

```rust
let x: Option<u32> = Some(2);
assert_eq!(x.is_some_and(|x| x > 1), true);

let x: Option<u32> = Some(0);
assert_eq!(x.is_some_and(|x| x > 1), false);

let x: Option<u32> = None;
assert_eq!(x.is_some_and(|x| x > 1), false);

let x: Option<String> = Some("ownership".to_string());
assert_eq!(x.as_ref().is_some_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### len example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows how to get the number of elements in a slice using len.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Get strong count from raw pointer with Rc::strong_count_from_raw

Source: https://docs.rs/rusqlite/latest/rusqlite/vtab/array/type.Array.html

Nightly-only example using the arc_raw_get_strong feature. Demonstrates getting the strong count from a raw pointer without consuming the Rc. The pointer must point to a live Rc allocation. The example converts back to Rc to avoid leaking memory.

```rust
#![feature(arc_raw_get_strong)]
use std::rc::Rc;

let five = Rc::new(5);
let _also_five = Rc::clone(&five);
let ptr = Rc::into_raw(five);

unsafe {
    assert_eq!(2, Rc::strong_count_from_raw(ptr));

    // Convert back to an `Rc` to avoid leaking memory.
    let five = Rc::from_raw(ptr);
    assert_eq!(2, Rc::strong_count(&five));
}
```

--------------------------------

### element_offset basic usage

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows how to use element_offset to get the index of an element reference within a slice. The example gets a reference to the third element and verifies the offset is 2.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

--------------------------------

### prepare example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/struct.ConnectionRef.html?search=

Prepares a SQL statement and executes it multiple times with different parameters. The statement is prepared once and reused for each execution.

```rust
fn insert_new_people(conn: &Connection) -> Result<()> {
    let mut stmt = conn.prepare("INSERT INTO People (name) VALUES (?1)")?;
    stmt.execute(["Joe Smith"])?;
    stmt.execute(["Bob Jones"])?;
    Ok(())
}
```

--------------------------------

### prepare_and_bind! usage example

Source: https://docs.rs/rusqlite/latest/rusqlite/macro.prepare_and_bind.html?search=u32+-%3E+bool

Shows how to use prepare_and_bind! with a connection and a SQL literal. Only SQLite `$x`, `@x`, and `:x` parameter syntax works; Rust `&x` syntax and `$x.y` expressions are not supported.

```rust
fn misc(db: &Connection) -> Result<Statement> {
    let name = "Lisa";
    let age = 8;
    let smart = true;
    Ok(prepare_and_bind!(db, "SELECT $name, @age, :smart;"))
}
```

--------------------------------

### get example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Returns a reference to an element or subslice depending on the index type. Returns None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Blob I/O Example (std::io)

Source: https://docs.rs/rusqlite/latest/rusqlite/blob/index.html

Opens an in-memory database, creates a table, inserts a BLOB using ZEROBLOB, opens it for I/O, writes and reads data, and demonstrates reopening a blob on a new row. Note that the Blob I/O API cannot insert or resize BLOBs; use SQL for that. Check the number of bytes written/read to avoid truncation.

```rust
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE test_table (content BLOB);")?;

// Insert a BLOB into the `content` column of `test_table`. Note that the Blob
// I/O API provides no way of inserting or resizing BLOBs in the DB -- this
// must be done via SQL.
db.execute("INSERT INTO test_table (content) VALUES (ZEROBLOB(10))", [])?;

// Get the row id off the BLOB we just inserted.
let rowid = db.last_insert_rowid();
// Open the BLOB we just inserted for IO.
let mut blob = db.blob_open(MAIN_DB, "test_table", "content", rowid, false)?;

// Write some data into the blob. Make sure to test that the number of bytes
// written matches what you expect; if you try to write too much, the data
// will be truncated to the size of the BLOB.
let bytes_written = blob.write(b"01234567")?;
assert_eq!(bytes_written, 8);

// Move back to the start and read into a local buffer.
// Same guidance - make sure you check the number of bytes read!
blob.seek(SeekFrom::Start(0))?;
let mut buf = [0u8; 20];
let bytes_read = blob.read(&mut buf[..])?;
assert_eq!(bytes_read, 10); // note we read 10 bytes because the blob has size 10

// Insert another BLOB, this time using a parameter passed in from
// rust (potentially with a dynamic size).
db.execute(
    "INSERT INTO test_table (content) VALUES (?1)",
    [ZeroBlob(64)],
)?;

// given a new row ID, we can reopen the blob on that row
let rowid = db.last_insert_rowid();
blob.reopen(rowid)?;
// Just check that the size is right.
assert_eq!(blob.len(), 64);
```

--------------------------------

### Option::iter_mut example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Shows how to get a mutable iterator over the possibly contained value using iter_mut().

```rust
let mut x = Some(4);
match x.iter_mut().next() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### ok example

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html

Demonstrates converting a Result to an Option, returning Some(value) for Ok and None for Err.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### as_rchunks example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Splits the slice into chunks of size N starting from the end, with a remainder at the beginning. The example shows a slice of length 5 with N=2, resulting in a remainder of length 1 and chunks of length 2.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

--------------------------------

### Rc::get_mut example

Source: https://docs.rs/rusqlite/latest/rusqlite/vtab/array/type.Array.html

Shows how to get a mutable reference to the Rc's data when there are no other Rc or Weak pointers. Returns None otherwise. The example mutates the value and then checks that get_mut returns None after cloning.

```rust
use std::rc::Rc;

let mut x = Rc::new(3);
*Rc::get_mut(&mut x).unwrap() = 4;
assert_eq!(*x, 4);

let _y = Rc::clone(&x);
assert!(Rc::get_mut(&mut x).is_none());
```

--------------------------------

### as_simd example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Demonstrates splitting a slice into prefix, middle SIMD type, and suffix, and uses a basic SIMD sum function. Requires nightly feature portable_simd.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### prepare

Source: https://docs.rs/rusqlite/latest/rusqlite/vtab/struct.ConnectionRef.html?search=u32+-%3E+bool

Documentation for the `prepare` method on `Connection`.

```APIDOC
## prepare

### Description
Prepare a SQL statement for execution.

### Method
`pub fn prepare(&self, sql: &str) -> Result<Statement<'_>>`

### Parameters
- `sql` (`&str`) - Required - The SQL statement to prepare.

### Return Value
- `Result<Statement<'_>>` - The prepared statement, or an error.

### Errors
- Returns `Err` if `sql` cannot be converted to a C-compatible string or if the underlying SQLite call fails.

### Example
```rust
fn insert_new_people(conn: &Connection) -> Result<()> {
    let mut stmt = conn.prepare("INSERT INTO People (name) VALUES (?1)")?;
    stmt.execute(["Joe Smith"])?;
    stmt.execute(["Bob Jones"])?;
    Ok(())
}
```
```

--------------------------------

### as_ptr example: getting a raw pointer to slice buffer

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows how to use as_ptr to get a raw pointer to the slice's buffer and safely dereference it within an unsafe block. The caller must ensure the slice outlives the pointer and that the memory is not written to.

```rust
let x = &[1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
    }
}
```

--------------------------------

### Rc::strong_count example

Source: https://docs.rs/rusqlite/latest/rusqlite/vtab/array/type.Array.html

Shows how to get the number of strong (Rc) pointers to an Rc allocation. Clones the Rc and asserts the strong count is 2.

```rust
use std::rc::Rc;

let five = Rc::new(5);
let _also_five = Rc::clone(&five);

assert_eq!(2, Rc::strong_count(&five));
```

--------------------------------

### Blob I/O example: write, read, and reopen a blob

Source: https://docs.rs/rusqlite/latest/rusqlite/blob/index.html

Opens an in-memory database, creates a table, inserts a BLOB via SQL, and uses the Blob API to write data at an offset, read the whole blob, insert a ZeroBlob parameter, and reopen the blob on a new row. The example asserts the read buffer and blob length.

```rust
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE test_table (content BLOB);")?;
// Insert a blob into the `content` column of `test_table`. Note that the Blob
// I/O API provides no way of inserting or resizing blobs in the DB -- this
// must be done via SQL.
db.execute("INSERT INTO test_table (content) VALUES (ZEROBLOB(10))", [])?;
// Get the row id off the blob we just inserted.
let rowid = db.last_insert_rowid();
// Open the blob we just inserted for IO.
let mut blob = db.blob_open(MAIN_DB, "test_table", "content", rowid, false)?;
// Write some data into the blob.
blob.write_at(b"ABCDEF", 2)?;

// Read the whole blob into a local buffer.
let mut buf = [0u8; 10];
blob.read_at_exact(&mut buf, 0)?;
assert_eq!(&buf, b"\0\0ABCDEF\0\0");

// Insert another blob, this time using a parameter passed in from
// rust (potentially with a dynamic size).
db.execute(
    "INSERT INTO test_table (content) VALUES (?1)",
    [ZeroBlob(64)],
)?;

// given a new row ID, we can reopen the blob on that row
let rowid = db.last_insert_rowid();
blob.reopen(rowid)?;
assert_eq!(blob.len(), 64);
```

--------------------------------

### iter example: iterating over slice items

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows how to use the iter method to create an iterator over the slice and consume it with next(), yielding items from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

--------------------------------

### Option::from example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Demonstrates converting a value into Some using Option::from.

```rust
let o: Option<u8> = Option::from(67);

assert_eq!(Some(67), o);
```

--------------------------------

### Backup database with run_to_completion

Source: https://docs.rs/rusqlite/latest/rusqlite/backup/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a backup of a source database to a destination path using the Backup::new and run_to_completion methods. The destination connection is opened inside the function. The backup runs in chunks of 5 pages with a 250 millisecond sleep between chunks, and a progress callback is invoked during the backup. This example is equivalent to SQLite's 'Example 2: Online Backup of a Running Database'.

```rust
fn backup_db<P: AsRef<Path>>(
    src: &Connection,
    dst: P,
    progress: fn(backup::Progress),
) -> Result<()> {
    let mut dst = Connection::open(dst)?;
    let backup = backup::Backup::new(src, &mut dst)?;
    backup.run_to_completion(5, time::Duration::from_millis(250), Some(progress))
}
```

--------------------------------

### Rc::weak_count example

Source: https://docs.rs/rusqlite/latest/rusqlite/vtab/array/type.Array.html

Shows how to get the number of Weak pointers to an Rc allocation. Creates an Rc, downgrades it to a Weak, and asserts the weak count is 1.

```rust
use std::rc::Rc;

let five = Rc::new(5);
let _weak_five = Rc::downgrade(&five);

assert_eq!(1, Rc::weak_count(&five));
```

--------------------------------

### Begin a savepoint with Connection::savepoint

Source: https://docs.rs/rusqlite/latest/rusqlite/struct.Connection.html

Begins a DEFERRED savepoint with `Connection::savepoint`. The savepoint rolls back on drop unless `commit` is called; this example commits after two query steps.

```rust
fn perform_queries(conn: &mut Connection) -> Result<()> {
    let sp = conn.savepoint()?;

    do_queries_part_1(&sp)?; // sp causes rollback if this fails
    do_queries_part_2(&sp)?; // sp causes rollback if this fails

    sp.commit()
}

```

--------------------------------

### Option::as_slice example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Shows how to use as_slice to get a slice of the contained value, or an empty slice if None. Also demonstrates the inverse relationship with [_]::first.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);
```

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}
```

--------------------------------

### as_ref example

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html

Shows converting a Result to a Result with references, leaving the original intact.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### element_offset returning None for unaligned element

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows that element_offset returns None when the element reference does not point to the start of an element. The example uses a flattened array and a reference that spans two elements.

```rust
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

--------------------------------

### strip_circumfix example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Returns a subslice with both prefix and suffix removed, wrapped in Some if the slice starts with the prefix, ends with the suffix, and they do not overlap; otherwise None. Empty prefix or suffix returns the slice with the other removed.

```rust
let v = &[10, 50, 40, 30];
assert_eq!(v.strip_circumfix(&[10], &[30]), Some(&[50, 40][..]));
assert_eq!(v.strip_circumfix(&[10], &[40, 30]), Some(&[50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[40, 30]), Some(&[][..]));
assert_eq!(v.strip_circumfix(&[50], &[30]), None);
assert_eq!(v.strip_circumfix(&[10], &[40]), None);
assert_eq!(v.strip_circumfix(&[], &[40, 30]), Some(&[10, 50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[]), Some(&[40, 30][..]));
assert_eq!(v.strip_circumfix(&[10, 50, 40], &[50, 40, 30]), None);
```

--------------------------------

### Open a database with Connection::open

Source: https://docs.rs/rusqlite/latest/rusqlite/struct.Connection.html

Opens a SQLite database at the given path with `Connection::open`, creating the file if it does not exist. Equivalent to `Connection::open_with_flags` with `SQLITE_OPEN_READ_WRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_URI | SQLITE_OPEN_NO_MUTEX`.

```rust
fn open_my_db() -> Result<()> {
    let path = "./my_db.db3";
    let db = Connection::open(path)?;
    // Use the database somehow...
    println!("{}", db.is_autocommit());
    Ok(())
}

```

--------------------------------

### strip_prefix example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Returns a subslice with the prefix removed, wrapped in Some if the slice starts with the prefix; otherwise None. Empty prefix returns the original slice; prefix equal to the slice returns an empty slice.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

--------------------------------

### Rc::new_in example with System allocator

Source: https://docs.rs/rusqlite/latest/rusqlite/vtab/array/type.Array.html

Constructs a new Rc in the provided allocator. Requires nightly `allocator_ext` feature and non-`no_global_oom_handling` build.

```rust
#![feature(allocator_ext)]

use std::rc::Rc;
use std::alloc::System;

let five = Rc::new_in(5, System);
```

--------------------------------

### as_ptr_range example: checking pointer containment

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Demonstrates using as_ptr_range to get a range of raw pointers and checking if a pointer to an element is contained in that range. The range is half-open, so the end pointer points one past the last element.

```rust
let a = [1, 2, 3];
let x = &a[1] as *const _;
let y = &5 as *const _;

assert!(a.as_ptr_range().contains(&x));
assert!(!a.as_ptr_range().contains(&y));
```

--------------------------------

### Option::xor example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Shows how xor() returns Some if exactly one of self and optb is Some, otherwise returns None.

```rust
let x = Some(2);
let y: Option<u32> = None;
assert_eq!(x.xor(y), Some(2));

let x: Option<u32> = None;
let y = Some(2);
assert_eq!(x.xor(y), Some(2));

let x = Some(2);
let y = Some(2);
assert_eq!(x.xor(y), None);
```

--------------------------------

### and_then example: metadata and error handling

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html?search=

Uses and_then with Path::metadata to get modified time, showing success and failure cases. On Windows, "/" maps to "C:\". The failure case returns ErrorKind::NotFound.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Option::take example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Shows taking the value out of an Option, leaving None in its place.

```rust
let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);
```

--------------------------------

### Option::xor example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Shows how to use Option::xor to return None when both options are None.

```rust
let x: Option<u32> = None;
let y: Option<u32> = None;
assert_eq!(x.xor(y), None);
```

--------------------------------

### Result<T, E> iterator example

Source: https://docs.rs/rusqlite/latest/rusqlite/types/type.FromSqlResult.html?search=

Example usage of the Result iterator implementation.

```rust
```

```
```

--------------------------------

### windows example: overlapping windows of size 3

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Demonstrates the windows method to iterate over overlapping windows of a given size. Panics if size is zero. The example shows windows of length 3 on a slice of characters.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

--------------------------------

### Example: using named_params with execute

Source: https://docs.rs/rusqlite/latest/rusqlite/macro.named_params.html?search=

Example showing how to use named_params to pass named parameters to an INSERT statement. The example defines a Person struct and an add_person function that inserts a person into the database.

```rust
struct Person {
    name: String,
    age_in_years: u8,
    data: Option<Vec<u8>>,
}

fn add_person(conn: &Connection, person: &Person) -> Result<()> {
    conn.execute(
        "INSERT INTO person (name, age_in_years, data)
         VALUES (:name, :age, :data)",
        named_params! {
            ":name": person.name,
            ":age": person.age_in_years,
            ":data": person.data,
        },
    )?;
    Ok(())
}
```

--------------------------------

### trim_ascii_start example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Demonstrates trimming leading ASCII whitespace from a byte slice.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

--------------------------------

### Example for Result::is_err

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html

Example for the is_err method on Result<T, E>, which returns true if the result is Err.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### Example for Result::is_ok

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html

Example for the is_ok method on Result<T, E>, which returns true if the result is Ok.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

--------------------------------

### to_vec_in example

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Demonstrates using to_vec_in with a custom allocator (System). Requires the nightly feature allocator_ext. The example copies a slice into a Vec using the System allocator.

```rust
#![feature(allocator_ext)]

use std::alloc::System;

let s = [10, 40, 30];
let x = s.to_vec_in(System);
// Here, `s` and `x` can be modified independently.
```

--------------------------------

### Option::zip example

Source: https://docs.rs/rusqlite/latest/rusqlite/functions/type.SubType.html?search=

Shows how to combine two Option values into a tuple using zip. The result is Some((1, "hi")) when both are Some, and None when either is None.

```rust
assert_eq!(x.zip(y), Some((1, "hi")));
assert_eq!(x.zip(z), None);
```

--------------------------------

### Example for Result::cloned on &T

Source: https://docs.rs/rusqlite/latest/rusqlite/type.Result.html

Example for the cloned method on Result<&T, E>, which clones the contents of the Ok part.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### binary_search_by example: using a comparator

Source: https://docs.rs/rusqlite/latest/rusqlite/serialize/enum.Data.html

Shows how to use binary_search_by with a comparator closure that compares each probe to a seek value. The example searches for 13, 4, 100, and 1, with results similar to binary_search.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let seek = 13;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
let seek = 4;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
let seek = 100;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
let seek = 1;
let r = s.binary_search_by(|probe| probe.cmp(&seek));
assert!(match r { Ok(1..=4) => true, _ => false, });
```
Tokens:
Raw