Struct pliantdb_local::Storage

pub struct Storage<DB> {
    pub schema: Arc<Schematic>,
    // some fields omitted
}

A local, file-based database.

Fields

schema: Arc<Schematic>

The Schematic of DB.

Implementations

impl<DB> Storage<DB> where
    DB: Schema, 

pub async fn open_local<P: AsRef<Path> + Send>(
    path: P,
    configuration: &Configuration
) -> Result<Self, Error>

Opens a local file as a pliantdb.

Panics

Panics if tokio::task::spawn_blocking fails

pub async fn for_each_in_view<F: FnMut(IVec, ViewEntry) -> Result<(), Error> + Send + Sync>(
    &self,
    view: &dyn Serialized,
    key: Option<QueryKey<Vec<u8>>>,
    access_policy: AccessPolicy,
    callback: F
) -> Result<(), Error>

Iterate over each view entry matching key.

pub async fn for_each_view_entry<V: View, F: FnMut(IVec, ViewEntry) -> Result<(), Error> + Send + Sync>(
    &self,
    key: Option<QueryKey<V::Key>>,
    access_policy: AccessPolicy,
    callback: F
) -> Result<(), Error>

Iterate over each view entry matching key.

pub async fn get_from_collection_id(
    &self,
    id: u64,
    collection: &Id
) -> Result<Option<Document<'static>>, Error>

Retrieves document id from the specified collection.

pub async fn get_multiple_from_collection_id(
    &self,
    ids: &[u64],
    collection: &Id
) -> Result<Vec<Document<'static>>, Error>

Retrieves document id from the specified collection.

pub async fn reduce_in_view(
    &self,
    view_name: &str,
    key: Option<QueryKey<Vec<u8>>>,
    access_policy: AccessPolicy
) -> Result<Vec<u8>, Error>

Reduce view view_name.

pub async fn grouped_reduce_in_view(
    &self,
    view_name: &str,
    key: Option<QueryKey<Vec<u8>>>,
    access_policy: AccessPolicy
) -> Result<Vec<MappedValue<Vec<u8>, Vec<u8>>>, Error>

Reduce view view_name, grouping by unique keys.

Trait Implementations

impl<DB> Clone for Storage<DB>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, DB> Connection for Storage<DB> where
    DB: Schema, 

fn apply_transaction<'life0, 'async_trait>(
    &'life0 self,
    transaction: Transaction<'static>
) -> 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 get<'life0, 'async_trait, C: Collection>(
    &'life0 self,
    id: u64
) -> Pin<Box<dyn Future<Output = Result<Option<Document<'static>>, 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<Document<'static>>, 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_executed_transactions<'life0, 'async_trait>(
    &'life0 self,
    starting_id: Option<u64>,
    result_limit: Option<usize>
) -> Pin<Box<dyn Future<Output = Result<Vec<Executed<'static>>, 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.

#[must_use]fn query<'life0, 'async_trait, V: View>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    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: View>(
    &'life0 self,
    key: Option<QueryKey<V::Key>>,
    access_policy: AccessPolicy
) -> Pin<Box<dyn Future<Output = Result<Vec<MappedDocument<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 reduce<'life0, 'async_trait, V: View>(
    &'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: View>(
    &'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 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.

pub fn collection<C>(&'a self) -> Collection<'a, Self, C> where
    C: 'static + Collection, 

Accesses a collection for the connected schema::Schema.

#[must_use]pub fn insert<'life0, 'async_trait, C>(
    &'life0 self,
    contents: Vec<u8, Global>
) -> Pin<Box<dyn Future<Output = Result<Header, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    C: Collection + 'async_trait, 

Inserts a newly created document into the connected schema::Schema for the Collection C.

#[must_use]pub fn update<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    doc: &'life1 mut Document<'life2>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: '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.

#[must_use]pub fn delete<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    doc: &'life1 Document<'life2>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Removes a Document from the database.

#[must_use]pub fn view<V>(&self) -> View<'_, Self, V> where
    V: View, 

Initializes View for schema::View V.

impl<DB: Debug> Debug for Storage<DB>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.