Struct ScopedQuery 

pub struct ScopedQuery<Options> {
    pub scope: QueryScope,
    pub options: Options,
}

Shared scope plus query-family options.

Use Self::new with explicit options or the vector and text constructors, then embed the result in a concrete query request. This value does not execute work or contain a database connection.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents"))
    .text_field("body").limit(5);
assert_eq!(query.options.text_field.as_deref(), Some("body"));
assert_eq!(query.options.limit, Some(5));

Fields

scope: QueryScope

Collection and result scope.

options: Options

Query-family options.

Implementations

impl<Options> ScopedQuery<Options>

pub fn new(scope: impl Into<QueryScope>, options: Options) -> Self

Creates a scoped query.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::{ScopedQuery, TextQueryOptions};
let query = ScopedQuery::new(StorageLocator::new("documents"), TextQueryOptions::default());
assert_eq!(query.scope.locator.collection, "documents");
assert!(query.options.text_field.is_none());

pub fn with_scope(self, scope: QueryScope) -> Self

Replaces the shared scope.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::{QueryScope, ScopedQuery};
let scope = QueryScope::new(StorageLocator::new("published"));
let query = ScopedQuery::text(StorageLocator::new("drafts")).with_scope(scope);
assert_eq!(query.scope.locator.collection, "published");

pub fn filter(self, filter: FilterExpr) -> Self

Applies a filter.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::data::FilterExpr;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents"))
    .filter(FilterExpr::eq("published", true));
assert!(query.scope.filter.is_some());

pub fn projection(self, projection: Projection) -> Self

Replaces returned fields.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::{Projection, ScopedQuery};
let query = ScopedQuery::vector(StorageLocator::new("documents"))
    .projection(Projection::Columns(vec!["title".to_owned()]));
assert_eq!(query.scope.projection, Projection::Columns(vec!["title".to_owned()]));

pub fn map_options(self, update: impl FnOnce(&mut Options)) -> Self

Mutates family options.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents"))
    .map_options(|options| { options.set_field("body"); options.set_limit(5); });
assert_eq!(query.options.limit, Some(5));

impl ScopedQuery<VectorQueryOptions>

pub fn vector(locator: StorageLocator) -> Self

Creates a vector query.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::vector(StorageLocator::new("documents"));
assert_eq!(query.options.params.limit, 10);
assert!(query.options.vector_field.is_none());

pub fn vector_field(self, field: impl Into<String>) -> Self

Selects a vector field.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::vector(StorageLocator::new("documents")).vector_field("embedding");
assert_eq!(query.options.vector_field.as_deref(), Some("embedding"));

pub fn limit(self, limit: usize) -> Self

Sets the maximum hits.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::vector(StorageLocator::new("documents")).limit(5);
assert_eq!(query.options.params.limit, 5);

pub fn params(self, params: VectorSearchParams) -> Self

Replaces search shaping.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::{ScopedQuery, VectorSearchParams};
let query = ScopedQuery::vector(StorageLocator::new("documents"))
    .params(VectorSearchParams { limit: 5, offset: Some(2), ..Default::default() });
assert_eq!(query.options.params.offset, Some(2));

impl ScopedQuery<TextQueryOptions>

pub fn text(locator: StorageLocator) -> Self

Creates a text query.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents"));
assert!(query.options.text_field.is_none());
assert!(query.options.limit.is_none());

pub fn text_field(self, field: impl Into<String>) -> Self

Selects a text field.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents")).text_field("body");
assert_eq!(query.options.text_field.as_deref(), Some("body"));

pub fn limit(self, limit: usize) -> Self

Sets maximum hits.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents")).limit(5);
assert_eq!(query.options.limit, Some(5));

pub fn offset(self, offset: usize) -> Self

Sets hit offset.

Examples

use storage_kit::database::StorageLocator;
use storage_kit::database::query::ScopedQuery;
let query = ScopedQuery::text(StorageLocator::new("documents")).offset(10);
assert_eq!(query.options.offset, Some(10));

Trait Implementations

impl<Options: Clone> Clone for ScopedQuery<Options>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Options: Debug> Debug for ScopedQuery<Options>

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

Formats the value using the given formatter.

impl<'de, Options> Deserialize<'de> for ScopedQuery<Options>

where Options: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Options: PartialEq> PartialEq for ScopedQuery<Options>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Options> Serialize for ScopedQuery<Options>

where Options: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Options: PartialEq> StructuralPartialEq for ScopedQuery<Options>