Struct Connection

pub struct Connection<C: SqlExecutorMut> { /* private fields */ }

Connection abstraction that provides on possible implementation which uses the building blocks (State) provided by this crate.

For simplicity, it takes ownership of an existing type which implements SqlExecutor and initializes all the tracking infrastructure. The original type can still be accessed as Connection implements both Deref and DerefMut.

Remarks

To make sure all changes are capture, it’s recommended to always call Connection::sync_watcher_tables() before any query/statement or transaction.

Example

Single Query/Statement

use sqlite_watcher::connection::Connection;
use sqlite_watcher::connection::SqlExecutor;
use sqlite_watcher::watcher::Watcher;

pub fn track_changes<C:SqlExecutor>(connection: C) {
    let watcher = Watcher::new().unwrap();
    let mut connection = Connection::new(connection, watcher).unwrap();

    // Sync tables so we are up to date.
    connection.sync_watcher_tables().unwrap();

    connection.sql_execute("sql query here").unwrap();

    // Publish changes to the watcher
    connection.publish_watcher_changes().unwrap();
}

Transaction

use sqlite_watcher::connection::Connection;
use sqlite_watcher::connection::{SqlExecutor};
use sqlite_watcher::watcher::Watcher;

pub fn track_changes<C:SqlExecutor>(connection: C) {
    let watcher = Watcher::new().unwrap();
    let mut connection = Connection::new(connection, watcher).unwrap();

    // Sync tables so we are up to date.
    connection.sync_watcher_tables().unwrap();

    // Start a transaction
    connection.sql_execute("sql query here").unwrap();
    connection.sql_execute("sql query here").unwrap();
    // Commit transaction

    // Publish changes to the watcher
    connection.publish_watcher_changes().unwrap();
}

Implementations

impl<C: SqlExecutorMut> Connection<C>

pub fn new(connection: C, watcher: Arc<Watcher>) -> Result<Self, C::Error>

Create a new connection with connection and watcher.

See State::start_tracking() for more information about initialization.

Errors

Returns error if the initialization failed.

pub fn sync_watcher_tables(&mut self) -> Result<(), C::Error>

Sync tables from the Watcher and update tracking infrastructure.

See State::sync_tables() for more information.

Errors

Returns error if we failed to sync the changes to the database.

pub fn publish_watcher_changes(&mut self) -> Result<(), C::Error>

Check if any tables have changed and notify the Watcher

See State::publish_changes() for more information.

It is recommended to call this method

Errors

Returns error if we failed to check for changes.

pub fn stop_tracking(&mut self) -> Result<(), C::Error>

Disable all tracking on this connection.

See State::stop_tracking for more details.

Errors

Returns error if the queries failed.

pub fn take(self) -> C

Consume the current connection and take ownership of the real sql connection.

Remarks

This does not stop the tracking infrastructure enabled on the connection. Use Self::stop_tracking() to disable it first.

Trait Implementations

impl<C: SqlExecutor> AsMut<C> for Connection<C>

fn as_mut(&mut self) -> &mut C

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C: SqlExecutor> AsRef<C> for Connection<C>

fn as_ref(&self) -> &C

Converts this type into a shared reference of the (usually inferred) input type.

impl<C: SqlExecutor> Deref for Connection<C>

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C: SqlExecutor> DerefMut for Connection<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.