Skip to main content

uqa_engine/capabilities/
composites.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind composite type DDL to namespace, identity and publication state, and expose composite attributes to value conversion.
8
9use crate::Engine;
10use std::collections::BTreeMap;
11use std::sync::Arc;
12use uqa_execution::catalog::composite_type::{
13    CompositeRegistry, CompositeRegistryPublication, CompositeRegistryRead,
14};
15use uqa_execution::schema::composites::attributes::CompositeAttributeContext;
16use uqa_execution::schema::composites::values::{CompositeValueContext, CompositeValueTables};
17use uqa_execution::schema::composites::CompositeTypeContext;
18use uqa_sql::catalog::roles::RoleDefinition;
19use uqa_sql::expr::composites::{CompositeTypeCatalog, CompositeTypeDescriptor};
20use uqa_sql::SQLError;
21
22impl Engine {
23    pub(crate) fn composite_type_context(&self) -> CompositeTypeContext<'_> {
24        CompositeTypeContext {
25            creation: self.relation_creation_context(),
26            identities: self.catalog_identity_reservation_context(),
27            writer: self,
28            types: self,
29            allocate_identity: || {
30                crate::new_nonzero_catalog_identity("composite", "object identity")
31                    .map_err(|error| SQLError::Internal(error.to_string()))
32            },
33            publication: self,
34            enums: self,
35            domains: self,
36            changes: self,
37        }
38    }
39
40    pub(crate) fn composite_value_context(&self) -> CompositeValueContext<'_> {
41        CompositeValueContext {
42            memory: self.session.as_ref(),
43            cancellation: &self.runtime.cancellation,
44            tables: self,
45            reads: self,
46            writes: self,
47            views: self.view_dependency_context(),
48            types: self,
49            catalogs:
50                uqa_execution::schema::composites::catalog_values::CompositeCatalogValueContext {
51                    schema: self.schema_dependency_publication_context(),
52                    domains: self,
53                    events: self.event_catalog_context(),
54                    routines: self.routine_mutation_context(),
55                    indexes: uqa_execution::schema::indexes::routines::IndexRoutineContext {
56                        registry: self,
57                        catalog: self.storage.catalog.as_deref(),
58                    },
59                    index_publication: self,
60                    types: self,
61                    bindings: self,
62                    resolution: self,
63                },
64        }
65    }
66
67    pub(crate) fn composite_attribute_context(&self) -> CompositeAttributeContext<'_> {
68        CompositeAttributeContext {
69            publication: self,
70            values: self.composite_value_context(),
71            changes: self,
72        }
73    }
74
75    /// Composite definitions restore after enums and before domains and relations, whose declared types can refer to them.
76    pub(crate) fn restore_composites_from_catalog(
77        &self,
78        catalog: &dyn uqa_storage::CatalogFacade,
79    ) -> uqa_storage::StorageBackendResult<()> {
80        let registry =
81            uqa_execution::catalog::composite_type::restore(catalog, &self.durable.roles.read())?;
82        *self.durable.composites.write() = registry;
83        Ok(())
84    }
85
86    /// The composite registry generation of the running statement: the pinned query snapshot when one exists, otherwise the session's current definitions.
87    pub(crate) fn composite_registry_snapshot(&self) -> Arc<CompositeRegistry> {
88        self.query_catalog_snapshot.as_ref().map_or_else(
89            || self.durable.composites.snapshot(),
90            |snapshot| Arc::clone(&snapshot.composites),
91        )
92    }
93}
94
95impl CompositeTypeCatalog for Engine {
96    fn composite_type(
97        &self,
98        type_oid: u32,
99    ) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError> {
100        let descriptor = self
101            .runtime
102            .composite_descriptor_cache
103            .descriptor(&self.composite_registry_snapshot(), type_oid);
104        match descriptor {
105            Some(descriptor) => Ok(Some(descriptor)),
106            None => uqa_execution::catalog::composite_type::relations::descriptor(
107                &self.catalog_execution(),
108                type_oid,
109            ),
110        }
111    }
112}
113
114impl CompositeValueTables for Engine {
115    fn composite_value_tables(
116        &self,
117    ) -> Result<Vec<(String, Vec<uqa_sql::ast::ColumnDef>)>, SQLError> {
118        let catalog = self.catalog_read_view();
119        Ok(catalog
120            .snapshot()
121            .tables
122            .iter()
123            .map(|(identity, table)| (identity.qualified_name(), table.columns.as_ref().clone()))
124            .collect())
125    }
126}
127
128impl CompositeRegistryPublication for Engine {
129    fn composite_registry(&self) -> CompositeRegistryRead<'_> {
130        Box::new(self.durable.composites.read())
131    }
132    fn composite_catalog(&self) -> Option<&dyn uqa_storage::CatalogFacade> {
133        self.storage.catalog.as_deref()
134    }
135    fn composite_role_definitions(&self) -> BTreeMap<String, RoleDefinition> {
136        self.durable.roles.read().clone()
137    }
138    fn publish_composite_definitions(&self, registry: CompositeRegistry) {
139        *self.durable.composites.write() = registry;
140    }
141}