icydb-core 0.94.0

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! Module: db::query::fluent::load::validation
//! Shares fluent load validation helpers for terminal field resolution and
//! paged-vs-non-paged mode checks.

use crate::{
    db::query::{
        fluent::load::FluentLoadQuery,
        intent::{IntentError, QueryError},
        plan::{
            FieldSlot, resolve_aggregate_target_field_slot, validate_fluent_non_paged_mode,
            validate_fluent_paged_mode,
        },
    },
    traits::EntityKind,
};

impl<E> FluentLoadQuery<'_, E>
where
    E: EntityKind,
{
    // Enforce non-paged intent readiness before resolving one terminal slot so
    // field-based scalar terminals do not each repeat the same policy gate and
    // planner slot lookup shell.
    pub(super) fn with_non_paged_slot<T>(
        &self,
        field: impl AsRef<str>,
        f: impl FnOnce(FieldSlot) -> Result<T, QueryError>,
    ) -> Result<T, QueryError> {
        self.ensure_non_paged_mode_ready()?;
        let target_slot = resolve_aggregate_target_field_slot(E::MODEL, field.as_ref())?;
        f(target_slot)
    }

    pub(super) fn ensure_cursor_mode_ready(&self) -> Result<(), QueryError> {
        // Cursor-mode fluent queries only need the paged policy gate when a
        // continuation token is actually present on the request boundary.
        if self.cursor_token.is_some() {
            validate_fluent_paged_mode(
                self.query.has_grouping(),
                self.query.has_explicit_order(),
                self.query.load_spec(),
            )
            .map_err(IntentError::from)
            .map_err(QueryError::intent)?;
        }

        Ok(())
    }

    pub(super) fn ensure_paged_mode_ready(&self) -> Result<(), QueryError> {
        validate_fluent_paged_mode(
            self.query.has_grouping(),
            self.query.has_explicit_order(),
            self.query.load_spec(),
        )
        .map_err(IntentError::from)
        .map_err(QueryError::intent)
    }

    pub(super) fn ensure_non_paged_mode_ready(&self) -> Result<(), QueryError> {
        validate_fluent_non_paged_mode(self.cursor_token.is_some(), self.query.has_grouping())
            .map_err(IntentError::from)
            .map_err(QueryError::intent)
    }
}