icydb_core/db/query/predicate/validate/
schema.rs

1use crate::{
2    db::{
3        identity::{EntityName, EntityNameError, IndexName, IndexNameError},
4        query::predicate::{UnsupportedQueryFeature, coercion::CoercionId},
5    },
6    model::{entity::EntityModel, index::IndexModel},
7};
8use std::collections::{BTreeMap, BTreeSet};
9
10use crate::db::query::predicate::validate::model::{FieldType, field_type_from_model_kind};
11
12fn validate_index_fields(
13    fields: &BTreeMap<String, FieldType>,
14    indexes: &[&IndexModel],
15) -> Result<(), ValidateError> {
16    let mut seen_names = BTreeSet::new();
17    for index in indexes {
18        if seen_names.contains(index.name) {
19            return Err(ValidateError::DuplicateIndexName {
20                name: index.name.to_string(),
21            });
22        }
23        seen_names.insert(index.name);
24
25        let mut seen = BTreeSet::new();
26        for field in index.fields {
27            if !fields.contains_key(*field) {
28                return Err(ValidateError::IndexFieldUnknown {
29                    index: **index,
30                    field: (*field).to_string(),
31                });
32            }
33            if seen.contains(*field) {
34                return Err(ValidateError::IndexFieldDuplicate {
35                    index: **index,
36                    field: (*field).to_string(),
37                });
38            }
39            seen.insert(*field);
40
41            let field_type = fields
42                .get(*field)
43                .expect("index field existence checked above");
44            // Guardrail: map fields are deterministic stored values but remain
45            // non-queryable and non-indexable in 0.7.
46            if matches!(field_type, FieldType::Map { .. }) {
47                return Err(ValidateError::IndexFieldMapNotQueryable {
48                    index: **index,
49                    field: (*field).to_string(),
50                });
51            }
52            if !field_type.value_kind().is_queryable() {
53                return Err(ValidateError::IndexFieldNotQueryable {
54                    index: **index,
55                    field: (*field).to_string(),
56                });
57            }
58        }
59    }
60
61    Ok(())
62}
63
64///
65/// SchemaInfo
66///
67/// Lightweight, runtime-usable field-type map for one entity.
68/// This is the *only* schema surface the predicate validator depends on.
69///
70
71#[derive(Clone, Debug)]
72pub struct SchemaInfo {
73    fields: BTreeMap<String, FieldType>,
74}
75
76impl SchemaInfo {
77    #[must_use]
78    pub(crate) fn field(&self, name: &str) -> Option<&FieldType> {
79        self.fields.get(name)
80    }
81
82    /// Builds runtime predicate schema information from an entity model.
83    pub fn from_entity_model(model: &EntityModel) -> Result<Self, ValidateError> {
84        // Validate identity constraints before building schema maps.
85        let entity_name = EntityName::try_from_str(model.entity_name).map_err(|err| {
86            ValidateError::InvalidEntityName {
87                name: model.entity_name.to_string(),
88                source: err,
89            }
90        })?;
91
92        if !model
93            .fields
94            .iter()
95            .any(|field| std::ptr::eq(field, model.primary_key))
96        {
97            return Err(ValidateError::InvalidPrimaryKey {
98                field: model.primary_key.name.to_string(),
99            });
100        }
101
102        let mut fields = BTreeMap::new();
103        for field in model.fields {
104            if fields.contains_key(field.name) {
105                return Err(ValidateError::DuplicateField {
106                    field: field.name.to_string(),
107                });
108            }
109            let ty = field_type_from_model_kind(&field.kind);
110            fields.insert(field.name.to_string(), ty);
111        }
112
113        let pk_field_type = fields
114            .get(model.primary_key.name)
115            .expect("primary key verified above");
116        if !pk_field_type.is_keyable() {
117            return Err(ValidateError::InvalidPrimaryKeyType {
118                field: model.primary_key.name.to_string(),
119            });
120        }
121
122        validate_index_fields(&fields, model.indexes)?;
123        for index in model.indexes {
124            IndexName::try_from_parts(&entity_name, index.fields).map_err(|err| {
125                ValidateError::InvalidIndexName {
126                    index: **index,
127                    source: err,
128                }
129            })?;
130        }
131
132        Ok(Self { fields })
133    }
134}
135
136/// Predicate/schema validation failures, including invalid model contracts.
137#[derive(Debug, thiserror::Error)]
138pub enum ValidateError {
139    #[error("invalid entity name '{name}': {source}")]
140    InvalidEntityName {
141        name: String,
142        #[source]
143        source: EntityNameError,
144    },
145
146    #[error("invalid index name for '{index}': {source}")]
147    InvalidIndexName {
148        index: IndexModel,
149        #[source]
150        source: IndexNameError,
151    },
152
153    #[error("unknown field '{field}'")]
154    UnknownField { field: String },
155
156    #[error("field '{field}' is not queryable")]
157    NonQueryableFieldType { field: String },
158
159    #[error("duplicate field '{field}'")]
160    DuplicateField { field: String },
161
162    #[error("{0}")]
163    UnsupportedQueryFeature(#[from] UnsupportedQueryFeature),
164
165    #[error("primary key '{field}' not present in entity fields")]
166    InvalidPrimaryKey { field: String },
167
168    #[error("primary key '{field}' has a non-keyable type")]
169    InvalidPrimaryKeyType { field: String },
170
171    #[error("index '{index}' references unknown field '{field}'")]
172    IndexFieldUnknown { index: IndexModel, field: String },
173
174    #[error("index '{index}' references non-queryable field '{field}'")]
175    IndexFieldNotQueryable { index: IndexModel, field: String },
176
177    #[error(
178        "index '{index}' references map field '{field}'; map fields are not queryable in icydb 0.7"
179    )]
180    IndexFieldMapNotQueryable { index: IndexModel, field: String },
181
182    #[error("index '{index}' repeats field '{field}'")]
183    IndexFieldDuplicate { index: IndexModel, field: String },
184
185    #[error("duplicate index name '{name}'")]
186    DuplicateIndexName { name: String },
187
188    #[error("operator {op} is not valid for field '{field}'")]
189    InvalidOperator { field: String, op: String },
190
191    #[error("coercion {coercion:?} is not valid for field '{field}'")]
192    InvalidCoercion { field: String, coercion: CoercionId },
193
194    #[error("invalid literal for field '{field}': {message}")]
195    InvalidLiteral { field: String, message: String },
196}
icydb_core/db/query/predicate/validate/schema.rs

icydb_core/db/query/predicate/validate/
schema.rs
