use super::{
apply_propagated_view_lock, attach_qualifier_filter,
execute_view_plan_output_with_parent_cache, qualifier_filter, qualifier_for,
qualify_source_operator_with_columns, query_cte_names, query_output_shared,
try_build_streaming_subquery_operator, ColumnPrune, CteScope, PhysicalOperator,
QualifierFilters, SQLError, SQLParam, SourceContext, SourcePlan, Value,
};
use uqa_sql::semantics::sets::placement_scope::SetPlacementScope;
fn table_source_aliases(
source_columns: &[String],
catalog_aliases: &[String],
range_aliases: &[String],
) -> Vec<String> {
let mut aliases = source_columns.to_vec();
for (column, alias) in aliases.iter_mut().zip(catalog_aliases) {
column.clone_from(alias);
}
for (column, alias) in aliases.iter_mut().zip(range_aliases) {
column.clone_from(alias);
}
aliases
}
pub(super) fn output_aliases(catalog_aliases: &[String], range_aliases: &[String]) -> Vec<String> {
let mut aliases = range_aliases.to_vec();
aliases.extend(catalog_aliases.iter().skip(aliases.len()).cloned());
aliases
}
pub(super) fn prune_query_outputs<S: Clone + Send + Sync + 'static>(
context: &SourceContext<'_, S>,
query: &mut uqa_sql::plan::QueryPlan,
aliases: &[String],
projection: &uqa_sql::plan::source_projection::SourceProjection,
params: &[SQLParam],
scope: &CteScope<S>,
outer: Option<&crate::RowSchema>,
) -> Result<(), SQLError> {
let schema = crate::query::binding::bind_query_plan_schema(
context.ctes.routines,
query,
params,
scope,
outer,
)?;
context
.ctes
.rewrites
.prune_query_outputs(query, aliases, projection, &schema, &|name| {
scope.contains_cte_name(name)
})
}
#[expect(
clippy::too_many_lines,
reason = "preserves source schema and row identity"
)]
pub(super) fn build_table_source_operator<'a, S: Clone + Send + Sync + 'static>(
context: &SourceContext<'a, S>,
from: &SourcePlan,
params: &'a [SQLParam],
ctes: &mut CteScope<S>,
prune: Option<&ColumnPrune>,
filters: Option<&QualifierFilters>,
) -> Result<Box<dyn PhysicalOperator + 'a>, SQLError> {
match from {
SourcePlan::Table {
name,
executable_query,
qualifier,
alias,
column_aliases,
bound_columns,
..
} => {
let qualifier = qualifier_for(qualifier, alias.as_deref());
if let Some(materialized) = ctes.materialized_for_scan(name) {
let scan: Box<dyn PhysicalOperator + 'a> = materialized.into_operator();
if let Some(visible) = uqa_sql::semantics::cte_reference_name(name)
.and_then(|name| ctes.recursive_control_width(&name))
{
let operator: Box<dyn PhysicalOperator + 'a> = Box::new(
crate::ColumnSelection::hiding_trailing_columns(scan, visible, &qualifier),
);
let source_columns = operator.schema().to_vec();
let aliases = table_source_aliases(&source_columns, &[], column_aliases);
let operator = qualify_source_operator_with_columns(
operator,
&source_columns,
&qualifier,
prune,
&aliases,
ctes.lock_identities.emit,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
let source_columns = scan.schema().to_vec();
let aliases = table_source_aliases(&source_columns, &[], column_aliases);
let operator = qualify_source_operator_with_columns(
scan,
&source_columns,
&qualifier,
prune,
&aliases,
ctes.lock_identities.emit,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
if let Some((mut plan, mut definition_scope)) = ctes.take_deferred_input(name) {
if let (Some(query), Some(prepared)) =
(plan.body.query_mut(), executable_query.as_deref())
{
*query = prepared.clone();
} else if let (Some(query), Some(projection)) = (
plan.body.query_mut(),
prune.and_then(|prune| prune.get(&qualifier)),
) {
let aliases = output_aliases(&plan.columns, column_aliases);
prune_query_outputs(
context,
query,
&aliases,
projection,
params,
&definition_scope,
definition_scope.row_lock_outer_row().map(|row| &row.schema),
)?;
}
let specialized = plan
.body
.query()
.map(|query| {
super::output_filter::specialize_source_filter(
context,
query,
&qualifier,
&output_aliases(&plan.columns, column_aliases),
filters,
)
})
.transpose()?
.flatten();
let filters = if let Some(specialized) = specialized {
*plan.body.query_mut().expect("query specialization") = specialized;
None
} else {
filters
};
let streamed = {
let mut scoped_ctes = definition_scope.enter_lock_identity_emission(false);
match plan.body.query() {
Some(query)
if scoped_ctes.streams_command_progress()
|| !uqa_sql::semantics::volatility::query_contains_volatile_function(
context.volatility,
query,
)? =>
{
match try_build_streaming_subquery_operator(context, query, params, &mut scoped_ctes)? {
Some(operator) => Some(operator),
None => context.ctes.queries.retained_query(query, params, &scoped_ctes)?,
}
}
_ => None,
}
};
if let Some(operator) = streamed {
let source_columns = operator.schema().to_vec();
let aliases =
table_source_aliases(&source_columns, &plan.columns, column_aliases);
let operator = qualify_source_operator_with_columns(
operator,
&source_columns,
&qualifier,
prune,
&aliases,
false,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
let materialized = if plan.materialization
== uqa_sql::ast::CteMaterialization::NotMaterialized
&& !plan.body.modifies_data()
{
let output = {
let mut scoped_ctes = definition_scope.enter_lock_identity_emission(false);
context.ctes.queries.execute_query(
plan.body.query().ok_or_else(|| {
SQLError::Internal(
"data-modifying CTE entered the folded query path".into(),
)
})?,
params,
&mut scoped_ctes,
)?
};
crate::query::cte::recursive::alias_query_output_to_shared(
context.ctes,
output,
&plan.columns,
)
.map(crate::query::cte::rows::CteRows::Complete)?
} else {
crate::query::cte::materialize_plan_ctes(
context.ctes,
std::slice::from_ref(&plan),
params,
&mut definition_scope,
)?;
let rows = definition_scope
.materialized_for_scan(name)
.ok_or_else(|| {
SQLError::Internal(format!(
"deferred CTE `{name}` did not produce a materialized input"
))
})?;
ctes.insert_rows(plan.name.clone(), rows.clone());
rows
};
let scan: Box<dyn PhysicalOperator + 'a> = materialized.into_operator();
let source_columns = scan.schema().to_vec();
let aliases = table_source_aliases(&source_columns, &[], column_aliases);
let operator = qualify_source_operator_with_columns(
scan,
&source_columns,
&qualifier,
prune,
&aliases,
false,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
let catalog = ctes.catalog_read_view()?;
let resolution = ctes.relation_name_resolution()?;
if let Some(sequence) = catalog.sequence_resolved(&resolution, name)? {
let privilege_subject = ctes.privilege_subject()?;
if !catalog.sequence_is_selectable_to(&sequence.security, privilege_subject) {
return Err(SQLError::Routine {
sqlstate: "42501".into(),
message: format!(
"permission denied for sequence {}",
sequence.relation.name
),
});
}
let columns = vec!["last_value".into(), "log_cnt".into(), "is_called".into()];
let types = vec![
Some(uqa_sql::ast::ColumnType::BigInteger),
Some(uqa_sql::ast::ColumnType::BigInteger),
Some(uqa_sql::ast::ColumnType::Boolean),
];
let rows = vec![std::collections::BTreeMap::from([
("last_value".into(), Value::Int(sequence.state.current)),
("log_cnt".into(), Value::Int(sequence.state.log_count)),
("is_called".into(), Value::Bool(sequence.state.called)),
])];
let scan: Box<dyn PhysicalOperator + 'a> = Box::new(
crate::TableScan::from_typed_rows(columns.clone(), types, rows),
);
let aliases = table_source_aliases(&columns, &[], column_aliases);
let operator = qualify_source_operator_with_columns(
scan, &columns, &qualifier, prune, &aliases, false,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
if let Some(view) = catalog.view_resolved(&resolution, name)?.cloned() {
if view.kind == uqa_sql::catalog::view::StoredViewKind::Materialized {
uqa_sql::catalog::view::require_materialized_view_population(
name,
view.populated,
)?;
let schema = view.definition.materialized_schema()?;
let columns = schema.columns().to_vec();
let rows = view.definition.materialized_rows;
let scan: Box<dyn PhysicalOperator + 'a> =
Box::new(crate::TableScan::from_rows_with_schema(schema, rows));
let aliases = table_source_aliases(&columns, &[], column_aliases);
let operator = qualify_source_operator_with_columns(
scan, &columns, &qualifier, prune, &aliases, false,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
let privilege_subject = if view.security_invoker() {
ctes.privilege_subject()?.clone()
} else {
catalog.view_owner(&view)?
};
let mut privilege_scope = ctes.enter_privilege_subject(privilege_subject);
let ctes: &mut CteScope<S> = &mut privilege_scope;
let _stored = SetPlacementScope::stored_definition();
let plan = executable_query.as_deref().unwrap_or(&view.query);
let output_columns = view.output_columns.as_deref().unwrap_or(&[]);
let inherited_lock = ctes.source_row_lock_for_view(&qualifier, name);
let mut recheck_scope = ctes.enter_recheck_storage_pins(&qualifier);
let ctes: &mut CteScope<S> = &mut recheck_scope;
let specialized_plan = super::output_filter::specialize_source_filter(
context,
plan,
&qualifier,
&output_aliases(output_columns, column_aliases),
filters,
)?;
let filters = if specialized_plan.is_some() {
None
} else {
filters
};
let propagated_plan = inherited_lock.as_ref().map(|target| {
let mut plan = specialized_plan.clone().unwrap_or_else(|| plan.clone());
apply_propagated_view_lock(&mut plan, target);
plan
});
let execution_plan = propagated_plan
.as_ref()
.or(specialized_plan.as_ref())
.unwrap_or(plan);
let mut execution_plan = execution_plan.clone();
if executable_query.is_none() {
crate::query::binding::restore_query_layouts(
context.ctes.routines,
&mut execution_plan,
params,
ctes,
ctes.row_lock_outer_row().map(|row| &row.schema),
)?;
}
if let Some(projection) = prune
.and_then(|prune| prune.get(&qualifier))
.filter(|_| executable_query.is_none())
{
let aliases = output_aliases(output_columns, column_aliases);
prune_query_outputs(
context,
&mut execution_plan,
&aliases,
projection,
params,
ctes,
ctes.row_lock_outer_row().map(|row| &row.schema),
)?;
}
let optimized = if executable_query.is_some() {
execution_plan
} else {
context
.ctes
.rewrites
.optimize_retained_query(&execution_plan)?
};
let execution_plan = &optimized;
let streamed = match try_build_streaming_subquery_operator(
context,
execution_plan,
params,
ctes,
)? {
Some(operator) => Some(operator),
None => context
.ctes
.queries
.retained_query(execution_plan, params, ctes)?,
};
if let Some(operator) = streamed {
let source_columns = operator.schema().to_vec();
let aliases =
table_source_aliases(&source_columns, output_columns, column_aliases);
let operator = qualify_source_operator_with_columns(
operator,
&source_columns,
&qualifier,
prune,
&aliases,
ctes.lock_identities.emit,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
let local_cte_names = query_cte_names(execution_plan);
let is_volatile = uqa_sql::semantics::volatility::query_contains_volatile_function(
context.volatility,
execution_plan,
)?;
let output = if is_volatile || propagated_plan.is_some() {
let mut scoped = ctes.clone();
context
.ctes
.queries
.execute_query(execution_plan, params, &mut scoped)?
} else {
execute_view_plan_output_with_parent_cache(
context,
execution_plan,
params,
ctes,
&local_cte_names,
)?
};
let columns = output.internal_schema.columns().to_vec();
let shared = query_output_shared(output, "view")?;
let scan: Box<dyn PhysicalOperator + 'a> =
Box::new(crate::SharedSpillScan::new(shared));
let aliases = table_source_aliases(&columns, output_columns, column_aliases);
let operator = qualify_source_operator_with_columns(
scan,
&columns,
&qualifier,
prune,
&aliases,
ctes.lock_identities.emit,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
if let Some(schema) =
crate::catalog::schema::virtual_relation_schema(&catalog, &resolution, name)?
{
let (columns, types): (Vec<_>, Vec<_>) = schema
.into_iter()
.map(|(column, ty)| (column, Some(ty)))
.unzip();
let schema = crate::RowSchema::with_types(columns.clone(), types);
let tracks_reads = catalog
.virtual_relation_resolved(&resolution, name)?
.is_none_or(|relation| {
uqa_sql::catalog::SystemRelation::Projected(relation)
.tracks_serializable_reads()
});
let catalog = if tracks_reads {
context.catalog.catalog.bind_query_reads(catalog)?
} else {
catalog
};
let catalog = context.catalog.catalog.retain_catalog_rows(catalog)?;
let projection = context.catalog;
let name = name.clone();
let aliases = table_source_aliases(&columns, &[], column_aliases);
let request = crate::query::source_projection::catalog_request(
&columns, &aliases, &qualifier, prune, filters,
);
let scan: Box<dyn PhysicalOperator + 'a> =
Box::new(crate::query::deferred::DeferredOperator::from_rows(
schema.clone(),
Box::new(move || {
let rows = crate::catalog::projection::build_requested_catalog_rows(
&projection,
&catalog,
&resolution,
projection.session,
&name,
&request,
)?
.ok_or_else(|| {
SQLError::Internal(format!(
"virtual relation `{name}` disappeared from retained catalog"
))
})?;
Ok(Box::new(crate::scan::VecSource::with_row_schema(
schema, rows,
)))
}),
));
let operator = qualify_source_operator_with_columns(
scan,
&columns,
&qualifier,
prune,
&aliases,
ctes.lock_identities.emit,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
if let Some((foreign_name, foreign_table)) =
catalog.foreign_table_entry_resolved(&resolution, name)?
{
let definitions = &catalog.snapshot().definitions;
foreign_table
.bound_server(&definitions.foreign_servers)?
.bound_wrapper(&definitions.foreign_wrappers)?
.require_handler()?;
let rows = context
.scan_foreign_source(&foreign_name, None, &[])
.map_err(SQLError::Unsupported)?;
let schema =
crate::RowSchema::with_column_definitions(None, &foreign_table.columns);
let scan: Box<dyn PhysicalOperator + 'a> =
Box::new(crate::RowIteratorScan::with_row_schema(
schema,
Box::new(rows.map(|row| {
row.map_err(SQLError::Unsupported)
.map_err(crate::ExecError::from)
})),
));
let scan = crate::query::source_projection::bound_source_operator(
scan,
bound_columns.as_deref(),
)?;
let columns = scan.schema().to_vec();
let aliases = table_source_aliases(&columns, &[], column_aliases);
let operator = qualify_source_operator_with_columns(
scan,
&columns,
&qualifier,
prune,
&aliases,
ctes.lock_identities.emit,
);
return Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
));
}
if let Some(predicate) =
qualifier_filter(filters, &qualifier).filter(uqa_sql::semantics::contains_retrieval)
{
return crate::query::table_sources::hierarchy::build_hierarchy_retrieval_operator(
context.retrieval,
from,
&qualifier,
&predicate,
params,
ctes,
prune,
);
}
let Some((operator, filter_pushed)) =
crate::query::table_sources::scan::try_streaming_local_table_scan(
context.scans,
from,
ctes,
prune,
filters,
params,
)?
else {
return Err(SQLError::UnknownTable(name.clone()));
};
if filter_pushed {
Ok(operator)
} else {
Ok(attach_qualifier_filter(
operator, &qualifier, filters, context, params, ctes,
))
}
}
_ => unreachable!("table source builder called for a different source kind"),
}
}