glaredb_core 25.6.3

Core functionality for GlareDB
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
134
135
136
137
138
139
140
141
142
143
144
145

pub mod evaluator;
pub mod planner;
pub mod selection_evaluator;

pub mod case_expr;
pub mod cast_expr;
pub mod column_expr;
pub mod conjunction_expr;
pub mod literal_expr;
pub mod scalar_function_expr;

use std::fmt;

use case_expr::PhysicalCaseExpr;
use cast_expr::PhysicalCastExpr;
use column_expr::PhysicalColumnExpr;
use conjunction_expr::PhysicalConjunctionExpr;
use evaluator::ExpressionState;
use glaredb_error::Result;
use literal_expr::PhysicalLiteralExpr;
use scalar_function_expr::PhysicalScalarFunctionExpr;

use crate::arrays::datatype::DataType;
use crate::functions::aggregate::PlannedAggregateFunction;

#[derive(Debug, Clone)]
pub enum PhysicalScalarExpression {
    Case(PhysicalCaseExpr),
    Cast(PhysicalCastExpr),
    Column(PhysicalColumnExpr),
    Conjunction(PhysicalConjunctionExpr),
    Literal(PhysicalLiteralExpr),
    ScalarFunction(PhysicalScalarFunctionExpr),
}

impl From<PhysicalCaseExpr> for PhysicalScalarExpression {
    fn from(value: PhysicalCaseExpr) -> Self {
        PhysicalScalarExpression::Case(value)
    }
}

impl From<PhysicalCastExpr> for PhysicalScalarExpression {
    fn from(value: PhysicalCastExpr) -> Self {
        PhysicalScalarExpression::Cast(value)
    }
}

impl From<PhysicalColumnExpr> for PhysicalScalarExpression {
    fn from(value: PhysicalColumnExpr) -> Self {
        PhysicalScalarExpression::Column(value)
    }
}

impl From<PhysicalConjunctionExpr> for PhysicalScalarExpression {
    fn from(value: PhysicalConjunctionExpr) -> Self {
        PhysicalScalarExpression::Conjunction(value)
    }
}

impl From<PhysicalLiteralExpr> for PhysicalScalarExpression {
    fn from(value: PhysicalLiteralExpr) -> Self {
        PhysicalScalarExpression::Literal(value)
    }
}

impl From<PhysicalScalarFunctionExpr> for PhysicalScalarExpression {
    fn from(value: PhysicalScalarFunctionExpr) -> Self {
        PhysicalScalarExpression::ScalarFunction(value)
    }
}

impl PhysicalScalarExpression {
    pub(crate) fn create_state(&self, batch_size: usize) -> Result<ExpressionState> {
        match self {
            Self::Case(expr) => expr.create_state(batch_size),
            Self::Cast(expr) => expr.create_state(batch_size),
            Self::Column(expr) => expr.create_state(batch_size),
            Self::Conjunction(expr) => expr.create_state(batch_size),
            Self::Literal(expr) => expr.create_state(batch_size),
            Self::ScalarFunction(expr) => expr.create_state(batch_size),
        }
    }

    pub fn datatype(&self) -> DataType {
        match self {
            Self::Case(expr) => expr.datatype(),
            Self::Cast(expr) => expr.datatype(),
            Self::Column(expr) => expr.datatype(),
            Self::Conjunction(expr) => expr.datatype(),
            Self::Literal(expr) => expr.datatype(),
            Self::ScalarFunction(expr) => expr.datatype(),
        }
    }
}

impl fmt::Display for PhysicalScalarExpression {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Case(expr) => expr.fmt(f),
            Self::Cast(expr) => expr.fmt(f),
            Self::Column(expr) => expr.fmt(f),
            Self::Conjunction(expr) => expr.fmt(f),
            Self::Literal(expr) => expr.fmt(f),
            Self::ScalarFunction(expr) => expr.fmt(f),
        }
    }
}

#[derive(Debug, Clone)]
pub struct PhysicalAggregateExpression {
    /// The function we'll be calling to produce the aggregate states.
    pub function: PlannedAggregateFunction,
    /// Column expressions we're aggregating on.
    pub columns: Vec<PhysicalColumnExpr>,
    /// If inputs are distinct.
    pub is_distinct: bool,
    // TODO: Filter
}

impl PhysicalAggregateExpression {
    pub fn new<C>(function: PlannedAggregateFunction, columns: impl IntoIterator<Item = C>) -> Self
    where
        C: Into<PhysicalColumnExpr>,
    {
        PhysicalAggregateExpression {
            function,
            columns: columns.into_iter().map(|c| c.into()).collect(),
            is_distinct: false,
        }
    }

    pub fn contains_column_idx(&self, column: usize) -> bool {
        self.columns.iter().any(|expr| expr.idx == column)
    }
}

#[derive(Debug, Clone)]
pub struct PhysicalSortExpression {
    /// Column this expression is for.
    pub column: PhysicalScalarExpression,
    /// If sort should be descending.
    pub desc: bool,
    /// If nulls should be ordered first.
    pub nulls_first: bool,
}