icydb_schema/node/
entity.rs

1use crate::{MAX_INDEX_FIELDS, prelude::*};
2use std::{any::Any, collections::HashSet};
3
4///
5/// Entity
6///
7
8#[derive(Clone, Debug, Serialize)]
9pub struct Entity {
10    pub def: Def,
11    pub store: &'static str,
12    pub primary_key: &'static str,
13
14    #[serde(default, skip_serializing_if = "Option::is_none")]
15    pub name: Option<&'static str>,
16
17    #[serde(default, skip_serializing_if = "<[_]>::is_empty")]
18    pub indexes: &'static [Index],
19
20    pub fields: FieldList,
21    pub ty: Type,
22}
23
24impl Entity {
25    #[must_use]
26    /// Return the primary key field if it exists on the entity.
27    pub fn get_pk_field(&self) -> Option<&Field> {
28        self.fields.get(self.primary_key)
29    }
30
31    #[must_use]
32    /// Resolve the entity name used for schema identity.
33    pub fn resolved_name(&self) -> &'static str {
34        self.name.unwrap_or(self.def.ident)
35    }
36}
37
38impl MacroNode for Entity {
39    fn as_any(&self) -> &dyn Any {
40        self
41    }
42}
43
44impl TypeNode for Entity {
45    fn ty(&self) -> &Type {
46        &self.ty
47    }
48}
49
50impl ValidateNode for Entity {
51    fn validate(&self) -> Result<(), ErrorTree> {
52        let mut errs = ErrorTree::new();
53        let schema = schema_read();
54
55        // primary key must exist and be single-valued
56        match self.fields.get(self.primary_key) {
57            Some(pk) => {
58                if !matches!(pk.value.cardinality, Cardinality::One) {
59                    err!(
60                        errs,
61                        "primary key '{0}' must have cardinality One",
62                        self.primary_key
63                    );
64                }
65            }
66            None => {
67                err!(errs, "missing primary key field '{0}'", self.primary_key);
68            }
69        }
70
71        // entity name length/encoding
72        if let Err(msg) = crate::validate::validate_entity_name(self.resolved_name()) {
73            err!(errs, "{msg}");
74        }
75
76        // store
77        match schema.cast_node::<DataStore>(self.store) {
78            Ok(_) => {}
79            Err(e) => errs.add(e),
80        }
81
82        // Load and validate index references
83        let mut resolved_indexes = Vec::new();
84
85        // check indexes have proper fields
86        for index in self.indexes {
87            // Indexing is hash-based over Value equality for all variants; collisions surface as corruption.
88            // index store
89            match schema.cast_node::<IndexStore>(index.store) {
90                Ok(_) => {}
91                Err(e) => errs.add(e),
92            }
93
94            // basic length checks
95            if index.fields.is_empty() {
96                err!(errs, "index must reference at least one field");
97            }
98            if index.fields.len() > MAX_INDEX_FIELDS {
99                err!(
100                    errs,
101                    "index has {} fields; maximum is {}",
102                    index.fields.len(),
103                    MAX_INDEX_FIELDS
104                );
105            }
106
107            // no duplicate fields in a single index definition
108            let mut seen = HashSet::new();
109            // Check all fields in the index exist on the entity
110            for field in index.fields {
111                if !seen.insert(*field) {
112                    err!(errs, "index contains duplicate field '{field}'");
113                }
114                if let Some(field) = self.fields.get(field) {
115                    if field.value.cardinality == Cardinality::Many {
116                        err!(errs, "cannot add an index field with many cardinality");
117                    }
118                } else {
119                    err!(errs, "index field '{field}' not found");
120                }
121            }
122
123            if let Err(msg) =
124                crate::validate::validate_index_name_len(self.resolved_name(), index.fields)
125            {
126                err!(errs, "{msg}");
127            }
128            resolved_indexes.push(index);
129        }
130
131        // Check for redundant indexes (prefix relationships)
132        for (i, a) in resolved_indexes.iter().enumerate() {
133            for b in resolved_indexes.iter().skip(i + 1) {
134                if a.unique == b.unique {
135                    if a.is_prefix_of(b) {
136                        err!(
137                            errs,
138                            "index {:?} is redundant (prefix of {:?})",
139                            a.fields,
140                            b.fields
141                        );
142                    } else if b.is_prefix_of(a) {
143                        err!(
144                            errs,
145                            "index {:?} is redundant (prefix of {:?})",
146                            b.fields,
147                            a.fields
148                        );
149                    }
150                }
151            }
152        }
153
154        errs.result()
155    }
156}
157
158impl VisitableNode for Entity {
159    fn route_key(&self) -> String {
160        self.def.path()
161    }
162
163    fn drive<V: Visitor>(&self, v: &mut V) {
164        self.def.accept(v);
165        self.fields.accept(v);
166        self.ty.accept(v);
167    }
168}
icydb_schema/node/entity.rs

icydb_schema/node/
entity.rs
