Skip to main content

uqa_sql/plan/scalar/owned/
references.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Generated column references retain their supplied name owners.
8
9use super::{OwnedScalarExpr, Result, ScalarExpr, ScalarMemory};
10use uqa_core::memory::{Produced, ProductionControl};
11
12impl OwnedScalarExpr {
13    /// Construct a generated column reference without copying its admitted name or qualification.
14    pub fn column(
15        column: Produced<String>,
16        qualifier: Option<Produced<String>>,
17        control: &ProductionControl<'_>,
18    ) -> Result<Self> {
19        Self::positioned_column(column, qualifier, None, control)
20    }
21
22    /// Preserve the source location when a rewrite changes a column's namespace or physical name.
23    pub fn positioned_column(
24        column: Produced<String>,
25        qualifier: Option<Produced<String>>,
26        position: Option<u32>,
27        control: &ProductionControl<'_>,
28    ) -> Result<Self> {
29        let (column, memory) = column.into_parts();
30        let column = control.finish(column, memory)?;
31        let qualifier = qualifier
32            .map(|qualifier| {
33                let (qualifier, memory) = qualifier.into_parts();
34                control.finish(qualifier, memory)
35            })
36            .transpose()?;
37        let (column, column_memory) = column.into_parts();
38        let (expression, memory) = match qualifier {
39            Some(qualifier) => {
40                let (qualifier, qualifier_memory) = qualifier.into_parts();
41                (
42                    ScalarExpr::QualifiedColumn {
43                        qualifier,
44                        column: crate::ast::ReferenceName::from(column).with_position(position),
45                    },
46                    control.combine(column_memory, qualifier_memory),
47                )
48            }
49            None => (
50                ScalarExpr::Column(crate::ast::ReferenceName::from(column).with_position(position)),
51                column_memory,
52            ),
53        };
54        let output = Self {
55            expression,
56            memory: memory.map(|direct| ScalarMemory {
57                children: Vec::new(),
58                direct,
59            }),
60        };
61        output.rewrite(control, Ok)
62    }
63
64    /// Replace only a reference's qualifier. Existing capacity is reused; growth admits a replacement buffer while the original is still live.
65    pub fn replace_qualifier(
66        mut self,
67        qualifier: &str,
68        control: &ProductionControl<'_>,
69    ) -> Result<Self> {
70        self.assert_owner(control);
71        control.check()?;
72        let current = self.expression.reference_qualifier_mut().ok_or_else(|| {
73            crate::SQLError::Internal("qualifier replacement requires a qualified reference".into())
74        })?;
75        if qualifier.len() <= current.capacity() {
76            current.clear();
77            current.push_str(qualifier);
78        } else {
79            let (value, lease) = control.copy_text(qualifier)?.into_parts();
80            let capacity = current.capacity();
81            *current = value;
82            if let Some(memory) = &mut self.memory {
83                drop(memory.direct.split(capacity));
84                memory.direct.absorb(lease.expect("controlled qualifier"));
85            }
86        }
87        control.check()?;
88        Ok(self)
89    }
90}
91
92impl OwnedScalarExpr {
93    /// Remove only a column reference's qualifier, preserving its name buffer and parser position.
94    pub fn remove_reference_qualifier(mut self, control: &ProductionControl<'_>) -> Result<Self> {
95        self.assert_owner(control);
96        control.check()?;
97        let ScalarExpr::QualifiedColumn { qualifier, column } = std::mem::replace(
98            &mut self.expression,
99            ScalarExpr::Literal(uqa_core::Value::Null),
100        ) else {
101            panic!("qualifier removal requires a qualified column")
102        };
103        let bytes = qualifier.capacity();
104        drop(qualifier);
105        self.expression = ScalarExpr::Column(column);
106        if let Some(memory) = &mut self.memory {
107            drop(memory.direct.split(bytes));
108        }
109        Ok(self)
110    }
111}