uqa_sql/plan/scalar/owned/
references.rs1use super::{OwnedScalarExpr, Result, ScalarExpr, ScalarMemory};
10use uqa_core::memory::{Produced, ProductionControl};
11
12impl OwnedScalarExpr {
13 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 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 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 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}