Skip to main content

uqa_sql/schema/production/
virtual_names.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Generated recursive names own static lookup metadata independently of visible row slots.
8
9use crate::{
10    schema::{ColumnIdentity, RowSchema, SchemaMap, SchemaSet},
11    ColumnType, SQLError,
12};
13use uqa_core::memory::{ProductionControl, ProductionMap};
14
15impl RowSchema {
16    pub(crate) fn with_conflicting_virtual_columns_with_control<'a>(
17        input: &'a Self,
18        fields: impl IntoIterator<Item = (&'a str, Option<&'a ColumnType>)>,
19        control: &ProductionControl<'_>,
20    ) -> Result<Self, SQLError> {
21        let mut generated = ProductionMap::new(*control);
22        for (name, ty) in fields {
23            if generated.get(&name).is_none() {
24                generated.insert_copy(name, ty)?;
25            }
26        }
27        let mut metadata = super::copy::metadata(input, control)?;
28        metadata.binding_only = SchemaMap::from_produced(
29            input
30                .typed_virtual_identities()
31                .map(|(identity, ty)| {
32                    Ok((
33                        identity.clone_with_control(control)?,
34                        super::optional_type(ty, control)?,
35                    ))
36                })
37                .chain(
38                    generated
39                        .iter()
40                        .filter(|(name, _)| {
41                            !input.index.cold.binding_only.keys().any(|identity| {
42                                identity.qualifier().is_none() && identity.column() == **name
43                            })
44                        })
45                        .map(|(name, ty)| {
46                            Ok((
47                                ColumnIdentity::from_parts_with_control(None, name, control)?,
48                                super::optional_type(*ty, control)?,
49                            ))
50                        }),
51                ),
52            control,
53        )?;
54        metadata.extra_ambiguous_unqualified = SchemaSet::from_produced(
55            input
56                .index
57                .ambiguous_unqualified
58                .iter()
59                .map(|name| super::lease::boxed_text(name, control))
60                .chain(
61                    generated
62                        .iter()
63                        .filter(|(name, _)| {
64                            input.index.unqualified.contains_key(**name)
65                                || input
66                                    .index
67                                    .aliases
68                                    .keys()
69                                    .chain(input.index.cold.binding_only.keys())
70                                    .any(|identity| {
71                                        identity.qualifier().is_none()
72                                            && identity.column() == **name
73                                    })
74                        })
75                        .map(|(name, _)| super::lease::boxed_text(name, control)),
76                ),
77            control,
78        )?;
79        super::copy::with_metadata(input, metadata, control)
80    }
81}
82
83impl RowSchema {
84    pub fn with_virtual_columns_with_control<'a>(
85        input: &'a Self,
86        columns: impl IntoIterator<Item = (Option<&'a str>, &'a str, Option<&'a ColumnType>)>,
87        control: &ProductionControl<'_>,
88    ) -> Result<Self, SQLError> {
89        let mut selected = ProductionMap::new(*control);
90        for (qualifier, column, ty) in columns {
91            let identity = ColumnIdentity::from_parts_with_control(qualifier, column, control)?;
92            let exists = if qualifier.is_some() {
93                input.has_qualified_identity(&identity)
94            } else {
95                input.index.ambiguous_unqualified.contains(column)
96                    || input.index.unqualified.contains_key(column)
97                    || input.index.aliases.contains_key(&*identity)
98                    || input.index.cold.binding_only.contains_key(&*identity)
99            };
100            if !exists && selected.get(&(qualifier, column)).is_none() {
101                selected.insert_copy((qualifier, column), ty)?;
102            }
103        }
104        if selected.is_empty() {
105            return Ok(input.clone());
106        }
107        let mut metadata = super::copy::metadata(input, control)?;
108        metadata.binding_only = SchemaMap::from_produced(
109            input
110                .typed_virtual_identities()
111                .map(|(identity, ty)| {
112                    Ok((
113                        identity.clone_with_control(control)?,
114                        super::optional_type(ty, control)?,
115                    ))
116                })
117                .chain(selected.iter().map(|((qualifier, column), ty)| {
118                    Ok((
119                        ColumnIdentity::from_parts_with_control(*qualifier, column, control)?,
120                        super::optional_type(*ty, control)?,
121                    ))
122                })),
123            control,
124        )?;
125        super::copy::with_metadata(input, metadata, control)
126    }
127
128    pub(crate) fn has_qualified_identity(&self, identity: &ColumnIdentity) -> bool {
129        self.index.qualified.contains_key(identity)
130            || self.index.aliases.contains_key(identity)
131            || self.index.cold.binding_only.contains_key(identity)
132    }
133
134    pub(crate) fn qualified_identity_type(&self, identity: &ColumnIdentity) -> Option<&ColumnType> {
135        if self.index.ambiguous_qualified.contains(identity) {
136            return None;
137        }
138        self.index
139            .qualified
140            .get(identity)
141            .and_then(|position| self.column_type(*position))
142            .or_else(|| {
143                self.index
144                    .cold
145                    .aliases
146                    .get(identity)
147                    .and_then(Option::as_ref)
148            })
149            .or_else(|| {
150                self.index
151                    .cold
152                    .binding_only
153                    .get(identity)
154                    .and_then(Option::as_ref)
155            })
156    }
157}