Skip to main content

uqa_execution/mutation/rules/
returning.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Physical capture and outer projection of a rule action's RETURNING rows.
8use crate::{
9    mutation::{
10        returning::{
11            build_returning_value_row, dml_returning_result, DmlReturningShape,
12            ReturningExecutionContext, ReturningValueProjectionRow,
13        },
14        row_images::RuleRowImage,
15    },
16    OwnedPhysicalRow,
17};
18use uqa_core::Value;
19use uqa_sql::{SQLError, SQLResult};
20pub struct RuleReturningResult {
21    current: Vec<Vec<Value>>,
22    old: Vec<Vec<Value>>,
23    new: Vec<Vec<Value>>,
24    contexts: Vec<Option<OwnedPhysicalRow>>,
25    affected_rows: u64,
26}
27
28impl RuleReturningResult {
29    pub fn empty() -> Self {
30        Self {
31            current: Vec::new(),
32            old: Vec::new(),
33            new: Vec::new(),
34            contexts: Vec::new(),
35            affected_rows: 0,
36        }
37    }
38
39    pub fn project<S: Clone + 'static>(
40        self,
41        context: ReturningExecutionContext<'_, S>,
42        shape: DmlReturningShape<'_, S>,
43    ) -> Result<SQLResult, SQLError> {
44        if self.current.len() != self.old.len()
45            || self.current.len() != self.new.len()
46            || self.current.len() != self.contexts.len()
47        {
48            return Err(SQLError::Internal(
49                "rewrite-rule RETURNING images and source contexts have different cardinalities"
50                    .into(),
51            ));
52        }
53        let mut rows = Vec::with_capacity(self.current.len());
54        for index in 0..self.current.len() {
55            rows.push(build_returning_value_row(
56                context,
57                ReturningValueProjectionRow {
58                    table: shape.table,
59                    target_qualifier: shape.target_qualifier,
60                    current: &self.current[index],
61                    old: Some(&self.old[index]),
62                    new: Some(&self.new[index]),
63                    aliases: shape.aliases,
64                    context: self.contexts[index].as_ref(),
65                },
66                shape.returning,
67                shape.params,
68                shape.ctes,
69            )?);
70        }
71        dml_returning_result(context, shape, rows, self.affected_rows)
72    }
73}
74
75pub fn capture_rule_returning_result(
76    assignment: &dyn uqa_sql::assignment::AssignmentContext,
77    result: SQLResult,
78    columns: &[uqa_sql::ast::ColumnDef],
79    source_rows: Option<&[RuleRowImage]>,
80) -> Result<RuleReturningResult, SQLError> {
81    let width = columns.len();
82    let image_width = width.saturating_mul(3);
83    let expected_width = image_width + usize::from(source_rows.is_some());
84    if result.columns.len() != expected_width {
85        return Err(SQLError::Internal(format!(
86            "rewrite-rule RETURNING provider produced {} columns, expected {}",
87            result.columns.len(),
88            expected_width
89        )));
90    }
91    let extract = |row: usize, offset: usize| {
92        columns
93            .iter()
94            .enumerate()
95            .map(|(position, column)| {
96                let value = result
97                    .value_at(row, offset + position)
98                    .cloned()
99                    .ok_or_else(|| {
100                        SQLError::Internal(
101                            "rewrite-rule RETURNING provider lost a positional value".into(),
102                        )
103                    })?;
104                uqa_sql::assignment::conversion::coerce_assignment_value(
105                    assignment,
106                    value,
107                    &column.ty,
108                    result
109                        .column_types
110                        .get(offset + position)
111                        .and_then(Option::as_ref),
112                )
113            })
114            .collect::<Result<Vec<_>, SQLError>>()
115    };
116    let mut current = Vec::with_capacity(result.rows.len());
117    let mut old = Vec::with_capacity(result.rows.len());
118    let mut new = Vec::with_capacity(result.rows.len());
119    let mut contexts = Vec::with_capacity(result.rows.len());
120    for row in 0..result.rows.len() {
121        current.push(extract(row, 0)?);
122        old.push(extract(row, width)?);
123        new.push(extract(row, width * 2)?);
124        let context = source_rows
125            .map(|source_rows| {
126                let source_index = match result.value_at(row, image_width) {
127                    Some(Value::Int(index)) if *index >= 0 => usize::try_from(*index).map_err(|_| {
128                        SQLError::Internal(
129                            "rewrite-rule RETURNING source index exceeds usize".into(),
130                        )
131                    })?,
132                    Some(value) => {
133                        return Err(SQLError::Internal(format!(
134                            "rewrite-rule RETURNING source index is not a non-negative integer: {value:?}"
135                        )))
136                    }
137                    None => {
138                        return Err(SQLError::Internal(
139                            "rewrite-rule RETURNING provider lost its source index".into(),
140                        ))
141                    }
142                };
143                source_rows
144                    .get(source_index)
145                    .map(|source| source.context.clone())
146                    .ok_or_else(|| {
147                        SQLError::Internal(
148                            "rewrite-rule RETURNING source index is outside the event row set"
149                                .into(),
150                        )
151                    })
152            })
153            .transpose()?
154            .flatten();
155        contexts.push(context);
156    }
157    Ok(RuleReturningResult {
158        current,
159        old,
160        new,
161        contexts,
162        affected_rows: result.affected_rows,
163    })
164}