uqa_sql/schema/production/
virtual_names.rs1use 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}