Trait bonsaidb::core::connection::Connection

source · [−]
pub trait Connection: Send + Sync {

Show 22 methods    fn get<'life0, 'async_trait, C, PrimaryKey>(
        &'life0 self, 
        id: PrimaryKey
    ) -> Pin<Box<dyn Future<Output = Result<Option<OwnedDocument>, Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        C: Collection + 'async_trait,
        PrimaryKey: Into<AnyDocumentId<<C as Collection>::PrimaryKey>> + Send + 'async_trait,
        Self: 'async_trait;

    fn get_multiple<'life0, 'async_trait, C, PrimaryKey, DocumentIds, I>(
        &'life0 self, 
        ids: DocumentIds
    ) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedDocument, Global>, Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        C: Collection + 'async_trait,
        DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync + 'async_trait,
        I: Iterator<Item = PrimaryKey> + Send + Sync + 'async_trait,
        PrimaryKey: Into<AnyDocumentId<<C as Collection>::PrimaryKey>> + Send + Sync + 'async_trait,
        Self: 'async_trait;

    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, Global>, Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        C: Collection + 'async_trait,
        R: Into<Range<PrimaryKey>> + Send + 'async_trait,
        PrimaryKey: Into<AnyDocumentId<<C as Collection>::PrimaryKey>> + Send + 'async_trait,
        Self: 'async_trait;

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

    fn query<'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<Vec<Map<<V as View>::Key, <V as View>::Value>, Global>, Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        V: SerializedView + 'async_trait,
        Self: 'async_trait;

    fn query_with_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<OwnedDocument, V>, Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        V: SerializedView + 'async_trait,
        Self: 'async_trait;

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

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

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

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

    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, Global>, Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

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

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

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

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

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

    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,
    { ... }

    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,
    { ... }

    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,
    { ... }

    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,
    { ... }

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

    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,
    { ... }

}
Expand description

Defines all interactions with a schema::Schema, regardless of whether it is local or remote.

Required methods

Retrieves a stored document from Collection C identified by id.

This is the lower-level API. For better ergonomics, consider using one of:

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

This is the lower-level API. For better ergonomics, consider using one of:

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

This is the lower-level API. For better ergonomics, consider using one of:

Counts the number of documents within the range of ids.

This is the lower-level API. For better ergonomics, consider using one of:

Queries for view entries matching View.

This is the lower-level API. For better ergonomics, consider querying the view using self.view::<View>().query() instead. The parameters for the query can be customized on the builder returned from Self::view().

Queries for view entries matching View with their source documents.

This is the lower-level API. For better ergonomics, consider querying the view using self.view::<View>().query_with_docs() instead. The parameters for the query can be customized on the builder returned from Self::view().

Reduces the view entries matching View.

This is the lower-level API. For better ergonomics, consider reducing the view using self.view::<View>().reduce() instead. The parameters for the query can be customized on the builder returned from Self::view().

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

This is the lower-level API. For better ergonomics, consider reducing the view using self.view::<View>().reduce_grouped() instead. The parameters for the query can be customized on the builder returned from Self::view().

Deletes all of the documents associated with this view.

This is the lower-level API. For better ergonomics, consider querying the view using self.view::<View>().delete_docs() instead. The parameters for the query can be customized on the builder returned from Self::view().

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.

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.

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

Compacts the entire database to reclaim unused disk space.

This process is done by writing data to a new file and swapping the file once the process completes. This ensures that if a hardware failure, power outage, or crash occurs that the original collection data is left untouched.

Errors
  • Error::Io: an error occurred while compacting the database.

Compacts the collection to reclaim unused disk space.

This process is done by writing data to a new file and swapping the file once the process completes. This ensures that if a hardware failure, power outage, or crash occurs that the original collection data is left untouched.

Errors

Compacts the key value store to reclaim unused disk space.

This process is done by writing data to a new file and swapping the file once the process completes. This ensures that if a hardware failure, power outage, or crash occurs that the original collection data is left untouched.

Errors
  • Error::Io: an error occurred while compacting the database.

Provided methods

Accesses a collection for the connected schema::Schema.

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.

This is the lower-level API. For better ergonomics, consider using one of:

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

This is the lower-level API. For better ergonomics, consider using one of:

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

This is the lower-level API. For better ergonomics, consider using one of:

Removes a Document from the database.

This is the lower-level API. For better ergonomics, consider using one of:

Initializes View for schema::View V.

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

This is the lower-level API. For better ergonomics, consider querying the view using self.view::<View>().query_with_collection_docs() instead. The parameters for the query can be customized on the builder returned from Self::view().

Implementors

Pass-through implementation