Struct bonsaidb_local::Storage

pub struct Storage { /* private fields */ }

A file-based, multi-database, multi-user database engine. This type blocks the current thread when used. See AsyncStorage for this type’s async counterpart.

Converting between Blocking and Async Types

AsyncStorage and Storage can be converted to and from each other using:

• AsyncStorage::into_blocking()
• AsyncStorage::to_blocking()
• AsyncStorage::as_blocking()
• Storage::into_async()
• Storage::to_async()
• Storage::into_async_with_runtime()
• Storage::to_async_with_runtime()

Converting from Database::open to Storage::open

Database::open is a simple method that uses Storage to create a database named default with the schema provided. These two ways of opening the database are the same:

// `bonsaidb_core` is re-exported to `bonsaidb::core` or `bonsaidb_local::core`.
use bonsaidb_core::{connection::StorageConnection, schema::Schema};
// `bonsaidb_local` is re-exported to `bonsaidb::local` if using the omnibus crate.
use bonsaidb_local::{
    config::{Builder, StorageConfiguration},
    Database, Storage,
};
// This creates a Storage instance, creates a database, and returns it.
let db = Database::open::<MySchema>(StorageConfiguration::new("my-db.bonsaidb"))?;

// This is the equivalent code being executed:
let storage =
    Storage::open(StorageConfiguration::new("my-db.bonsaidb").with_schema::<MySchema>()?)?;
storage.create_database::<MySchema>("default", true)?;
let db = storage.database::<MySchema>("default")?;

Using multiple databases

This example shows how to use Storage to create and use multiple databases with multiple schemas:

use bonsaidb_core::{
    connection::StorageConnection,
    schema::{Collection, Schema},
};
use bonsaidb_local::{
    config::{Builder, StorageConfiguration},
    Storage,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Schema)]
#[schema(name = "my-schema", collections = [BlogPost, Author])]
struct MySchema;

#[derive(Debug, Serialize, Deserialize, Collection)]
#[collection(name = "blog-posts")]
struct BlogPost {
    pub title: String,
    pub contents: String,
    pub author_id: u64,
}

#[derive(Debug, Serialize, Deserialize, Collection)]
#[collection(name = "blog-posts")]
struct Author {
    pub name: String,
}

let storage = Storage::open(
    StorageConfiguration::new("my-db.bonsaidb")
        .with_schema::<BlogPost>()?
        .with_schema::<MySchema>()?,
)?;

storage.create_database::<BlogPost>("ectons-blog", true)?;
let ectons_blog = storage.database::<BlogPost>("ectons-blog")?;
storage.create_database::<MySchema>("another-db", true)?;
let another_db = storage.database::<MySchema>("another-db")?;

Implementations

impl Storage

pub fn backup<L: AnyBackupLocation>(&self, location: &L) -> Result<(), Error>

Stores a copy of all data in this instance to location.

pub fn restore<L: AnyBackupLocation>(&self, location: &L) -> Result<(), Error>

Restores all data from a previously stored backup location.

impl Storage

pub fn open(configuration: StorageConfiguration) -> Result<Self, Error>

Creates or opens a multi-database Storage with its data stored in directory.

pub fn unique_id(&self) -> StorageId

Returns the unique id of the server.

This value is set from the StorageConfiguration or randomly generated when creating a server. It shouldn’t be changed after a server is in use, as doing can cause issues. For example, the vault that manages encrypted storage uses the server ID to store the vault key. If the server ID changes, the vault key storage will need to be updated with the new server ID.

pub fn register_schema<DB: Schema>(&self) -> Result<(), Error>

Registers a schema for use within the server.

pub fn with_effective_permissions(
    &self,
    effective_permissions: Permissions
) -> Option<Self>

Restricts an unauthenticated instance to having effective_permissions. Returns None if a session has already been established.

pub fn into_async(self) -> AsyncStorage

Converts this instance into its blocking version, which is able to be used without async. The returned instance uses the current Tokio runtime handle to spawn blocking tasks.

Panics

Panics if called outside the context of a Tokio runtime.

pub fn into_async_with_runtime(self, runtime: Handle) -> AsyncStorage

Converts this instance into its blocking version, which is able to be used without async. The returned instance uses the provided runtime handle to spawn blocking tasks.

pub fn to_async(&self) -> AsyncStorage

Converts this instance into its blocking version, which is able to be used without async. The returned instance uses the current Tokio runtime handle to spawn blocking tasks.

Panics

Panics if called outside the context of a Tokio runtime.

pub fn to_async_with_runtime(&self, runtime: Handle) -> AsyncStorage

Converts this instance into its blocking version, which is able to be used without async. The returned instance uses the provided runtime handle to spawn blocking tasks.

Trait Implementations

impl Clone for Storage

fn clone(&self) -> Storage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Storage

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

Formats the value using the given formatter.

impl<'a> From<&'a AsyncStorage> for Storage

fn from(storage: &'a AsyncStorage) -> Self

Converts to this type from the input type.

impl From<AsyncStorage> for Storage

fn from(storage: AsyncStorage) -> Self

Converts to this type from the input type.

impl HasSession for Storage

fn session(&self) -> Option<&Session>

Returns the currently authenticated session, if any.

fn allowed_to<'a, R, P>(&self, resource_name: R, action: &P) -> bool where
    R: AsRef<[Identifier<'a>]>,
    P: Action, 

Checks if action is permitted against resource_name.

fn check_permission<'a, R, P>(
    &self,
    resource_name: R,
    action: &P
) -> Result<(), Error> where
    R: AsRef<[Identifier<'a>]>,
    P: Action, 

Checks if action is permitted against resource_name. If permission is denied, returns a PermissionDenied error.

impl StorageConnection for Storage

type Database = Database

The type that represents a database for this implementation.

type Authenticated = Storage

The StorageConnection type returned from authentication calls.

fn admin(&self) -> Self::Database

Returns the administration database.

fn create_database_with_schema(
    &self,
    name: &str,
    schema: SchemaName,
    only_if_needed: bool
) -> Result<(), Error>

Creates a database named name using the SchemaName schema.

fn database<DB: Schema>(&self, name: &str) -> Result<Self::Database, Error>

Returns a reference to database name with schema DB.

fn delete_database(&self, name: &str) -> Result<(), Error>

Deletes a database named name.

fn list_databases(&self) -> Result<Vec<Database>, Error>

Lists the databases in this storage.

fn list_available_schemas(&self) -> Result<Vec<SchemaName>, Error>

Lists the SchemaNames registered with this storage.

fn create_user(&self, username: &str) -> Result<u64, Error>

Creates a user.

fn delete_user<'user, U: Nameable<'user, u64> + Send + Sync>(
    &self,
    user: U
) -> Result<(), Error>

Deletes a user.

fn set_user_password<'user, U: Nameable<'user, u64> + Send + Sync>(
    &self,
    user: U,
    password: SensitiveString
) -> Result<(), Error>

Sets a user’s password.

fn authenticate(&self, authentication: Authentication) -> Result<Self, Error>

Authenticates using the active session, returning a connection with a new session upon success. The existing connection will remain usable with the existing authentication, if any.

fn assume_identity(
    &self,
    identity: IdentityReference<'_>
) -> Result<Self::Authenticated, Error>

Assumes the identity. If successful, the returned instance will have the permissions from identity.

fn add_permission_group_to_user<'user, 'group, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &self,
    user: U,
    permission_group: G
) -> Result<(), Error>

Adds a user to a permission group.

fn remove_permission_group_from_user<'user, 'group, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &self,
    user: U,
    permission_group: G
) -> Result<(), Error>

Removes a user from a permission group.

fn add_role_to_user<'user, 'group, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &self,
    user: U,
    role: G
) -> Result<(), Error>

Adds a user to a permission group.

fn remove_role_from_user<'user, 'group, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &self,
    user: U,
    role: G
) -> Result<(), Error>

Removes a user from a permission group.

fn create_database<DB>(
    &self,
    name: &str,
    only_if_needed: bool
) -> Result<Self::Database, Error> where
    DB: Schema, 

Creates a database named name with the Schema provided.

fn authenticate_with_token(
    &self,
    id: u64,
    token: &SensitiveString
) -> Result<<Self::Authenticated as StorageConnection>::Authenticated, Error>

Authenticates using an AuthenticationToken. If successful, the returned instance will have the permissions from identity.

fn authenticate_with_password<'name, User>(
    &self,
    user: User,
    password: SensitiveString
) -> Result<Self::Authenticated, Error> where
    User: Nameable<'name, u64>, 

Authenticates a User using a password. If successful, the returned instance will have the permissions from identity.

impl StorageNonBlocking for Storage

fn path(&self) -> &Path

Returns the path of the database storage.

fn assume_session(&self, session: Session) -> Result<Storage, Error>

Returns a new instance of Storage with session as the effective authentication session. This call will only succeed if there is no current session.