pub struct View<'a, Cn, V: SerializedView, Key> where
    V::Key: Borrow<Key> + PartialEq<Key>,
    Key: PartialEq + ?Sized
{ pub key: Option<QueryKey<'a, V::Key, Key>>, pub access_policy: AccessPolicy, pub sort: Sort, pub limit: Option<u32>, /* private fields */ }
Expand description

Parameters to query a schema::View.

The examples for this type use this view definition:

use bonsaidb_core::{
    define_basic_unique_mapped_view,
    document::{CollectionDocument, Emit},
    schema::{
        CollectionViewSchema, DefaultViewSerialization, Name, ReduceResult, View,
        ViewMapResult, ViewMappedValue,
    },
};

#[derive(Debug, Clone, View)]
#[view(collection = MyCollection, key = u32, value = f32, name = "scores-by-rank")]
pub struct ScoresByRank;

impl CollectionViewSchema for ScoresByRank {
    type View = Self;
    fn map(
        &self,
        document: CollectionDocument<<Self::View as View>::Collection>,
    ) -> ViewMapResult<Self::View> {
        document
            .header
            .emit_key_and_value(document.contents.rank, document.contents.score)
    }

    fn reduce(
        &self,
        mappings: &[ViewMappedValue<Self::View>],
        rereduce: bool,
    ) -> ReduceResult<Self::View> {
        if mappings.is_empty() {
            Ok(0.)
        } else {
            Ok(mappings.iter().map(|map| map.value).sum::<f32>() / mappings.len() as f32)
        }
    }
}

Fields

key: Option<QueryKey<'a, V::Key, Key>>

Key filtering criteria.

access_policy: AccessPolicy

The view’s data access policy. The default value is AccessPolicy::UpdateBefore.

sort: Sort

The sort order of the query.

limit: Option<u32>

The maximum number of results to return.

Implementations

Filters for entries in the view with key.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).with_key(&42).query()? {
    assert_eq!(mapping.key, 42);
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Filters for entries in the view with keys.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).with_keys(&[42, 43]).query()? {
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Filters for entries in the view with the range keys.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).with_key_range(42..).query()? {
    assert!(mapping.key >= 42);
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Filters for entries in the view with keys that begin with prefix.

#[derive(View, Debug, Clone)]
#[view(name = "by-name", key = String, collection = MyCollection)]
struct ByName;

// score is an f32 in this example
for mapping in ByName::entries(&db).with_key_prefix("a").query()? {
    assert!(mapping.key.starts_with("a"));
    println!("{} in document {:?}", mapping.key, mapping.source);
}

Sets the access policy for queries.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db)
    .with_access_policy(AccessPolicy::UpdateAfter)
    .query()?
{
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Returns the matching mappings in ascending key order. This is the default sorting behavior.

When more than one mapping exists for a single key, all matching mappings are returned as a unique entry. The resulting mappings are sorted only by the key, and as such, the order of mappings with the same key is undefined.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).ascending().query()? {
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Returns the matching mappings in descending key order.

When more than one mapping exists for a single key, all matching mappings are returned as a unique entry. The resulting mappings are sorted only by the key, and as such, the order of mappings with the same key is undefined.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).descending().query()? {
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Sets the maximum number of results to return.

// score is an f32 in this example
let mappings = ScoresByRank::entries(&db).limit(10).query()?;
assert!(mappings.len() <= 10);

Executes the query and retrieves the results.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).query()? {
    println!("Rank {} has a score of {:3}", mapping.key, mapping.value);
}

Executes the query and retrieves the results with the associated Documents.

for mapping in &ScoresByRank::entries(&db)
    .with_key_range(42..=44)
    .query_with_docs()?
{
    println!(
        "Mapping from #{} with rank: {} and score: {}. Document bytes: {:?}",
        mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents
    );
}

Executes the query and retrieves the results with the associated CollectionDocuments.

for mapping in &ScoresByRank::entries(&db)
    .with_key_range(42..=44)
    .query_with_collection_docs()?
{
    println!(
        "Mapping from #{} with rank: {} and score: {}. Deserialized Contents: {:?}",
        mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents
    );
}

Executes a reduce over the results of the query

// score is an f32 in this example
let score = ScoresByRank::entries(&db).reduce()?;
println!("Average score: {:3}", score);

Executes a reduce over the results of the query, grouping by key.

// score is an f32 in this example
for mapping in ScoresByRank::entries(&db).reduce_grouped()? {
    println!(
        "Rank {} has an average score of {:3}",
        mapping.key, mapping.value
    );
}

Deletes all of the associated documents that match this view query.

ScoresByRank::entries(&db).delete_docs()?;

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Should always be Self

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more