1use crate::ast::ColumnType;
10use crate::plan::{ProjectionPlan, QueryBlockPlan, QueryPlan};
11use crate::RowSchema;
12use crate::{SQLError, SQLParam};
13
14use super::{
15 bind_query_plan_schema, projection_columns, BindingContext, QueryFunctionTypeResolver,
16 ScalarExpr, SchemaScope,
17};
18use crate::routines::RoutineResolution;
19
20type ProjectionStarColumn = (String, Option<ColumnType>, Option<u32>);
21
22#[cfg(test)]
23mod tests;
24
25pub(super) struct ProjectionMetadata {
26 pub ty: Option<ColumnType>,
27 pub collation: Option<u32>,
28 pub record: Option<crate::schema::RecordMetadata>,
29}
30
31#[derive(Default)]
33pub(super) struct OutputCollations(Vec<(usize, u32)>);
34
35impl OutputCollations {
36 pub(super) fn push(&mut self, position: usize, ty: Option<&ColumnType>, oid: Option<u32>) {
37 if let Some((ty, oid)) = ty.zip(oid) {
38 if crate::schema::composites::type_is_collatable(ty)
39 && crate::catalog::type_metadata::pg_type_collation_oid(ty) != i64::from(oid)
40 {
41 self.0.push((position, oid));
42 }
43 }
44 }
45
46 pub(super) fn apply(self, mut schema: RowSchema) -> RowSchema {
47 for (position, oid) in self.0 {
48 schema = schema
49 .with_collation_override(crate::schema::CollationBinding::Column(position), oid)
50 .expect("selected collation belongs to its typed output");
51 }
52 schema
53 }
54}
55
56pub fn bind_projection_output_schema(
58 routines: &dyn RoutineResolution,
59 projections: &[ProjectionPlan],
60 expression_schema: &RowSchema,
61 star_schema: &RowSchema,
62 subqueries: &[QueryPlan],
63 params: &[SQLParam],
64 ctes: &BindingContext,
65) -> Result<RowSchema, SQLError> {
66 projection_output_schema(
67 SchemaScope::from_context(ctes)?,
68 routines,
69 projections,
70 expression_schema,
71 star_schema,
72 subqueries,
73 params,
74 )
75}
76
77pub fn analyze_projection_output_schema(
79 routines: &dyn RoutineResolution,
80 projections: &[ProjectionPlan],
81 expression_schema: &RowSchema,
82 star_schema: &RowSchema,
83 subqueries: &[QueryPlan],
84 params: &[SQLParam],
85 ctes: &BindingContext,
86) -> Result<RowSchema, SQLError> {
87 projection_output_schema(
88 SchemaScope::for_analysis(ctes)?,
89 routines,
90 projections,
91 expression_schema,
92 star_schema,
93 subqueries,
94 params,
95 )
96}
97
98fn projection_output_schema(
99 mut scope: SchemaScope,
100 routines: &dyn RoutineResolution,
101 projections: &[ProjectionPlan],
102 expression_schema: &RowSchema,
103 star_schema: &RowSchema,
104 subqueries: &[QueryPlan],
105 params: &[SQLParam],
106) -> Result<RowSchema, SQLError> {
107 let labels = projection_columns(projections);
108 let mut columns = Vec::new();
109 let mut types = Vec::new();
110 let mut records = Vec::new();
111 let mut collations = OutputCollations::default();
112 for (position, projection) in projections.iter().enumerate() {
113 let expansion_schema = match projection.expr {
114 ScalarExpr::QualifiedStar(_) => expression_schema,
115 _ => star_schema,
116 };
117 if let Some(star_columns) = projection_star_columns(&projection.expr, expansion_schema)? {
118 records.extend(
119 super::record_fields::star_metadata(&projection.expr, expansion_schema)
120 .unwrap_or_default(),
121 );
122 for (column, ty, collation) in star_columns {
123 collations.push(types.len(), ty.as_ref(), collation);
124 columns.push(column);
125 types.push(ty);
126 }
127 continue;
128 }
129 columns.push(labels[position].clone());
130 let metadata = scope.bind_projection_metadata(
131 routines,
132 &projection.expr,
133 expression_schema,
134 subqueries,
135 params,
136 )?;
137 collations.push(types.len(), metadata.ty.as_ref(), metadata.collation);
138 types.push(metadata.ty);
139 records.push(metadata.record);
140 }
141 for projection in projections {
142 scope.collations.validate_expression(&projection.expr)?;
143 }
144 Ok(collations
145 .apply(RowSchema::with_types(columns, types))
146 .with_record_metadata(
147 records
148 .into_iter()
149 .enumerate()
150 .filter_map(|(index, fields)| fields.map(|fields| (index, fields))),
151 ))
152}
153
154pub fn validate_query_block_expression_types(
156 routines: &dyn RoutineResolution,
157 statement: &QueryBlockPlan,
158 schema: &RowSchema,
159 params: &[SQLParam],
160 ctes: &BindingContext,
161) -> Result<(), SQLError> {
162 let scalar_subquery_schemas = statement
163 .subqueries
164 .iter()
165 .map(|plan| bind_query_plan_schema(routines, plan, params, ctes, Some(schema)).map(Some))
166 .collect::<Result<Vec<_>, _>>()?;
167 let resolver = QueryFunctionTypeResolver {
168 routines,
169 scalar_subquery_schemas: Some(scalar_subquery_schemas),
170 defer_routine_namespace_errors: true,
171 };
172 let resolve =
173 |expression| crate::scalar_type_with_resolver(expression, schema, params, &resolver);
174 for projection in &statement.projections {
175 resolve(&projection.expr)?;
176 }
177 let mut equality_types = statement
178 .group_by
179 .iter()
180 .chain(statement.grouping_sets.iter().flatten())
181 .map(resolve)
182 .collect::<Result<Vec<_>, _>>()?;
183 let ordering_types = statement
184 .order_by
185 .iter()
186 .map(|order| resolve(&order.expr))
187 .collect::<Result<Vec<_>, _>>()?;
188 for expression in &statement.distinct_on {
189 equality_types.push(resolve(expression)?);
190 }
191 for expression in statement
192 .r#where
193 .iter()
194 .chain(statement.having.iter())
195 .chain(statement.limit.iter())
196 .chain(statement.offset.iter())
197 {
198 resolve(expression)?;
199 }
200 for ty in equality_types.iter().flatten() {
202 crate::type_resolution::ComparisonSupport::Equality.require_in_catalog(ty, routines)?;
203 }
204 for ty in ordering_types.iter().flatten() {
205 crate::type_resolution::ComparisonSupport::Ordering.require_in_catalog(ty, routines)?;
206 }
207 Ok(())
208}
209
210pub fn validate_query_block_references(
212 routines: &dyn RoutineResolution,
213 statement: &QueryBlockPlan,
214 schema: &RowSchema,
215 params: &[SQLParam],
216 ctes: &BindingContext,
217 outer: Option<&RowSchema>,
218) -> Result<(), SQLError> {
219 let output = analyze_projection_output_schema(
220 routines,
221 &statement.projections,
222 schema,
223 schema,
224 &statement.subqueries,
225 params,
226 ctes,
227 )?;
228 if statement.distinct && statement.distinct_on.is_empty() {
229 for ty in output.column_types().iter().flatten() {
230 crate::type_resolution::ComparisonSupport::Equality.require_in_catalog(ty, routines)?;
231 }
232 }
233 SchemaScope::for_analysis(ctes)?
234 .validate_query_block_clauses(routines, statement, schema, &output, params, outer)
235}
236
237pub(super) fn projection_star_columns(
238 expression: &ScalarExpr,
239 schema: &RowSchema,
240) -> Result<Option<Vec<ProjectionStarColumn>>, SQLError> {
241 projection_star_columns_inner(expression, schema)
242 .map_err(|error| error.at_position(expression.reference_position()))
243}
244
245fn projection_star_columns_inner(
246 expression: &ScalarExpr,
247 schema: &RowSchema,
248) -> Result<Option<Vec<ProjectionStarColumn>>, SQLError> {
249 match expression {
250 ScalarExpr::Star => Ok(Some(
251 schema
252 .columns()
253 .iter()
254 .enumerate()
255 .map(|(position, column)| {
256 (
257 schema.public_name(position).unwrap_or(column).to_string(),
258 schema.column_type(position).cloned(),
259 schema.column_collation(position),
260 )
261 })
262 .collect(),
263 )),
264 ScalarExpr::QualifiedStar(qualifier) => {
265 schema.require_lateral_qualifier(qualifier)?;
266 let columns = schema
267 .qualified_star_position_layout(qualifier)
268 .into_iter()
269 .map(|(column, logical, _, ty)| {
270 let collation = logical.map_or_else(
271 || schema.qualified_collation(qualifier, &column),
272 |position| schema.column_collation(position),
273 );
274 (column, ty, collation)
275 })
276 .collect::<Vec<_>>();
277 if columns.is_empty() && !schema.has_qualifier(qualifier) {
278 if let Some(error) = schema.unavailable_qualifier_error(qualifier) {
279 return Err(error);
280 }
281 return Err(SQLError::UnknownTable(qualifier.to_string()));
282 }
283 Ok(Some(columns))
284 }
285 _ => Ok(None),
286 }
287}
288
289pub(super) fn rename_schema(
290 schema: &RowSchema,
291 aliases: &[String],
292 qualifier: Option<&str>,
293) -> RowSchema {
294 let columns = schema
295 .columns()
296 .iter()
297 .enumerate()
298 .map(|(position, column)| {
299 aliases
300 .get(position)
301 .cloned()
302 .unwrap_or_else(|| schema.public_name(position).unwrap_or(column).to_string())
303 })
304 .collect();
305 let renamed = match qualifier {
306 Some(qualifier) => {
307 RowSchema::with_qualified_types(qualifier, columns, schema.column_types().to_vec())
308 }
309 None => RowSchema::with_types(columns, schema.column_types().to_vec()),
310 };
311 let renamed = renamed
312 .with_column_collations((0..schema.len()).map(|position| schema.column_collation(position)))
313 .with_record_fields_from(schema);
314 let renamed = if schema.columns_are_open(None) {
315 RowSchema::with_open_columns(&renamed, qualifier)
316 } else {
317 renamed
318 };
319 let mut hidden = Vec::new();
320 let mut conflicting = Vec::new();
321 for (identity, ty) in schema.typed_virtual_identities() {
322 let conflicts = match identity.qualifier() {
323 Some(source) => schema.qualified_column_is_ambiguous(source, identity.column()),
324 None => schema.column_is_ambiguous(identity.column()),
325 };
326 let mapped = qualifier.map_or_else(
327 || vec![identity.clone()],
328 |qualifier| {
329 vec![
330 crate::ColumnIdentity::unqualified(identity.column()),
331 crate::ColumnIdentity::qualified(qualifier, identity.column()),
332 ]
333 },
334 );
335 for identity in mapped {
336 if conflicts {
337 conflicting.push((identity, ty.cloned()));
338 } else {
339 hidden.push((identity, ty.cloned()));
340 }
341 }
342 }
343 let renamed = RowSchema::with_typed_virtual_identities(&renamed, &hidden);
344 RowSchema::with_typed_conflicting_virtual_identities(&renamed, &conflicting)
345}