Struct bonsaidb::client::RemoteDatabase

pub struct RemoteDatabase<A = ()> where
    A: CustomApi,  { /* private fields */ }

A database on a remote server.

Implementations

impl<A> RemoteDatabase<A> where
    A: CustomApi, 

pub fn name(&self) -> &str

Returns the name of the database.

Methods from Deref<Target = Client<A>>

pub async fn send_api_request(
    &'_ self,
    request: <A as CustomApi>::Request
) -> Result<<A as CustomApi>::Response, Error<<A as CustomApi>::Error>>

Sends an api request.

pub async fn effective_permissions(&'_ self) -> Option<Permissions>

Returns the current effective permissions for the client. Returns None if unauthenticated.

Trait Implementations

impl<A> Clone for RemoteDatabase<A> where
    A: CustomApi, 

pub fn clone(&self) -> RemoteDatabase<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Connection for RemoteDatabase<A> where
    A: CustomApi, 

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

Retrieves a stored document from Collection C identified by id.

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

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

pub fn list<'life0, 'async_trait, C, R>(
    &'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<u64>> + Send + 'async_trait,
    RemoteDatabase<A>: '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.

pub 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,
    RemoteDatabase<A>: Sized,
    RemoteDatabase<A>: 'async_trait, 

Queries for view entries matching View.

pub 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,
    RemoteDatabase<A>: Sized,
    RemoteDatabase<A>: 'async_trait, 

Queries for view entries matching View with their source documents.

pub 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,
    RemoteDatabase<A>: Sized,
    RemoteDatabase<A>: 'async_trait, 

Reduces the view entries matching View.

pub 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,
    RemoteDatabase<A>: Sized,
    RemoteDatabase<A>: 'async_trait, 

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

pub 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,
    RemoteDatabase<A>: Sized,
    RemoteDatabase<A>: 'async_trait, 

Deletes all of the documents associated with this view.

pub 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,
    RemoteDatabase<A>: '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.

pub 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,
    RemoteDatabase<A>: '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.

pub 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,
    RemoteDatabase<A>: 'async_trait, 

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

pub 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,
    RemoteDatabase<A>: 'async_trait, 

Compacts the collection to reclaim unused disk space.

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

Compacts the entire database to reclaim unused disk space.

pub 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,
    RemoteDatabase<A>: '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.

impl<A> Debug for RemoteDatabase<A> where
    A: Debug + CustomApi, 

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

Formats the value using the given formatter.

impl<A> Deref for RemoteDatabase<A> where
    A: CustomApi, 

type Target = Client<A>

The resulting type after dereferencing.

pub fn deref(&self) -> &<RemoteDatabase<A> as Deref>::Target

Dereferences the value.

impl<A> KeyValue for RemoteDatabase<A> where
    A: CustomApi, 

pub fn execute_key_operation<'life0, 'async_trait>(
    &'life0 self,
    op: KeyOperation
) -> Pin<Box<dyn Future<Output = Result<Output, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    RemoteDatabase<A>: 'async_trait, 

Executes a single KeyOperation.

fn set_key<S, V>(&'a self, key: S, value: &'a V) -> Builder<'a, Self, V> where
    S: Into<String>,
    V: Serialize + Send + Sync, 

Sets key to value. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Set with the options given.

fn set_binary_key<S>(&'a self, key: S, bytes: &'a [u8]) -> Builder<'a, Self, ()> where
    S: Into<String>, 

Sets key to bytes. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Set with the options given.

fn set_numeric_key<S, V>(&self, key: S, value: V) -> Builder<'_, Self, ()> where
    S: Into<String>,
    V: Into<Numeric>, 

Sets key to value. This stores the value as a Numeric, enabling atomic math operations to be performed on this key. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Set with the options given.

fn increment_key_by<S, V>(&self, key: S, value: V) -> Builder<'_, Self, V> where
    S: Into<String> + Send + Sync,
    V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync, 

Increments key by value. The value stored must be a Numeric, otherwise an error will be returned. The result of the increment will be the value’s type. For example, if the stored value is currently a u64, but value is a f64, the current value will be converted to an f64, and the stored value will be an f64.

fn decrement_key_by<S, V>(&self, key: S, value: V) -> Builder<'_, Self, V> where
    S: Into<String> + Send + Sync,
    V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync, 

Decrements key by value. The value stored must be a Numeric, otherwise an error will be returned. The result of the decrement will be the value’s type. For example, if the stored value is currently a u64, but value is a f64, the current value will be converted to an f64, and the stored value will be an f64.

fn get_key<S>(&self, key: S) -> Builder<'_, Self> where
    S: Into<String>, 

Gets the value stored at key. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Get with the options given.

fn delete_key<'life0, 'async_trait, S>(
    &'life0 self,
    key: S
) -> Pin<Box<dyn Future<Output = Result<KeyStatus, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    S: Into<String> + Send + 'async_trait,
    Self: 'async_trait, 

Deletes the value stored at key.

fn key_namespace(&self) -> Option<&str>

The current namespace.

fn with_key_namespace(&self, namespace: &str) -> Namespaced<'_, Self>

Access this Key-Value store within a namespace. When using the returned Namespaced instance, all keys specified will be separated into their own storage designated by namespace.

impl<A> PubSub for RemoteDatabase<A> where
    A: CustomApi, 

type Subscriber = RemoteSubscriber<A>

The Subscriber type for this PubSub connection.

pub fn create_subscriber<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<<RemoteDatabase<A> as PubSub>::Subscriber, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    RemoteDatabase<A>: 'async_trait, 

Create a new Subscriber for this relay.

pub fn publish<'life0, 'life1, 'async_trait, S, P>(
    &'life0 self,
    topic: S,
    payload: &'life1 P
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    S: Into<String> + Send + 'async_trait,
    P: Serialize + Sync + 'async_trait,
    RemoteDatabase<A>: 'async_trait, 

Publishes a payload to all subscribers of topic.

pub fn publish_to_all<'life0, 'life1, 'async_trait, P>(
    &'life0 self,
    topics: Vec<String, Global>,
    payload: &'life1 P
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    P: Serialize + Sync + 'async_trait,
    RemoteDatabase<A>: 'async_trait, 

Publishes a payload to all subscribers of all topics.