uqa-execution 0.5.0

Volcano physical operators with row-batch pipelines
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Retain added-column defaults in the same per-row evaluation queue as type transforms.

use super::super::{backfill::ColumnBackfillContext, rows::RewriteDeferral};
use std::cell::RefCell;
use uqa_core::Value;
use uqa_sql::{ast::Expr, SQLError};

pub enum AddedValue {
    Constant(Value),
    Expression(Expr),
}

pub struct AddedColumnValue {
    pub table: String,
    pub column: String,
    pub value: AddedValue,
}

#[derive(Default)]
pub struct AddedColumnRows {
    pub deferral: RewriteDeferral,
    pending: RefCell<Vec<AddedColumnValue>>,
}

impl AddedColumnRows {
    pub fn retain(
        &self,
        context: &ColumnBackfillContext<'_>,
        table: &str,
        column: &str,
        expression: Option<Expr>,
    ) -> Result<(), SQLError> {
        let value = match expression {
            Some(expression)
                if uqa_sql::semantics::volatility::expr_contains_volatile_function(
                    context.volatility,
                    &uqa_sql::plan::ExpressionPlan::lower(expression.clone()).scalar,
                ) =>
            {
                AddedValue::Expression(expression)
            }
            expression => AddedValue::Constant(context.evaluate_default(
                table,
                column,
                expression.as_ref(),
            )?),
        };
        self.pending.borrow_mut().push(AddedColumnValue {
            table: table.to_string(),
            column: column.to_string(),
            value,
        });
        Ok(())
    }

    pub fn take(&self) -> Vec<AddedColumnValue> {
        std::mem::take(&mut *self.pending.borrow_mut())
    }
}

impl AddedColumnValue {
    pub fn evaluate(&self, context: &ColumnBackfillContext<'_>) -> Result<Value, SQLError> {
        match &self.value {
            AddedValue::Constant(value) => Ok(value.clone()),
            AddedValue::Expression(expression) => {
                context.evaluate_default(&self.table, &self.column, Some(expression))
            }
        }
    }
}