1use super::{DOC_ID_COLUMN, TABLE_OID_COLUMN};
10use crate::ast::ReturningAliases;
11use crate::plan::ProjectionPlan;
12use crate::{ColumnIdentity, RowSchema, SQLError, ScalarExpr};
13
14pub fn projection_columns(projections: &[ProjectionPlan]) -> Vec<String> {
15 projections.iter().map(projection_label_at).collect()
16}
17
18pub fn query_output_position(position: i64, width: usize, clause: &str) -> Result<usize, SQLError> {
20 usize::try_from(position)
21 .ok()
22 .and_then(|position| position.checked_sub(1))
23 .filter(|position| *position < width)
24 .ok_or_else(|| output_position_error(clause, position))
25}
26
27pub fn output_position_error(clause: &str, position: i64) -> SQLError {
28 SQLError::Routine {
29 sqlstate: "42P10".into(),
30 message: format!("{clause} position {position} is not in select list"),
31 }
32}
33
34pub fn projection_label_at(proj: &ProjectionPlan) -> String {
36 if let Some(a) = &proj.alias {
37 return a.clone();
38 }
39 let mut expression = &proj.expr;
40 while let ScalarExpr::Collated { expr, .. } = expression {
41 expression = expr;
42 }
43 match expression {
44 ScalarExpr::Column(c) => c.to_string(),
45 ScalarExpr::QualifiedColumn { column, .. } => column.to_string(),
46 ScalarExpr::Star | ScalarExpr::QualifiedStar(_) => "*".into(),
47 ScalarExpr::Func {
48 name,
49 binding,
50 args,
51 ..
52 } => field_selection_label(binding.as_ref(), args.get(1))
53 .unwrap_or_else(|| function_projection_label(name, binding.as_ref())),
54 ScalarExpr::WindowCall { name, .. } => function_projection_label(name, None),
55 _ => "?column?".into(),
56 }
57}
58
59pub(crate) fn field_selection_label<E: FieldNameLiteral>(
61 binding: Option<&crate::ast::FunctionBinding>,
62 field: Option<&E>,
63) -> Option<String> {
64 (binding.and_then(|binding| binding.dispatch)
65 == Some(crate::ast::FunctionDispatch::FieldSelect))
66 .then(|| field.and_then(FieldNameLiteral::field_name))
67 .flatten()
68 .map(str::to_owned)
69}
70
71pub(crate) trait FieldNameLiteral {
73 fn field_name(&self) -> Option<&str>;
74}
75
76impl FieldNameLiteral for ScalarExpr {
77 fn field_name(&self) -> Option<&str> {
78 match self {
79 ScalarExpr::Literal(uqa_core::Value::Str(field)) => Some(field),
80 _ => None,
81 }
82 }
83}
84
85impl FieldNameLiteral for crate::ast::Expr {
86 fn field_name(&self) -> Option<&str> {
87 match self {
88 crate::ast::Expr::Literal(uqa_core::Value::Str(field)) => Some(field),
89 _ => None,
90 }
91 }
92}
93
94pub fn function_projection_label(
95 name: &str,
96 binding: Option<&crate::ast::FunctionBinding>,
97) -> String {
98 if matches!(
100 binding.and_then(|binding| binding.dispatch),
101 Some(
102 crate::ast::FunctionDispatch::NumericOperator(_)
103 | crate::ast::FunctionDispatch::Pattern { .. }
104 | crate::ast::FunctionDispatch::Concat { .. }
105 | crate::ast::FunctionDispatch::ArrayConcat
106 | crate::ast::FunctionDispatch::ArrayAppend
107 | crate::ast::FunctionDispatch::ArrayPrepend
108 | crate::ast::FunctionDispatch::IsDistinct
109 | crate::ast::FunctionDispatch::DistinctNot
110 | crate::ast::FunctionDispatch::RowDistinct
111 | crate::ast::FunctionDispatch::ValueIsDistinct
112 | crate::ast::FunctionDispatch::ValueNullTest { .. }
113 | crate::ast::FunctionDispatch::BooleanTest(_)
114 | crate::ast::FunctionDispatch::AnyOperator
115 | crate::ast::FunctionDispatch::AllOperator
116 | crate::ast::FunctionDispatch::BetweenSymmetric
117 | crate::ast::FunctionDispatch::JsonExtract { .. }
118 )
119 ) {
120 return "?column?".into();
121 }
122 let name = crate::parse_regobject_name(name)
123 .and_then(|mut names| names.pop())
124 .unwrap_or_else(|| name.to_string());
125 if operator_call(&name) {
126 return "?column?".into();
127 }
128 name
129}
130
131fn operator_call(name: &str) -> bool {
133 matches!(
134 name,
135 "fts_match"
136 | "jsonpath_exists"
137 | "contains_op"
138 | "contained_by_op"
139 | "array_overlap"
140 | "json_has_key"
141 | "json_has_any_key"
142 | "json_has_all_keys"
143 | "json_delete_path"
144 )
145}
146
147pub fn expand_from_star_columns(
148 columns: Vec<String>,
149 projections: &[ProjectionPlan],
150 source_schema: &RowSchema,
151) -> Result<Vec<String>, SQLError> {
152 let mut output = Vec::new();
153 for (position, projection) in projections.iter().enumerate() {
154 match &projection.expr {
155 ScalarExpr::Star => {
156 output.extend(
157 source_schema
158 .columns()
159 .iter()
160 .enumerate()
161 .filter(|(position, _)| {
162 visible_projection_source_position(source_schema, *position)
163 })
164 .map(|(source_position, column)| {
165 source_schema
166 .public_name(source_position)
167 .unwrap_or(column)
168 .to_string()
169 }),
170 );
171 }
172 ScalarExpr::QualifiedStar(qualifier) => {
173 let qualified_columns = source_schema
174 .qualified_star_position_layout(qualifier)
175 .into_iter()
176 .filter(|(_, logical, _, _)| {
177 logical.is_none_or(|position| {
178 visible_projection_source_position(source_schema, position)
179 })
180 })
181 .map(|(column, _, _, _)| column)
182 .collect::<Vec<_>>();
183 if qualified_columns.is_empty() && !source_schema.has_qualifier(qualifier) {
184 return Err(SQLError::UnknownTable(qualifier.to_string()));
185 }
186 output.extend(qualified_columns);
187 }
188 _ => output.push(columns[position].clone()),
189 }
190 }
191 Ok(output)
192}
193
194pub fn bound_projection_expression(schema: &RowSchema, position: usize) -> ScalarExpr {
195 let Some(identity) = schema.identity(position) else {
196 return ScalarExpr::Position(position);
197 };
198 if let Some(qualifier) = identity.qualifier() {
199 if schema.qualified_position(qualifier, identity.column()) == Some(position) {
200 return ScalarExpr::qualified_column(qualifier, identity.column());
201 }
202 } else if schema.unqualified_position(identity.column()) == Some(position) {
203 return ScalarExpr::Column(identity.column().to_string().into());
204 }
205 ScalarExpr::Position(position)
206}
207
208pub fn expand_bound_projection_stars(
209 projections: &[ProjectionPlan],
210 schema: &RowSchema,
211) -> Result<Vec<ProjectionPlan>, SQLError> {
212 expand_bound_projection_stars_in_scope(projections, schema, schema)
213}
214
215pub(crate) fn row_star_fields(
217 expression: &ScalarExpr,
218 schema: &RowSchema,
219) -> Result<Option<Vec<ScalarExpr>>, SQLError> {
220 if !matches!(expression, ScalarExpr::QualifiedStar(_)) {
221 return Ok(None);
222 }
223 expand_bound_projection_stars(
224 &[ProjectionPlan {
225 expr: expression.clone(),
226 alias: None,
227 }],
228 schema,
229 )
230 .map(|fields| Some(fields.into_iter().map(|field| field.expr).collect()))
231}
232
233pub fn expand_bound_projection_stars_in_scope(
235 projections: &[ProjectionPlan],
236 schema: &RowSchema,
237 expression_schema: &RowSchema,
238) -> Result<Vec<ProjectionPlan>, SQLError> {
239 let mut expanded = Vec::new();
240 for projection in projections {
241 match &projection.expr {
242 ScalarExpr::Star => {
243 for (position, column) in schema.columns().iter().enumerate() {
244 if !visible_projection_source_position(schema, position) {
245 continue;
246 }
247 expanded.push(ProjectionPlan {
248 expr: bound_projection_expression(schema, position),
249 alias: Some(schema.public_name(position).unwrap_or(column).to_string()),
250 });
251 }
252 }
253 ScalarExpr::QualifiedStar(qualifier) => {
254 let schema = expression_schema;
255 schema.require_lateral_qualifier(qualifier)?;
256 let layout = schema.qualified_star_position_layout(qualifier);
257 if layout.is_empty() && !schema.has_qualifier(qualifier) {
258 if let Some(error) = schema.unavailable_qualifier_error(qualifier) {
259 return Err(error);
260 }
261 return Err(SQLError::UnknownTable(qualifier.to_string()));
262 }
263 for (column, logical, _, _) in layout {
264 if logical.is_some_and(|position| {
265 !visible_projection_source_position(schema, position)
266 }) {
267 continue;
268 }
269 expanded.push(ProjectionPlan {
270 expr: logical.map_or_else(
271 || ScalarExpr::qualified_column(qualifier, &column),
272 |position| bound_projection_expression(schema, position),
273 ),
274 alias: Some(column),
275 });
276 }
277 }
278 _ => expanded.push(projection.clone()),
279 }
280 }
281 Ok(expanded)
282}
283
284pub fn visible_projection_source_position(schema: &RowSchema, position: usize) -> bool {
285 schema.wildcard_position_visible(position)
286}
287
288pub fn returning_context_schema(
289 columns: &[String],
290 types: &[Option<crate::ast::ColumnType>],
291 composite_width: usize,
292 target_qualifier: &str,
293 aliases: &ReturningAliases,
294) -> RowSchema {
295 let target =
296 RowSchema::with_qualified_types(target_qualifier, columns.to_vec(), types.to_vec());
297 returning_schema_for_target(target, composite_width, aliases)
298}
299
300pub fn returning_schema_for_target(
302 target: RowSchema,
303 composite_width: usize,
304 aliases: &ReturningAliases,
305) -> RowSchema {
306 let width = target.len();
307 assert_eq!(
308 target.physical_width(),
309 width,
310 "RETURNING target must be positional"
311 );
312 assert!(
313 composite_width <= width,
314 "RETURNING user columns must belong to the target"
315 );
316 debug_assert!((0..width).all(|position| target.slot(position) == Some(position)));
317 let target = RowSchema::with_wildcard_hidden_positions(&target, composite_width..width);
318 let types = target.column_types();
319 let hidden_types = types
320 .iter()
321 .cloned()
322 .chain(types.iter().cloned())
323 .collect::<Vec<_>>();
324 let schema = RowSchema::append_hidden_typed(&target, &hidden_types);
325 let identity_aliases = target
326 .columns()
327 .iter()
328 .enumerate()
329 .flat_map(|(position, column)| {
330 [
331 (
332 ColumnIdentity::qualified(&aliases.old, column),
333 width + position,
334 types[position].clone(),
335 ),
336 (
337 ColumnIdentity::qualified(&aliases.new, column),
338 width * 2 + position,
339 types[position].clone(),
340 ),
341 ]
342 })
343 .collect::<Vec<_>>();
344 let mut schema = RowSchema::with_physical_identity_aliases(&schema, &identity_aliases);
345 for (binding, oid) in target.collation_overrides() {
346 let crate::schema::CollationBinding::Column(position) = binding else {
347 continue;
348 };
349 for qualifier in [&aliases.old, &aliases.new] {
350 let identity = ColumnIdentity::qualified(qualifier, &target.columns()[position]);
351 schema = schema
352 .with_collation_override(crate::schema::CollationBinding::Alias(&identity), oid)
353 .expect("RETURNING image alias retains its target's type");
354 }
355 }
356 schema
357}
358
359pub fn returning_expression_schema(
360 target: &RowSchema,
361 target_qualifier: &str,
362 aliases: &ReturningAliases,
363 supplemental: Option<&RowSchema>,
364) -> RowSchema {
365 let composite_width = target.len();
366 let (columns, types) = target_with_system_columns(target);
367 let width = columns.len();
368 let schema = RowSchema::with_qualified_types(target_qualifier, columns, types)
369 .with_column_collations((0..width).map(|position| target.column_collation(position)));
370 let target = returning_schema_for_target(schema, composite_width, aliases);
371 supplemental.map_or(target.clone(), |source| {
372 RowSchema::join(&target, source, std::iter::empty())
373 })
374}
375
376#[must_use]
378pub fn mutation_clause_schema(
379 target: &RowSchema,
380 target_qualifier: &str,
381 supplemental: Option<&RowSchema>,
382) -> RowSchema {
383 let composite_width = target.len();
384 let (columns, types) = target_with_system_columns(target);
385 let width = columns.len();
386 let target = RowSchema::with_wildcard_hidden_positions(
387 &RowSchema::with_qualified_types(target_qualifier, columns, types)
388 .with_column_collations((0..width).map(|position| target.column_collation(position))),
389 composite_width..width,
390 );
391 supplemental.map_or(target.clone(), |source| {
392 RowSchema::join(&target, source, std::iter::empty())
393 })
394}
395
396fn target_with_system_columns(
398 target: &RowSchema,
399) -> (Vec<String>, Vec<Option<crate::ast::ColumnType>>) {
400 let mut columns = target.columns().to_vec();
401 let mut types = target.column_types().to_vec();
402 if !columns.iter().any(|column| column == DOC_ID_COLUMN) {
403 columns.push(DOC_ID_COLUMN.into());
404 types.push(Some(crate::ast::ColumnType::BigInteger));
405 }
406 columns.push(TABLE_OID_COLUMN.into());
407 types.push(Some(crate::ast::ColumnType::Oid));
408 columns.push(crate::semantics::XMIN_COLUMN.into());
409 types.push(Some(crate::ast::ColumnType::Xid));
410 (columns, types)
411}
412
413pub fn query_plan_output_columns(plan: &crate::plan::QueryPlan) -> Option<Vec<String>> {
414 match &plan.root {
415 crate::plan::RelationalPlan::QueryBlock(block) => {
416 Some(projection_columns(&block.projections))
417 }
418 crate::plan::RelationalPlan::SetOp { left, .. } => query_plan_output_columns(left),
419 crate::plan::RelationalPlan::Values { rows, .. } => rows.first().map(|row| {
420 (1..=row.len())
421 .map(|index| format!("column{index}"))
422 .collect()
423 }),
424 }
425}
426
427pub fn should_defer_distinct_limit(stmt: &crate::plan::QueryBlockPlan) -> bool {
428 stmt.distinct && (stmt.limit.is_some() || stmt.offset.is_some())
429}
430
431pub fn select_execution_stmt(
432 stmt: &crate::plan::QueryBlockPlan,
433 defer_distinct_limit: bool,
434) -> crate::plan::QueryBlockPlan {
435 if !defer_distinct_limit {
436 return stmt.clone();
437 }
438 let mut exec_stmt = stmt.clone();
439 exec_stmt.limit = None;
440 exec_stmt.offset = None;
441 exec_stmt
442}