uqa-engine 0.2.3

Engine: schema-aware table store, catalog restore, transactions
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

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Constraint-owned index identities in catalog snapshots.

use super::{CatalogReadView, SQLError};

impl CatalogReadView {
    pub(crate) fn has_constraint_index(&self, relation: &crate::RelationIdentity) -> bool {
        self.snapshot.tables.iter().any(|(table, snapshot)| {
            table.schema == relation.schema
                && snapshot
                    .keys
                    .iter()
                    .any(|key| key.name.as_ref() == Some(&relation.name))
        })
    }

    pub(crate) fn constraint_index(
        &self,
        relation: &crate::RelationIdentity,
    ) -> Result<Option<uqa_storage::CatalogIndexRow>, SQLError> {
        for (table, snapshot) in &self.snapshot.tables {
            if table.schema != relation.schema {
                continue;
            }
            let Some(key) = snapshot
                .keys
                .iter()
                .find(|key| key.name.as_ref() == Some(&relation.name))
            else {
                continue;
            };
            let definition = crate::engine_catalog_indexes::IndexDefinition {
                unique: true,
                nulls_not_distinct: key.nulls_not_distinct,
                ..Default::default()
            };
            return Ok(Some(uqa_storage::CatalogIndexRow {
                relation: relation.clone(),
                table_name: table.qualified_name(),
                index_type: if key.without_overlaps {
                    "gist"
                } else {
                    "btree"
                }
                .into(),
                columns_json: serde_json::to_string(&key.columns)
                    .map_err(|error| SQLError::Internal(error.to_string()))?,
                parameters_json: "{}".into(),
                definition_json: Some(
                    serde_json::to_string(&definition)
                        .map_err(|error| SQLError::Internal(error.to_string()))?,
                ),
            }));
        }
        Ok(None)
    }
}