Skip to main content

uqa_sql/schema/production/composition/
qualifier.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use super::{
8    copy, optional_text, Layout, ProductionControl, ProductionVec, RowSchema, SQLError,
9    SchemaBuildMetadata, SchemaMemory, SchemaSet, ScoreSource,
10};
11
12impl RowSchema {
13    /// Replace positional wildcard visibility without changing addressable columns or physical slots.
14    pub fn with_wildcard_hidden_positions_with_control(
15        input: &Self,
16        positions: impl IntoIterator<Item = usize>,
17        control: &ProductionControl<'_>,
18    ) -> Result<Self, SQLError> {
19        let mut metadata = copy::metadata(input, control)?;
20        metadata.wildcard_hidden = SchemaSet::from_produced(
21            positions
22                .into_iter()
23                .map(|position| Ok(control.finish(position, control.empty_reservation())?)),
24            control,
25        )?;
26        copy::with_metadata(input, metadata, control)
27    }
28
29    /// Replace the public relation boundary while preserving physical identities and retained descriptors.
30    pub fn with_relation_qualifier_with_control(
31        input: &Self,
32        qualifier: &str,
33        control: &ProductionControl<'_>,
34    ) -> Result<Self, SQLError> {
35        control.check()?;
36        let mut layout = Layout::new(control);
37        layout.append(input, 0, Some(qualifier), control)?;
38        let mut scores = ProductionVec::new(*control);
39        for source in &input.index.cold.score_sources {
40            let (qualifier, memory) = optional_text(Some(qualifier), control)?.into_parts();
41            scores.push_produced(control.finish(
42                ScoreSource {
43                    qualifier,
44                    column: source.column,
45                },
46                memory,
47            )?)?;
48        }
49        let (score_sources, memory) = scores.finish()?.into_parts();
50        let source = copy::metadata(input, control)?;
51        let metadata = SchemaBuildMetadata {
52            collations: source.collations,
53            row_types: input
54                .index
55                .cold
56                .row_types
57                .requalified_with_control(input, qualifier, control)?,
58            record_fields: source.record_fields,
59            lateral_restrictions: Self::requalified_column_names_with_control(input, control)?,
60            internal: source.internal,
61            internal_types: source.internal_types,
62            score_sources,
63            open_qualifiers: SchemaSet::from_produced(
64                input
65                    .columns_are_open(None)
66                    .then_some(Some(qualifier))
67                    .into_iter()
68                    .map(|name| optional_text(name, control)),
69                control,
70            )?,
71            wildcard_hidden: source.wildcard_hidden,
72            memory: SchemaMemory::new(memory),
73            ..SchemaBuildMetadata::empty_with_control(control)
74        };
75        layout.finish(input.physical_width(), metadata, control)
76    }
77}
78
79impl RowSchema {
80    pub fn with_open_columns_with_control(
81        input: &Self,
82        qualifier: Option<&str>,
83        control: &ProductionControl<'_>,
84    ) -> Result<Self, SQLError> {
85        let mut metadata = copy::metadata(input, control)?;
86        metadata.open_qualifiers = SchemaSet::from_produced(
87            input
88                .index
89                .cold
90                .open_qualifiers
91                .iter()
92                .map(|name| name.as_deref())
93                .chain(std::iter::once(qualifier))
94                .map(|name| optional_text(name, control)),
95            control,
96        )?;
97        metadata.local_width = None;
98        metadata.lateral_restrictions = None;
99        copy::with_metadata(input, metadata, control)
100    }
101}