Struct bonsaidb_core::connection::Collection

pub struct Collection<'a, Cn, Cl> { /* private fields */ }

Interacts with a collection over a Connection.

These examples in this type use this basic collection definition:

use bonsaidb_core::{schema::Collection, Error};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Default, Collection)]
#[collection(name = "MyCollection")]
pub struct MyCollection {
    pub rank: u32,
    pub score: f32,
}

Implementations

impl<'a, Cn, Cl> Collection<'a, Cn, Cl> where
    Cn: Connection,
    Cl: Collection, 

pub async fn push(
    &self,
    item: &<Cl as SerializedCollection>::Contents
) -> Result<Header, Error> where
    Cl: SerializedCollection, 

Adds a new Document<Cl> with the contents item.

let inserted_header = db
    .collection::<MyCollection>()
    .push(&MyCollection::default())
    .await?;
println!(
    "Inserted id {} with revision {}",
    inserted_header.id, inserted_header.revision
);

pub async fn push_bytes<B: Into<Bytes> + Send>(
    &self,
    contents: B
) -> Result<Header, Error> where
    Cl: SerializedCollection, 

Adds a new Document<Cl> with the contents.

let inserted_header = db.collection::<MyCollection>().push_bytes(vec![]).await?;
println!(
    "Inserted id {} with revision {}",
    inserted_header.id, inserted_header.revision
);

pub async fn insert(
    &self,
    id: u64,
    item: &<Cl as SerializedCollection>::Contents
) -> Result<Header, Error> where
    Cl: SerializedCollection, 

Adds a new Document<Cl> with the given id and contents item.

let inserted_header = db
    .collection::<MyCollection>()
    .insert(42, &MyCollection::default())
    .await?;
println!(
    "Inserted id {} with revision {}",
    inserted_header.id, inserted_header.revision
);

pub async fn insert_bytes<B: Into<Bytes> + Send>(
    &self,
    id: u64,
    contents: B
) -> Result<Header, Error> where
    Cl: SerializedCollection, 

Adds a new Document<Cl> with the the given id and contents.

let inserted_header = db
    .collection::<MyCollection>()
    .insert_bytes(42, vec![])
    .await?;
println!(
    "Inserted id {} with revision {}",
    inserted_header.id, inserted_header.revision
);

pub async fn update<'d, D: Document<'d> + Send + Sync>(
    &self,
    doc: &mut D
) -> Result<(), Error>

Updates an existing document. Upon success, doc.revision will be updated with the new revision.

if let Some(mut document) = db.collection::<MyCollection>().get(42).await? {
    // modify the document
    db.collection::<MyCollection>().update(&mut document);
    println!("Updated revision: {:?}", document.header.revision);
}

pub async fn get(&self, id: u64) -> Result<Option<OwnedDocument>, Error>

Retrieves a Document<Cl> with id from the connection.

if let Some(doc) = db.collection::<MyCollection>().get(42).await? {
    println!(
        "Retrieved bytes {:?} with revision {}",
        doc.contents, doc.header.revision
    );
    let deserialized = doc.contents::<MyCollection>()?;
    println!("Deserialized contents: {:?}", deserialized);
}

pub async fn get_multiple(
    &self,
    ids: &[u64]
) -> Result<Vec<OwnedDocument>, Error>

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

for doc in db
    .collection::<MyCollection>()
    .get_multiple(&[42, 43])
    .await?
{
    println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);
    let deserialized = doc.contents::<MyCollection>()?;
    println!("Deserialized contents: {:?}", deserialized);
}

pub fn list<R: Into<Range<u64>>>(&'a self, ids: R) -> List<'a, Cn, Cl>

Retrieves all documents matching the range of ids.

for doc in db
    .collection::<MyCollection>()
    .list(42..)
    .descending()
    .limit(20)
    .await?
{
    println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);
    let deserialized = doc.contents::<MyCollection>()?;
    println!("Deserialized contents: {:?}", deserialized);
}

pub fn all(&'a self) -> List<'a, Cn, Cl>

Retrieves all documents.

for doc in db.collection::<MyCollection>().all().await? {
    println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);
    let deserialized = doc.contents::<MyCollection>()?;
    println!("Deserialized contents: {:?}", deserialized);
}

pub async fn delete<H: AsRef<Header> + Send + Sync>(
    &self,
    doc: &H
) -> Result<(), Error>

Removes a Document from the database.

if let Some(doc) = db.collection::<MyCollection>().get(42).await? {
    db.collection::<MyCollection>().delete(&doc).await?;
}

Trait Implementations

impl<'a, Cn, Cl> Clone for Collection<'a, Cn, Cl>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.