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
71
72
73
74
75
76
77
78
79
80
81
82

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

//! Upgrade foreign identities inside the caller-owned initial catalog transaction.
use crate::catalog::foreign::StoredForeignTable;
use uqa_core::RelationIdentity;
use uqa_storage::{CatalogFacade, StorageBackendError, StorageBackendResult};

pub fn migrate_foreign_table_identities(
    catalog: &dyn CatalogFacade,
    roles: &std::collections::BTreeMap<String, uqa_sql::catalog::roles::RoleDefinition>,
) -> StorageBackendResult<()> {
    let attribute_format =
        crate::schema::constraints::restoration::require_attribute_format(catalog, true)?;
    let reference_format = crate::catalog::foreign::reference::check_format(catalog)?;
    for mut row in catalog.load_foreign_tables()? {
        let (mut table, legacy_schema) =
            StoredForeignTable::from_catalog_row(&row, reference_format)?;
        if attribute_format == crate::schema::constraints::restoration::AttributeFormat::Numbered {
            uqa_sql::catalog::relation_attributes::validate(
                &table.columns,
                &table.dropped_attributes,
            )
            .map_err(|error| StorageBackendError::backend("foreign relation attributes", error))?;
        }
        let mut changed = legacy_schema;
        if table.object_id == [0; 16] {
            table.object_id =
                crate::catalog::identity::new_nonzero_catalog_identity("table", "object identity")?;
            changed = true;
        }
        let mut constraints = uqa_sql::ast::TableConstraintSet {
            checks: std::mem::take(&mut table.checks),
            dropped_attributes: table.dropped_attributes.clone(),
            ..uqa_sql::ast::TableConstraintSet::default()
        };
        changed |=
            materialize_constraint_metadata(&row.relation, &mut table.columns, &mut constraints)?;
        table.checks = constraints.checks;
        let column_names = table
            .columns
            .iter()
            .map(|column| column.name.clone())
            .collect::<Vec<_>>();
        let security = crate::catalog::security::relation_restoration::restore_security(
            &row.security,
            Some(&column_names),
            roles,
            true,
        )?;
        changed |=
            crate::schema::sequences::migration::materialize_persisted_foreign_implicit_sequences(
                catalog,
                &row.relation,
                security.role_owner,
                table.object_id,
                &mut table.columns,
            )?;
        if changed {
            row.columns_json = table.schema_json()?;
            catalog.save_foreign_table(&row)?;
        }
    }
    Ok(())
}

fn materialize_constraint_metadata(
    relation: &RelationIdentity,
    columns: &mut [uqa_sql::ast::ColumnDef],
    constraints: &mut uqa_sql::ast::TableConstraintSet,
) -> StorageBackendResult<bool> {
    uqa_sql::schema::constraint_metadata::materialize_constraint_metadata(
        relation,
        columns,
        constraints,
        &mut crate::catalog::identity::allocate_catalog_object_id,
    )
    .map_err(|error| StorageBackendError::Other(error.to_string()))
}