icydb-core 0.188.2

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
Documentation 
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::db::{
    query::plan::{
        expr::{Alias, Expr, ProjectionField, ProjectionSpec},
        lower_global_aggregate_projection,
    },
    sql::{
        lowering::{
            SqlLoweringError,
            aggregate::{
                projection::remap::GlobalAggregateTerminalInterner,
                terminal::LoweredSqlGlobalAggregateTerminal,
            },
            expr::SqlExprPhase,
            select::lower_analyzed_select_item_expr,
        },
        parser::{SqlExpr, SqlProjection},
    },
};

///
/// LoweredSqlGlobalAggregateTerminals
///
/// Canonical global aggregate lowering result that keeps only unique
/// executable terminals plus the canonical projection spec that preserves
/// original SQL projection order.
///
pub(in crate::db::sql::lowering::aggregate) struct LoweredSqlGlobalAggregateTerminals {
    terminal_interner: GlobalAggregateTerminalInterner,
    pub(in crate::db::sql::lowering::aggregate) projection: ProjectionSpec,
    output_order_targets: Vec<SqlExpr>,
    #[cfg(test)]
    pub(in crate::db::sql::lowering::aggregate) output_remap: Vec<usize>,
}

pub(in crate::db::sql::lowering::aggregate) struct LoweredSqlGlobalAggregateTerminalParts {
    pub(in crate::db::sql::lowering::aggregate) terminals: Vec<LoweredSqlGlobalAggregateTerminal>,
    pub(in crate::db::sql::lowering::aggregate) projection: ProjectionSpec,
    #[cfg(test)]
    pub(in crate::db::sql::lowering::aggregate) output_remap: Vec<usize>,
}

impl LoweredSqlGlobalAggregateTerminals {
    /// Lower one SQL projection into unique executable aggregate terminals plus
    /// the output remap needed to preserve original projection order.
    pub(in crate::db::sql::lowering::aggregate) fn from_projection(
        projection: SqlProjection,
        projection_aliases: &[Option<String>],
    ) -> Result<Self, SqlLoweringError> {
        let SqlProjection::Items(items) = projection else {
            return Err(SqlLoweringError::unsupported_global_aggregate_projection());
        };
        if items.is_empty() {
            return Err(SqlLoweringError::unsupported_global_aggregate_projection());
        }

        let mut terminal_interner = GlobalAggregateTerminalInterner::with_capacity(items.len());
        let mut output_order_targets = Vec::<SqlExpr>::with_capacity(items.len());
        #[cfg(test)]
        let mut output_remap = Vec::<usize>::with_capacity(items.len());
        let mut fields = Vec::<ProjectionField>::with_capacity(items.len());
        #[cfg(test)]
        let mut saw_wrapped_projection = false;

        for (index, item) in items.into_iter().enumerate() {
            let analyzed =
                lower_analyzed_select_item_expr(&item, SqlExprPhase::PostAggregate, None)?;
            let analysis = analyzed.analysis();
            if !analysis.contains_aggregate() || analysis.references_direct_fields() {
                return Err(SqlLoweringError::unsupported_global_aggregate_projection());
            }
            output_order_targets.push(SqlExpr::from_select_item(&item));
            if let Some(alias) = projection_aliases.get(index).and_then(Option::as_deref) {
                output_order_targets.push(SqlExpr::Field(Alias::new(alias).as_str().to_string()));
            }

            let direct_terminal_index = terminal_interner.collect_from_analysis(
                analysis.aggregate_refs(),
                matches!(analyzed.expr(), Expr::Aggregate(_)),
            )?;
            #[cfg(test)]
            match direct_terminal_index {
                Some(unique_index) => output_remap.push(unique_index),
                None => {
                    saw_wrapped_projection = true;
                }
            }
            #[cfg(not(test))]
            let _ = direct_terminal_index;

            fields.push(ProjectionField::Scalar {
                expr: analyzed.into_expr(),
                alias: projection_aliases
                    .get(index)
                    .and_then(Option::as_deref)
                    .map(Alias::new),
            });
        }

        Ok(Self {
            terminal_interner,
            projection: lower_global_aggregate_projection(fields),
            output_order_targets,
            #[cfg(test)]
            output_remap: if saw_wrapped_projection {
                Vec::new()
            } else {
                output_remap
            },
        })
    }

    pub(in crate::db::sql::lowering::aggregate) const fn output_order_targets(&self) -> &[SqlExpr] {
        self.output_order_targets.as_slice()
    }

    pub(in crate::db::sql::lowering::aggregate) fn intern_having_terminal_index(
        &mut self,
        aggregate_expr: &crate::db::query::builder::AggregateExpr,
    ) -> Result<usize, SqlLoweringError> {
        self.terminal_interner.intern(aggregate_expr)
    }

    pub(in crate::db::sql::lowering::aggregate) fn into_parts(
        self,
    ) -> LoweredSqlGlobalAggregateTerminalParts {
        LoweredSqlGlobalAggregateTerminalParts {
            terminals: self.terminal_interner.into_terminals(),
            projection: self.projection,
            #[cfg(test)]
            output_remap: self.output_remap,
        }
    }
}