Skip to main content

uqa_execution/mutation/
views.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Physical row projection through automatically updatable view layers.
8use super::rows::context::{MutationExpressionContext, MutationRowContext};
9use crate::{query::CteScope, OwnedPhysicalRow, PhysicalRow};
10use std::collections::BTreeSet;
11use uqa_core::{DocId, Value};
12use uqa_sql::{semantics::view_rewrite::context::ViewRewriteContext, RowSchema, SQLError};
13use uqa_storage::document_store::Document;
14
15#[derive(Clone)]
16pub struct ViewRowContext<'a, S: Clone + 'static> {
17    pub rewrite: ViewRewriteContext<'a>,
18    pub volatility: &'a dyn uqa_sql::semantics::volatility::VolatilityCatalog,
19    pub rows: MutationRowContext<'a>,
20    pub expressions: MutationExpressionContext<'a, S>,
21}
22impl<S: Clone + 'static> Copy for ViewRowContext<'_, S> {}
23
24mod projection;
25pub use projection::automatic_view_rule_expressions;
26
27pub struct AutomaticViewRuleDocument<'a, S: Clone + 'static> {
28    pub context: ViewRowContext<'a, S>,
29    pub view: &'a str,
30    pub document_relation: Option<&'a str>,
31    pub storage_table: Option<&'a str>,
32    pub doc_id: Option<DocId>,
33    pub document: &'a Document,
34    pub required_columns: &'a BTreeSet<String>,
35    pub params: &'a [uqa_sql::SQLParam],
36    pub scope: &'a CteScope<S>,
37}
38
39pub fn automatic_view_rule_document<S: Clone + 'static>(
40    request: AutomaticViewRuleDocument<'_, S>,
41) -> Result<Document, SQLError> {
42    let context = request.context;
43    let params = request.params;
44    let scope = request.scope;
45    let projected = automatic_view_rule_expressions(request)?;
46    projected
47        .expressions
48        .into_iter()
49        .map(|(name, expression)| {
50            crate::query::catalog_expression::eval_stored_expression_plan_with_row(
51                context.expressions.expressions,
52                scope.clone(),
53                &expression,
54                &projected.source.schema,
55                &projected.source.row,
56                params,
57            )
58            .map(|value| (name, value))
59        })
60        .collect()
61}
62
63pub fn stored_view_document_row(
64    context: MutationRowContext<'_>,
65    view: &str,
66    qualifier: &str,
67    document: &Document,
68) -> Result<OwnedPhysicalRow, SQLError> {
69    let schema = context.relations.view_schema(view)?;
70    let columns = schema
71        .columns()
72        .iter()
73        .enumerate()
74        .map(|(position, column)| schema.public_name(position).unwrap_or(column).to_string())
75        .collect::<Vec<_>>();
76    let types = schema.column_types().to_vec();
77    let values = columns
78        .iter()
79        .map(|column| document.get(column).cloned().unwrap_or(Value::Null))
80        .collect();
81    Ok(OwnedPhysicalRow::new(
82        RowSchema::with_qualified_types(qualifier, columns, types),
83        PhysicalRow::from_values(values),
84    ))
85}
86
87pub mod commands;