1use crate::ast::{ColumnType, InternalColumnRef};
10
11use super::{ColumnIdentity, RowSchema, SchemaBuildMetadata, ScoreSource, NULL_SLOT};
12
13impl RowSchema {
14 pub(crate) fn has_sql_bindings(&self) -> bool {
16 !self.index.columns.is_empty()
17 || self.index.cold.lateral_restrictions.is_some()
18 || !self.index.aliases.is_empty()
19 || !self.index.ambiguous_unqualified.is_empty()
20 || !self.index.ambiguous_qualified.is_empty()
21 || !self.index.cold.binding_only.is_empty()
22 || !self.index.cold.open_qualifiers.is_empty()
23 || self.index.cold.row_types.qualifiers().next().is_some()
24 || !self.index.cold.score_sources.is_empty()
25 || self.whole_row_presences().next().is_some()
26 }
27
28 pub fn with_relation_qualifier(input: &Self, qualifier: &str) -> Self {
30 let identities = input
31 .columns()
32 .iter()
33 .cloned()
34 .map(|column| ColumnIdentity::qualified(qualifier, column))
35 .collect();
36 let score_sources = input
37 .index
38 .cold
39 .score_sources
40 .iter()
41 .map(|source| ScoreSource {
42 qualifier: Some(Box::<str>::from(qualifier)),
43 column: source.column,
44 })
45 .collect();
46 Self::from_typed_parts_with_aliases_and_exact_precedence(
47 input.columns().to_vec(),
48 identities,
49 input.column_types().to_vec(),
50 input.index.slots.to_vec(),
51 input.physical_width(),
52 SchemaBuildMetadata {
53 collations: input.index.cold.collations.clone(),
54 row_types: input.index.cold.row_types.requalified(input, qualifier),
55 record_fields: input.index.cold.record_fields.clone(),
56 lateral_restrictions: Self::requalified_column_names(input),
57 internal: input.index.executor_attributes.clone(),
58 internal_types: input.index.cold.executor_attribute_types.clone(),
59 score_sources,
60 open_qualifiers: input
61 .columns_are_open(None)
62 .then(|| Some(Box::<str>::from(qualifier)))
63 .into_iter()
64 .collect(),
65 wildcard_hidden: input.index.cold.wildcard_hidden.clone(),
66 ..SchemaBuildMetadata::default()
67 },
68 )
69 }
70
71 #[must_use]
73 pub fn has_qualifier(&self, qualifier: &str) -> bool {
74 self.lateral_qualifier_is_ambiguous(qualifier)
75 || self
76 .index
77 .identities
78 .iter()
79 .chain(self.index.aliases.keys())
80 .chain(self.index.cold.binding_only.keys())
81 .any(|identity| identity.qualifier() == Some(qualifier))
82 || self.columns_are_open(Some(qualifier))
83 || self.index.cold.row_types.contains(qualifier)
84 || self.whole_row_presence(qualifier).is_some()
85 }
86
87 #[must_use]
89 pub fn has_unqualified_column(&self, column: &str) -> bool {
90 let identity = ColumnIdentity::unqualified(column);
91 self.index.unqualified.contains_key(column)
92 || self.index.aliases.contains_key(&identity)
93 || self.index.cold.binding_only.contains_key(&identity)
94 }
95
96 #[must_use]
98 pub fn has_qualified_column(&self, qualifier: &str, column: &str) -> bool {
99 let identity = ColumnIdentity::qualified(qualifier, column);
100 self.index.qualified.contains_key(&identity)
101 || self.index.aliases.contains_key(&identity)
102 || self.index.cold.binding_only.contains_key(&identity)
103 }
104
105 pub fn typed_virtual_identities(
107 &self,
108 ) -> impl Iterator<Item = (&ColumnIdentity, Option<&ColumnType>)> {
109 self.index
110 .cold
111 .binding_only
112 .iter()
113 .map(|(identity, ty)| (identity, ty.as_ref()))
114 }
115
116 pub fn typed_physical_alias_identities(
118 &self,
119 ) -> impl Iterator<Item = (&ColumnIdentity, Option<&ColumnType>)> {
120 self.index.aliases.keys().map(|identity| {
121 (
122 identity,
123 self.index
124 .cold
125 .aliases
126 .get(identity)
127 .and_then(Option::as_ref),
128 )
129 })
130 }
131
132 pub fn type_of(&self, name: &str) -> Option<&ColumnType> {
134 if self.index.ambiguous_unqualified.contains(name) {
135 return None;
136 }
137 self.index
138 .unqualified
139 .get(name)
140 .and_then(|logical| self.column_type(*logical))
141 .or_else(|| {
142 self.index
143 .cold
144 .aliases
145 .get(&ColumnIdentity::unqualified(name))
146 .and_then(Option::as_ref)
147 })
148 .or_else(|| {
149 self.index
150 .cold
151 .binding_only
152 .get(&ColumnIdentity::unqualified(name))
153 .and_then(Option::as_ref)
154 })
155 }
156
157 pub fn qualified_type(&self, qualifier: &str, column: &str) -> Option<&ColumnType> {
159 let identity = ColumnIdentity::qualified(qualifier, column);
160 if self.index.ambiguous_qualified.contains(&identity) {
161 return None;
162 }
163 self.index
164 .qualified
165 .get(&identity)
166 .and_then(|logical| self.column_type(*logical))
167 .or_else(|| {
168 self.index
169 .cold
170 .aliases
171 .get(&identity)
172 .and_then(Option::as_ref)
173 })
174 .or_else(|| {
175 self.index
176 .cold
177 .binding_only
178 .get(&identity)
179 .and_then(Option::as_ref)
180 })
181 }
182
183 pub fn column_is_ambiguous(&self, name: &str) -> bool {
184 self.index.ambiguous_unqualified.contains(name)
185 }
186
187 pub fn qualified_column_is_ambiguous(&self, qualifier: &str, column: &str) -> bool {
188 self.index
189 .ambiguous_qualified
190 .contains(&ColumnIdentity::qualified(qualifier, column))
191 }
192
193 pub fn with_identity_aliases(input: &Self, aliases: &[(ColumnIdentity, usize)]) -> Self {
195 Self::with_identity_aliases_with_control(
196 input,
197 aliases
198 .iter()
199 .map(|(identity, logical)| (identity.qualifier(), identity.column(), *logical)),
200 &uqa_core::memory::ProductionControl::uncontrolled(),
201 )
202 .expect("ordinary identity aliases")
203 }
204
205 pub fn with_physical_identity_aliases(
209 input: &Self,
210 aliases: &[(ColumnIdentity, usize, Option<ColumnType>)],
211 ) -> Self {
212 Self::with_physical_identity_aliases_with_control(
213 input,
214 aliases.iter().map(|(identity, slot, ty)| {
215 (identity.qualifier(), identity.column(), *slot, ty.as_ref())
216 }),
217 &uqa_core::memory::ProductionControl::uncontrolled(),
218 )
219 .expect("ordinary physical identity aliases")
220 }
221
222 pub fn with_physical_internal_aliases(
224 input: &Self,
225 aliases: &[(InternalColumnRef, usize, Option<ColumnType>)],
226 ) -> Self {
227 for (_, slot, _) in aliases {
228 assert!(
229 *slot < input.physical_width(),
230 "physical internal alias is outside row width"
231 );
232 }
233 Self::with_internal_alias_slots(input, aliases)
234 }
235
236 pub fn with_named_internal_aliases(
238 input: &Self,
239 aliases: &[(InternalColumnRef, ColumnIdentity)],
240 ) -> Self {
241 let slots: Vec<_> = aliases
242 .iter()
243 .filter_map(|(column, identity)| {
244 if input.has_internal_column(*column) {
245 return None;
246 }
247 let qualifier = identity.qualifier()?;
248 if !input.has_qualified_column(qualifier, identity.column()) {
249 return None;
250 }
251 Some((
252 *column,
253 input
254 .qualified_slot(qualifier, identity.column())
255 .unwrap_or(NULL_SLOT),
256 input.qualified_type(qualifier, identity.column()).cloned(),
257 ))
258 })
259 .collect();
260 let mut result = Self::with_internal_alias_slots(input, &slots);
261 for (column, identity) in aliases {
262 if input.has_internal_column(*column) {
263 continue;
264 }
265 if let Some(qualifier) = identity.qualifier() {
266 let collation = input.qualified_collation(qualifier, identity.column());
267 let ty = input.qualified_type(qualifier, identity.column());
268 std::sync::Arc::make_mut(&mut result.index)
269 .cold
270 .collations
271 .internal(*column, collation, ty);
272 }
273 }
274 result
275 }
276
277 pub fn has_internal_column(&self, column: InternalColumnRef) -> bool {
279 self.index.executor_attributes.contains_key(&column)
280 }
281
282 fn with_internal_alias_slots(
283 input: &Self,
284 aliases: &[(InternalColumnRef, usize, Option<ColumnType>)],
285 ) -> Self {
286 let mut collations = input.index.cold.collations.clone();
287 let mut internal = input.index.executor_attributes.clone();
288 let mut internal_types = input.index.cold.executor_attribute_types.clone();
289 for (column, slot, ty) in aliases {
290 collations.internal(
291 *column,
292 input.inherited_physical_collation(*slot),
293 ty.as_ref(),
294 );
295 internal.insert(*column, *slot);
296 internal_types.insert(*column, ty.clone());
297 }
298 Self::from_typed_parts_with_aliases_and_exact_precedence(
299 input.columns().to_vec(),
300 input.identities().to_vec(),
301 input.column_types().to_vec(),
302 input.index.slots.to_vec(),
303 input.physical_width(),
304 SchemaBuildMetadata {
305 collations,
306 record_fields: input.index.cold.record_fields.clone(),
307 aliases: input.index.aliases.clone(),
308 alias_types: input.index.cold.aliases.clone(),
309 internal,
310 internal_types,
311 score_sources: input.index.cold.score_sources.clone(),
312 wildcard_hidden: input.index.cold.wildcard_hidden.clone(),
313 binding_only: input.index.cold.binding_only.clone(),
314 lateral_restrictions: input.index.cold.lateral_restrictions.clone(),
315 local_width: input.index.cold.local_width,
316 row_types: input.index.cold.row_types.clone(),
317 row_presence: input.index.cold.row_presence.clone(),
318 open_qualifiers: input.index.cold.open_qualifiers.clone(),
319 extra_ambiguous_unqualified: input.index.ambiguous_unqualified.clone(),
320 extra_ambiguous_qualified: input.index.ambiguous_qualified.clone(),
321 ..SchemaBuildMetadata::default()
322 },
323 )
324 }
325
326 pub fn with_trailing_internal_aliases(input: &Self, trailing: &Self) -> Self {
328 let mut collations = input.index.cold.collations.clone();
329 let offset = input
330 .physical_width()
331 .checked_sub(trailing.physical_width())
332 .expect("trailing internal-alias scope exceeds input row width");
333 let mut internal = input.index.executor_attributes.clone();
334 let mut internal_types = input.index.cold.executor_attribute_types.clone();
335 for (column, slot) in &trailing.index.executor_attributes {
336 let slot = if *slot == NULL_SLOT {
337 NULL_SLOT
338 } else {
339 offset + *slot
340 };
341 if let Some(previous) = internal.insert(*column, slot) {
342 assert_eq!(
343 previous, slot,
344 "structural identity moved between row scopes"
345 );
346 }
347 }
348 for (column, ty) in &trailing.index.cold.executor_attribute_types {
349 collations.internal(*column, trailing.internal_collation(*column), ty.as_ref());
350 if let Some(previous) = internal_types.insert(*column, ty.clone()) {
351 assert_eq!(
352 previous, *ty,
353 "structural identity type changed between row scopes"
354 );
355 }
356 }
357 Self::from_typed_parts_with_aliases_and_exact_precedence(
358 input.columns().to_vec(),
359 input.identities().to_vec(),
360 input.column_types().to_vec(),
361 input.index.slots.to_vec(),
362 input.physical_width(),
363 SchemaBuildMetadata {
364 collations,
365 record_fields: input.index.cold.record_fields.clone(),
366 aliases: input.index.aliases.clone(),
367 alias_types: input.index.cold.aliases.clone(),
368 internal,
369 internal_types,
370 score_sources: input.index.cold.score_sources.clone(),
371 wildcard_hidden: input.index.cold.wildcard_hidden.clone(),
372 binding_only: input.index.cold.binding_only.clone(),
373 lateral_restrictions: input.index.cold.lateral_restrictions.clone(),
374 row_types: input.index.cold.row_types.clone(),
375 row_presence: input.index.cold.row_presence.clone(),
376 open_qualifiers: input.index.cold.open_qualifiers.clone(),
377 extra_ambiguous_unqualified: input.index.ambiguous_unqualified.clone(),
378 extra_ambiguous_qualified: input.index.ambiguous_qualified.clone(),
379 ..SchemaBuildMetadata::default()
380 },
381 )
382 }
383
384 pub fn with_wildcard_hidden_positions(
388 input: &Self,
389 positions: impl IntoIterator<Item = usize>,
390 ) -> Self {
391 let wildcard_hidden = positions.into_iter().collect();
392 Self::from_typed_parts_with_aliases_and_exact_precedence(
393 input.columns().to_vec(),
394 input.identities().to_vec(),
395 input.column_types().to_vec(),
396 input.index.slots.to_vec(),
397 input.physical_width(),
398 SchemaBuildMetadata {
399 collations: input.index.cold.collations.clone(),
400 record_fields: input.index.cold.record_fields.clone(),
401 aliases: input.index.aliases.clone(),
402 alias_types: input.index.cold.aliases.clone(),
403 internal: input.index.executor_attributes.clone(),
404 internal_types: input.index.cold.executor_attribute_types.clone(),
405 score_sources: input.index.cold.score_sources.clone(),
406 wildcard_hidden,
407 binding_only: input.index.cold.binding_only.clone(),
408 lateral_restrictions: input.index.cold.lateral_restrictions.clone(),
409 row_types: input.index.cold.row_types.clone(),
410 row_presence: input.index.cold.row_presence.clone(),
411 open_qualifiers: input.index.cold.open_qualifiers.clone(),
412 ..SchemaBuildMetadata::default()
413 },
414 )
415 }
416
417 #[must_use]
418 pub fn internal_slot(&self, column: InternalColumnRef) -> Option<usize> {
419 self.index
420 .executor_attributes
421 .get(&column)
422 .copied()
423 .filter(|slot| *slot != NULL_SLOT)
424 }
425
426 #[must_use]
428 pub fn unique_internal_column_for_slot(&self, slot: usize) -> Option<InternalColumnRef> {
429 let mut columns = self
430 .index
431 .executor_attributes
432 .iter()
433 .filter_map(|(column, candidate)| (*candidate == slot).then_some(*column));
434 let column = columns.next()?;
435 columns.next().is_none().then_some(column)
436 }
437
438 #[must_use]
439 pub fn internal_type(&self, column: InternalColumnRef) -> Option<&ColumnType> {
440 self.index
441 .cold
442 .executor_attribute_types
443 .get(&column)
444 .and_then(Option::as_ref)
445 }
446
447 pub fn with_score_source(
449 input: &Self,
450 qualifier: Option<&str>,
451 column: InternalColumnRef,
452 ) -> Self {
453 assert!(
454 input.index.executor_attributes.contains_key(&column),
455 "score source must reference an existing internal attribute"
456 );
457 let mut score_sources = input.index.cold.score_sources.clone();
458 score_sources.retain(|source| source.column != column);
459 score_sources.push(ScoreSource {
460 qualifier: qualifier.map(Box::<str>::from),
461 column,
462 });
463 Self::from_typed_parts_with_aliases_and_exact_precedence(
464 input.columns().to_vec(),
465 input.identities().to_vec(),
466 input.column_types().to_vec(),
467 input.index.slots.to_vec(),
468 input.physical_width(),
469 SchemaBuildMetadata {
470 collations: input.index.cold.collations.clone(),
471 record_fields: input.index.cold.record_fields.clone(),
472 aliases: input.index.aliases.clone(),
473 alias_types: input.index.cold.aliases.clone(),
474 internal: input.index.executor_attributes.clone(),
475 internal_types: input.index.cold.executor_attribute_types.clone(),
476 score_sources,
477 wildcard_hidden: input.index.cold.wildcard_hidden.clone(),
478 binding_only: input.index.cold.binding_only.clone(),
479 lateral_restrictions: input.index.cold.lateral_restrictions.clone(),
480 row_types: input.index.cold.row_types.clone(),
481 row_presence: input.index.cold.row_presence.clone(),
482 open_qualifiers: input.index.cold.open_qualifiers.clone(),
483 ..SchemaBuildMetadata::default()
484 },
485 )
486 }
487
488 pub fn with_rebound_score_sources(input: &Self, qualifier: Option<&str>) -> Self {
490 let score_sources = input
491 .index
492 .cold
493 .score_sources
494 .iter()
495 .map(|source| ScoreSource {
496 qualifier: qualifier.map(Box::<str>::from),
497 column: source.column,
498 })
499 .collect();
500 Self::from_typed_parts_with_aliases_and_exact_precedence(
501 input.columns().to_vec(),
502 input.identities().to_vec(),
503 input.column_types().to_vec(),
504 input.index.slots.to_vec(),
505 input.physical_width(),
506 SchemaBuildMetadata {
507 collations: input.index.cold.collations.clone(),
508 record_fields: input.index.cold.record_fields.clone(),
509 aliases: input.index.aliases.clone(),
510 alias_types: input.index.cold.aliases.clone(),
511 internal: input.index.executor_attributes.clone(),
512 internal_types: input.index.cold.executor_attribute_types.clone(),
513 score_sources,
514 wildcard_hidden: input.index.cold.wildcard_hidden.clone(),
515 binding_only: input.index.cold.binding_only.clone(),
516 lateral_restrictions: input.index.cold.lateral_restrictions.clone(),
517 row_types: input.index.cold.row_types.clone(),
518 row_presence: input.index.cold.row_presence.clone(),
519 open_qualifiers: input.index.cold.open_qualifiers.clone(),
520 ..SchemaBuildMetadata::default()
521 },
522 )
523 }
524
525 fn matching_score_sources<'a>(
526 &'a self,
527 qualifier: Option<&'a str>,
528 ) -> impl Iterator<Item = InternalColumnRef> + 'a {
529 self.index
530 .cold
531 .score_sources
532 .iter()
533 .filter(move |source| {
534 qualifier.is_none_or(|qualifier| source.qualifier.as_deref() == Some(qualifier))
535 })
536 .map(move |source| source.column)
537 }
538
539 #[must_use]
540 pub fn score_source_column(&self, qualifier: Option<&str>) -> Option<InternalColumnRef> {
541 let mut columns = self.matching_score_sources(qualifier);
542 let column = columns.next()?;
543 columns.next().is_none().then_some(column)
544 }
545
546 #[must_use]
547 pub fn score_source_is_ambiguous(&self, qualifier: Option<&str>) -> bool {
548 let mut columns = self.matching_score_sources(qualifier);
549 columns.next().is_some() && columns.next().is_some()
550 }
551
552 #[must_use]
553 pub fn score_source_slot(&self, qualifier: Option<&str>) -> Option<usize> {
554 self.score_source_column(qualifier)
555 .and_then(|column| self.internal_slot(column))
556 }
557
558 pub fn with_typed_virtual_identities(
560 input: &Self,
561 identities: &[(ColumnIdentity, Option<ColumnType>)],
562 ) -> Self {
563 Self::with_owned_virtual_identities(input.clone(), identities)
564 }
565
566 pub(super) fn with_owned_virtual_identities(
567 mut input: Self,
568 identities: &[(ColumnIdentity, Option<ColumnType>)],
569 ) -> Self {
570 for (identity, ty) in identities {
571 let already_visible = match identity.qualifier() {
572 Some(qualifier) => input.has_qualified_column(qualifier, identity.column()),
573 None => {
574 input.column_is_ambiguous(identity.column())
575 || input.has_unqualified_column(identity.column())
576 }
577 };
578 if already_visible {
579 continue;
580 }
581 std::sync::Arc::make_mut(&mut input.index)
582 .cold
583 .binding_only
584 .entry(identity.clone())
585 .or_insert_with(|| ty.clone());
586 }
587 input
588 }
589
590 pub fn resolves_local_column(&self, qualifier: Option<&str>, column: &str) -> bool {
592 let slot = match qualifier {
593 Some(qualifier) => self.qualified_slot(qualifier, column),
594 None => self.column_slot(column),
595 };
596 slot.is_some_and(|slot| self.slot_is_local(slot))
597 }
598
599 pub(crate) fn slot_is_local(&self, slot: usize) -> bool {
600 self.index.cold.local_width.is_none_or(|width| slot < width)
601 }
602
603 pub(crate) fn internal_identities(
604 &self,
605 ) -> impl Iterator<Item = (InternalColumnRef, usize)> + '_ {
606 self.index
607 .executor_attributes
608 .iter()
609 .filter_map(|(column, slot)| (*slot != super::NULL_SLOT).then_some((*column, *slot)))
610 }
611
612 pub fn with_typed_conflicting_virtual_identities(
614 input: &Self,
615 identities: &[(ColumnIdentity, Option<ColumnType>)],
616 ) -> Self {
617 let mut binding_only = input.index.cold.binding_only.clone();
618 let mut ambiguous_unqualified = input.index.ambiguous_unqualified.clone();
619 let mut ambiguous_qualified = input.index.ambiguous_qualified.clone();
620 for (identity, ty) in identities {
621 if input.column_is_ambiguous(identity.column())
622 || input.has_unqualified_column(identity.column())
623 {
624 ambiguous_unqualified.insert(Box::<str>::from(identity.column()));
625 }
626 if let Some(qualifier) = identity.qualifier() {
627 if input.has_qualified_column(qualifier, identity.column()) {
628 ambiguous_qualified.insert(identity.clone());
629 }
630 }
631 binding_only
632 .entry(identity.clone())
633 .or_insert_with(|| ty.clone());
634 }
635 Self::from_typed_parts_with_aliases_and_exact_precedence(
636 input.columns().to_vec(),
637 input.identities().to_vec(),
638 input.column_types().to_vec(),
639 input.index.slots.to_vec(),
640 input.physical_width(),
641 SchemaBuildMetadata {
642 collations: input.index.cold.collations.clone(),
643 record_fields: input.index.cold.record_fields.clone(),
644 aliases: input.index.aliases.clone(),
645 alias_types: input.index.cold.aliases.clone(),
646 internal: input.index.executor_attributes.clone(),
647 internal_types: input.index.cold.executor_attribute_types.clone(),
648 score_sources: input.index.cold.score_sources.clone(),
649 wildcard_hidden: input.index.cold.wildcard_hidden.clone(),
650 binding_only,
651 row_types: input.index.cold.row_types.clone(),
652 row_presence: input.index.cold.row_presence.clone(),
653 open_qualifiers: input.index.cold.open_qualifiers.clone(),
654 extra_ambiguous_unqualified: ambiguous_unqualified,
655 extra_ambiguous_qualified: ambiguous_qualified,
656 ..SchemaBuildMetadata::default()
657 },
658 )
659 }
660}