Enum bonsaidb::AnyDatabase

pub enum AnyDatabase<B: Backend = NoBackend> {
    Local(ServerDatabase<B>),
    Networked(RemoteDatabase<B::CustomApi>),
}

A database connection that can be either from a local server or a server over a network connection.

Variants

Local(ServerDatabase<B>)

A local database.

Networked(RemoteDatabase<B::CustomApi>)

A networked database accessed with a Client.

Trait Implementations

impl<B: Backend> Connection for AnyDatabase<B>

fn get<'life0, 'async_trait, C: Collection>(
    &'life0 self,
    id: u64
) -> Pin<Box<dyn Future<Output = Result<Option<OwnedDocument>, Error>> + Send + 'async_trait>> where
    C: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Retrieves a stored document from Collection C identified by id.

fn get_multiple<'life0, 'life1, 'async_trait, C: Collection>(
    &'life0 self,
    ids: &'life1 [u64]
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedDocument>, Error>> + Send + 'async_trait>> where
    C: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Retrieves all documents matching ids. Documents that are not found are not returned, but no error will be generated.

fn list<'life0, 'async_trait, C: Collection, R: Into<Range<u64>> + Send>(
    &'life0 self,
    ids: R,
    order: Sort,
    limit: Option<usize>
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedDocument>, Error>> + Send + 'async_trait>> where
    C: 'async_trait,
    R: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Retrieves all documents within the range of ids. Documents that are not found are not returned, but no error will be generated. To retrieve all documents, pass in .. for ids.

fn query<'life0, 'async_trait, V: SerializedView>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    order: Sort,
    limit: Option<usize>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<Vec<Map<V::Key, V::Value>>, Error>> + Send + 'async_trait>> where
    Self: Sized,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Queries for view entries matching View.

fn query_with_docs<'life0, 'async_trait, V: SerializedView>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    order: Sort,
    limit: Option<usize>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<MappedDocuments<OwnedDocument, V>, Error>> + Send + 'async_trait>> where
    Self: Sized,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Queries for view entries matching View with their source documents.

fn reduce<'life0, 'async_trait, V: SerializedView>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<V::Value, Error>> + Send + 'async_trait>> where
    Self: Sized,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Reduces the view entries matching View.

fn reduce_grouped<'life0, 'async_trait, V: SerializedView>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<Vec<MappedValue<V::Key, V::Value>>, Error>> + Send + 'async_trait>> where
    Self: Sized,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Reduces the view entries matching View, reducing the values by each unique key.

fn delete_docs<'life0, 'async_trait, V: SerializedView>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>> where
    Self: Sized,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Deletes all of the documents associated with this view.

fn apply_transaction<'life0, 'async_trait>(
    &'life0 self,
    transaction: Transaction
) -> Pin<Box<dyn Future<Output = Result<Vec<OperationResult>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Applies a Transaction to the schema::Schema. If any operation in the Transaction fails, none of the operations will be applied to the schema::Schema.

fn list_executed_transactions<'life0, 'async_trait>(
    &'life0 self,
    starting_id: Option<u64>,
    result_limit: Option<usize>
) -> Pin<Box<dyn Future<Output = Result<Vec<Executed>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists executed Transactions from this schema::Schema. By default, a maximum of 1000 entries will be returned, but that limit can be overridden by setting result_limit. A hard limit of 100,000 results will be returned. To begin listing after another known transaction_id, pass transaction_id + 1 into starting_id.

fn last_transaction_id<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<u64>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Fetches the last transaction id that has been committed, if any.

fn compact_collection<'life0, 'async_trait, C: Collection>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    C: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Compacts the collection to reclaim unused disk space.

fn compact<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Compacts the entire database to reclaim unused disk space.

fn compact_key_value_store<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Compacts the key value store to reclaim unused disk space.

fn collection<C>(&self) -> Collection<'_, Self, C> where
    C: Collection, 

Accesses a collection for the connected schema::Schema.

fn insert<'life0, 'async_trait, C, B>(
    &'life0 self,
    id: Option<u64>,
    contents: B
) -> Pin<Box<dyn Future<Output = Result<Header, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    C: Collection + 'async_trait,
    B: Into<Bytes> + Send + 'async_trait,
    Self: 'async_trait, 

Inserts a newly created document into the connected schema::Schema for the Collection C. If id is None a unique id will be generated. If an id is provided and a document already exists with that id, a conflict error will be returned.

fn update<'a, 'life0, 'life1, 'async_trait, C, D>(
    &'life0 self,
    doc: &'life1 mut D
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    C: Collection + 'async_trait,
    D: Document<'a> + Send + Sync + 'async_trait,
    Self: 'async_trait, 

Updates an existing document in the connected schema::Schema for the Collection C. Upon success, doc.revision will be updated with the new revision.

fn delete<'life0, 'life1, 'async_trait, C, H>(
    &'life0 self,
    doc: &'life1 H
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    C: Collection + 'async_trait,
    H: AsRef<Header> + Send + Sync + 'async_trait,
    Self: 'async_trait, 

Removes a Document from the database.

fn view<V>(&self) -> View<'_, Self, V> where
    V: SerializedView, 

Initializes View for schema::View V.

fn query_with_collection_docs<'life0, 'async_trait, V>(
    &'life0 self,
    key: Option<QueryKey<<V as View>::Key>>,
    order: Sort,
    limit: Option<usize>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<MappedDocuments<CollectionDocument<<V as View>::Collection>, V>, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    V: SerializedView + 'async_trait,
    Self: 'async_trait,
    <V as View>::Collection: SerializedCollection,
    <<V as View>::Collection as SerializedCollection>::Contents: Debug, 

Queries for view entries matching View with their source documents, deserialized.