icydb-core 0.150.14

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Module: db::query::plan::validate::symbols
//! Responsibility: validate user-facing field and symbol references against
//! the model and grouped/query projection surfaces.
//! Does not own: ordering, cursor, or grouped policy enforcement outside symbol lookup.
//! Boundary: keeps symbol-resolution failures localized within query-plan validation.

use crate::{
    db::query::{
        intent::QueryError,
        plan::{
            FieldSlot,
            validate::{GroupPlanError, PlanError},
        },
    },
    db::schema::{FieldType, SchemaInfo},
    model::entity::EntityModel,
};

/// Resolve one grouped field into a stable field slot.
pub(in crate::db) fn resolve_group_field_slot(
    model: &EntityModel,
    field: &str,
) -> Result<FieldSlot, PlanError> {
    FieldSlot::resolve(model, field)
        .ok_or_else(|| PlanError::from(GroupPlanError::unknown_group_field(field)))
}

/// Resolve one grouped field through schema slot authority.
pub(in crate::db) fn resolve_group_field_slot_with_schema(
    model: &EntityModel,
    schema: &SchemaInfo,
    field: &str,
) -> Result<FieldSlot, PlanError> {
    let index = schema
        .field_slot_index(field)
        .ok_or_else(|| PlanError::from(GroupPlanError::unknown_group_field(field)))?;
    let model_field = model
        .fields()
        .iter()
        .find(|model_field| model_field.name() == field)
        .ok_or_else(|| PlanError::from(GroupPlanError::unknown_group_field(field)))?;

    Ok(FieldSlot {
        index,
        field: model_field.name().to_string(),
        kind: Some(model_field.kind()),
    })
}

/// Resolve one aggregate target field through schema slot authority.
///
/// Accepted-schema planning paths use this helper so the physical slot comes
/// from the selected `SchemaInfo`; the generated model is retained only for
/// field labels and type metadata used by diagnostics and explain surfaces.
pub(in crate::db) fn resolve_aggregate_target_field_slot_with_schema(
    model: &EntityModel,
    schema: &SchemaInfo,
    field: &str,
) -> Result<FieldSlot, QueryError> {
    let index = schema
        .field_slot_index(field)
        .ok_or_else(|| QueryError::unknown_aggregate_target_field(field))?;
    let model_field = model
        .fields()
        .iter()
        .find(|model_field| model_field.name() == field)
        .ok_or_else(|| QueryError::unknown_aggregate_target_field(field))?;

    Ok(FieldSlot {
        index,
        field: model_field.name().to_string(),
        kind: Some(model_field.kind()),
    })
}

/// Resolve one grouped aggregate target field into one schema field type.
pub(in crate::db::query::plan::validate) fn resolve_group_aggregate_target_field_type<'a>(
    schema: &'a SchemaInfo,
    field: &str,
    index: usize,
) -> Result<&'a FieldType, GroupPlanError> {
    schema
        .field(field)
        .ok_or_else(|| GroupPlanError::unknown_aggregate_target_field(index, field))
}