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, PrimaryKey>(
    &'life0 self,
    id: PrimaryKey
) -> Pin<Box<dyn Future<Output = Result<Option<OwnedDocument>, Error>> + Send + 'async_trait>> where
    C: Collection,
    PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send,
    C: 'async_trait,
    PrimaryKey: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Retrieves a stored document from Collection C identified by id.

fn get_multiple<'life0, 'async_trait, C, PrimaryKey, DocumentIds, I>(
    &'life0 self,
    ids: DocumentIds
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedDocument>, Error>> + Send + 'async_trait>> where
    C: Collection,
    DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync,
    I: Iterator<Item = PrimaryKey> + Send + Sync,
    PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send + Sync,
    C: 'async_trait,
    PrimaryKey: 'async_trait,
    DocumentIds: 'async_trait,
    I: 'async_trait,
    'life0: '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, R, PrimaryKey>(
    &'life0 self,
    ids: R,
    order: Sort,
    limit: Option<usize>
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedDocument>, Error>> + Send + 'async_trait>> where
    C: Collection,
    R: Into<Range<PrimaryKey>> + Send,
    PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send,
    C: 'async_trait,
    R: 'async_trait,
    PrimaryKey: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Retrieves all documents within the range of ids. To retrieve all documents, pass in .. for ids.

fn count<'life0, 'async_trait, C, R, PrimaryKey>(
    &'life0 self,
    ids: R
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>> where
    C: Collection,
    R: Into<Range<PrimaryKey>> + Send,
    PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send,
    C: 'async_trait,
    R: 'async_trait,
    PrimaryKey: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Counts the number of documents within the range of 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, PrimaryKey, B>(
    &'life0 self,
    id: Option<PrimaryKey>,
    contents: B
) -> Pin<Box<dyn Future<Output = Result<CollectionHeader<<C as Collection>::PrimaryKey>, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    C: Collection + 'async_trait,
    PrimaryKey: Into<AnyDocumentId<<C as Collection>::PrimaryKey>> + Send + '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<'life0, 'life1, 'async_trait, C, D>(
    &'life0 self,
    doc: &'life1 mut D
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    C: Collection + 'async_trait,
    D: Document<C> + 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 overwrite<'a, 'life0, 'async_trait, C, PrimaryKey>(
    &'life0 self,
    id: PrimaryKey,
    contents: Vec<u8, Global>
) -> Pin<Box<dyn Future<Output = Result<CollectionHeader<<C as Collection>::PrimaryKey>, Error>> + Send + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    C: Collection + 'async_trait,
    PrimaryKey: Into<AnyDocumentId<<C as Collection>::PrimaryKey>> + Send + 'async_trait,
    Self: 'async_trait, 

Overwrites an existing document, or inserts a new document. Upon success, doc.revision will be updated with the new revision information.

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: HasHeader + 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.