uqa_sql/schema/table_alteration/

syntax.rs

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

//! Validate ALTER TABLE transaction restrictions and bind native relation-kind actions.
use crate::{
    ast::{AlterTableAction, AlterTableStmt, TableLockMode},
    SQLError,
};

mod views;

pub fn table_alter_lock_mode(statement: &AlterTableStmt) -> TableLockMode {
    let mut mode = TableLockMode::ShareUpdateExclusive;
    for action in &statement.actions {
        match action {
            AlterTableAction::SetTriggerEnableMode { .. }
            | AlterTableAction::AddForeignKeyConstraint { .. } => {
                mode = TableLockMode::ShareRowExclusive;
            }
            AlterTableAction::ValidateConstraint { .. }
            | AlterTableAction::AttachPartition { .. }
            | AlterTableAction::DetachPartition {
                concurrently: true, ..
            }
            | AlterTableAction::DetachPartition { finalize: true, .. } => {}
            _ => return TableLockMode::AccessExclusive,
        }
    }
    mode
}

pub fn validate_alter_table_transaction(
    stmt: &AlterTableStmt,
    in_transaction_block: bool,
) -> Result<(), SQLError> {
    if in_transaction_block
        && stmt.actions.iter().any(|action| {
            matches!(
                action,
                AlterTableAction::DetachPartition {
                    concurrently: true,
                    ..
                }
            )
        })
    {
        return Err(SQLError::Routine {
            sqlstate: "25001".into(),
            message: "ALTER TABLE ... DETACH CONCURRENTLY cannot run inside a transaction block"
                .into(),
        });
    }
    Ok(())
}

pub fn alter_sequence_from_table_syntax(
    canonical: &str,
    stmt: &AlterTableStmt,
) -> Result<crate::ast::AlterSequence, SQLError> {
    let mut alter = crate::ast::AlterSequence {
        name: canonical.to_string(),
        if_exists: stmt.if_exists,
        ..crate::ast::AlterSequence::default()
    };
    match stmt.actions.as_slice() {
        [AlterTableAction::RenameColumn { .. }] => {
            let relation = uqa_core::RelationIdentity::from_legacy_name(canonical)
                .map_err(SQLError::Internal)?;
            return Err(SQLError::Diagnostic {
                sqlstate: "42809".into(),
                message: format!("cannot rename columns of relation \"{}\"", relation.name),
                detail: Some("This operation is not supported for sequences.".into()),
                hint: None,
            });
        }
        [AlterTableAction::SetPersistence { persistence }] => {
            alter.persistence = Some(*persistence);
        }
        [AlterTableAction::RenameTable { to }] => {
            alter.lifecycle = crate::ast::SequenceLifecycle::RenameTo { name: to.clone() };
        }
        [AlterTableAction::SetSchema { schema }] => {
            alter.lifecycle = crate::ast::SequenceLifecycle::SetSchema {
                schema: schema.clone(),
            };
        }
        [AlterTableAction::ChangeOwner { owner }] => {
            alter.role_owner = Some(owner.clone());
        }
        _ => {
            return Err(SQLError::Routine {
                sqlstate: "42809".into(),
                message: format!("ALTER TABLE: relation `{canonical}` is a sequence, not a table"),
            });
        }
    }
    Ok(alter)
}

/// Return a native view owner or name change, or None for a valid sequence of view event renames.
pub fn alter_view_from_table_syntax(
    canonical: &str,
    local_name: &str,
    kind: &str,
    stmt: &AlterTableStmt,
) -> Result<Option<crate::ast::AlterViewStmt>, SQLError> {
    views::validate_actions(local_name, kind, &stmt.actions)?;
    let action = match stmt.actions.as_slice() {
        [AlterTableAction::RenameColumn { from, to }] => {
            Some(crate::ast::AlterViewAction::RenameColumn {
                from: from.clone(),
                to: to.clone(),
            })
        }
        [AlterTableAction::RenameTable { to }] => {
            Some(crate::ast::AlterViewAction::RenameTo(to.clone()))
        }
        [AlterTableAction::ChangeOwner { owner }] => {
            Some(crate::ast::AlterViewAction::OwnerTo(owner.clone()))
        }
        [AlterTableAction::SetSchema { schema }] => {
            Some(crate::ast::AlterViewAction::SetSchema(schema.clone()))
        }
        _ => None,
    };
    if let Some(action) = action {
        return Ok(Some(crate::ast::AlterViewStmt {
            name: canonical.to_string(),
            kind: if kind == "view" {
                crate::ast::AlterViewKind::View
            } else {
                crate::ast::AlterViewKind::MaterializedView
            },
            if_exists: stmt.if_exists,
            action,
        }));
    }
    if kind == "view"
        && stmt.actions.iter().all(|action| {
            matches!(
                action,
                AlterTableAction::RenameRule { .. } | AlterTableAction::RenameTrigger { .. }
            )
        })
    {
        return Ok(None);
    }
    Err(SQLError::Routine {
        sqlstate: "42809".into(),
        message: format!("ALTER TABLE: relation `{canonical}` is a {kind}, not a table"),
    })
}

/// Return native foreign-table column, owner or name changes, or None for valid trigger actions.
pub fn alter_foreign_table_from_table_syntax(
    canonical: &str,
    stmt: &AlterTableStmt,
) -> Result<Option<crate::ast::AlterForeignTableStmt>, SQLError> {
    if stmt.actions.iter().all(|action| {
        matches!(
            action,
            AlterTableAction::RenameTrigger { .. } | AlterTableAction::SetTriggerEnableMode { .. }
        )
    }) {
        return Ok(None);
    }
    let drops = stmt
        .actions
        .iter()
        .map(|action| match action {
            AlterTableAction::DropColumn {
                name,
                if_exists,
                cascade,
            } => Some(crate::ast::DropColumnAction {
                name: name.clone(),
                if_exists: *if_exists,
                cascade: *cascade,
            }),
            _ => None,
        })
        .collect::<Option<Vec<_>>>();
    if let Some(columns) = drops {
        return Ok(Some(crate::ast::AlterForeignTableStmt {
            name: canonical.to_string(),
            if_exists: stmt.if_exists,
            action: crate::ast::AlterForeignTableAction::DropColumns(columns),
        }));
    }
    let action = match stmt.actions.as_slice() {
        [AlterTableAction::ChangeOwner { owner }] => {
            crate::ast::AlterForeignTableAction::OwnerTo(owner.clone())
        }
        [AlterTableAction::RenameTable { to }] => {
            crate::ast::AlterForeignTableAction::RenameTo(to.clone())
        }
        [AlterTableAction::SetSchema { schema }] => {
            crate::ast::AlterForeignTableAction::SetSchema(schema.clone())
        }
        _ => {
            return Err(SQLError::Routine {
                sqlstate: "42809".into(),
                message: format!(
                    "ALTER TABLE: relation `{canonical}` is a foreign table, not a table"
                ),
            });
        }
    };
    Ok(Some(crate::ast::AlterForeignTableStmt {
        name: canonical.to_string(),
        if_exists: stmt.if_exists,
        action,
    }))
}

#[cfg(test)]
mod tests;