uqa-execution 0.5.3

Volcano physical operators with row-batch pipelines
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

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

//! Minimal immutable catalog and routine fixtures for execution unit tests.

use super::{
    CatalogDefinitionSnapshot, CatalogReadSnapshot, CatalogReadView, CatalogTableSnapshot,
};
use std::{collections::BTreeMap, sync::Arc};
use uqa_sql::{ast::FunctionBinding, ColumnType, SQLError};

mod services;
pub(crate) use services::CatalogServices;

pub(crate) fn table_snapshot(
    object_id: [u8; 16],
    columns: Vec<uqa_sql::ast::ColumnDef>,
    constraints: uqa_sql::ast::TableConstraintSet,
) -> CatalogTableSnapshot {
    CatalogTableSnapshot {
        dropped_attributes: constraints.dropped_attributes.into(),
        object_id,
        catalog_oids: constraints.catalog_oids.unwrap_or_else(|| {
            uqa_sql::catalog::relation_oids::RelationCatalogOids::legacy(
                uqa_sql::catalog::relation_oids::RelationOidKind::Table,
                &object_id,
            )
        }),
        row_type_array_name: constraints.row_type_array_name,
        security: Arc::new(super::security::BoundTableSecurity::owner(
            uqa_sql::catalog::roles::RoleIdentity::BOOTSTRAP,
        )),
        columns: columns.into(),
        columns_declared: true,
        checks: constraints.checks.into(),
        foreign_keys: constraints.foreign_keys.into(),
        keys: constraints.key_constraints.into(),
        hierarchy: constraints.hierarchy.into(),
        persistence: constraints.persistence,
    }
}

pub(crate) fn empty_catalog() -> CatalogReadView {
    CatalogReadView::new(CatalogReadSnapshot {
        tables: BTreeMap::default(),
        definitions: CatalogDefinitionSnapshot {
            builtin_routine_security: Arc::default(),
            foreign_wrappers: Arc::default(),
            foreign_servers: Arc::default(),
            sequence_persistence: Arc::default(),
            foreign_tables: Arc::default(),
            sql_user_functions: Arc::default(),
            role_memberships: Arc::default(),
            domains: Arc::default(),
            enums: Arc::default(),
            composites: Arc::default(),
            graphs: Arc::default(),
            views: Arc::default(),
            catalog_indexes: Arc::default(),
            database_security: crate::catalog::security::BoundDatabaseSecurity::bootstrap().into(),
            schemas: Arc::default(),
            sequences: Arc::default(),
            sequence_object_ids: Arc::default(),
            sequence_catalog_oids: Arc::default(),
            graph_catalog_oids: Arc::default(),
            sequence_security: Arc::default(),
            foreign_table_security: Arc::default(),
            system_relation_security: Arc::default(),
            roles: Arc::default(),
            triggers: Arc::default(),
            rules: Arc::default(),
        },
        temporary_namespace: None,
    })
}

pub(crate) struct NoRoutines;

impl uqa_sql::FunctionTypeResolver for NoRoutines {
    fn resolve_function_type(
        &self,
        _: &str,
        _: Option<&FunctionBinding>,
        _: &[Option<String>],
        _: &[Option<ColumnType>],
        _: bool,
    ) -> Result<Option<ColumnType>, SQLError> {
        Ok(None)
    }
}
impl uqa_sql::routines::RoutineResolution for NoRoutines {}

impl uqa_sql::semantics::volatility::VolatilityCatalog for NoRoutines {
    fn host_function_volatility(&self, _: &str) -> Option<uqa_sql::ast::FunctionVolatility> {
        None
    }

    fn routine_volatilities(
        &self,
        _: &str,
        _: Option<&FunctionBinding>,
    ) -> Option<Vec<uqa_sql::ast::FunctionVolatility>> {
        None
    }

    fn view_query(&self, _: &str) -> Result<Option<uqa_sql::plan::QueryPlan>, SQLError> {
        Ok(None)
    }
}

pub(crate) fn empty_scope() -> crate::query::CteScope {
    crate::query::CteScope::with_catalog(
        empty_catalog(),
        uqa_sql::catalog::resolution::RelationNameResolution {
            search_path: vec!["public".into()],
            temporary_schema: "pg_temp_1".into(),
            temporary_namespace_allocated: false,
            current_user: "owner".into(),
            lookup_mode: uqa_sql::catalog::resolution::RelationLookupMode::Dynamic,
        },
        None,
    )
}