Struct dittolive_ditto::store::Store

pub struct Store { /* private fields */ }

Implementations

impl Store

pub fn new(ditto: Arc<BoxedDitto>) -> Self

pub fn collection(
    &self,
    collection_name: &str
) -> Result<Collection, DittoError>

Returns a Collection with the provided name.

pub fn collections(&self) -> PendingCollectionsOperation<'_>

Returns an object that lets you fetch or observe the collections in the store.

pub fn with_batched_write<F>(
    &self,
    f: F
) -> Result<Vec<WriteTransactionResult>, DittoError> where
    for<'batch> F: FnOnce(ScopedStore<'batch>) -> Action<'batch>, 

Allows you to group multiple operations together that affect multiple documents, potentially across multiple collections, without auto-committing on each operation.

At the end of the batch of operations, either batch.commit_changes() or batch.revert_changes() must be called.

Example

ditto.store().with_batched_write(|batch| {
    let mut foo_coll = batch.collection("foo");
    foo_coll.find...().remove();
    let mut bar_coll = batch.collection("bar");
    // Expensive multi-mutation op:
    for _ in 0 .. 10_000 {
        let doc = ...;
        bar_coll.insert(doc, None, false);
    }
    // At this point, we must say whether we commit or revert
    // these changes:
    batch.commit_changes()
})

pub fn collection_names(&self) -> Result<Vec<String>, DittoError>

Returns a list of the names of collections in the store.

pub fn queries_hash(
    &self,
    live_queries: &[LiveQuery]
) -> Result<u64, DittoError>

Returns a hash representing the current version of the given queries. When a document matching such queries gets mutated, the hash will change as well.

Please note that the hash depends on how queries are constructed, so you should make sure to always compare hashes generated with the same set of queries.

pub fn queries_hash_mnemonic(
    &self,
    live_queries: &[LiveQuery]
) -> Result<String, DittoError>

Returns a sequence of English words representing the current version of the given queries. When a document matching such queries gets mutated, the words will change as well.

Please note that the resulting sequence of words depends on how queries are constructed, so you should make sure to always compare hashes generated with the same set of queries.

pub fn start_all_live_query_webhooks(&self) -> Result<(), DittoError>

pub fn start_live_query_webhook_by_id(
    &self,
    doc_id: DocumentId
) -> Result<(), DittoError>

pub fn register_live_query_webhook(
    &self,
    collection_name: &str,
    query: &str,
    url: &str
) -> Result<DocumentId, DittoError>

pub fn live_query_webhook_generate_new_api_secret(
    &self
) -> Result<(), DittoError>

pub fn timeseries(&self, ts_name: &str) -> Result<TimeSeries, DittoError>

Returns a Timeseries with the provided name.

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DiskUser for Store

fn ditto_component() -> FsComponent

Specify which component’s file system is being monitored

fn ditto(&self) -> Arc<BoxedDitto>

Return a pointer to Ditto

fn disk_usage_exec(&self) -> DiskUsageChild

Return the tree representation of the ditto disk usage of the component

fn disk_usage_observe(
    &self,
    callback: impl Fn(DiskUsageChild) + 'static + Send + Sync
) -> Arc<Mutex<DiskUsageObserver>>

Register a callback to monitor the disk usage of the component