iridium_core 0.1.0

SQL Server-compatible Rust engine core for Iridium SQL
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

use crate::ast::Expr;

use crate::executor::aggregates::is_aggregate_function;
use crate::executor::projection::{expand_projection_columns, resolve_projected_order_index};
use crate::executor::query::plan::RelationalQuery;
use crate::executor::window::has_window_function;

#[derive(Debug, Clone)]
pub(crate) struct PipelineState {
    pub(crate) has_aggregate: bool,
    pub(crate) has_window: bool,
    pub(crate) needs_pre_sort: bool,
}

impl PipelineState {
    pub(crate) fn new(query: &RelationalQuery) -> Self {
        let has_aggregate = query
            .projection
            .items
            .iter()
            .any(|item| matches!(&item.expr, Expr::FunctionCall { name, .. } if is_aggregate_function(name)));

        let has_window = query
            .projection
            .items
            .iter()
            .any(|item| has_window_function(&item.expr));

        let projection_columns: Vec<String> = query
            .projection
            .items
            .iter()
            .flat_map(|item| expand_projection_columns(std::slice::from_ref(item), None))
            .collect();

        let needs_pre_sort = requires_pre_sort(query, &projection_columns, has_aggregate);

        Self {
            has_aggregate,
            has_window,
            needs_pre_sort,
        }
    }
}

fn requires_pre_sort(
    query: &RelationalQuery,
    projection_columns: &[String],
    has_aggregate: bool,
) -> bool {
    !query.sort.order_by.is_empty()
        && !has_aggregate
        && query
            .sort
            .order_by
            .iter()
            .any(|ob| resolve_projected_order_index(projection_columns, ob).is_none())
}