uqa-execution 0.4.5

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

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

//! Retain the requested ALTER TABLE name until relation locking has selected its current target.

use crate::{
    catalog::security::table_inquiry::TablePrivilegeContext,
    row_locks::binding::{
        bind_relation_with_mode, RelationBinding, RelationDefinitionSession, RelationLockCatalog,
    },
    schema::{
        namespaces::relations::RelationCreationContext,
        relation_alteration::validate_relation_alter_authority,
    },
};
use uqa_sql::{
    ast::{AlterTableAction, AlterTableStmt},
    schema::{
        relation_alteration::RelationAlterNames,
        table_alteration::{
            syntax::table_alter_lock_mode,
            targets::{self, BoundTableAlteration},
        },
    },
    SQLError,
};

pub struct TableAlterBindingContext<'a> {
    pub names: &'a dyn RelationAlterNames,
    pub catalog: &'a dyn RelationLockCatalog,
    pub authority: TablePrivilegeContext<'a>,
    pub creation: RelationCreationContext<'a>,
    pub locks: &'a dyn RelationDefinitionSession,
    pub notices: &'a parking_lot::Mutex<Vec<(String, String)>>,
}

pub fn bind_table_alteration(
    context: &TableAlterBindingContext<'_>,
    statement: AlterTableStmt,
) -> Result<Option<BoundTableAlteration>, SQLError> {
    bind_alteration(context, statement, false)
}

pub(super) fn bind_alteration(
    context: &TableAlterBindingContext<'_>,
    statement: AlterTableStmt,
    index_rename: bool,
) -> Result<Option<BoundTableAlteration>, SQLError> {
    let binding = bind_relation_with_mode(
        context.locks,
        |binding: &RelationBinding<uqa_sql::schema::relation_alteration::RelationAlterTarget>| {
            if index_rename && binding.value.kind == "index" {
                crate::row_locks::RelationLockMode::ShareUpdateExclusive
            } else {
                table_alter_lock_mode(&statement).into()
            }
        },
        false,
        || {
            let Some(target) = targets::table_alter_target(
                context.names.resolve_relation_kind(&statement.table)?,
                &statement,
                &mut |message| {
                    context
                        .notices
                        .lock()
                        .push(("NOTICE".into(), message.into()));
                },
            )?
            else {
                return Ok(None);
            };
            Ok(Some(RelationBinding {
                object_id: context.catalog.relation_object_id(&target.canonical)?,
                name: target.canonical.clone(),
                value: target,
            }))
        },
        |binding| {
            let target = &binding.value;
            validate_relation_alter_authority(
                &context.authority,
                &context.creation,
                &target.relation,
                target.kind,
                matches!(
                    statement.actions.as_slice(),
                    [AlterTableAction::RenameTable { .. }]
                ),
            )
        },
    )?;
    binding
        .map(|binding| targets::bind_table_alteration(binding.value, statement))
        .transpose()
}