Struct QueryBuilder

pub struct QueryBuilder<'a> {
    arguments: <Db as Database>::Arguments<'a>,
}

Helper type for programmatically constructing queries.

This type can be used to bind arguments of various types, similar to Query or QueryAs. With QueryBuilder, though, the arguments are bound first and the SQL statement is given last. Each time an argument is bound, a SQL fragment is returned as a string which can be used to represent that argument in the statement (e.g. $1 for the first argument bound). This makes it easier to programmatically construct queries where the statement is not a compile time constant.

Example

async fn search_and_maybe_filter<T, Mode>(
    tx: &mut Transaction<Mode>,
    id: Option<i64>,
) -> QueryResult<Vec<T>>
where
    for<'r> T: FromRow<'r, <Db as Database>::Row> + Send + Unpin,
{
    let mut query = QueryBuilder::default();
    let mut sql = "SELECT * FROM table".into();
    if let Some(id) = id {
        sql = format!("{sql} WHERE id = {}", query.bind(id)?);
    }
    let results = query
        .query_as(&sql)
        .fetch_all(tx.as_mut())
        .await?;
    Ok(results)
}

Fields

arguments: <Db as Database>::Arguments<'a>

Implementations

impl<'q> QueryBuilder<'q>

pub fn bind<T>(&mut self, arg: T) -> QueryResult<String>

where T: 'q + Encode<'q, Db> + Type<Db>,

Add an argument and return its name as a formal parameter in a SQL prepared statement.

pub fn query(self, sql: &'q str) -> Query<'q>

Finalize the query with a constructed SQL statement.

pub fn query_as<T>(self, sql: &'q str) -> QueryAs<'q, T>

where T: for<'r> FromRow<'r, <Db as Database>::Row>,

Finalize the query with a constructed SQL statement and a specified output type.

impl QueryBuilder<'_>

pub fn header_where_clause<Types: NodeType>( &mut self, id: BlockId<Types>, ) -> QueryResult<String>

Construct a SQL WHERE clause which filters for a header exactly matching id.

pub fn bounds_to_where_clause<R>( &mut self, range: R, column: &str, ) -> QueryResult<String>

where R: RangeBounds<usize>,

Convert range bounds to a SQL WHERE clause constraining a given column.

Trait Implementations

impl<'a> Debug for QueryBuilder<'a>

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

Formats the value using the given formatter.

impl<'a> Default for QueryBuilder<'a>

fn default() -> QueryBuilder<'a>

Returns the “default value” for a type.