Struct logins::LoginDb

pub struct LoginDb {
    pub db: Connection,
    interrupt_counter: Arc<AtomicUsize>,
}

Fields

db: Connection

interrupt_counter: Arc<AtomicUsize>

Implementations

impl LoginDb

pub fn with_connection(
    db: Connection,
    encryption_key: Option<&str>,
    salt: Option<&str>
) -> Result<Self>

pub fn open(
    path: impl AsRef<Path>,
    encryption_key: Option<&str>
) -> Result<Self>

pub fn open_with_salt(
    path: impl AsRef<Path>,
    encryption_key: &str,
    salt: &str
) -> Result<Self>

pub fn open_in_memory(encryption_key: Option<&str>) -> Result<Self>

pub fn open_and_get_salt(
    path: impl AsRef<Path>,
    encryption_key: &str
) -> Result<String>

Opens an existing database and fetches the salt. This method is used by iOS consumers as part as the migration plan to store the salt outside of the sqlite db headers.

Will return an error if the database does not exist.

pub fn open_and_migrate_to_plaintext_header(
    path: impl AsRef<Path>,
    encryption_key: &str,
    salt: &str
) -> Result<()>

pub fn disable_mem_security(&self) -> Result<()>

pub fn rekey_database(&self, new_encryption_key: &str) -> Result<()>

Change the key on an existing encrypted database, it must first be unlocked with the current encryption key. Once the database is readable and writeable, PRAGMA rekey can be used to re-encrypt every page in the database with a new key. https://www.zetetic.net/sqlcipher/sqlcipher-api/#Changing_Key

pub fn new_interrupt_handle(&self) -> SqlInterruptHandle

pub fn begin_interrupt_scope(&self) -> SqlInterruptScope

impl LoginDb

fn mark_as_synchronized(
    &self,
    guids: &[&str],
    ts: ServerTimestamp,
    scope: &SqlInterruptScope
) -> Result<()>

fn fetch_login_data(
    &self,
    records: &[(Payload, ServerTimestamp)],
    telem: &mut EngineIncoming,
    scope: &SqlInterruptScope
) -> Result<Vec<SyncLoginData>>

fn find_dupe(&self, l: &Login) -> Result<Option<Login>>

pub fn get_all(&self) -> Result<Vec<Login>>

pub fn get_by_base_domain(&self, base_domain: &str) -> Result<Vec<Login>>

pub fn get_by_id(&self, id: &str) -> Result<Option<Login>>

pub fn touch(&self, id: &str) -> Result<()>

pub fn add(&self, login: Login) -> Result<Login>

pub fn import_multiple(&self, logins: &[Login]) -> Result<MigrationMetrics>

pub fn update(&self, login: Login) -> Result<()>

pub fn check_valid_with_no_dupes(&self, login: &Login) -> Result<()>

pub fn fixup_and_check_for_dupes(&self, login: Login) -> Result<Login>

pub fn check_for_dupes(&self, login: &Login) -> Result<()>

pub fn dupe_exists(&self, login: &Login) -> Result<bool>

pub fn potential_dupes_ignoring_username(
    &self,
    login: &Login
) -> Result<Vec<Login>>

pub fn exists(&self, id: &str) -> Result<bool>

pub fn delete(&self, id: &str) -> Result<bool>

Delete the record with the provided id. Returns true if the record existed already.

fn mark_mirror_overridden(&self, guid: &str) -> Result<()>

fn ensure_local_overlay_exists(&self, guid: &str) -> Result<()>

fn clone_mirror_to_overlay(&self, guid: &str) -> Result<usize>

pub fn reset(&self, assoc: &StoreSyncAssociation) -> Result<()>

pub fn wipe(&self, scope: &SqlInterruptScope) -> Result<()>

pub fn wipe_local(&self) -> Result<()>

fn reconcile(
    &self,
    records: Vec<SyncLoginData>,
    server_now: ServerTimestamp,
    telem: &mut EngineIncoming,
    scope: &SqlInterruptScope
) -> Result<UpdatePlan>

fn execute_plan(
    &self,
    plan: UpdatePlan,
    scope: &SqlInterruptScope
) -> Result<()>

pub fn fetch_outgoing(
    &self,
    st: ServerTimestamp,
    scope: &SqlInterruptScope
) -> Result<OutgoingChangeset>

fn do_apply_incoming(
    &self,
    inbound: IncomingChangeset,
    telem: &mut Engine,
    scope: &SqlInterruptScope
) -> Result<OutgoingChangeset>

fn put_meta(&self, key: &str, value: &dyn ToSql) -> Result<()>

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

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

fn set_last_sync(&self, last_sync: ServerTimestamp) -> Result<()>

fn get_last_sync(&self) -> Result<Option<ServerTimestamp>>

pub fn set_global_state(&self, state: &Option<String>) -> Result<()>

pub fn get_global_state(&self) -> Result<Option<String>>

pub fn migrate_global_state(&self) -> Result<()>

A utility we can kill by the end of 2019 ;)

Trait Implementations

impl ConnExt for LoginDb

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 LoginDb

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.