reifydb_evaluate/expression/
context.rs1use std::sync::LazyLock;
5
6use reifydb_core::{
7 interface::{catalog::property::ColumnSaturationStrategy, evaluate::TargetColumn},
8 value::column::{cast::convert::TargetConvert, columns::Columns},
9};
10use reifydb_routine_abi::registry::Routines;
11use reifydb_runtime::context::{RuntimeContext, clock::Clock};
12use reifydb_value::{params::Params, value::identity::IdentityId};
13
14use crate::stack::SymbolTable;
15
16pub struct EvalContext<'a> {
17 pub target: Option<TargetColumn>,
18 pub columns: Columns,
19 pub row_count: usize,
20 pub take: Option<usize>,
21 pub params: &'a Params,
22 pub symbols: &'a SymbolTable,
23 pub is_aggregate_context: bool,
24 pub routines: &'a Routines,
25 pub runtime_context: &'a RuntimeContext,
26 pub identity: IdentityId,
27}
28
29impl<'a> EvalContext<'a> {
30 pub fn testing() -> EvalContext<'static> {
31 static EMPTY_PARAMS: LazyLock<Params> = LazyLock::new(|| Params::None);
32 static EMPTY_SYMBOL_TABLE: LazyLock<SymbolTable> = LazyLock::new(SymbolTable::new);
33 static EMPTY_ROUTINES: LazyLock<Routines> = LazyLock::new(Routines::empty);
34 static DEFAULT_RUNTIME_CONTEXT: LazyLock<RuntimeContext> =
35 LazyLock::new(|| RuntimeContext::with_clock(Clock::Real));
36
37 EvalContext {
38 target: None,
39 columns: Columns::empty(),
40 row_count: 1,
41 take: None,
42 params: &EMPTY_PARAMS,
43 symbols: &EMPTY_SYMBOL_TABLE,
44 is_aggregate_context: false,
45 routines: &EMPTY_ROUTINES,
46 runtime_context: &DEFAULT_RUNTIME_CONTEXT,
47 identity: IdentityId::root(),
48 }
49 }
50
51 pub fn with_eval(&self, columns: Columns, row_count: usize) -> EvalContext<'a> {
52 EvalContext {
53 target: None,
54 columns,
55 row_count,
56 take: None,
57 params: self.params,
58 symbols: self.symbols,
59 is_aggregate_context: self.is_aggregate_context,
60 routines: self.routines,
61 runtime_context: self.runtime_context,
62 identity: self.identity,
63 }
64 }
65
66 pub fn with_eval_empty(&self) -> EvalContext<'a> {
67 self.with_eval(Columns::empty(), 1)
68 }
69
70 pub fn with_eval_join(&self, columns: Columns) -> EvalContext<'a> {
71 let mut ctx = self.with_eval(columns, 1);
72 ctx.take = Some(1);
73 ctx
74 }
75
76 pub(crate) fn saturation_policy(&self) -> ColumnSaturationStrategy {
77 TargetConvert {
78 target: self.target.as_ref(),
79 }
80 .saturation_policy()
81 }
82}
83
84pub struct CompileContext<'a> {
85 pub symbols: &'a SymbolTable,
86}