safe-migrate 0.9.0

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

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum OnCommitFact {
    PreserveRows,
    DeleteRows,
    Drop,
}

/// Properties selected by `CREATE TABLE ... LIKE` after applying its ordered
/// INCLUDING/EXCLUDING clauses.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct LikePropertiesFact {
    pub defaults: bool,
    pub generated: bool,
    pub storage: bool,
    pub compression: bool,
    pub statistics: bool,
    pub constraints: bool,
    pub indexes: bool,
    pub identity: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) struct LikeSourceFact {
    pub relation: QualifiedName,
    pub properties: LikePropertiesFact,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) enum ReplicaIdentityFact {
    Default,
    Full,
    Nothing,
    UsingIndex(QualifiedName),
}

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

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) enum TypeCreationKind {
    Enum {
        variants: Vec<String>,
    },
    #[expect(dead_code, reason = "reserved for typed Squawk range support")]
    Range,
    Composite {
        fields: Vec<CompositeFieldFact>,
    },
    #[expect(dead_code, reason = "reserved for typed Squawk base-type support")]
    Base,
}

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) enum AlterViewAction {
    RenameTo {
        new_name: Ident,
    },
    OwnerTo {
        new_owner: RoleFact,
    },
    SetSchema {
        new_schema: String,
    },
    #[expect(dead_code, reason = "reserved for typed Squawk view-default support")]
    SetDefault {
        column: String,
        default: Option<ExprIr>,
    },
    #[expect(dead_code, reason = "reserved for typed Squawk view-default support")]
    DropDefault {
        column: String,
    },
    RenameColumn {
        from: Ident,
        to: Ident,
    },
    #[expect(dead_code, reason = "reserved for typed Squawk view-option support")]
    SetOptions {
        options: Vec<String>,
    },
    #[expect(dead_code, reason = "reserved for typed Squawk view-option support")]
    ResetOptions {
        options: Vec<String>,
    },
}

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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,
        on_commit: Option<OnCommitFact>,
        columns: Vec<ColumnFact>,
        foreign_keys: Vec<FkFact>,
        table_constraints: Vec<TableConstraintFact>,
        partition_by: Option<String>,
        partition_strategy: Option<String>,
        partition_of: Option<QualifiedName>,
        partition_bound: Option<String>,
        inherits: Vec<QualifiedName>,
        like_sources: Vec<LikeSourceFact>,
        of_type: Option<QualifiedName>,
        select_source: Option<QualifiedName>,
        select_outputs: Vec<SelectOutputFact>,
        select_projection_complete: bool,
    },
    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>,
        row_level: bool,
    },
    DropTrigger {
        name: String,
        table: QualifiedName,
        if_exists: bool,
    },
    AlterTrigger {
        name: String,
        table: QualifiedName,
        new_name: String,
    },
    AlterTable {
        name: QualifiedName,
        only: bool,
        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)>,
        persistence: PersistenceFact,
        options: IdentitySequenceOptionsFact,
    },
    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,
    },
    Lock {
        targets: Vec<RelationTargetFact>,
        mode: LockModeFact,
        nowait: bool,
    },
    Truncate {
        targets: Vec<RelationTargetFact>,
        cascade: bool,
        restart_identity: 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,
    },
}

/// A relation target whose `ONLY` modifier materially changes inheritance and
/// partition behavior.
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct RelationTargetFact {
    pub name: QualifiedName,
    pub only: bool,
}

/// Lifecycle form used by `ALTER TABLE ... DETACH PARTITION`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum DetachPartitionMode {
    Immediate,
    Concurrently,
    Finalize,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum LockModeFact {
    AccessShare,
    RowShare,
    RowExclusive,
    ShareUpdateExclusive,
    Share,
    ShareRowExclusive,
    Exclusive,
    AccessExclusive,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum RuleEnableModeFact {
    Origin,
    Disabled,
    Replica,
    Always,
}

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) enum RoleFact {
    #[default]
    Unknown,
    Named {
        name: String,
        via_legacy_group_syntax: bool,
    },
    CurrentUser,
    CurrentRole,
    SessionUser,
}

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) 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(crate) enum ParamModeFact {
    In,
    Out,
    InOut,
    Variadic,
}

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

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) 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(crate) enum VolatilityKind {
    Immutable,
    Stable,
    Volatile,
}
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) enum SecurityKind {
    Invoker,
    Definer,
}
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) enum StrictKind {
    Strict,
    CalledOnNull,
    ReturnsNullOnNull,
}

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) struct DropFunctionFact {
    pub signatures: Vec<FunctionSigFact>,
    pub if_exists: bool,
    pub cascade: bool,
}

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

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

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

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

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

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

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

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

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

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) 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(crate) enum PublicationRowFilter {
    Parsed(ExprIr),
    CatalogSql(String),
}

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) 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(crate) struct AlterSubscriptionFact {
    pub name: String,
    pub action: AlterSubscriptionActionFact,
}

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) struct DropSubscriptionFact {
    pub name: String,
    pub if_exists: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) 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(crate) enum RoleMembershipOptionFact {
    Admin(bool),
    Inherit(bool),
    Set(bool),
}

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) enum GrantTarget {
    Tables(Vec<QualifiedName>),
    AllTablesInSchema(Vec<String>),
    Roles(Vec<String>),
}

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) struct DropDatabaseFact {
    pub name: QualifiedName,
    pub if_exists: bool,
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub(crate) enum ColumnGeneration {
    Ordinary,
    Serial,
    IdentityAlways,
    IdentityByDefault,
    GeneratedStored,
    GeneratedVirtual,
}

#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub(crate) struct IdentitySequenceOptionsFact {
    pub data_type: Option<String>,
    pub start_value: Option<i64>,
    pub increment: Option<i64>,
    pub min_value: Option<Option<i64>>,
    pub max_value: Option<Option<i64>>,
    pub cache_size: Option<i64>,
    pub cycle: Option<bool>,
    pub persistence: Option<bool>,
    pub sequence_name: Option<QualifiedName>,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) 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,
    pub identity_sequence: Option<IdentitySequenceOptionsFact>,
    pub generated_expr: Option<ExprIr>,
    #[serde(default)]
    pub generated_expr_sql: Option<String>,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) enum SelectOutputFact {
    AllColumns,
    Column {
        source_name: String,
        output_name: String,
    },
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) 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(crate) enum TableConstraintFact {
    PrimaryKey {
        constraint_name: Option<String>,
        columns: Vec<String>,
    },
    Unique {
        constraint_name: Option<String>,
        columns: Vec<String>,
    },
    Check {
        constraint_name: Option<String>,
        name_hint: Option<String>,
        definition: String,
        columns: Vec<String>,
        columns_complete: bool,
    },
    Exclude {
        constraint_name: Option<String>,
        columns: Vec<String>,
        columns_complete: bool,
    },
}

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

#[derive(Clone, Debug, PartialEq)]
pub(crate) enum AlterTableActionFact {
    AddColumn {
        name: String,
        ty: Option<String>,
        if_not_exists: bool,
        not_null: bool,
        default: Option<ExprIr>,
        generation: ColumnGeneration,
        identity_sequence: Option<Box<IdentitySequenceOptionsFact>>,
        generated_expr: Option<ExprIr>,
        generated_expr_sql: Option<String>,
    },
    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>,
        definition: 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,
        expression_sql: String,
    },
    SetOptions {
        column: String,
        attributes: Vec<AttributeFact>,
    },
    ResetOptions {
        column: String,
        names: Vec<String>,
    },
    SetTableOptions {
        attributes: Vec<AttributeFact>,
    },
    ResetTableOptions {
        names: Vec<String>,
    },
    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>,
        bound: Option<String>,
    },
    DetachPartition {
        child: QualifiedName,
        mode: DetachPartitionMode,
    },
    SetStorage {
        column: String,
        mode: String,
    },
    SetCompression {
        column: String,
        method: Option<String>,
    },
    SetStatistics {
        column: String,
        target: Option<i32>,
    },
    DropExpression {
        column: String,
        if_exists: bool,
    },
    SetAccessMethod {
        access_method: Option<String>,
    },
    ClusterOn {
        index: QualifiedName,
    },
    SetWithoutCluster,
    InheritTable {
        parent: QualifiedName,
    },
    NoInheritTable {
        parent: QualifiedName,
    },
    OfType {
        type_name: QualifiedName,
    },
    NotOf,
    MergePartitions {
        parent: QualifiedName,
    },
    SplitPartition,
    SetSchema {
        new_schema: String,
    },
    SetTablespace {
        tablespace: String,
    },
    SetLogged,
    SetUnlogged,
    OwnerTo {
        new_owner: RoleFact,
    },
    ReplicaIdentity {
        option: ReplicaIdentityFact,
    },
    ForceRls,
    NoForceRls,
    EnableRls,
    DisableRls,
    EnableAlwaysTrigger {
        trigger_name: Option<String>,
    },
    EnableReplicaTrigger {
        trigger_name: Option<String>,
    },
    SetRuleMode {
        rule_name: Option<String>,
        mode: RuleEnableModeFact,
    },
}