Struct SqliteBindCollector 

pub struct SqliteBindCollector<'a> { /* private fields */ }

Available on crate features __sqlite-shared and i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

The BindCollector used by the SQLite backend.

You only interact with this when adding a third-party SQLite backend.

Implementations

impl<'a> SqliteBindCollector<'a>

pub fn new() -> Self

Construct an empty SqliteBindCollector

pub fn binds( &self, ) -> impl ExactSizeIterator<Item = (&SqliteBindValueRef<'a>, SqliteType)>

Iterate over the collected bind values and their SQLite storage classes, in positional order.

Each yielded tuple carries a reference to the SqliteBindValueRef as it lives inside the collector, so borrowed string and blob variants are exposed without an intervening copy. If the caller needs a Send snapshot instead, use MoveableBindCollector::moveable and inspect SqliteBindCollectorData.

Example

A third-party backend can render a typed Diesel query into placeholder SQL and recover the ordered bind values:

use diesel::expression::IntoSql;
use diesel::query_builder::{QueryBuilder, QueryFragment};
use diesel::sql_types::{BigInt, Integer, Text};
use diesel::sqlite::{
    Sqlite, SqliteBindCollector, SqliteBindValueRef, SqliteQueryBuilder, SqliteType,
};

fn render<Q: QueryFragment<Sqlite>>(query: &Q) -> (String, Vec<SqliteType>) {
    let mut qb = SqliteQueryBuilder::new();
    query.to_sql(&mut qb, &Sqlite).unwrap();

    let mut collector = SqliteBindCollector::new();
    query.collect_binds(&mut collector, &mut (), &Sqlite).unwrap();

    let binds: Vec<(&SqliteBindValueRef<'_>, SqliteType)> = collector.binds().collect();
    assert!(matches!(binds[0].0, SqliteBindValueRef::I32(1)));
    assert!(matches!(binds[1].0, SqliteBindValueRef::I64(2)));
    assert!(matches!(binds[2].0, SqliteBindValueRef::BorrowedString("hi")));

    (qb.finish(), binds.iter().map(|(_, t)| *t).collect())
}

let query = diesel::select((
    1_i32.into_sql::<Integer>(),
    2_i64.into_sql::<BigInt>(),
    "hi".into_sql::<Text>(),
));

let (sql, types) = render(&query);
assert!(sql.contains('?'));
assert_eq!(types, [SqliteType::Integer, SqliteType::Long, SqliteType::Text]);

Trait Implementations

impl<'a> BindCollector<'a, Sqlite> for SqliteBindCollector<'a>

type Buffer = SqliteBindValue<'a>

The internal buffer type used by this bind collector

fn push_bound_value<T, U>( &mut self, bind: &'a U, metadata_lookup: &mut (), ) -> QueryResult<()>

where Sqlite: HasSqlType<T>, U: ToSql<T, Sqlite> + ?Sized,

Serializes the given bind value, and collects the result.

fn push_null_value(&mut self, metadata: SqliteType) -> QueryResult<()>

Push a null value with the given type information onto the bind collector

impl<'a> Debug for SqliteBindCollector<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for SqliteBindCollector<'a>

fn default() -> SqliteBindCollector<'a>

Returns the “default value” for a type.

impl MoveableBindCollector<Sqlite> for SqliteBindCollector<'_>

type BindData = SqliteBindCollectorData

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

The movable bind data of this bind collector

fn moveable(&self) -> Self::BindData

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Builds a movable version of the bind collector

fn append_bind_data(&mut self, from: &Self::BindData)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Refill the bind collector with its bind data

fn push_debug_binds<'a, 'b>( bind_data: &Self::BindData, f: &'a mut Vec<Box<dyn Debug + 'b>>, )

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Push bind data as debug representation