uqa-engine 0.3.0

Engine: schema-aware table store, catalog restore, transactions
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

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Capture statement metadata for planner-owned predicate placement.

use crate::{capabilities::query_scope::CteScope, Engine};
use std::collections::BTreeMap;
use uqa_planner::filter_pushdown::context::{FilterPushdownContext, FilterPushdownScope};
use uqa_sql::{
    plan::{
        source_projection::{ColumnPrune, QualifierFilters},
        QueryBlockPlan, QueryPlan, SourcePlan,
    },
    SQLError, ScalarExpr,
};

fn with_context<T>(engine: &Engine, action: impl FnOnce(FilterPushdownContext<'_>) -> T) -> T {
    let catalog = engine.catalog_read_view();
    let resolution = engine.session_execution_view().relation_name_resolution();
    action(FilterPushdownContext {
        volatility: engine,
        correlation: uqa_sql::binding::correlation::CorrelationContext {
            catalog: &catalog,
            resolution: &resolution,
        },
        optimizer: &|plan| {
            crate::capabilities::statement_planning::optimize_engine_plan(engine, plan)
        },
    })
}
fn with_scope<T>(
    ctes: &CteScope,
    action: impl FnOnce(FilterPushdownScope<'_>) -> Result<T, SQLError>,
) -> Result<T, SQLError> {
    let catalog = ctes.catalog_read_view()?;
    let resolution = ctes.relation_name_resolution()?;
    action(FilterPushdownScope {
        catalog: &catalog,
        resolution: &resolution,
        is_visible_cte: &|name| ctes.is_visible_cte(name),
    })
}

pub(crate) fn qualifier_filters_for_stmt(
    engine: &Engine,
    stmt: &QueryBlockPlan,
    from: &SourcePlan,
    ctes: &CteScope,
) -> Result<Option<QualifierFilters>, SQLError> {
    with_context(engine, |context| {
        with_scope(ctes, |scope| {
            uqa_planner::filter_pushdown::qualifier_filters_for_stmt(context, stmt, from, scope)
        })
    })
}

pub(crate) fn final_filter_after_qualifier_pushdown(
    engine: &Engine,
    stmt: &QueryBlockPlan,
    from: &SourcePlan,
    filters: Option<&QualifierFilters>,
    ctes: &CteScope,
) -> Result<Option<ScalarExpr>, SQLError> {
    with_context(engine, |context| {
        with_scope(ctes, |scope| {
            uqa_planner::filter_pushdown::final_filter_after_qualifier_pushdown(
                context, stmt, from, filters, scope,
            )
        })
    })
}

pub(crate) fn cte_output_filters(
    engine: &Engine,
    plan: &QueryPlan,
    ctes: &CteScope,
) -> Result<BTreeMap<String, (String, ScalarExpr)>, SQLError> {
    with_context(engine, |context| {
        with_scope(ctes, |scope| {
            uqa_planner::filter_pushdown::cte_output_filters(context, plan, scope)
        })
    })
}

pub(crate) fn push_output_filter_into_query_plan(
    engine: &Engine,
    plan: &QueryPlan,
    qualifier: &str,
    filter: &ScalarExpr,
    output_columns_override: Option<&[String]>,
) -> Result<Option<QueryPlan>, SQLError> {
    with_context(engine, |context| {
        uqa_planner::filter_pushdown::push_output_filter_into_query_plan(
            context,
            plan,
            qualifier,
            filter,
            output_columns_override,
        )
    })
}

pub(crate) fn column_prune_for_stmt(
    engine: &Engine,
    stmt: &QueryBlockPlan,
    from: &SourcePlan,
    ctes: &CteScope,
) -> Result<Option<ColumnPrune>, SQLError> {
    column_prune_for_stmt_with_filter(engine, stmt, from, stmt.r#where.as_ref(), ctes)
}

pub(crate) fn column_prune_for_stmt_with_filter(
    engine: &Engine,
    stmt: &QueryBlockPlan,
    from: &SourcePlan,
    filter: Option<&ScalarExpr>,
    ctes: &CteScope,
) -> Result<Option<ColumnPrune>, SQLError> {
    let catalog = ctes.catalog_read_view()?;
    let resolution = ctes.relation_name_resolution()?;
    uqa_planner::column_pruning::column_prune_for_stmt_with_filter(
        uqa_planner::column_pruning::ColumnPruneContext {
            catalog: &catalog,
            resolution: &resolution,
            volatility: engine,
            is_visible_cte: &|name| ctes.is_visible_cte(name),
        },
        stmt,
        from,
        filter,
    )
}