fosk 0.1.13

In-memory SQL-like query engine and lightweight data store for testing and prototyping.
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

use crate::{
    parser::ast::{Column, JoinType, OrderBy, Predicate}, planner::aggregate_call::AggregateCall
};

#[derive(Debug, Clone)]
pub enum LogicalPlan {
    /// Scan a single collection (backing table) with a visible name (alias or table name).
    Scan {
        backing: String,   // backing collection (table) name
        visible: String,   // visible name (alias or table)
    },

    Join {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        join_type: JoinType,
        on: Predicate,                       // already qualified + folded
    },

    /// Row-level filter (WHERE or HAVING depending on position in the tree).
    Filter {
        input: Box<LogicalPlan>,
        predicate: crate::parser::ast::Predicate,
    },

    /// Group-by aggregation.
    Aggregate {
        input: Box<LogicalPlan>,
        group_keys: Vec<Column>,            // qualified
        aggs: Vec<AggregateCall>,           // aggregate calls we’ll compute
    },

    /// Projection in SELECT order (qualified & folded).
    Project {
        input: Box<LogicalPlan>,
        exprs: Vec<crate::parser::analyzer::AnalyzedIdentifier>,
    },

    /// Stable sort with NULLS LAST policy (enforced in executor).
    Sort {
        input: Box<LogicalPlan>,
        keys: Vec<OrderBy>,                 // qualified & folded
    },

    /// LIMIT / OFFSET
    Limit {
        input: Box<LogicalPlan>,
        limit: Option<i64>,
        offset: Option<i64>,
    },
}