use crate::catalog::{CatalogReadView, RelationNameResolution};
use std::{
collections::{BTreeMap, BTreeSet},
sync::Arc,
};
use uqa_core::RelationIdentity;
use uqa_sql::{
ast::{ColumnDef, RuleEvent, TriggerEvent, TriggerTiming},
binding::snapshot::BindingSnapshot,
catalog::{
events::{selection, StoredRule},
view::{StoredViewKind, ViewRewriteDefinition},
},
semantics::view_rewrite::context::ViewRewriteCatalog,
SQLError,
};
pub struct RetainedViewCatalog<'a> {
pub catalog: &'a CatalogReadView,
pub resolution: &'a RelationNameResolution,
pub fallback: &'a dyn ViewRewriteCatalog,
pub replica: bool,
pub control: uqa_core::memory::OwnedProductionControl,
}
impl RetainedViewCatalog<'_> {
fn relation_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<uqa_core::memory::Produced<RelationIdentity>, SQLError> {
let resolved =
self.catalog
.relation_kind_resolution_with_control(self.resolution, name, control)?;
let crate::catalog::RelationResolution::Found(canonical, _) = &*resolved else {
return Err(SQLError::UnknownTable(
control.copy_text(name)?.into_parts().0,
));
};
let reference = RelationIdentity::try_borrowed_reference(canonical).map_err(|error| {
control
.format(format_args!("{error}"))
.map(|text| SQLError::Internal(text.into_parts().0))
.unwrap_or_else(Into::into)
})?;
Ok(reference.identity_with_control(uqa_core::RelationName::decoded("public"), control)?)
}
fn relation(&self, name: &str) -> Result<RelationIdentity, SQLError> {
let (name, _) = self
.catalog
.relation_kind_resolution(self.resolution, name)?
.into_found()
.ok_or_else(|| SQLError::UnknownTable(name.into()))?;
RelationIdentity::from_legacy_name(&name).map_err(SQLError::Internal)
}
}
impl ViewRewriteCatalog for RetainedViewCatalog<'_> {
fn capture_rules(
&self,
name: &str,
event: RuleEvent,
) -> Result<selection::CapturedRules, SQLError> {
self.capture_rules_with_control(name, event, &self.control.control())
}
fn capture_rules_with_control(
&self,
name: &str,
event: RuleEvent,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<selection::CapturedRules, SQLError> {
let relation = self.relation_with_control(name, control)?;
selection::CapturedRules::from_catalog(
Arc::clone(&self.catalog.snapshot().definitions.rules),
relation,
event,
self.replica,
control,
)
}
fn try_table_column_names_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<uqa_core::memory::Produced<Vec<String>>, SQLError> {
if let Some(columns) = self.try_relation_column_names_with_control(name, control)? {
return Ok(columns);
}
self.fallback
.try_table_column_names_with_control(name, control)
}
fn try_relation_column_names_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<uqa_core::memory::Produced<Vec<String>>>, SQLError> {
control.check()?;
let columns = if let Some(table) =
self.catalog
.table_resolved_with_control(self.resolution, name, control)?
{
table.columns.as_slice()
} else if let Some(table) =
self.catalog
.foreign_table_resolved_with_control(self.resolution, name, control)?
{
table.columns.as_slice()
} else {
return Ok(None);
};
if columns.is_empty() {
return self
.fallback
.try_table_column_names_with_control(name, control)
.map(Some);
}
let mut output = uqa_core::memory::ProductionVec::new(*control);
for column in columns {
output.push_produced(control.copy_text(&column.name)?)?;
}
Ok(Some(output.finish()?))
}
fn with_view_definition_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
read: &mut dyn FnMut(
Option<uqa_sql::catalog::view::ViewRewriteDefinitionRef<'_>>,
) -> Result<(), SQLError>,
) -> Result<(), SQLError> {
read(
self.catalog
.view_resolved_with_control(self.resolution, name, control)?
.map(|view| view.rewrite_definition_ref()),
)
}
fn try_resolve_view_name_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<uqa_core::memory::Produced<String>>, SQLError> {
self.catalog
.view_name_resolved_with_control(self.resolution, name, control)
}
fn visit_rules_with_control(
&self,
name: &str,
event: RuleEvent,
reverse: bool,
control: &uqa_core::memory::ProductionControl<'_>,
visit: &mut dyn FnMut(&StoredRule) -> Result<(), SQLError>,
) -> Result<(), SQLError> {
let relation = self.relation_with_control(name, control)?;
selection::visit_active_rules_with_control(
&self.catalog.snapshot().definitions.rules,
&relation,
event,
self.replica,
reverse,
control,
visit,
)
}
fn has_trigger_definition_with_control(
&self,
name: &str,
timing: TriggerTiming,
event: TriggerEvent,
row: bool,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<bool, SQLError> {
selection::has_trigger_definition_with_control(
&self.catalog.snapshot().definitions.triggers,
&*self.relation_with_control(name, control)?,
timing,
event,
row,
control,
)
}
fn rule_new_row_columns_with_control(
&self,
rule: &StoredRule,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<uqa_core::memory::Produced<Vec<String>>>, SQLError> {
self.fallback
.rule_new_row_columns_with_control(rule, control)
}
fn target_view_kind_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<StoredViewKind>, SQLError> {
Ok(self
.catalog
.view_resolved_with_control(self.resolution, name, control)?
.map(|view| view.kind))
}
fn binding_scope_with_control(
&self,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<uqa_sql::binding::production::ControlledBindingSnapshot, SQLError> {
let scope = self.restored_view_scope_with_control(control)?;
Ok(uqa_sql::binding::production::ControlledBindingSnapshot {
catalog: scope.catalog,
resolution: scope.resolution,
ctes: scope.ctes,
deferred_ctes: scope.deferred_ctes,
non_returning_ctes: scope.non_returning_ctes,
scalar_subqueries: uqa_sql::plan::RetainedQueryArena::default(),
})
}
fn restored_view_scope_with_control(
&self,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<uqa_sql::binding::production::ControlledBindingContext<'static>, SQLError> {
use uqa_sql::binding::production::{
BindingMap, BindingNameSet, BindingResolution, ControlledBindingContext,
};
let catalog = control
.finish(self.catalog.clone(), control.empty_reservation())?
.into_shared(control)?;
Ok(ControlledBindingContext {
catalog,
resolution: BindingResolution::from_produced(
self.resolution.copy_with_control(control)?,
),
ctes: BindingMap::new(),
deferred_ctes: BindingMap::new(),
non_returning_ctes: BindingNameSet::new(),
scalar_subqueries: &[],
})
}
fn view_definition(&self, name: &str) -> Result<Option<ViewRewriteDefinition>, SQLError> {
Ok(self
.catalog
.view_resolved(self.resolution, name)?
.map(super::StoredView::rewrite_definition))
}
fn try_resolve_view_name(&self, name: &str) -> Result<Option<String>, String> {
self.catalog
.view_name_resolved(self.resolution, name)
.map_err(|error| error.to_string())
}
fn try_describe_table(&self, name: &str) -> Result<Option<Vec<ColumnDef>>, String> {
if let Some(table) = self
.catalog
.table_resolved(self.resolution, name)
.map_err(|error| error.to_string())?
{
return Ok(Some(table.columns.as_ref().clone()));
}
Ok(self
.catalog
.foreign_table_resolved(self.resolution, name)
.map_err(|error| error.to_string())?
.map(|table| table.columns.clone()))
}
fn try_table_columns(&self, name: &str) -> Result<Vec<String>, String> {
let columns = self.try_describe_table(name)?.unwrap_or_default();
if columns.is_empty() {
return self.fallback.try_table_columns(name);
}
Ok(columns.into_iter().map(|column| column.name).collect())
}
fn rules_for(&self, name: &str, event: RuleEvent) -> Result<Vec<StoredRule>, SQLError> {
Ok(selection::active_rules(
&self.catalog.snapshot().definitions.rules,
&self.relation(name)?,
event,
self.replica,
))
}
fn rule_definitions_for(
&self,
name: &str,
event: RuleEvent,
) -> Result<Vec<StoredRule>, SQLError> {
Ok(selection::rule_definitions(
&self.catalog.snapshot().definitions.rules,
&self.relation(name)?,
event,
))
}
fn has_trigger_definition(
&self,
name: &str,
timing: TriggerTiming,
event: TriggerEvent,
row: bool,
) -> Result<bool, SQLError> {
Ok(selection::has_trigger_definition(
&self.catalog.snapshot().definitions.triggers,
&self.relation(name)?,
timing,
event,
row,
))
}
fn rule_new_row_columns(
&self,
rule: &StoredRule,
) -> Result<Option<BTreeSet<String>>, SQLError> {
self.fallback.rule_new_row_columns(rule)
}
fn target_view_kind(&self, name: &str) -> Result<Option<StoredViewKind>, SQLError> {
Ok(self
.catalog
.view_resolved(self.resolution, name)?
.map(|view| view.kind))
}
fn binding_scope(&self) -> Result<BindingSnapshot, SQLError> {
Ok(BindingSnapshot {
catalog: Arc::new(self.catalog.clone()),
resolution: self.resolution.clone(),
ctes: BTreeMap::new(),
deferred_ctes: BTreeMap::new(),
non_returning_ctes: BTreeSet::new(),
scalar_subqueries: uqa_sql::plan::RetainedQueryArena::default(),
})
}
fn restored_view_catalog(
&self,
) -> (
uqa_sql::catalog::analysis::CatalogReadView,
RelationNameResolution,
) {
(Arc::new(self.catalog.clone()), self.resolution.clone())
}
}