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