dbx-core 0.2.2

High-performance file-based database engine with 5-Tier Hybrid Storage
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

//! Rule 1: Predicate Pushdown
//!
//! Filter를 Scan에 가까이 이동하여 I/O 감소

use crate::error::DbxResult;
use crate::sql::planner::{BinaryOperator, Expr, LogicalPlan};

use super::OptimizationRule;

/// Filter를 Scan에 가까이 이동하여 I/O 감소
pub struct PredicatePushdownRule;

impl OptimizationRule for PredicatePushdownRule {
    fn name(&self) -> &str {
        "PredicatePushdown"
    }

    fn apply(&self, plan: LogicalPlan) -> DbxResult<LogicalPlan> {
        self.push_down(plan)
    }
}

impl PredicatePushdownRule {
    fn push_down(&self, plan: LogicalPlan) -> DbxResult<LogicalPlan> {
        match plan {
            LogicalPlan::Filter { input, predicate } => {
                let optimized_input = self.push_down(*input)?;
                match optimized_input {
                    LogicalPlan::Project {
                        input: project_input,
                        projections: columns,
                    } if self.can_push_through_project(&predicate, &columns) => {
                        let pushed = self.push_down(LogicalPlan::Filter {
                            input: project_input,
                            predicate,
                        })?;
                        Ok(LogicalPlan::Project {
                            input: Box::new(pushed),
                            projections: columns,
                        })
                    }
                    LogicalPlan::Scan {
                        table,
                        columns,
                        filter: None,
                        ros_files,
                    } => Ok(LogicalPlan::Scan {
                        table,
                        columns,
                        filter: Some(predicate),
                        ros_files,
                    }),
                    LogicalPlan::Scan {
                        table,
                        columns,
                        filter: Some(existing),
                        ros_files,
                    } => Ok(LogicalPlan::Scan {
                        table,
                        columns,
                        filter: Some(Expr::BinaryOp {
                            left: Box::new(existing),
                            op: BinaryOperator::And,
                            right: Box::new(predicate),
                        }),
                        ros_files,
                    }),
                    other => Ok(LogicalPlan::Filter {
                        input: Box::new(other),
                        predicate,
                    }),
                }
            }
            LogicalPlan::Project { input, projections } => Ok(LogicalPlan::Project {
                input: Box::new(self.push_down(*input)?),
                projections,
            }),
            LogicalPlan::Sort { input, order_by } => Ok(LogicalPlan::Sort {
                input: Box::new(self.push_down(*input)?),
                order_by,
            }),
            LogicalPlan::Limit {
                input,
                count,
                offset,
            } => Ok(LogicalPlan::Limit {
                input: Box::new(self.push_down(*input)?),
                count,
                offset,
            }),
            LogicalPlan::Aggregate {
                input,
                group_by,
                aggregates,
                mode,
            } => Ok(LogicalPlan::Aggregate {
                input: Box::new(self.push_down(*input)?),
                group_by,
                aggregates,
                mode,
            }),
            other => Ok(other),
        }
    }

    /// Check if a predicate references only columns available before projection.
    fn can_push_through_project(
        &self,
        predicate: &Expr,
        _projections: &[(Expr, Option<String>)],
    ) -> bool {
        self.is_simple_column_predicate(predicate)
    }

    fn is_simple_column_predicate(&self, expr: &Expr) -> bool {
        match expr {
            Expr::Column(_) | Expr::Literal(_) => true,
            Expr::BinaryOp { left, right, .. } => {
                self.is_simple_column_predicate(left) && self.is_simple_column_predicate(right)
            }
            Expr::IsNull(inner) | Expr::IsNotNull(inner) => self.is_simple_column_predicate(inner),
            _ => false,
        }
    }
}