linkrs-query 0.1.0

Query engine, parser, and executor for Linkrs
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

//! Heuristic Optimization Module
//!
//! This module contains all the heuristic optimization rules, which are applied directly during the plan generation phase.
//! These rules do not rely on cost calculations; they always generate better or equivalent plans.
//!
//! # Module Structure
//!
//! ## Core Components
//!
//! - `context`: Rewrite context definition
//! - `pattern`: Pattern matching definitions
//! - `result`: Rewrite result types
//! - `rule`: Rewrite rule trait definitions
//! - `macros`: Macro definitions for rewriting rules
//! - `rewrite_rule`: Rewrite rule trait and adapters
//! - `plan_rewriter`: Plan rewriter implementation
//! - `visitor`: Node visitor for tree traversal
//!
//! ## Rule Categories
//!
//! ### Predicate Pushdown Rules
//! Push filtering conditions to the lowest level of the planning tree to reduce data processing volume.
//!
//! ### Projection Pushdown Rules
//! Push projection operations down to reduce data transfer between operators.
//!
//! ### Merge Rules
//! Merge multiple consecutive operations of the same type to reduce intermediate results.
//!
//! ### Elimination Rules
//! Remove redundant operations:
//! - `EliminateFilterRule`: Remove tautological filters
//! - `RemoveNoopProjectRule`: Remove no-operation projections
//! - `DedupEliminationRule`: Remove unnecessary deduplication
//! - `EliminateSortRule`: Remove redundant sorting
//!
//! ### Limit Pushdown Rules
//! Push LIMIT/TOPN operations down to reduce result set size early.
//!
//! ### Aggregate Optimization Rules
//! Optimize aggregate operations.
//!
//! # Relationship with Cost-Based Optimization
//!
//! The rules in this module are **heuristic rules** that do not rely on cost calculations and are always executed.
//! Cost-based optimization is implemented in the `cost_based` module, which includes:
//! - `SortEliminationOptimizer`: Decides whether to convert Sort+Limit to TopN based on cost
//! - `AggregateStrategySelector`: Selects optimal aggregation strategy
//! - `JoinOrderOptimizer`: Optimizes join order using dynamic programming
//! - `TraversalDirectionOptimizer`: Selects optimal traversal direction
//! - `SubqueryUnnestingOptimizer`: Transforms correlated subqueries
//!
//! Heuristic rules are executed first, followed by cost-based optimization.
//!
//! # Usage Examples
//!
//! Heuristic rules are applied through the batch optimizer:
//!
//! ```rust,ignore
//! use crate::optimizer::heuristic::batch::BatchOptimizer;
//! use crate::optimizer::heuristic::rule_enum::RuleRegistry;
//!
//! let batch = BatchOptimizer::from_registry(RuleRegistry::default());
//! let optimized_root = batch.optimize(root)?;
//! ```

// Core Type Modules (New)
pub mod context;
pub mod expression_utils;
pub mod pattern;
pub mod result;
pub mod rule;
pub mod visitor;

// Macro module
pub mod macros;

// Core trait and implementation
pub mod plan_rewriter;
pub mod rewrite_rule;

// Enumeration of static distribution rules
pub mod rule_enum;

// Batch optimizer (phased rule application with diagnostics)
pub mod batch;
// Logical heuristic optimizer (operates on LogicalNodeEnum)
pub mod logical_batch;
pub mod logical_rule;
// Physical heuristic optimizer (operates on PlanNodeEnum, post-mapping)
pub mod physical_heuristic;

// Specific Rules Module
pub mod aggregate;
pub mod constant_folding;
pub mod decorrelation;
pub mod elimination;
pub mod expand_pushdown;
pub mod join_optimization;
pub mod limit_pushdown;
pub mod merge;
pub mod predicate_pushdown;
pub mod projection_pushdown;
pub mod scan_edge_identity;
pub mod scan_identity;
pub mod slot_coverage;

// ==================== Exporting Core Types =====================

// Export from the new independent module.
pub use context::RewriteContext;
pub use pattern::{
    MatchNode, NodeVisitor, NodeVisitorFinder, NodeVisitorRecorder, Pattern, PlanNodeMatcher,
};
pub use result::{MatchedResult, RewriteError, RewriteResult, TransformResult};
pub use rule::{
    BaseRewriteRule, EliminationRule, IntoRuleWrapper, MergeRule, PushDownRule, RewriteRule,
    RuleWrapper,
};
pub use visitor::ChildRewriteVisitor;

// Export from the compatibility layer
pub use rewrite_rule::{HeuristicRule, HeuristicRuleAdapter, IntoOptRule};

pub use plan_rewriter::NodeRewriter;

// Export the logical heuristic optimizer.
pub use logical_batch::{LogicalBatchOptimizer, LogicalOptimizationResult};
pub use logical_rule::{LogicalRule, LogicalRuleContext};
pub use physical_heuristic::PhysicalHeuristicOptimizer;

// Export the enumeration of static distribution rules.
pub use rule_enum::{RewriteRule as RewriteRuleEnum, RuleRegistry};

// Export all rewriting rules in a unified manner.
pub use aggregate::*;
pub use decorrelation::*;
pub use elimination::*;
pub use expand_pushdown::*;
pub use join_optimization::*;
pub use limit_pushdown::*;
pub use merge::*;
pub use predicate_pushdown::*;
pub use projection_pushdown::*;
pub use slot_coverage::*;