use super::super::{analysis, overlay_outer_schema_with_control};
use super::ownership::AnalysisVec;
use super::{
error, ColumnType, ExpressionType, Preparation, QueryOutput, QueryPlan, RowSchema, SQLError,
ScalarExpr,
};
use crate::plan::{ProjectionPlan, QueryBlockPlan, RelationalPlan};
use crate::semantics::sets::placement::SetPlacement;
#[cfg(test)]
thread_local! {
pub(crate) static BLOCK_ANALYSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
impl Preparation<'_> {
pub(super) fn scalar_query_schema(
&mut self,
index: usize,
input: &RowSchema,
subqueries: &[QueryPlan],
) -> Result<RowSchema, SQLError> {
if let Some(schema) = self
.bound_condition_queries
.and_then(|queries| queries.get(index, input, subqueries))
{
return Ok(schema.clone());
}
let query = subqueries
.get(index)
.ok_or_else(|| error("XX000", "scalar subquery slot is outside its plan".into()))?;
self.query(query, Some(input))
}
pub(super) fn query(
&mut self,
plan: &QueryPlan,
outer: Option<&RowSchema>,
) -> Result<RowSchema, SQLError> {
let output = self.query_output(plan, outer, false)?;
self.parameters
.query_output_schema(plan)
.cloned()
.map_or_else(|| output.schema(&self.scope.control()), Ok)
}
pub(super) fn query_output(
&mut self,
plan: &QueryPlan,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
self.in_query_level(|analysis| analysis.query_level_output(plan, outer, preserve_unknown))
}
fn query_level_output(
&mut self,
plan: &QueryPlan,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
let mode = if plan.relations_bound {
crate::catalog::resolution::RelationLookupMode::Bound
} else {
crate::catalog::resolution::RelationLookupMode::Dynamic
};
let lookup = self.scope.resolution.set_lookup_mode(mode);
let result = (|| {
let previous = self.ctes(&plan.ctes, outer)?;
let result = self.root(&plan.root, outer, preserve_unknown);
self.scope.restore_cte_schemas(previous);
let output = result?;
self.parameters.collations.validate_query(plan)?;
for value in &output.types {
value.derivation.validate()?;
}
self.parameters.retain_query_output(plan, &output)?;
Ok(output)
})();
self.scope.resolution.set_lookup_mode(lookup);
result
}
pub(super) fn root(
&mut self,
root: &RelationalPlan,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
match root {
RelationalPlan::QueryBlock(block) => self.block(block, outer, preserve_unknown),
RelationalPlan::Values { rows, subqueries } => self.values(rows, subqueries, outer),
RelationalPlan::SetOp {
kind,
all,
left,
right,
order_by,
limit,
offset,
subqueries,
..
} => {
let mut left_output = self.query_output(left, outer, true)?;
let mut right_output = self.query_output(right, outer, true)?;
left_output.retain_set_operand_names(left)?;
right_output.retain_set_operand_names(right)?;
let owner = self.scope.control().capture();
let control = owner.control();
let unknowns = |output: &QueryOutput| -> Result<AnalysisVec<usize>, SQLError> {
let mut positions = AnalysisVec::new(&control);
for (index, value) in output.types.iter().enumerate() {
if value.is_sql_unknown() {
positions.push(index, &control)?;
}
}
Ok(positions)
};
let left_unknowns = unknowns(&left_output)?;
let right_unknowns = unknowns(&right_output)?;
let output = self.set_output(left_output, right_output, *kind, *all)?;
self.parameters
.retain_set_operand_coercions(left, &left_unknowns, &output)?;
self.parameters
.retain_set_operand_coercions(right, &right_unknowns, &output)?;
self.set_ordering(order_by, &output, subqueries)?;
let input = overlay_outer_schema_with_control(
&RowSchema::empty_with_control(&control)?,
outer,
&control,
)?;
self.slice(limit.as_deref(), offset.as_deref(), &input, subqueries)?;
Ok(output)
}
}
}
pub(super) fn set_output(
&mut self,
mut left: QueryOutput,
right: QueryOutput,
kind: crate::ast::SetOpKind,
all: bool,
) -> Result<QueryOutput, SQLError> {
if left.types.len() != right.types.len() {
return Err(error(
"42601",
format!(
"each {} query must have the same number of columns",
match kind {
crate::ast::SetOpKind::Union => "UNION",
crate::ast::SetOpKind::Intersect => "INTERSECT",
crate::ast::SetOpKind::Except => "EXCEPT",
}
),
));
}
let allow_indeterminate = matches!((kind, all), (crate::ast::SetOpKind::Union, true));
for (left, right) in left.types.iter_mut().zip(right.types) {
let mut values = [
std::mem::replace(left, ExpressionType::resolved(None)),
right,
];
let ty = self.common(
crate::type_resolution::CommonTypeContext::set_operation(kind),
&mut values,
)?;
if let Some(target) = &ty {
for value in &mut values {
value.derivation = value.derivation.coerce(value.ty.as_deref(), target);
}
}
let mut result = ExpressionType::combined_owned(ty, &values);
let oid = result.derivation.common_oid(allow_indeterminate)?;
if !allow_indeterminate {
if let Some(ty) = &result.ty {
crate::type_resolution::ComparisonSupport::Equality
.require_in_catalog(ty, self.routines)?;
}
}
result.derivation = crate::catalog::collations::derivation::Derivation::implicit(oid);
result.record_fields = super::super::record_fields::common_fields(
values.iter().map(|value| value.record_fields.as_ref()),
);
result
.record_descriptor
.clone_from(&values[0].record_descriptor);
*left = result;
}
left.key_origins.clear();
let control = left.control.control();
left.set_sources
.reserve(right.set_sources.len(), &control)?;
for source in right.set_sources {
left.set_sources.push(source, &control)?;
}
Ok(left)
}
fn block(
&mut self,
block: &QueryBlockPlan,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
let captured_outer = outer
.map(|schema| {
crate::semantics::view_rewrite::bind_outer_rewrite_scope_with_control(
block,
schema,
&self.scope.control(),
)
})
.transpose()?;
let outer = captured_outer.as_deref();
if !block.deferred_outer_rewrites.is_empty() {
return self.rewritten_block(block, outer, preserve_unknown);
}
self.analyzed_block(block, outer, preserve_unknown)
}
fn analyzed_block(
&mut self,
block: &QueryBlockPlan,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
let source = block
.from
.as_ref()
.map(|source| self.source(source, &block.subqueries, outer))
.transpose()?;
let source = match source {
Some(source) => source,
None => RowSchema::empty_with_control(&self.scope.control())?,
};
let source = analysis::with_query_source_columns_with_control(
&source,
block,
&self.scope.control(),
)?;
if let Some(from) = &block.from {
self.parameters.retain_source_schema(from, &source)?;
}
self.in_query_level(|analysis| {
analysis.block_level_output(block, &source, outer, preserve_unknown)
})
}
fn rewritten_block(
&mut self,
original: &QueryBlockPlan,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
if let Some(block) = self.parameters.take_rewritten_block(original) {
let RelationalPlan::QueryBlock(rewritten) = &block.root else {
unreachable!("rewritten query block");
};
let result = self.analyzed_block(rewritten, outer, preserve_unknown);
self.parameters.retain_rewritten_block(original, block)?;
return result;
}
let params = self.parameters.values()?;
let owner = self.scope.control().capture();
let control = owner.control();
let block = crate::semantics::view_rewrite::resolve_outer_sources_owned(
original.copy_for_rewrite(&control)?,
outer,
&mut |source, subqueries, scope| {
self.scope
.bind_source_input(self.routines, source, subqueries, ¶ms, scope)
},
&control,
)?;
let RelationalPlan::QueryBlock(query) = &block.root else {
unreachable!("rewritten query block");
};
let source = query
.from
.as_ref()
.map(|source| {
self.scope
.bind_source(self.routines, source, &query.subqueries, ¶ms, outer)
})
.transpose()?
.unwrap_or_default();
let block =
crate::semantics::view_rewrite::resolve_outer_rewrites_owned(block, &source, &control)?;
let RelationalPlan::QueryBlock(query) = &block.root else {
unreachable!("rewritten query block");
};
let result = self.analyzed_block(query, outer, preserve_unknown);
self.parameters.retain_rewritten_block(original, block)?;
result
}
pub(super) fn block_with_source(
&mut self,
block: &QueryBlockPlan,
source: &RowSchema,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
let captured_outer = outer
.map(|schema| {
crate::semantics::view_rewrite::bind_outer_rewrite_scope_with_control(
block,
schema,
&self.scope.control(),
)
})
.transpose()?;
let outer = captured_outer.as_deref();
if block.deferred_outer_rewrites.is_empty() {
return self.in_query_level(|analysis| {
analysis.block_level_output(block, source, outer, preserve_unknown)
});
}
let owner = self.scope.control().capture();
let control = owner.control();
let rewritten = crate::semantics::view_rewrite::resolve_outer_rewrites_owned(
block.copy_for_rewrite(&control)?,
source,
&control,
)?;
let RelationalPlan::QueryBlock(query) = &rewritten.root else {
unreachable!("rewritten query block");
};
let result = self.in_query_level(|analysis| {
analysis.block_level_output(query, source, outer, preserve_unknown)
});
self.parameters.retain_rewritten_block(block, rewritten)?;
result
}
fn block_level_output(
&mut self,
block: &QueryBlockPlan,
source: &RowSchema,
outer: Option<&RowSchema>,
preserve_unknown: bool,
) -> Result<QueryOutput, SQLError> {
#[cfg(test)]
BLOCK_ANALYSES.with(|count| count.set(count.get() + 1));
let input = overlay_outer_schema_with_control(source, outer, &self.scope.control())?;
let input = self.scope.with_stored_outer_internal_aliases(&input)?;
let mut output = self.projections(&block.projections, source, &input, &block.subqueries)?;
if let Some(predicate) = &block.r#where {
self.in_placement(SetPlacement::Where, |analysis| {
analysis.require_boolean(predicate, &input, &block.subqueries, "WHERE")
})?;
}
if let Some(having) = &block.having {
self.in_placement(SetPlacement::Having, |analysis| {
analysis.require_boolean(having, &input, &block.subqueries, "HAVING")
})?;
}
let projected = output.schema(&self.scope.control())?;
for order in &block.order_by {
let value = self.alias_expression(
&order.expr,
&output,
&projected,
&input,
&block.subqueries,
"ORDER BY",
)?;
if let Some(ty) = &value.ty {
crate::type_resolution::ComparisonSupport::Ordering
.require_in_catalog(ty, self.routines)?;
}
self.query_key(&order.expr, value.derivation, block, &input)?;
}
let owner = self.scope.control().capture();
let control = owner.control();
let grouping_inputs = self.grouping_inputs(block, source, &input, outer, &projected)?;
for expression in &block.distinct_on {
let value = self.alias_expression(
expression,
&output,
&projected,
&input,
&block.subqueries,
"DISTINCT ON",
)?;
if let Some(ty) = &value.ty {
crate::type_resolution::ComparisonSupport::Equality
.require_in_catalog(ty, self.routines)?;
}
self.query_key(expression, value.derivation, block, &input)?;
}
if block.distinct && block.distinct_on.is_empty() {
for (position, value) in output.types.iter().enumerate() {
if let Some(ty) = &value.ty {
crate::type_resolution::ComparisonSupport::Equality
.require_in_catalog(ty, self.routines)?;
}
if let Some(origin) = output.key_origin(position) {
self.parameters.collations.require_key_at(origin);
}
}
}
self.slice(
block.limit.as_ref(),
block.offset.as_ref(),
&input,
&block.subqueries,
)?;
self.query_windows(block, &input)?;
crate::semantics::grouping_sets::validate_grouped_expressions_with_inputs(
self.routines,
block,
&input,
outer,
&self.parameters.values()?,
grouping_inputs.iter().copied(),
&control,
)?;
self.parameters
.retain_distinct_grouping(block, &input, outer)?;
if !preserve_unknown {
self.resolve_targets(&mut output)?;
}
Ok(output)
}
fn grouping_inputs<'a>(
&mut self,
block: &'a QueryBlockPlan,
source: &RowSchema,
input: &RowSchema,
outer: Option<&RowSchema>,
projected: &RowSchema,
) -> Result<uqa_core::memory::Produced<Vec<&'a ScalarExpr>>, SQLError> {
let owner = self.scope.control().capture();
let control = owner.control();
let mut grouping_inputs = uqa_core::memory::ProductionVec::new(control);
for expression in block
.group_by
.iter()
.chain(block.grouping_sets.iter().flatten())
{
let site_output = self.scope.variable_sites.as_mut().and_then(|sites| {
let site = sites.site(expression)?;
let name = sites.bare_name(site)?;
if source.has_unqualified_column(name) || source.column_is_ambiguous(name) {
return None;
}
let slot = projected.column_slot(name)?;
sites.resolutions.as_mut_slice()[site] =
super::super::VariableSiteResolution::Output;
block
.projections
.get(slot)
.map(|projection| &projection.expr)
});
let expression = site_output.unwrap_or(expression);
let expression =
crate::semantics::grouping_sets::resolve_grouping_expression_reference_with_control(
self.routines,
expression,
&block.projections,
input,
outer,
&self.parameters.values()?,
&control,
)?;
grouping_inputs.push_copy(expression)?;
let mut value = self.expression(expression, input, &block.subqueries)?;
self.parameters
.coerce_unknown(&mut value, &ColumnType::Text)?;
if let Some(ty) = &value.ty {
crate::type_resolution::ComparisonSupport::Equality
.require_in_catalog(ty, self.routines)?;
}
self.query_key(expression, value.derivation, block, input)?;
}
Ok(grouping_inputs.finish()?)
}
fn query_windows(&mut self, block: &QueryBlockPlan, input: &RowSchema) -> Result<(), SQLError> {
let owner = self.scope.control().capture();
let control = owner.control();
let mut order_types = AnalysisVec::new(&control);
order_types.reserve(block.windows.len(), &control)?;
for (slot, window) in block.windows.iter().enumerate() {
let inherited = window
.inherited
.map(|parent| {
order_types
.get(parent)
.filter(|_| parent < slot)
.ok_or_else(|| {
SQLError::Internal(
"window inheritance is outside its query block".into(),
)
})
})
.transpose()?;
let order =
self.window_definition(&window.spec, input, &block.subqueries, inherited)?;
order_types.push(order, &control)?;
}
let mut result = Ok(());
for expression in block
.projections
.iter()
.map(|projection| &projection.expr)
.chain(block.order_by.iter().map(|order| &order.expr))
{
expression.visit(&mut |node| {
if result.is_ok() {
if let ScalarExpr::WindowCall { spec, .. } = node {
if spec.definition.is_none() {
result = self.window_specification(spec, input, &block.subqueries);
} else if spec
.definition
.is_some_and(|slot| slot >= block.windows.len())
{
result = Err(SQLError::Internal(
"window call is outside its query block".into(),
));
}
}
}
});
}
result
}
pub(super) fn projections<'a>(
&mut self,
projections: impl IntoIterator<Item = &'a ProjectionPlan>,
source: &RowSchema,
input: &RowSchema,
subqueries: &[QueryPlan],
) -> Result<QueryOutput, SQLError> {
let owner = self.scope.control().capture();
let control = owner.control();
let mut output = QueryOutput::new(&control);
for projection in projections {
let expansion = if matches!(projection.expr, ScalarExpr::QualifiedStar(_)) {
input
} else {
source
};
if super::super::projection::visit_projection_star_metadata(
&projection.expr,
expansion,
&control,
&mut |field| {
output
.columns
.push(control.copy_text(field.name)?, &control)?;
let mut value = ExpressionType::resolved_produced(
field
.ty
.map(|ty| ty.clone_with_control(&control))
.transpose()?,
&control,
)?;
if let Some(oid) = field.collation {
value.derivation =
crate::catalog::collations::derivation::Derivation::implicit(
i64::from(oid),
);
}
if let Some(record) = field.record {
value.record_fields.clone_from(&record.types);
value.record_descriptor.clone_from(&record.descriptor);
}
output.types.push(value, &control)?;
Ok(())
},
)? {
output.open |= match &projection.expr {
ScalarExpr::QualifiedStar(qualifier) => {
expansion.columns_are_open(Some(qualifier))
}
_ => expansion.columns_are_open(None),
};
} else {
let mut value = self.expression(&projection.expr, input, subqueries)?;
if matches!(value.ty.as_deref(), Some(ColumnType::Composite(_))) {
value.record_fields = self.scope.bind_record_fields(
self.routines,
&projection.expr,
input,
subqueries,
&self.parameters.values()?,
)?;
}
if matches!(
value.derivation,
crate::catalog::collations::derivation::Derivation::Conflict(..)
) {
output.key_origins.push(
(
output.types.len(),
std::ptr::NonNull::from(&projection.expr),
),
&control,
)?;
self.parameters
.collations
.record_target(&projection.expr, value.derivation)?;
}
let site_label = projection
.alias
.is_none()
.then(|| {
self.scope.variable_sites.as_ref().and_then(|sites| {
sites
.site(&projection.expr)
.and_then(|site| sites.label(site))
})
})
.flatten();
let name = if let Some(name) = site_label {
control.copy_text(name)?
} else {
crate::semantics::with_projection_label(projection, &control, |name| {
Ok(control.copy_text(name)?)
})?
};
output.columns.push(name, &control)?;
output.types.push(value, &control)?;
}
}
Ok(output)
}
pub(super) fn resolve_targets(&mut self, output: &mut QueryOutput) -> Result<(), SQLError> {
for ty in &mut output.types {
self.parameters.coerce_unknown(ty, &ColumnType::Text)?;
}
Ok(())
}
pub(super) fn values(
&mut self,
rows: &[Vec<ScalarExpr>],
subqueries: &[QueryPlan],
outer: Option<&RowSchema>,
) -> Result<QueryOutput, SQLError> {
let owner = self.scope.control().capture();
let control = owner.control();
let width = rows.first().map_or(0, Vec::len);
let mut columns = AnalysisVec::new(&control);
columns.reserve(width, &control)?;
for _ in 0..width {
columns.push(AnalysisVec::new(&control), &control)?;
}
let empty = RowSchema::empty_with_control(&control)?;
let input = outer.unwrap_or(&empty);
for row in rows {
for (position, expression) in row.iter().enumerate() {
let value = self.in_placement(SetPlacement::Values, |analysis| {
analysis.expression(expression, input, subqueries)
})?;
if let Some(column) = columns.get_mut(position) {
column.push(value, &control)?;
}
}
if row.len() != width {
return Err(error(
"42601",
"VALUES lists must all be the same length".into(),
));
}
}
let mut output = QueryOutput::new(&control);
output.types.reserve(width, &control)?;
output.columns.reserve(width, &control)?;
for (index, column) in columns.iter_mut().enumerate() {
let ty = self.common(crate::type_resolution::CommonTypeContext::Values, column)?;
let mut value = ExpressionType::combined_owned(ty, column);
let oid = value.derivation.common_oid(true)?;
value.derivation = crate::catalog::collations::derivation::Derivation::implicit(oid);
value.record_fields = super::super::record_fields::common_fields(
column.iter().map(|item| item.record_fields.as_ref()),
);
output.types.push(value, &control)?;
output.columns.push(
control.format(format_args!("column{}", index + 1))?,
&control,
)?;
}
Ok(output)
}
pub(super) fn alias_expression(
&mut self,
expression: &ScalarExpr,
output: &QueryOutput,
primary: &RowSchema,
fallback: &RowSchema,
subqueries: &[QueryPlan],
clause: &str,
) -> Result<ExpressionType, SQLError> {
let site_output = self.scope.variable_sites.as_mut().and_then(|sites| {
let site = sites.site(expression)?;
let name = sites.bare_name(site)?;
let slot = primary.column_slot(name)?;
sites.resolutions.as_mut_slice()[site] = super::super::VariableSiteResolution::Output;
Some(slot)
});
let index = site_output.or(match expression {
ScalarExpr::Literal(uqa_core::Value::Int(position)) => Some(
crate::semantics::query_output_position(*position, primary.len(), clause)?,
),
ScalarExpr::Column(name) if primary.column_is_ambiguous(name) => {
return Err(SQLError::Routine {
sqlstate: "42702".into(),
message: format!("{clause} \"{name}\" is ambiguous"),
});
}
ScalarExpr::Column(name) => primary.column_slot(name),
ScalarExpr::Position(position) if *position < output.types.len() => Some(*position),
_ => None,
});
if let Some(index) = index.filter(|index| *index < output.types.len()) {
if let Some(origin) = output.key_origin(index) {
self.parameters.collations.require_key_at(origin);
}
let mut value = ExpressionType::resolved_owned(output.types[index].ty.clone());
value.derivation = output.types[index].derivation;
return Ok(value);
}
let mut value = if matches!(expression, ScalarExpr::Column(_) | ScalarExpr::Position(_)) {
let input =
overlay_outer_schema_with_control(primary, Some(fallback), &self.scope.control())?;
self.expression(expression, &input, subqueries)?
} else {
self.expression(expression, fallback, subqueries)?
};
self.parameters
.coerce_unknown(&mut value, &ColumnType::Text)?;
Ok(value)
}
fn query_key(
&mut self,
expression: &ScalarExpr,
selected: crate::catalog::collations::derivation::Derivation,
block: &QueryBlockPlan,
input: &RowSchema,
) -> Result<(), SQLError> {
use crate::catalog::collations::derivation::Derivation;
if !matches!(selected, Derivation::Conflict(..)) {
return Ok(());
}
self.parameters
.collations
.require_key(expression, selected)?;
let mut identity = None;
for projection in &block.projections {
if !self
.parameters
.collations
.indeterminate_target(&projection.expr)
{
continue;
}
let same = if projection.expr == *expression {
true
} else {
let parameters = self.parameters.values()?;
let key = match &identity {
Some(key) => key,
None => identity.insert(crate::semantics::grouping_sets::expression_identity(
self.routines,
expression,
input,
¶meters,
)?),
};
*key == crate::semantics::grouping_sets::expression_identity(
self.routines,
&projection.expr,
input,
¶meters,
)?
};
if same {
self.parameters
.collations
.require_key(&projection.expr, selected)?;
break;
}
}
Ok(())
}
fn slice(
&mut self,
limit: Option<&ScalarExpr>,
offset: Option<&ScalarExpr>,
input: &RowSchema,
subqueries: &[QueryPlan],
) -> Result<(), SQLError> {
for (expression, context, placement) in offset
.map(|value| (value, "OFFSET", SetPlacement::Offset))
.into_iter()
.chain(limit.map(|value| (value, "LIMIT", SetPlacement::Limit)))
{
let mut value = self.in_placement(placement, |analysis| {
analysis.expression(expression, input, subqueries)
})?;
self.parameters
.coerce_unknown(&mut value, &ColumnType::BigInteger)?;
let ty = value.ty.as_deref().expect("coerced slice expression");
if !crate::assignment_type_compatible(ty, &ColumnType::BigInteger) {
return Err(error(
"42804",
format!(
"argument of {context} must be type bigint, not type {}",
ty.regtype_name()
),
));
}
if analysis::references_local_column(expression, input) {
return Err(error(
"42P10",
format!("argument of {context} must not contain variables"),
));
}
}
Ok(())
}
}