safe-migrate 0.8.0

use crate::_internal::analysis::expr_ir::ExprIr;
use crate::_internal::ast::identifiers::{Ident, QualifiedName};

#[derive(Clone, Debug, PartialEq)]
pub enum PersistenceFact {
    Permanent,
    Temporary,
    Unlogged,
}

#[derive(Clone, Debug, PartialEq)]
pub enum PolicyCommand {
    All,
    Select,
    Insert,
    Update,
    Delete,
}

#[derive(Clone, Debug, PartialEq)]
pub enum SearchPathTarget {
    Default,
    Schemas(Vec<String>),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TimeoutSetting {
    Lock,
    Statement,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TimeoutSettingValue {
    Default,
    Milliseconds(u64),
    Current,
    Invalid(String),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ResetSettingTarget {
    All,
    SearchPath,
    LockTimeout,
    StatementTimeout,
}

#[derive(Clone, Debug, PartialEq)]
pub enum TypeCreationKind {
    Enum { variants: Vec<String> },
    Range,
    Composite,
    Base,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterViewAction {
    RenameTo {
        new_name: Ident,
    },
    OwnerTo {
        new_owner: RoleFact,
    },
    SetSchema {
        new_schema: String,
    },
    SetDefault {
        column: String,
        default: Option<ExprIr>,
    },
    DropDefault {
        column: String,
    },
    RenameColumn {
        from: Ident,
        to: Ident,
    },
    SetOptions {
        options: Vec<String>,
    },
    ResetOptions {
        options: Vec<String>,
    },
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterSchemaActionFact {
    RenameTo { new_name: Ident },
    OwnerTo { new_owner: RoleFact },
}

#[derive(Clone, Debug, PartialEq)]
pub enum StatementFact {
    CreateSchema {
        name: QualifiedName,
        if_not_exists: bool,
        authorization: Option<RoleFact>,
    },
    AlterSchema {
        name: QualifiedName,
        action: AlterSchemaActionFact,
    },
    DropSchema {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    CreateTable {
        name: QualifiedName,
        if_not_exists: bool,
        as_select: bool,
        persistence: PersistenceFact,
        columns: Vec<ColumnFact>,
        foreign_keys: Vec<FkFact>,
        table_constraints: Vec<TableConstraintFact>,
        partition_by: Option<String>,
        partition_of: Option<QualifiedName>,
        partition_type: Option<String>,
    },
    CreateView {
        name: QualifiedName,
        or_replace: bool,
        depends_on: Vec<QualifiedName>,
    },
    AlterView {
        name: QualifiedName,
        action: AlterViewAction,
    },
    CreateMaterializedView {
        name: QualifiedName,
        depends_on: Vec<QualifiedName>,
    },
    AlterMaterializedView {
        name: QualifiedName,
        new_name: Option<Ident>,
    },
    RefreshMaterializedView {
        name: QualifiedName,
        concurrently: bool,
    },
    CreateIndex {
        name: QualifiedName,
        relation: QualifiedName,
        if_not_exists: bool,
        concurrently: bool,
        using_method: Option<String>,
        has_predicate: bool,
        unique: bool,
        key_columns: Vec<String>,
        included_columns: Vec<String>,
        has_expression_keys: bool,
        has_default_sort_order: bool,
        has_default_opclasses: bool,
        has_default_collations: bool,
    },
    CreatePolicy {
        name: String,
        table: QualifiedName,
        permissive: bool,
        command: PolicyCommand,
        /// False when roles or policy expressions are present but not modeled.
        semantics_complete: bool,
    },
    DropPolicy {
        name: String,
        table: QualifiedName,
        if_exists: bool,
    },
    CreateTrigger {
        name: String,
        table: QualifiedName,
        function: Option<QualifiedName>,
    },
    DropTrigger {
        name: String,
        table: QualifiedName,
        if_exists: bool,
    },
    AlterTrigger {
        name: String,
        table: QualifiedName,
        new_name: String,
    },
    AlterTable {
        name: QualifiedName,
        actions: Vec<AlterTableActionFact>,
    },
    AlterIndex {
        name: QualifiedName,
        actions: Vec<AlterIndexActionFact>,
    },
    CreateType(CreateTypeFact),
    AlterType(AlterTypeFact),
    CreateDomain {
        name: QualifiedName,
        base_type: String,
    },
    AlterDomain {
        name: QualifiedName,
        action: Option<AlterDomainActionFact>,
    },
    DropDomain {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    DropType {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    CreateSequence {
        name: QualifiedName,
        if_not_exists: bool,
        owned_by: Option<(QualifiedName, String)>,
    },
    AlterSequence {
        name: QualifiedName,
        if_exists: bool,
        action: AlterSequenceActionFact,
    },
    DropSequence {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    DropTable {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    DropView {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    DropMaterializedView {
        names: Vec<QualifiedName>,
        if_exists: bool,
        cascade: bool,
    },
    DropIndex {
        names: Vec<QualifiedName>,
        if_exists: bool,
        concurrently: bool,
        cascade: bool,
    },
    SetSearchPath {
        target: SearchPathTarget,
        local: bool,
    },
    SetTimeout {
        setting: TimeoutSetting,
        value: TimeoutSettingValue,
        local: bool,
    },
    ResetSettings {
        target: ResetSettingTarget,
    },
    BeginTransaction,
    CommitTransaction,
    CommitAndChain,
    RollbackTransaction,
    RollbackAndChain,
    RollbackToSavepoint {
        name: String,
    },
    Savepoint {
        name: String,
    },
    ReleaseSavepoint {
        name: String,
    },
    PrepareTransaction {
        name: String,
    },
    SetTransaction,
    SetConstraints,
    OpaqueBlock,
    Execute,
    /// Parsed SQL that changes PostgreSQL metadata but no schema state modeled
    /// by safe-migrate, such as `COMMENT ON`.
    SchemaNeutralNoop,
    Vacuum {
        relation: Option<QualifiedName>,
        is_full: bool,
    },
    CreateFunction(CreateFunctionFact),
    AlterFunction(AlterFunctionFact),
    DropFunction(DropFunctionFact),
    CreateProcedure(CreateProcedureFact),
    AlterProcedure(AlterProcedureFact),
    DropProcedure(DropProcedureFact),
    CreateAggregate(CreateAggregateFact),
    AlterAggregate(AlterAggregateFact),
    DropAggregate(DropAggregateFact),
    CreatePublication(CreatePublicationFact),
    AlterPublication(AlterPublicationFact),
    DropPublication(DropPublicationFact),
    CreateSubscription(CreateSubscriptionFact),
    AlterSubscription(AlterSubscriptionFact),
    DropSubscription(DropSubscriptionFact),
    CreateRole(CreateRoleFact),
    AlterRole(AlterRoleFact),
    DropRole(DropRoleFact),
    Grant(GrantFact),
    Revoke(RevokeFact),
    CreateDatabase(CreateDatabaseFact),
    AlterDatabase(AlterDatabaseFact),
    DropDatabase(DropDatabaseFact),
    /// `SET [LOCAL] ROLE { rolename | NONE }` or
    /// `SET [LOCAL] SESSION AUTHORIZATION { rolename | DEFAULT }`.
    /// `role = None` means NONE / DEFAULT (restore the session default).
    /// `local = true` means the change is scoped to the current transaction.
    /// `is_session_auth = true` means SET SESSION AUTHORIZATION (which also
    /// updates the session-level default, unlike plain SET ROLE).
    SetRole {
        role: Option<RoleFact>,
        local: bool,
        is_session_auth: bool,
    },
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterSequenceActionFact {
    OwnedBy(Option<(QualifiedName, String)>),
    OwnerTo(RoleFact),
    RenameTo(Ident),
    SetSchema(String),
    Other,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterIndexActionFact {
    RenameTo { new_name: Ident },
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateTypeFact {
    pub name: QualifiedName,
    pub kind: TypeCreationKind,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterTypeFact {
    pub name: QualifiedName,
    pub actions: Vec<AlterTypeActionFact>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterTypeActionFact {
    RenameTo {
        new_name: Ident,
    },
    SetSchema {
        new_schema: String,
    },
    AddValue {
        new_value: String,
        neighbor: Option<String>,
        before: bool,
    },
    RenameValue {
        old_value: String,
        new_value: String,
    },
}

#[derive(Clone, Debug, PartialEq, Default)]
pub enum RoleFact {
    #[default]
    Unknown,
    Named {
        name: String,
        via_legacy_group_syntax: bool,
    },
    CurrentUser,
    CurrentRole,
    SessionUser,
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateRoleFact {
    pub name: String,
    pub inherits: bool,
    pub can_login: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterRoleFact {
    pub name: RoleFact,
    pub inherits: Option<bool>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropRoleFact {
    pub names: Vec<String>,
    pub if_exists: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateFunctionFact {
    pub name: QualifiedName,
    pub or_replace: bool,
    pub params: Vec<ParamFact>,
    pub return_type: Option<RetTypeFact>,
    pub options: Vec<FuncOptionFact>,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct ParamFact {
    pub mode: ParamModeFact,
    pub name: Option<String>,
    pub ty: String,
    pub default: Option<ExprIr>,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum ParamModeFact {
    In,
    Out,
    InOut,
    Variadic,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum RetTypeFact {
    Table(Vec<ColumnFact>),
    Scalar(String),
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FuncOptionFact {
    Language(String),
    Volatility(VolatilityKind),
    Security(SecurityKind),
    Strict(StrictKind),
    Leakproof(bool),
    Parallel(String),
    Cost,
    Rows,
    Reset(String),
    As {
        definition: Option<String>,
        obj_file: Option<String>,
        link_symbol: Option<String>,
    },
    Transform,
    Window,
    Support,
    Unknown,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum VolatilityKind {
    Immutable,
    Stable,
    Volatile,
}
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum SecurityKind {
    Invoker,
    Definer,
}
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum StrictKind {
    Strict,
    CalledOnNull,
    ReturnsNullOnNull,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterFunctionFact {
    pub name: QualifiedName,
    pub params: Vec<String>,
    pub action: AlterFunctionAction,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterFunctionAction {
    Rename { from: String, to: String },
    OwnerChange(RoleFact),
    SchemaChange { new_schema: String },
    DependsOnExtension { extension: String },
    NoDependsOnExtension { extension: String },
    OptionsChange(Vec<FuncOptionFact>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropFunctionFact {
    pub signatures: Vec<FunctionSigFact>,
    pub if_exists: bool,
    pub cascade: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct FunctionSigFact {
    pub name: QualifiedName,
    pub params: Vec<String>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateProcedureFact {
    pub name: QualifiedName,
    pub or_replace: bool,
    pub params: Vec<ParamFact>,
    pub options: Vec<FuncOptionFact>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterProcedureFact {
    pub name: QualifiedName,
    pub params: Vec<String>,
    pub action: AlterFunctionAction,
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropProcedureFact {
    pub signatures: Vec<FunctionSigFact>,
    pub if_exists: bool,
    pub cascade: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateAggregateFact {
    pub name: QualifiedName,
    pub or_replace: bool,
    pub params: Vec<ParamFact>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterAggregateFact {
    pub name: QualifiedName,
    pub params: Vec<String>,
    pub action: AlterFunctionAction,
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropAggregateFact {
    pub signatures: Vec<FunctionSigFact>,
    pub if_exists: bool,
    pub cascade: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreatePublicationFact {
    pub name: String,
    pub scope: PublicationScope,
    pub params: Vec<AttributeFact>,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum PublicationScope {
    AllTables { except: Vec<String> },
    Explicit(Vec<PublicationObjectFact>),
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum PublicationObjectFact {
    Table {
        name: QualifiedName,
        only: bool,
        include_partitions: bool,
        columns: Option<Vec<String>>,
        row_filter: Option<PublicationRowFilter>,
    },
    SchemaTables {
        schema: String,
        row_filter: Option<PublicationRowFilter>,
    },
    CurrentSchemaShorthand,
    Unknown,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum PublicationRowFilter {
    Parsed(ExprIr),
    CatalogSql(String),
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterPublicationFact {
    pub name: String,
    pub action: AlterPublicationActionFact,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterPublicationActionFact {
    AddObjects(Vec<PublicationObjectFact>),
    SetObjects(PublicationScope),
    DropObjects(Vec<PublicationObjectFact>),
    SetOptions(Vec<AttributeFact>),
    OwnerChange(RoleFact),
    Rename { to: String },
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropPublicationFact {
    pub names: Vec<String>,
    pub if_exists: bool,
    pub cascade: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateSubscriptionFact {
    pub name: Option<String>,
    pub connection: ConnectionTarget,
    pub publications: Vec<String>,
    pub params: Option<Vec<AttributeFact>>,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum ConnectionTarget {
    Literal(Option<String>),
    Server(Option<String>),
    /// A synchronized subscription exists, but its connection string is never
    /// read from PostgreSQL or written to the cache.
    Redacted,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterSubscriptionFact {
    pub name: String,
    pub action: AlterSubscriptionActionFact,
}

#[derive(Clone, Debug, PartialEq)]
pub enum SubscriptionPublicationMode {
    Set,
    Add,
    Drop,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterSubscriptionActionFact {
    SetConnection(ConnectionTarget),
    Publications {
        mode: SubscriptionPublicationMode,
        publications: Vec<String>,
        params: Vec<AttributeFact>,
    },
    RefreshPublication(Vec<AttributeFact>),
    SetEnabled(bool),
    SetOptions(Vec<AttributeFact>),
    SetServer(Option<String>),
    Skip(Vec<AttributeFact>),
    OwnerChange(RoleFact),
    Rename {
        to: String,
    },
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropSubscriptionFact {
    pub name: String,
    pub if_exists: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct GrantFact {
    pub privileges: PrivilegeSpec,
    pub target: GrantTarget,
    pub grantees: Vec<RoleFact>,
    pub with_grant_option: bool,
    pub role_options: Vec<RoleMembershipOptionFact>,
    pub granted_by: Option<RoleFact>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct RevokeFact {
    pub grant_option_only: bool,
    pub role_option: Option<RoleMembershipOptionFact>,
    pub privileges: PrivilegeSpec,
    pub target: GrantTarget,
    pub revokees: Vec<RoleFact>,
    pub granted_by: Option<RoleFact>,
    pub cascade: bool,
}

/// Per-membership option supported by PostgreSQL 16+ role grants. The option
/// name and value are kept typed at extraction time so state transitions never
/// need to infer semantics from raw SQL text.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RoleMembershipOptionFact {
    Admin(bool),
    Inherit(bool),
    Set(bool),
}

#[derive(Clone, Debug, PartialEq)]
pub enum PrivilegeSpec {
    All,
    List(Vec<PrivilegeFact>),
}

#[derive(Clone, Debug, PartialEq)]
pub enum PrivilegeFact {
    Select,
    Insert,
    Update,
    Delete,
    Truncate,
    References,
    Trigger,
    Maintain,
    Execute,
    Create,
    Temporary,
    AlterSystem,
    All,
    Named(String),
    RoleMembership(String),
    Unknown,
}

#[derive(Clone, Debug, PartialEq)]
pub enum GrantTarget {
    Tables(Vec<QualifiedName>),
    AllTablesInSchema(Vec<String>),
    Roles(Vec<String>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct CreateDatabaseFact {
    pub name: String,
    pub options: Vec<DatabaseOptionFact>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum DatabaseOptionFact {
    Owner(DatabaseOptionValue),
    Template(DatabaseOptionValue),
    Encoding(DatabaseOptionValue),
    Tablespace(DatabaseOptionValue),
    ConnectionLimit(DatabaseOptionValue),
    Named(String, DatabaseOptionValue),
    Unknown(DatabaseOptionValue),
}

#[derive(Clone, Debug, PartialEq)]
pub enum DatabaseOptionValue {
    Default,
    Literal(Option<String>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct AlterDatabaseFact {
    pub name: QualifiedName,
    pub action: AlterDatabaseAction,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterDatabaseAction {
    Rename { to: String },
    OwnerChange(RoleFact),
    TablespaceChange { new_tablespace: String },
    SetConfigParam { param: String },
    ResetConfigParam { param: Option<String> },
    RefreshCollationVersion,
    OptionChanges(Vec<DatabaseOptionFact>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct DropDatabaseFact {
    pub name: QualifiedName,
    pub if_exists: bool,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct AttributeFact {
    pub name: String,
    pub value: String,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum ColumnGeneration {
    Ordinary,
    Serial,
    Identity,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct ColumnFact {
    pub name: String,
    pub ty: Option<String>,
    pub not_null: bool,
    pub is_primary_key: bool,
    pub primary_key_constraint_name: Option<String>,
    pub is_unique: bool,
    pub unique_constraint_name: Option<String>,
    pub default: Option<ExprIr>,
    pub generation: ColumnGeneration,
}

#[derive(Clone, Debug, PartialEq)]
pub struct FkFact {
    pub constraint_name: Option<String>,
    pub references: QualifiedName,
    pub from_columns: Vec<String>,
    pub to_columns: Vec<String>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum TableConstraintFact {
    PrimaryKey {
        constraint_name: Option<String>,
        columns: Vec<String>,
    },
    Unique {
        constraint_name: Option<String>,
        columns: Vec<String>,
    },
    Check {
        constraint_name: Option<String>,
        columns: Vec<String>,
        columns_complete: bool,
    },
    Exclude {
        constraint_name: Option<String>,
        columns: Vec<String>,
        columns_complete: bool,
    },
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterDomainActionFact {
    AddConstraint,
    DropConstraint,
    DropDefault,
    DropNotNull,
    OwnerChange,
    RenameConstraint,
    RenameTo,
    SetDefault,
    SetNotNull,
    SetSchema,
    ValidateConstraint,
}

#[derive(Clone, Debug, PartialEq)]
pub enum AlterTableActionFact {
    AddColumn {
        name: String,
        ty: Option<String>,
        if_not_exists: bool,
        not_null: bool,
        default: Option<ExprIr>,
        generation: ColumnGeneration,
    },
    DropColumn {
        name: String,
        if_exists: bool,
        cascade: bool,
    },
    RenameColumn {
        from: Ident,
        to: Ident,
    },
    RenameTo {
        new_name: Ident,
    },
    AddForeignKey {
        constraint_name: Option<String>,
        references: QualifiedName,
        from_columns: Vec<String>,
        to_columns: Vec<String>,
        not_valid: bool,
    },
    AlterConstraint {
        name: Option<String>,
        deferrable: bool,
    },
    RenameConstraint {
        old_name: String,
        new_name: String,
    },
    DropConstraint {
        name: String,
        if_exists: bool,
        cascade: bool,
    },
    AddCheckConstraint {
        constraint_name: Option<String>,
        columns: Vec<String>,
        columns_complete: bool,
        not_valid: bool,
    },
    AddUniqueConstraint {
        constraint_name: Option<String>,
        columns: Vec<String>,
        using_index: Option<QualifiedName>,
    },
    AddPrimaryKeyConstraint {
        constraint_name: Option<String>,
        columns: Vec<String>,
        using_index: Option<QualifiedName>,
    },
    AddExcludeConstraint {
        constraint_name: Option<String>,
        columns: Vec<String>,
        columns_complete: bool,
    },
    SetNotNull {
        column: String,
    },
    DropNotNull {
        column: String,
    },
    SetType {
        column: String,
        ty: String,
        has_using: bool,
    },
    SetDefault {
        column: String,
        default: Option<ExprIr>,
    },
    SetExpression {
        column: String,
        expr: ExprIr,
    },
    SetOptions {
        column: String,
        attributes: Vec<AttributeFact>,
    },
    Inherit {
        column: String,
        parent: QualifiedName,
    },
    NoInherit {
        column: String,
        parent: QualifiedName,
    },
    ValidateConstraint {
        constraint_name: String,
    },
    DisableTrigger {
        trigger_name: Option<String>,
    },
    EnableTrigger {
        trigger_name: Option<String>,
    },
    AttachPartition {
        child: QualifiedName,
        strategy: Option<String>,
    },
    DetachPartition {
        child: QualifiedName,
    },
    SetStorage {
        column: String,
    },
    SetAccessMethod,
    ClusterOn {
        index: String,
    },
    InheritTable {
        parent: QualifiedName,
    },
    NoInheritTable {
        parent: QualifiedName,
    },
    MergePartitions {
        parent: QualifiedName,
    },
    SplitPartition,
    SetSchema {
        new_schema: String,
    },
    SetTablespace {
        tablespace: String,
    },
    SetLogged,
    SetUnlogged,
    OwnerTo {
        new_owner: RoleFact,
    },
    ReplicaIdentity {
        option: String,
    },
    ForceRls,
    EnableRls,
    DisableRls,
    EnableAlwaysTrigger {
        trigger_name: Option<String>,
    },
    EnableReplicaTrigger {
        trigger_name: Option<String>,
    },
}