Trait bonsaidb::core::schema::SerializedCollection [−][src]
pub trait SerializedCollection: Collection {
type Contents: Send + Sync;
type Format: OwnedDeserializer<Self::Contents>;
Show 28 methods
fn format() -> Self::Format;
fn natural_id(contents: &Self::Contents) -> Option<Self::PrimaryKey> { ... }
fn deserialize(data: &[u8]) -> Result<Self::Contents, Error> { ... }
fn document_contents<D>(doc: &D) -> Result<Self::Contents, Error>
where
D: Document<Self>,
{ ... }
fn set_document_contents<D>(
doc: &mut D,
contents: Self::Contents
) -> Result<(), Error>
where
D: Document<Self>,
{ ... }
fn serialize(item: &Self::Contents) -> Result<Vec<u8, Global>, Error> { ... }
fn get<C, PrimaryKey>(
id: PrimaryKey,
connection: &C
) -> Result<Option<CollectionDocument<Self>>, Error>
where
C: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
{ ... }
fn get_async<'life0, 'async_trait, C, PrimaryKey>(
id: PrimaryKey,
connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
C: AsyncConnection + 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'async_trait + Send,
{ ... }
fn get_multiple<C, DocumentIds, PrimaryKey, I>(
ids: DocumentIds,
connection: &C
) -> Result<Vec<CollectionDocument<Self>, Global>, Error>
where
C: Connection,
DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync,
I: Iterator<Item = PrimaryKey> + Send + Sync,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
{ ... }
fn get_multiple_async<'life0, 'async_trait, C, DocumentIds, PrimaryKey, I>(
ids: DocumentIds,
connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>, Global>, Error>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
C: AsyncConnection + 'async_trait,
DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync + 'async_trait,
I: Iterator<Item = PrimaryKey> + Send + Sync + 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'async_trait + Send,
{ ... }
fn list<R, PrimaryKey, C>(
ids: R,
connection: &C
) -> List<'_, C, Self, PrimaryKey>
where
R: Into<Range<PrimaryKey>>,
C: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
{ ... }
fn list_async<R, PrimaryKey, C>(
ids: R,
connection: &C
) -> AsyncList<'_, C, Self, PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
R: Into<Range<PrimaryKey>>,
C: AsyncConnection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
{ ... }
fn list_with_prefix<C>(
prefix: Self::PrimaryKey,
connection: &C
) -> List<'_, C, Self, Self::PrimaryKey>
where
C: Connection,
Self::PrimaryKey: IntoPrefixRange,
{ ... }
fn list_with_prefix_async<C>(
prefix: Self::PrimaryKey,
connection: &C
) -> AsyncList<'_, C, Self, Self::PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
C: AsyncConnection,
Self::PrimaryKey: IntoPrefixRange,
{ ... }
fn all<C>(connection: &C) -> List<'_, C, Self, Self::PrimaryKey>
where
C: Connection,
{ ... }
fn all_async<C>(connection: &C) -> AsyncList<'_, C, Self, Self::PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
C: AsyncConnection,
{ ... }
fn push<Cn>(
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
where
Cn: Connection,
Self: 'static,
{ ... }
fn push_async<'life0, 'async_trait, Cn>(
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
Self: 'static + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
Self::Contents: 'async_trait,
{ ... }
fn push_into<Cn>(
self,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>
where
Cn: Connection,
Self: 'static + SerializedCollection<Contents = Self>,
{ ... }
fn push_into_async<'life0, 'async_trait, Cn>(
self,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
{ ... }
fn insert<PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static,
{ ... }
fn insert_async<'life0, 'async_trait, PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + 'async_trait + Send,
Self::Contents: 'async_trait,
{ ... }
fn insert_into<PrimaryKey, Cn>(
self,
id: PrimaryKey,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>
where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static + SerializedCollection<Contents = Self>,
{ ... }
fn insert_into_async<'life0, 'async_trait, PrimaryKey, Cn>(
self,
id: PrimaryKey,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
{ ... }
fn overwrite<PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static,
{ ... }
fn overwrite_async<'life0, 'async_trait, PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + 'async_trait + Send,
Self::Contents: 'async_trait,
{ ... }
fn overwrite_into<Cn, PrimaryKey>(
self,
id: PrimaryKey,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>
where
Cn: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Self: 'static + SerializedCollection<Contents = Self>,
{ ... }
fn overwrite_into_async<'life0, 'async_trait, Cn, PrimaryKey>(
self,
id: PrimaryKey,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>>
where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
{ ... }
}
Expand description
A collection that knows how to serialize and deserialize documents to an associated type.
These examples for this type use this basic collection definition:
use bonsaidb_core::{
schema::{Collection, DefaultSerialization, Schematic},
Error,
};
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize, Default, Collection)]
#[collection(name = "MyCollection")]
pub struct MyCollection {
pub rank: u32,
pub score: f32,
}
Associated Types
type Format: OwnedDeserializer<Self::Contents>
type Format: OwnedDeserializer<Self::Contents>
The serialization format for this collection.
Required methods
Returns the configured instance of Self::Format
.
Provided methods
fn natural_id(contents: &Self::Contents) -> Option<Self::PrimaryKey>
fn natural_id(contents: &Self::Contents) -> Option<Self::PrimaryKey>
Returns the natural identifier of contents
. This is called when
pushing values into a collection, before attempting to automatically
assign a unique id.
Deserialize data
as Self::Contents
using this collection’s format.
Returns the deserialized contents of doc
.
Sets the contents of doc
to contents
.
Serialize item
using this collection’s format.
fn get<C, PrimaryKey>(
id: PrimaryKey,
connection: &C
) -> Result<Option<CollectionDocument<Self>>, Error> where
C: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
fn get<C, PrimaryKey>(
id: PrimaryKey,
connection: &C
) -> Result<Option<CollectionDocument<Self>>, Error> where
C: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Gets a CollectionDocument
with id
from connection
.
if let Some(doc) = MyCollection::get(42, &db)? {
println!(
"Retrieved revision {} with deserialized contents: {:?}",
doc.header.revision, doc.contents
);
}
fn get_async<'life0, 'async_trait, C, PrimaryKey>(
id: PrimaryKey,
connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
C: AsyncConnection + 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'async_trait + Send,
fn get_async<'life0, 'async_trait, C, PrimaryKey>(
id: PrimaryKey,
connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
C: AsyncConnection + 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'async_trait + Send,
Gets a CollectionDocument
with id
from connection
.
if let Some(doc) = MyCollection::get_async(42, &db).await? {
println!(
"Retrieved revision {} with deserialized contents: {:?}",
doc.header.revision, doc.contents
);
}
fn get_multiple<C, DocumentIds, PrimaryKey, I>(
ids: DocumentIds,
connection: &C
) -> Result<Vec<CollectionDocument<Self>, Global>, Error> where
C: Connection,
DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync,
I: Iterator<Item = PrimaryKey> + Send + Sync,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
fn get_multiple<C, DocumentIds, PrimaryKey, I>(
ids: DocumentIds,
connection: &C
) -> Result<Vec<CollectionDocument<Self>, Global>, Error> where
C: Connection,
DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync,
I: Iterator<Item = PrimaryKey> + Send + Sync,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Retrieves all documents matching ids
. Documents that are not found
are not returned, but no error will be generated.
for doc in MyCollection::get_multiple([42, 43], &db)? {
println!(
"Retrieved #{} with deserialized contents: {:?}",
doc.header.id, doc.contents
);
}
fn get_multiple_async<'life0, 'async_trait, C, DocumentIds, PrimaryKey, I>(
ids: DocumentIds,
connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>, Global>, Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
C: AsyncConnection + 'async_trait,
DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync + 'async_trait,
I: Iterator<Item = PrimaryKey> + Send + Sync + 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'async_trait + Send,
fn get_multiple_async<'life0, 'async_trait, C, DocumentIds, PrimaryKey, I>(
ids: DocumentIds,
connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>, Global>, Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
C: AsyncConnection + 'async_trait,
DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync + 'async_trait,
I: Iterator<Item = PrimaryKey> + Send + Sync + 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'async_trait + Send,
Retrieves all documents matching ids
. Documents that are not found
are not returned, but no error will be generated.
for doc in MyCollection::get_multiple_async([42, 43], &db).await? {
println!(
"Retrieved #{} with deserialized contents: {:?}",
doc.header.id, doc.contents
);
}
fn list<R, PrimaryKey, C>(
ids: R,
connection: &C
) -> List<'_, C, Self, PrimaryKey> where
R: Into<Range<PrimaryKey>>,
C: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
fn list<R, PrimaryKey, C>(
ids: R,
connection: &C
) -> List<'_, C, Self, PrimaryKey> where
R: Into<Range<PrimaryKey>>,
C: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Retrieves all documents matching the range of ids
.
for doc in MyCollection::list(42.., &db)
.descending()
.limit(20)
.query()?
{
println!(
"Retrieved #{} with deserialized contents: {:?}",
doc.header.id, doc.contents
);
}
fn list_async<R, PrimaryKey, C>(
ids: R,
connection: &C
) -> AsyncList<'_, C, Self, PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
R: Into<Range<PrimaryKey>>,
C: AsyncConnection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
fn list_async<R, PrimaryKey, C>(
ids: R,
connection: &C
) -> AsyncList<'_, C, Self, PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
R: Into<Range<PrimaryKey>>,
C: AsyncConnection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
Retrieves all documents matching the range of ids
.
for doc in MyCollection::list_async(42.., &db)
.descending()
.limit(20)
.await?
{
println!(
"Retrieved #{} with deserialized contents: {:?}",
doc.header.id, doc.contents
);
}
fn list_with_prefix<C>(
prefix: Self::PrimaryKey,
connection: &C
) -> List<'_, C, Self, Self::PrimaryKey> where
C: Connection,
Self::PrimaryKey: IntoPrefixRange,
fn list_with_prefix<C>(
prefix: Self::PrimaryKey,
connection: &C
) -> List<'_, C, Self, Self::PrimaryKey> where
C: Connection,
Self::PrimaryKey: IntoPrefixRange,
Retrieves all documents with ids that start with prefix
.
use bonsaidb_core::{
connection::Connection,
document::CollectionDocument,
schema::{Collection, Schematic, SerializedCollection},
Error,
};
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize, Default, Collection)]
#[collection(name = "MyCollection", primary_key = String)]
pub struct MyCollection;
async fn starts_with_a<C: Connection>(
db: &C,
) -> Result<Vec<CollectionDocument<MyCollection>>, Error> {
MyCollection::list_with_prefix(String::from("a"), db).query()
}
fn list_with_prefix_async<C>(
prefix: Self::PrimaryKey,
connection: &C
) -> AsyncList<'_, C, Self, Self::PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
C: AsyncConnection,
Self::PrimaryKey: IntoPrefixRange,
fn list_with_prefix_async<C>(
prefix: Self::PrimaryKey,
connection: &C
) -> AsyncList<'_, C, Self, Self::PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
C: AsyncConnection,
Self::PrimaryKey: IntoPrefixRange,
impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
Retrieves all documents with ids that start with prefix
.
use bonsaidb_core::{
connection::AsyncConnection,
document::CollectionDocument,
schema::{Collection, Schematic, SerializedCollection},
Error,
};
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize, Default, Collection)]
#[collection(name = "MyCollection", primary_key = String)]
pub struct MyCollection;
async fn starts_with_a<C: AsyncConnection>(
db: &C,
) -> Result<Vec<CollectionDocument<MyCollection>>, Error> {
MyCollection::list_with_prefix_async(String::from("a"), db).await
}
fn all<C>(connection: &C) -> List<'_, C, Self, Self::PrimaryKey> where
C: Connection,
fn all<C>(connection: &C) -> List<'_, C, Self, Self::PrimaryKey> where
C: Connection,
Retrieves all documents.
for doc in MyCollection::all(&db).query()? {
println!(
"Retrieved #{} with deserialized contents: {:?}",
doc.header.id, doc.contents
);
}
fn all_async<C>(connection: &C) -> AsyncList<'_, C, Self, Self::PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
C: AsyncConnection,
fn all_async<C>(connection: &C) -> AsyncList<'_, C, Self, Self::PrimaryKey>ⓘNotable traits for AsyncList<'a, Cn, Cl, PrimaryKey>impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
where
C: AsyncConnection,
impl<'a, Cn, Cl, PrimaryKey> Future for AsyncList<'a, Cn, Cl, PrimaryKey> where
Cl: SerializedCollection + Unpin,
Cn: AsyncConnection,
PrimaryKey: 'a + for<'k> KeyEncoding<'k, <Cl as Collection>::PrimaryKey> + Unpin,
<Cl as Collection>::PrimaryKey: Unpin, type Output = Result<Vec<CollectionDocument<Cl>, Global>, Error>;
Retrieves all documents.
for doc in MyCollection::all_async(&db).await? {
println!(
"Retrieved #{} with deserialized contents: {:?}",
doc.header.id, doc.contents
);
}
fn push<Cn>(
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>> where
Cn: Connection,
Self: 'static,
fn push<Cn>(
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>> where
Cn: Connection,
Self: 'static,
Pushes this value into the collection, returning the created document.
This function is useful when Self != Self::Contents
.
Automatic ID Assignment
This function calls Self::natural_id()
to try to retrieve a primary
key value from contents
. If an id is returned, the item is inserted
with that id. If an id is not returned, an id will be automatically
assigned, if possible, by the storage backend, which uses the Key
trait to assign ids.
let document = MyCollection::push(MyCollection::default(), &db)?;
println!(
"Inserted {:?} with id {} with revision {}",
document.contents, document.header.id, document.header.revision
);
fn push_async<'life0, 'async_trait, Cn>(
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'static + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
Self::Contents: 'async_trait,
fn push_async<'life0, 'async_trait, Cn>(
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'static + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
Self::Contents: 'async_trait,
Pushes this value into the collection, returning the created document.
This function is useful when Self != Self::Contents
.
Automatic ID Assignment
This function calls Self::natural_id()
to try to retrieve a primary
key value from contents
. If an id is returned, the item is inserted
with that id. If an id is not returned, an id will be automatically
assigned, if possible, by the storage backend, which uses the Key
trait to assign ids.
let document = MyCollection::push_async(MyCollection::default(), &db).await?;
println!(
"Inserted {:?} with id {} with revision {}",
document.contents, document.header.id, document.header.revision
);
fn push_into<Cn>(
self,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>> where
Cn: Connection,
Self: 'static + SerializedCollection<Contents = Self>,
fn push_into<Cn>(
self,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>> where
Cn: Connection,
Self: 'static + SerializedCollection<Contents = Self>,
Pushes this value into the collection, returning the created document.
Automatic ID Assignment
This function calls Self::natural_id()
to try to retrieve a primary
key value from self
. If an id is returned, the item is inserted with
that id. If an id is not returned, an id will be automatically assigned,
if possible, by the storage backend, which uses the Key
trait to
assign ids.
let document = MyCollection::default().push_into(&db)?;
println!(
"Inserted {:?} with id {} with revision {}",
document.contents, document.header.id, document.header.revision
);
fn push_into_async<'life0, 'async_trait, Cn>(
self,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
fn push_into_async<'life0, 'async_trait, Cn>(
self,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
Pushes this value into the collection, returning the created document.
Automatic ID Assignment
This function calls Self::natural_id()
to try to retrieve a primary
key value from self
. If an id is returned, the item is inserted with
that id. If an id is not returned, an id will be automatically assigned,
if possible, by the storage backend, which uses the Key
trait to
assign ids.
let document = MyCollection::default().push_into_async(&db).await?;
println!(
"Inserted {:?} with id {} with revision {}",
document.contents, document.header.id, document.header.revision
);
fn insert<PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>> where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static,
fn insert<PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>> where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static,
Inserts this value into the collection with the specified id, returning the created document.
let document = MyCollection::insert(42, MyCollection::default(), &db)?;
assert_eq!(document.header.id, 42);
println!(
"Inserted {:?} with revision {}",
document.contents, document.header.revision
);
fn insert_async<'life0, 'async_trait, PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + 'async_trait + Send,
Self::Contents: 'async_trait,
fn insert_async<'life0, 'async_trait, PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + 'async_trait + Send,
Self::Contents: 'async_trait,
Inserts this value into the collection with the specified id, returning the created document.
let document = MyCollection::insert_async(42, MyCollection::default(), &db).await?;
assert_eq!(document.header.id, 42);
println!(
"Inserted {:?} with revision {}",
document.contents, document.header.revision
);
fn insert_into<PrimaryKey, Cn>(
self,
id: PrimaryKey,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>> where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static + SerializedCollection<Contents = Self>,
fn insert_into<PrimaryKey, Cn>(
self,
id: PrimaryKey,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>> where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static + SerializedCollection<Contents = Self>,
Inserts this value into the collection with the given id
, returning
the created document.
let document = MyCollection::default().insert_into(42, &db)?;
assert_eq!(document.header.id, 42);
println!(
"Inserted {:?} with revision {}",
document.contents, document.header.revision
);
fn insert_into_async<'life0, 'async_trait, PrimaryKey, Cn>(
self,
id: PrimaryKey,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
fn insert_into_async<'life0, 'async_trait, PrimaryKey, Cn>(
self,
id: PrimaryKey,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Inserts this value into the collection with the given id
, returning
the created document.
let document = MyCollection::default().insert_into_async(42, &db).await?;
assert_eq!(document.header.id, 42);
println!(
"Inserted {:?} with revision {}",
document.contents, document.header.revision
);
fn overwrite<PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>> where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static,
fn overwrite<PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>> where
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Cn: Connection,
Self: 'static,
Overwrites this value into the collection with the specified id, returning the created or updated document.
let document = MyCollection::overwrite(42, MyCollection::default(), &db)?;
assert_eq!(document.header.id, 42);
println!(
"Overwrote {:?} with revision {}",
document.contents, document.header.revision
);
fn overwrite_async<'life0, 'async_trait, PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + 'async_trait + Send,
Self::Contents: 'async_trait,
fn overwrite_async<'life0, 'async_trait, PrimaryKey, Cn>(
id: PrimaryKey,
contents: Self::Contents,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Cn: AsyncConnection + 'async_trait,
Self: 'static + 'async_trait + Send,
Self::Contents: 'async_trait,
Overwrites this value into the collection with the specified id, returning the created or updated document.
let document = MyCollection::overwrite_async(42, MyCollection::default(), &db).await?;
assert_eq!(document.header.id, 42);
println!(
"Overwrote {:?} with revision {}",
document.contents, document.header.revision
);
fn overwrite_into<Cn, PrimaryKey>(
self,
id: PrimaryKey,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>> where
Cn: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Self: 'static + SerializedCollection<Contents = Self>,
fn overwrite_into<Cn, PrimaryKey>(
self,
id: PrimaryKey,
connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>> where
Cn: Connection,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey>,
Self: 'static + SerializedCollection<Contents = Self>,
Overwrites this value into the collection with the given id
, returning
the created or updated document.
let document = MyCollection::default().overwrite_into(42, &db)?;
assert_eq!(document.header.id, 42);
println!(
"Overwrote {:?} with revision {}",
document.contents, document.header.revision
);
fn overwrite_into_async<'life0, 'async_trait, Cn, PrimaryKey>(
self,
id: PrimaryKey,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
fn overwrite_into_async<'life0, 'async_trait, Cn, PrimaryKey>(
self,
id: PrimaryKey,
connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
PrimaryKey: for<'k> KeyEncoding<'k, Self::PrimaryKey> + 'async_trait,
Self: 'static + SerializedCollection<Contents = Self> + 'async_trait + Send,
Cn: 'async_trait + AsyncConnection,
Overwrites this value into the collection with the given id
, returning
the created or updated document.
let document = MyCollection::default()
.overwrite_into_async(42, &db)
.await?;
assert_eq!(document.header.id, 42);
println!(
"Overwrote {:?} with revision {}",
document.contents, document.header.revision
);