use crate::mutation::output::MutationOutput;
use crate::mutation::statement::context::{with_mutation_snapshot, MutationStatementContext};
use crate::mutation::{
expressions::eval_mutation_expr,
returning::{
build_returning_value_row, dml_returning_result, DmlReturningShape,
ReturningValueProjectionRow,
},
rows::join_rows as dml_join_rows,
};
use crate::query::{sources::build_join_spill_with_ctes, CteScope};
use crate::{OwnedPhysicalRow, PhysicalRow, RowSchema};
use std::collections::BTreeSet;
use uqa_core::Value;
pub use uqa_sql::semantics::view_mutation::{target_columns, ViewMutationTarget as ViewDmlTarget};
use uqa_sql::semantics::{
mutation_qualifiers::validate_dml_expression_qualifiers,
returning::validate_returning_alias_relations,
};
use uqa_sql::{
plan::{DeletePlan, InsertPlan, UpdatePlan},
SQLError, SQLParam, ScalarExpr,
};
use uqa_storage::document_store::Document;
pub type SourceOutputPruning = fn(
&dyn uqa_sql::semantics::volatility::VolatilityCatalog,
&dyn uqa_sql::routines::RoutineResolution,
uqa_sql::plan::MutableQueryPlan,
&dyn Fn(usize) -> bool,
usize,
&dyn Fn(&str) -> bool,
&uqa_core::memory::ProductionControl<'_>,
) -> Result<uqa_sql::plan::MutableQueryPlan, SQLError>;
mod checks;
mod insert;
mod update_delete;
pub use checks::TriggerViewChecks;
pub use insert::run_view_insert_inner;
pub use update_delete::{run_view_delete_inner, run_view_update_inner};
pub(crate) fn resolve_view_target<S: Clone + 'static>(
context: &MutationStatementContext<'_, S>,
name: &str,
) -> Result<uqa_core::memory::Produced<ViewDmlTarget>, SQLError> {
let retained = context.query.source.ctes.queries.read_control()?;
let control = uqa_core::memory::ProductionControl::new(
retained.memory(),
retained.cancellation(),
context.query.source.ctes.runtime.cancellation,
);
uqa_sql::semantics::view_mutation::resolve_view_target_with_control(
context.mutation.rules.views,
name,
&control,
)
}
pub fn materialize_view_rows<S: Clone + Send + Sync + 'static>(
context: &crate::query::statement::context::QueryContext<'_, S>,
target: &ViewDmlTarget,
params: &[SQLParam],
scope: &mut CteScope<S>,
) -> Result<crate::SharedSpill, SQLError> {
let retained = context.source.ctes.queries.read_control()?;
let control = uqa_core::memory::ProductionControl::new(
retained.memory(),
retained.cancellation(),
context.source.ctes.runtime.cancellation,
);
let privilege_subject = if target.security_invoker {
scope.invoking_role()?.clone_with_control(&control)?
} else {
control.finish(
scope
.catalog_read_view()?
.view_owner_with_control(target.security.role_owner, &control)?,
control.empty_reservation(),
)?
};
let mut privilege_scope =
scope.enter_privilege_subject_with_control(privilege_subject, &control)?;
let result = crate::query::statement::execute_query_plan_output(
context,
&target.query,
params,
&mut privilege_scope,
crate::query::statement::consumer::QueryOutputMode::SharedSpill,
)?;
if result.columns.len() != target.columns.len() {
return Err(SQLError::Internal(format!(
"view `{}` returned {} columns for a {}-column row type",
target.canonical_name,
result.columns.len(),
target.columns.len()
)));
}
let runtime = context.source.relational.runtime;
let mut columns = uqa_core::memory::ProductionVec::new(control);
for column in &target.columns {
columns.push_produced(control.copy_text(column)?)?;
}
let schema = RowSchema::new_with_control(columns.finish()?, &control)?;
let mut rows = crate::SpillBuffer::new(runtime.work_mem_bytes()?);
for row in crate::query::output::PublicQueryRows::new(result, "view mutation input")? {
runtime.check_cancelled()?;
rows.push(crate::Batch::from_physical_rows(
schema.clone(),
vec![PhysicalRow::from_values(row?)],
))
.map_err(crate::physical::physical_exec_error)?;
}
rows.into_shared(schema)
.map_err(crate::physical::physical_exec_error)
}
pub fn target_row(
target: &ViewDmlTarget,
qualifier: &str,
values: &[Value],
) -> Result<OwnedPhysicalRow, SQLError> {
if values.len() != target.columns.len() {
return Err(SQLError::Internal(
"view DML row does not match its declared row type".into(),
));
}
Ok(OwnedPhysicalRow::new(
RowSchema::with_relation_qualifier(&target.schema, qualifier),
PhysicalRow::from_values(values.to_vec()),
))
}
fn view_document(target: &ViewDmlTarget, values: &[Value]) -> Result<Document, SQLError> {
if values.len() != target.columns.len() {
return Err(SQLError::Internal(
"view rule row does not match its declared row type".into(),
));
}
Ok(target
.columns
.iter()
.cloned()
.zip(values.iter().cloned())
.collect())
}
fn finish_view_dml<S: Clone + 'static>(
returning: &crate::mutation::returning::ReturningExecutionContext<'_, S>,
shape: DmlReturningShape<'_, S>,
returning_rows: crate::mutation::returning::ReturningRows,
affected: u64,
) -> Result<MutationOutput, SQLError> {
if shape.returning.is_empty() {
return Ok(MutationOutput::from_affected(affected));
}
dml_returning_result(*returning, shape, returning_rows, affected)
}