uqa-execution 0.5.0

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

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

//! `DROP FUNCTION` and `DROP PROCEDURE`: the named routines and what depends on them, removed as the catalog's dependencies order them.

pub mod context;
mod publication;

pub use context::RoutineRemovalContext;
pub use publication::commit_routine_registry_drop;

use uqa_sql::{ast::DropFunctionStmt, routines::lifecycle::binding as analysis_binding, SQLError};

pub fn drop_sql_functions(
    context: &RoutineRemovalContext<'_>,
    statement: &DropFunctionStmt,
) -> Result<(), SQLError> {
    let kind = if statement.is_procedure {
        "procedure"
    } else {
        "function"
    };
    let registry = context.registry.routine_snapshot();
    let current_user = context.catalog.current_role();
    let resolution = analysis_binding::resolve_sql_function_drop_targets(
        context.names,
        context.bodies.compilation.analysis.types,
        statement,
        &registry,
        kind,
        |function, item| {
            let roles = context.roles.role_definitions();
            let memberships = context.roles.role_memberships();
            analysis_binding::ensure_routine_drop_owner(
                context.names,
                function,
                &item.name,
                kind,
                &current_user,
                &roles,
                &memberships,
            )
        },
    )?;
    drop(registry);
    for notice in resolution.notices {
        context.notices.routine_drop_notice(notice);
    }
    let targets = resolution.targets;
    crate::schema::deletion::perform_deletion(
        &context.deletion.catalog_removal_context(),
        |dependencies| {
            targets
                .iter()
                .map(|target| {
                    crate::schema::deletion::required_address(
                        target
                            .object_id
                            .and_then(|object_id| dependencies.routine_address(&object_id)),
                        || format!("{} {}", target.kind(), target.name),
                    )
                })
                .collect()
        },
        statement.cascade,
    )
}