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.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    /// 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.
29    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    /// Whether a visible or hidden lookup identity belongs to `qualifier`.
72    #[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    /// Whether a visible, aliased, or static binding-only identity contains this exact unqualified column, independently of its declared type.
88    #[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    /// Whether a visible or hidden lookup identity contains this exact qualified column, independently of its static type or ambiguity.
97    #[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    /// Iterate over static name-binding identities that deliberately have no physical value slot or wildcard visibility.
106    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    /// Iterate over hidden lookup aliases that resolve to physical value slots while retaining their declared SQL types.
117    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    /// Resolve an unqualified logical identity to its static type.
133    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    /// Resolve a qualified logical identity to its static type.
158    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    /// Add hidden structured lookup identities for existing logical positions.
194    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    /// Add hidden SQL lookup identities that point at explicit physical slots.
206    /// Unlike [`Self::with_identity_aliases`], these slots do not need a
207    /// SQL-visible logical column owner.
208    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    /// Add executor-only relation attributes at explicit physical slots.
223    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    /// Capture named attributes under structural identities before a descendant namespace can shadow their SQL spelling. Typed virtual attributes retain their type and absence of a physical slot.
237    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    /// Whether a physical or typed virtual attribute has already been captured.
278    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    /// Restore structural identities from a row scope that occupies the trailing physical slots of this schema.
327    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    /// Mark source-owned logical metadata attributes as explicitly
385    /// addressable but absent from `*` expansion. The identity is positional,
386    /// so an ordinary user column with the same text remains visible.
387    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    /// Return the sole executor-only identity attached to a physical slot. Slots with no structural identity or with multiple aliases are intentionally unresolved.
427    #[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    /// 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.
448    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    /// Rebind every carried score source at a relation-alias boundary while retaining its opaque internal attribute identity.
489    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    /// 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.
559    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    /// 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.
591    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    /// 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.
613    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}