Skip to main content

uqa_sql/schema/
name_binding.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Static SQL name and type binding over a physical row schema.
8
9use crate::ast::{ColumnType, InternalColumnRef};
10
11use super::{ColumnIdentity, RowSchema, SchemaBuildMetadata, ScoreSource, NULL_SLOT};
12
13impl RowSchema {
14    /// Whether this schema exposes any SQL name or whole-row namespace, including hidden aliases and names without physical slots.
15    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    /// Bind every SQL-visible column to one relation qualifier while preserving executor-only internal attributes and rebinding carried retrieval scores to the same relation boundary.
27    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    /// Whether a visible or hidden lookup identity belongs to `qualifier`.
69    #[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    /// Whether a visible, aliased, or static binding-only identity contains this exact unqualified column, independently of its declared type.
82    #[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    /// Whether a visible or hidden lookup identity contains this exact qualified column, independently of its static type or ambiguity.
91    #[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    /// Iterate over static name-binding identities that deliberately have no physical value slot or wildcard visibility.
100    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    /// Iterate over hidden lookup aliases that resolve to physical value slots while retaining their declared SQL types.
111    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    /// Resolve an unqualified logical identity to its static type.
127    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    /// Resolve a qualified logical identity to its static type.
152    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    /// Add hidden structured lookup identities for existing logical positions.
188    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    /// Add hidden SQL lookup identities that point at explicit physical slots.
227    /// Unlike [`Self::with_identity_aliases`], these slots do not need a
228    /// SQL-visible logical column owner.
229    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    /// Add executor-only relation attributes at explicit physical slots.
273    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    /// Restore structural identities from a row scope that occupies the trailing physical slots of this schema.
319    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    /// Mark source-owned logical metadata attributes as explicitly
375    /// addressable but absent from `*` expansion. The identity is positional,
376    /// so an ordinary user column with the same text remains visible.
377    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    /// Return the sole executor-only identity attached to a physical slot. Slots with no structural identity or with multiple aliases are intentionally unresolved.
415    #[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    /// Mark an existing internal attribute as the score carried by one retrieval relation. This semantic tag is schema metadata and never enters SQL name lookup or wildcard expansion.
436    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    /// Rebind every carried score source at a relation-alias boundary while retaining its opaque internal attribute identity.
475    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    /// Add statically typed hidden lookup identities that have no physical value slot. Visible columns and star expansion remain unchanged, while binders can resolve the identities and their declared SQL types.
543    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    /// Whether a column reference resolves to one of the schema's own columns rather than to an enclosing query's column overlaid by [`Self::with_outer_schema`], as `contain_vars_of_level(n, 0)` distinguishes them.
575    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    /// Add binding-only identities and preserve collisions as ambiguous names. This models SQL scopes that expose a hidden generated column for explicit lookup while deliberately excluding it from wildcard expansion.
597    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}