use std::{

    collections::BTreeMap,

    marker::PhantomData,

    ops::{Deref, DerefMut},

};

use arc_bytes::serde::Bytes;

use async_trait::async_trait;

use futures::{future::BoxFuture, Future, FutureExt};

use serde::{Deserialize, Serialize};

#[cfg(feature = "multiuser")]

use zeroize::Zeroize;

#[cfg(feature = "multiuser")]

use crate::schema::NamedReference;

use crate::{

    document::{CollectionDocument, Document, Header, OwnedDocument},

    permissions::Permissions,

    schema::{

        self,

        view::{self, map::MappedDocuments},

        Key, Map, MappedValue, Schema, SchemaName, SerializedCollection,

    },

    transaction::{self, OperationResult, Transaction},

    Error,

};

/// Defines all interactions with a [`schema::Schema`], regardless of whether it

/// is local or remote.

#[async_trait]

pub trait Connection: Send + Sync {

    /// Accesses a collection for the connected [`schema::Schema`].

    /// 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.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::push_into()`]

    /// - [`SerializedCollection::insert_into()`]

    /// - [`self.collection::<Collection>().insert()`](Collection::insert)

    /// - [`self.collection::<Collection>().push()`](Collection::push)

        } else {

        }

    /// Updates an existing document in the connected [`schema::Schema`] for the

    /// [`Collection`] `C`. Upon success, `doc.revision` will be updated with

    /// the new revision.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`CollectionDocument::update()`]

    /// - [`self.collection::<Collection>().update()`](Collection::update)

        } else {

        }

    /// Retrieves a stored document from [`Collection`] `C` identified by `id`.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::get()`]

    /// - [`self.collection::<Collection>().get()`](Collection::get)

    async fn get<C: schema::Collection>(&self, id: u64) -> Result<Option<OwnedDocument>, Error>;

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::get_multiple()`]

    /// - [`self.collection::<Collection>().get_multiple()`](Collection::get_multiple)

    async fn get_multiple<C: schema::Collection>(

        &self,

        ids: &[u64],

    ) -> Result<Vec<OwnedDocument>, Error>;

    /// 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`.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::all()`]

    /// - [`self.collection::<Collection>().all()`](Collection::all)

    /// - [`SerializedCollection::list()`]

    /// - [`self.collection::<Collection>().list()`](Collection::list)

    async fn list<C: schema::Collection, R: Into<Range<u64>> + Send>(

        &self,

        ids: R,

        order: Sort,

        limit: Option<usize>,

    ) -> Result<Vec<OwnedDocument>, Error>;

    /// Removes a `Document` from the database.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`CollectionDocument::delete()`]

    /// - [`self.collection::<Collection>().delete()`](Collection::delete)

        } else {

        }

    /// Initializes [`View`] for [`schema::View`] `V`.

    #[must_use]

    /// Queries for view entries matching [`View`].

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().query()`](View::query) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn query<V: schema::SerializedView>(

        &self,

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

        order: Sort,

        limit: Option<usize>,

        access_policy: AccessPolicy,

    ) -> Result<Vec<Map<V::Key, V::Value>>, Error>

    where

        Self: Sized;

    /// Queries for view entries matching [`View`] with their source documents.

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().query_with_docs()`](View::query_with_docs) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn query_with_docs<V: schema::SerializedView>(

        &self,

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

        order: Sort,

        limit: Option<usize>,

        access_policy: AccessPolicy,

    ) -> Result<MappedDocuments<OwnedDocument, V>, Error>

    where

        Self: Sized;

    /// Queries for view entries matching [`View`] with their source documents, deserialized.

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().query_with_collection_docs()`](View::query_with_collection_docs) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

        }

    /// Reduces the view entries matching [`View`].

    ///

    /// This is the lower-level API. For better ergonomics, consider reducing

    /// the view using [`self.view::<View>().reduce()`](View::reduce) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn reduce<V: schema::SerializedView>(

        &self,

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

        access_policy: AccessPolicy,

    ) -> Result<V::Value, Error>

    where

        Self: Sized;

    /// Reduces the view entries matching [`View`], reducing the values by each

    /// unique key.

    ///

    /// This is the lower-level API. For better ergonomics, consider reducing

    /// the view using

    /// [`self.view::<View>().reduce_grouped()`](View::reduce_grouped) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn reduce_grouped<V: schema::SerializedView>(

        &self,

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

        access_policy: AccessPolicy,

    ) -> Result<Vec<MappedValue<V::Key, V::Value>>, Error>

    where

        Self: Sized;

    /// Deletes all of the documents associated with this view.

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().delete_docs()`](View::delete_docs()) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn delete_docs<V: schema::SerializedView>(

        &self,

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

        access_policy: AccessPolicy,

    ) -> Result<u64, Error>

    where

        Self: Sized;

    /// 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`].

    async fn apply_transaction(

        &self,

        transaction: Transaction,

    ) -> Result<Vec<OperationResult>, Error>;

    /// Lists executed [`Transaction`]s 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`.

    async fn list_executed_transactions(

        &self,

        starting_id: Option<u64>,

        result_limit: Option<usize>,

    ) -> Result<Vec<transaction::Executed>, Error>;

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

    async fn last_transaction_id(&self) -> Result<Option<u64>, Error>;

    /// Compacts the entire database to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact(&self) -> Result<(), crate::Error>;

    /// Compacts the collection to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::CollectionNotFound`]: database `name` does not exist.

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact_collection<C: schema::Collection>(&self) -> Result<(), crate::Error>;

    /// Compacts the key value store to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact_key_value_store(&self) -> Result<(), crate::Error>;

}

/// Interacts with a collection over a `Connection`.

///

/// These examples in this type use this basic collection definition:

///

/// ```rust

/// use bonsaidb_core::{schema::Collection, Error};

/// use serde::{Deserialize, Serialize};

///

/// #[derive(Debug, Serialize, Deserialize, Default, Collection)]

/// #[collection(name = "MyCollection")]

/// # #[collection(core = bonsaidb_core)]

/// pub struct MyCollection {

///     pub rank: u32,

///     pub score: f32,

/// }

/// ```

pub struct Collection<'a, Cn, Cl> {

    connection: &'a Cn,

    _phantom: PhantomData<Cl>, /* allows for extension traits to be written for collections of specific types */

}

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

}

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

where

    Cn: Connection,

    Cl: schema::Collection,

{

    /// Creates a new instance using `connection`.

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

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db

    ///     .collection::<MyCollection>()

    ///     .push(&MyCollection::default())

    ///     .await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Adds a new `Document<Cl>` with the `contents`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db.collection::<MyCollection>().push_bytes(vec![]).await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

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

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db

    ///     .collection::<MyCollection>()

    ///     .insert(42, &MyCollection::default())

    ///     .await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

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

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db

    ///     .collection::<MyCollection>()

    ///     .insert_bytes(42, vec![])

    ///     .await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Updates an existing document. Upon success, `doc.revision` will be

    /// updated with the new revision.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// 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);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

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

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// 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);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// 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);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Retrieves all documents matching the range of `ids`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// 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);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Retrieves all documents.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// 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);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Removes a `Document` from the database.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// if let Some(doc) = db.collection::<MyCollection>().get(42).await? {

    ///     db.collection::<MyCollection>().delete(&doc).await?;

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

}

pub(crate) struct ListBuilder<'a, Cn, Cl> {

    collection: PossiblyOwned<'a, Collection<'a, Cn, Cl>>,

    range: Range<u64>,

    sort: Sort,

    limit: Option<usize>,

}

pub(crate) enum PossiblyOwned<'a, Cl> {

    Owned(Cl),

    Borrowed(&'a Cl),

}

impl<'a, Cl> Deref for PossiblyOwned<'a, Cl> {

    type Target = Cl;

        }

}

pub(crate) enum ListState<'a, Cn, Cl> {

    Pending(Option<ListBuilder<'a, Cn, Cl>>),

    Executing(BoxFuture<'a, Result<Vec<OwnedDocument>, Error>>),

}

/// Executes [`Connection::list()`] when awaited. Also offers methods to

/// customize the options for the operation.

#[must_use]

pub struct List<'a, Cn, Cl> {

    state: ListState<'a, Cn, Cl>,

}

impl<'a, Cn, Cl> List<'a, Cn, Cl> {

        } else {

        }

    /// Lists documents by id in ascending order.

    /// Lists documents by id in descending order.

    /// Sets the maximum number of results to return.

}

impl<'a, Cn, Cl> Future for List<'a, Cn, Cl>

where

    Cn: Connection,

    Cl: schema::Collection + Unpin,

{

    type Output = Result<Vec<OwnedDocument>, Error>;

            }

        }

}

/// Parameters to query a [`schema::View`].

///

/// The examples for this type use this view definition:

///

/// ```rust

/// # mod collection {

/// # bonsaidb_core::__doctest_prelude!();

/// # }

/// # use collection::MyCollection;

/// use bonsaidb_core::{

///     define_basic_unique_mapped_view,

///     document::CollectionDocument,

///     schema::{

///         CollectionViewSchema, DefaultViewSerialization, Name, ReduceResult, View,

///         ViewMapResult, ViewMappedValue,

///     },

/// };

///

/// #[derive(Debug, Clone, View)]

/// #[view(collection = MyCollection, key = u32, value = f32, name = "scores-by-rank")]

/// # #[view(core = bonsaidb_core)]

/// pub struct ScoresByRank;

///

/// impl CollectionViewSchema for ScoresByRank {

///     type View = Self;

///     fn map(

///         &self,

///         document: CollectionDocument<<Self::View as View>::Collection>,

///     ) -> ViewMapResult<Self::View> {

///         Ok(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)

///         }

///     }

/// }

/// ```

pub struct View<'a, Cn, V: schema::SerializedView> {

    connection: &'a Cn,

    /// Key filtering criteria.

    pub key: Option<QueryKey<V::Key>>,

    /// The view's data access policy. The default value is [`AccessPolicy::UpdateBefore`].

    pub access_policy: AccessPolicy,

    /// The sort order of the query.

    pub sort: Sort,

    /// The maximum number of results to return.

    pub limit: Option<usize>,

}

impl<'a, Cn, V> View<'a, Cn, V>

where

    V: schema::SerializedView,

    Cn: Connection,

{

    /// Filters for entries in the view with `key`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().with_key(42).query().await? {

    ///     assert_eq!(mapping.key, 42);

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    #[must_use]

    /// Filters for entries in the view with `keys`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db

    ///     .view::<ScoresByRank>()

    ///     .with_keys([42, 43])

    ///     .query()

    ///     .await?

    /// {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    #[must_use]

    /// Filters for entries in the view with the range `keys`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db

    ///     .view::<ScoresByRank>()

    ///     .with_key_range(42..)

    ///     .query()

    ///     .await?

    /// {

    ///     assert!(mapping.key >= 42);

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    #[must_use]

    /// Sets the access policy for queries.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db

    ///     .view::<ScoresByRank>()

    ///     .with_access_policy(AccessPolicy::UpdateAfter)

    ///     .query()

    ///     .await?

    /// {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Queries the view in ascending order. This is the default sorting

    /// behavior.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().ascending().query().await? {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Queries the view in descending order.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().descending().query().await? {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Sets the maximum number of results to return.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// let mappings = db.view::<ScoresByRank>().limit(10).query().await?;

    /// assert!(mappings.len() <= 10);

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes the query and retrieves the results.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().query().await? {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes the query and retrieves the results with the associated [`Document`s](crate::document::OwnedDocument).

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for mapping in &db

    ///     .view::<ScoresByRank>()

    ///     .with_key_range(42..=44)

    ///     .query_with_docs()

    ///     .await?

    /// {

    ///     println!(

    ///         "Mapping from #{} with rank: {} and score: {}. Document bytes: {:?}",

    ///         mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents

    ///     );

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes the query and retrieves the results with the associated [`CollectionDocument`s](crate::document::CollectionDocument).

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for mapping in &db

    ///     .view::<ScoresByRank>()

    ///     .with_key_range(42..=44)

    ///     .query_with_collection_docs()

    ///     .await?

    /// {

    ///     println!(

    ///         "Mapping from #{} with rank: {} and score: {}. Deserialized Contents: {:?}",

    ///         mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents

    ///     );

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes a reduce over the results of the query

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// let score = db.view::<ScoresByRank>().reduce().await?;

    /// println!("Average score: {:3}", score);

    /// # Ok(())

    /// # })

    /// # }

    /// ```

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

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().reduce_grouped().await? {

    ///     println!(

    ///         "Rank {} has an average score of {:3}",

    ///         mapping.key, mapping.value

    ///     );

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

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

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// db.view::<ScoresByRank>().delete_docs().await?;

    /// # Ok(())

    /// # })

    /// # }

    /// ```

}

/// A sort order.

pub enum Sort {

    /// Sort ascending (A -> Z).

    Ascending,

    /// Sort descending (Z -> A).

    Descending,

}

/// Filters a [`View`] by key.

pub enum QueryKey<K> {

    /// Matches all entries with the key provided.

    Matches(K),

    /// Matches all entires with keys in the range provided.

    Range(Range<K>),

    /// Matches all entries that have keys that are included in the set provided.

    Multiple(Vec<K>),

}

#[allow(clippy::use_self)] // clippy is wrong, Self is different because of generic parameters

impl<K: for<'a> Key<'a>> QueryKey<K> {

    /// Converts this key to a serialized format using the [`Key`] trait.

            }

        }

}

#[allow(clippy::use_self)] // clippy is wrong, Self is different because of generic parameters

impl<'a, T> QueryKey<T>

where

    T: AsRef<[u8]>,

{

    /// Deserializes the bytes into `K` via the [`Key`] trait.

            }

        }

}

/// A range type that can represent all std range types and be serialized.

pub struct Range<T> {

    /// The start of the range.

    pub start: Bound<T>,

    /// The end of the range.

    pub end: Bound<T>,

}

/// A range bound that can be serialized.

pub enum Bound<T> {

    /// No bound.

    Unbounded,

    /// Bounded by the contained value (inclusive).

    Included(T),

    /// Bounded by the contained value (exclusive).

    Excluded(T),

}

impl<T> Range<T> {

    /// Maps each contained value with the function provided.

    /// Maps each contained value as a reference.

}

impl<'a, T: Key<'a>> Range<T> {

    /// Serializes the range's contained values to big-endian bytes.

        })

}

impl<'a, B> Range<B>

where

    B: AsRef<[u8]>,

{

    /// Deserializes the range's contained values from big-endian bytes.

        })

}

impl<T> Bound<T> {

    /// Maps the contained value, if any, and returns the resulting `Bound`.

        }

    /// Maps each contained value as a reference.

        }

}

impl<'a, T: Key<'a>> Bound<T> {

    /// Serializes the contained value to big-endian bytes.

            ))),

            ))),

        }

}

impl<'a, B> Bound<B>

where

    B: AsRef<[u8]>,

{

    /// Deserializes the bound's contained value from big-endian bytes.

            }

            }

        }

}

impl<T> std::ops::RangeBounds<T> for Range<T> {

}

impl<'a, T> From<&'a Bound<T>> for std::ops::Bound<&'a T> {

        }