Struct push::storage::db::PushDb

pub struct PushDb {
    pub db: Connection,
}

Fields

db: Connection

Implementations

impl PushDb

pub fn with_connection(db: Connection) -> Result<Self>

pub fn open(path: impl AsRef<Path>) -> Result<Self>

pub fn open_in_memory() -> Result<Self>

pub fn normalize_uuid(uuid: &str) -> String

Normalize UUID values to undashed, lowercase.

pub fn uuid_to_dashed(uuid: &str) -> Result<String>

Dash UUID strings.

Trait Implementations

impl ConnExt for PushDb

fn conn(&self) -> &Connection

The method you need to implement to opt in to all of this.

fn set_pragma<T>(
    &self,
    pragma_name: &str,
    pragma_value: T
) -> Result<&Self, Error> where
    T: ToSql, 

Set the value of the pragma on the main database. Returns the same object, for chaining.

fn prepare_maybe_cached(
    &'conn self,
    sql: &str,
    cache: bool
) -> Result<MaybeCached<'conn>, Error>

Get a cached or uncached statement based on a flag.

fn execute_all(&self, stmts: &[&str]) -> Result<(), Error>

Execute all the provided statements.

fn execute_cached<P>(&self, sql: &str, params: P) -> Result<usize, Error> where
    P: IntoIterator,
    <P as IntoIterator>::Item: ToSql, 

Equivalent to Connection::execute_named but caches the statement so that subsequent calls to execute_cached will have improved performance.

fn execute_named_cached(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)]
) -> Result<usize, Error>

Equivalent to Connection::execute_named but caches the statement so that subsequent calls to execute_named_cached will have imprroved performance.

fn query_one<T>(&self, sql: &str) -> Result<T, Error> where
    T: FromSql, 

Execute a query that returns a single result column, and return that result.

fn try_query_one<T>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    cache: bool
) -> Result<Option<T>, Error> where
    T: FromSql, 

Execute a query that returns 0 or 1 result columns, returning None if there were no rows, or if the only result was NULL.

fn query_row_and_then_named<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F,
    cache: bool
) -> Result<T, E> where
    E: From<Error>,
    F: FnOnce(&Row<'_>) -> Result<T, E>, 

Equivalent to rusqlite::Connection::query_row_and_then but allows use of named parameters, and allows passing a flag to indicate that it's cached.

fn query_rows_and_then_named<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Vec<T>, E> where
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Helper for when you'd like to get a Vec of all the rows returned by a query that takes named arguments. See also query_rows_and_then_named_cached.

fn query_rows_and_then_named_cached<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Vec<T>, E> where
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Helper for when you'd like to get a Vec of all the rows returned by a query that takes named arguments.

fn query_rows_into<Coll, T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Coll, E> where
    Coll: FromIterator<T>,
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Like query_rows_and_then_named, but works if you want a non-Vec as a result. # Example: rust,no_run # use std::collections::HashSet; # use sql_support::ConnExt; # use rusqlite::Connection; fn get_visit_tombstones(conn: &Connection, id: i64) -> rusqlite::Result<HashSet<i64>> { Ok(conn.query_rows_into( "SELECT visit_date FROM moz_historyvisit_tombstones WHERE place_id = :place_id", &[(":place_id", &id)], |row| row.get::<_, i64>(0))?) } Note if the type isn't inferred, you'll have to do something gross like conn.query_rows_into::<HashSet<_>, _, _, _>(...).

fn query_rows_into_cached<Coll, T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Coll, E> where
    Coll: FromIterator<T>,
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Same as query_rows_into, but caches the stmt if possible.

fn try_query_row<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F,
    cache: bool
) -> Result<Option<T>, E> where
    E: From<Error>,
    F: FnOnce(&Row<'_>) -> Result<T, E>, 

Like query_row_and_then_named but returns None instead of erroring if no such row exists.

fn unchecked_transaction(&self) -> Result<UncheckedTransaction<'_>, Error>

fn unchecked_transaction_imm(&self) -> Result<UncheckedTransaction<'_>, Error>

Begin unchecked_transaction with TransactionBehavior::Immediate. Use when the first operation will be a read operation, that further writes depend on for correctness.

impl Deref for PushDb

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.

impl Storage for PushDb

fn get_record(&self, uaid: &str, chid: &str) -> Result<Option<PushRecord>>

fn get_record_by_chid(&self, chid: &str) -> Result<Option<PushRecord>>

fn put_record(&self, record: &PushRecord) -> Result<bool>

fn delete_record(&self, uaid: &str, chid: &str) -> Result<bool>

fn delete_all_records(&self, uaid: &str) -> Result<()>

fn get_channel_list(&self, uaid: &str) -> Result<Vec<String>>

fn update_endpoint(
    &self,
    uaid: &str,
    channel_id: &str,
    endpoint: &str
) -> Result<bool>

fn update_native_id(&self, uaid: &str, native_id: &str) -> Result<bool>

fn get_meta(&self, key: &str) -> Result<Option<String>>

fn set_meta(&self, key: &str, value: &str) -> Result<()>