kip-sql 0.0.1-alpha.8

build the SQL layer of KipDB database
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

use crate::expression::ScalarExpression;
use crate::optimizer::core::pattern::Pattern;
use crate::optimizer::core::rule::Rule;
use crate::optimizer::heuristic::graph::{HepGraph, HepNodeId};
use crate::optimizer::rule::column_pruning::ColumnPruning;
use crate::optimizer::rule::combine_operators::{CollapseProject, CombineFilter};
use crate::optimizer::rule::pushdown_limit::{
    EliminateLimits, LimitProjectTranspose, PushLimitIntoScan, PushLimitThroughJoin,
};
use crate::optimizer::rule::pushdown_predicates::PushPredicateIntoScan;
use crate::optimizer::rule::pushdown_predicates::PushPredicateThroughJoin;
use crate::optimizer::rule::simplification::ConstantCalculation;
use crate::optimizer::rule::simplification::SimplifyFilter;
use crate::optimizer::OptimizerError;

mod column_pruning;
mod combine_operators;
mod pushdown_limit;
mod pushdown_predicates;
mod simplification;

#[derive(Debug, Copy, Clone)]
pub enum RuleImpl {
    ColumnPruning,
    // Combine operators
    CollapseProject,
    CombineFilter,
    // PushDown limit
    LimitProjectTranspose,
    EliminateLimits,
    PushLimitThroughJoin,
    PushLimitIntoTableScan,
    // PushDown predicates
    PushPredicateThroughJoin,
    // Tips: need to be used with `SimplifyFilter`
    PushPredicateIntoScan,
    // Simplification
    SimplifyFilter,
    ConstantCalculation,
}

impl Rule for RuleImpl {
    fn pattern(&self) -> &Pattern {
        match self {
            RuleImpl::ColumnPruning => ColumnPruning.pattern(),
            RuleImpl::CollapseProject => CollapseProject.pattern(),
            RuleImpl::CombineFilter => CombineFilter.pattern(),
            RuleImpl::LimitProjectTranspose => LimitProjectTranspose.pattern(),
            RuleImpl::EliminateLimits => EliminateLimits.pattern(),
            RuleImpl::PushLimitThroughJoin => PushLimitThroughJoin.pattern(),
            RuleImpl::PushLimitIntoTableScan => PushLimitIntoScan.pattern(),
            RuleImpl::PushPredicateThroughJoin => PushPredicateThroughJoin.pattern(),
            RuleImpl::PushPredicateIntoScan => PushPredicateIntoScan.pattern(),
            RuleImpl::SimplifyFilter => SimplifyFilter.pattern(),
            RuleImpl::ConstantCalculation => ConstantCalculation.pattern(),
        }
    }

    fn apply(&self, node_id: HepNodeId, graph: &mut HepGraph) -> Result<(), OptimizerError> {
        match self {
            RuleImpl::ColumnPruning => ColumnPruning.apply(node_id, graph),
            RuleImpl::CollapseProject => CollapseProject.apply(node_id, graph),
            RuleImpl::CombineFilter => CombineFilter.apply(node_id, graph),
            RuleImpl::LimitProjectTranspose => LimitProjectTranspose.apply(node_id, graph),
            RuleImpl::EliminateLimits => EliminateLimits.apply(node_id, graph),
            RuleImpl::PushLimitThroughJoin => PushLimitThroughJoin.apply(node_id, graph),
            RuleImpl::PushLimitIntoTableScan => PushLimitIntoScan.apply(node_id, graph),
            RuleImpl::PushPredicateThroughJoin => PushPredicateThroughJoin.apply(node_id, graph),
            RuleImpl::SimplifyFilter => SimplifyFilter.apply(node_id, graph),
            RuleImpl::PushPredicateIntoScan => PushPredicateIntoScan.apply(node_id, graph),
            RuleImpl::ConstantCalculation => ConstantCalculation.apply(node_id, graph),
        }
    }
}

/// Return true when left is subset of right
pub fn is_subset_exprs(left: &[ScalarExpression], right: &[ScalarExpression]) -> bool {
    left.iter().all(|l| right.contains(l))
}