Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

489 KB
Raw Blame
use super::*;
use crate::models::connection::DatabaseType;
use crate::table_structure_sql::dialect::StructureDialect;
use crate::types::PgPartitionKind;

fn foreign_create_options(server: &str) -> CreateTableDialectOptions {
    CreateTableDialectOptions {
        postgres_foreign_table: Some(PostgresForeignTableCreateOptions {
            server: server.into(),
            options: vec![
                PostgresForeignTableOption { name: "schema_name".into(), value: "remote's schema".into() },
                PostgresForeignTableOption { name: "table_name".into(), value: "source table".into() },
            ],
        }),
        ..Default::default()
    }
}

#[test]
fn postgres_foreign_table_create_quotes_server_options_and_comments() {
    let mut options = structure_change_options(
        DatabaseType::Postgres,
        Some("local\"schema"),
        "foreign table",
        vec![column("remote\"column")],
    );
    options.table_comment = Some("foreign's comment".into());
    options.columns[0].comment = "column's comment".into();
    options.columns[0].is_nullable = false;
    options.columns[0].default_value = "'fallback'".into();
    let result = build_create_table_sql_with_dialect_options(options, None, foreign_create_options("server\"name"));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements.len(), 3);
    assert!(result.statements[0].starts_with("CREATE FOREIGN TABLE \"local\"\"schema\".\"foreign table\" ("));
    assert!(result.statements[0].contains("\"remote\"\"column\""));
    assert!(result.statements[0].contains("NOT NULL"));
    assert!(result.statements[0].contains("DEFAULT 'fallback'"));
    assert!(result.statements[0].ends_with(
        "SERVER \"server\"\"name\" OPTIONS (\"schema_name\" 'remote''s schema', \"table_name\" 'source table');"
    ));
    assert_eq!(
        result.statements[1],
        "COMMENT ON FOREIGN TABLE \"local\"\"schema\".\"foreign table\" IS 'foreign''s comment';"
    );
    assert!(result.statements[2].contains("COMMENT ON COLUMN"));
}

#[test]
fn postgres_foreign_table_create_validates_required_server_and_options() {
    let options = structure_change_options(DatabaseType::Postgres, Some("public"), "foreign_table", vec![column("id")]);
    for server in ["", " ", "invalid\0server"] {
        let result = build_create_table_sql_with_dialect_options(options.clone(), None, foreign_create_options(server));
        assert!(result.statements.is_empty());
        assert!(!result.warnings.is_empty());
    }
    for option in [
        PostgresForeignTableOption { name: "schema_name".into(), value: "duplicate".into() },
        PostgresForeignTableOption { name: "".into(), value: "orphan".into() },
        PostgresForeignTableOption { name: "bad\0name".into(), value: "value".into() },
        PostgresForeignTableOption { name: "filename".into(), value: "bad\0value".into() },
    ] {
        let mut settings = foreign_create_options("server");
        settings.postgres_foreign_table.as_mut().unwrap().options.push(option);
        let result = build_create_table_sql_with_dialect_options(options.clone(), None, settings);
        assert!(result.statements.is_empty());
        assert!(!result.warnings.is_empty());
    }
}

#[test]
fn postgres_foreign_table_create_rejects_unsupported_dialects_and_constraints() {
    let options = structure_change_options(DatabaseType::Postgres, Some("public"), "foreign_table", vec![column("id")]);
    for database_type in [DatabaseType::Mysql, DatabaseType::Sqlite, DatabaseType::OpenGauss, DatabaseType::Gaussdb] {
        let mut request = options.clone();
        request.database_type = Some(database_type);
        assert!(build_create_table_sql_with_dialect_options(request, None, foreign_create_options("server"))
            .statements
            .is_empty());
    }
    let mut primary = options.clone();
    primary.columns[0].is_primary_key = true;
    let mut identity = options.clone();
    identity.columns[0].extra =
        Some(serde_json::from_value(serde_json::json!({"identity":{"generation":"ALWAYS"}})).unwrap());
    let mut partition = options.clone();
    partition.partitioned = true;
    let mut redshift = options;
    redshift.driver_profile = Some("redshift".into());
    for request in [primary, identity, partition, redshift] {
        let result = build_create_table_sql_with_dialect_options(request, None, foreign_create_options("server"));
        assert!(result.statements.is_empty());
        assert!(!result.warnings.is_empty());
    }
}

#[test]
fn postgres_foreign_table_options_are_optional_and_allow_empty_values() {
    let mut options =
        structure_change_options(DatabaseType::Postgres, Some("public"), "foreign_table", vec![column("id")]);
    options.foreign_table = true;
    options.table_comment = Some("table comment".into());
    let regular =
        build_create_table_sql_with_dialect_options(options.clone(), None, CreateTableDialectOptions::default());
    assert!(regular.statements[0].starts_with("CREATE TABLE "));
    assert!(regular.statements[1].starts_with("COMMENT ON TABLE "));
    let mut settings = foreign_create_options("server");
    settings.postgres_foreign_table.as_mut().unwrap().options.clear();
    let result = build_create_table_sql_with_dialect_options(options.clone(), None, settings.clone());
    assert!(result.warnings.is_empty());
    assert!(result.statements[0].ends_with("SERVER \"server\";"));
    settings
        .postgres_foreign_table
        .as_mut()
        .unwrap()
        .options
        .push(PostgresForeignTableOption { name: "custom_option".into(), value: "".into() });
    let result = build_create_table_sql_with_dialect_options(options, None, settings);
    assert!(result.warnings.is_empty());
    assert!(result.statements[0].ends_with("OPTIONS (\"custom_option\" '');"));
}

#[test]
fn postgres_foreign_table_create_allows_serial_types() {
    let mut options =
        structure_change_options(DatabaseType::Postgres, Some("public"), "foreign_table", vec![column("id")]);
    options.columns[0].data_type = "serial".into();
    let result = build_create_table_sql_with_dialect_options(options, None, foreign_create_options("server"));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].starts_with("CREATE FOREIGN TABLE"));
    assert!(result.statements[0].to_ascii_lowercase().contains("serial"));
}

fn column(name: &str) -> EditableStructureColumn {
    EditableStructureColumn {
        id: name.to_string(),
        name: name.to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        default_value: String::new(),
        comment: String::new(),
        is_primary_key: false,
        extra: None,
        original: None,
        original_position: None,
        marked_for_drop: false,
        character_set: String::new(),
        collation: String::new(),
    }
}

/// Existing column draft with optional primary-key membership change.
fn existing_pk_column(
    name: &str,
    data_type: &str,
    was_primary_key: bool,
    is_primary_key: bool,
) -> EditableStructureColumn {
    let mut col = column(name);
    col.data_type = data_type.to_string();
    col.is_nullable = false;
    col.is_primary_key = is_primary_key;
    col.original = Some(ColumnInfo {
        name: name.to_string(),
        data_type: data_type.to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: was_primary_key,
        extra: None,
        comment: None,
        ..Default::default()
    });
    col
}

fn structure_change_options(
    database_type: DatabaseType,
    schema: Option<&str>,
    table_name: &str,
    columns: Vec<EditableStructureColumn>,
) -> TableStructureSqlOptions {
    TableStructureSqlOptions {
        database_type: Some(database_type),
        driver_profile: None,
        schema: schema.map(str::to_string),
        table_name: table_name.to_string(),
        columns,
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    }
}

#[test]
fn oceanbase_existing_primary_key_ordered_change_payload() {
    let options = structure_change_options(
        DatabaseType::OceanbaseOracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true), existing_pk_column("V", "NUMBER", true, true)],
    );
    let mut payload = serde_json::to_value(options).unwrap();
    payload["primaryKeyChange"] = serde_json::json!({
        "name": "PK_SOURCE",
        "originalColumns": ["ID", "V"],
        "columns": ["V", "ID"]
    });
    let result = build_table_structure_change_sql(serde_json::from_value(payload).unwrap());
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"APP\".\"SOURCE\" DROP CONSTRAINT \"PK_SOURCE\";",
            "ALTER TABLE \"APP\".\"SOURCE\" ADD CONSTRAINT \"PK_SOURCE\" PRIMARY KEY (\"V\", \"ID\");",
        ]
    );
}

#[test]
fn oceanbase_existing_primary_key_delete_payload() {
    let options = structure_change_options(
        DatabaseType::OceanbaseOracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true)],
    );
    let mut payload = serde_json::to_value(options).unwrap();
    payload["primaryKeyChange"] = serde_json::json!({
        "name": "PK_SOURCE",
        "originalColumns": ["ID"],
        "columns": []
    });
    let result = build_table_structure_change_sql(serde_json::from_value(payload).unwrap());
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE \"APP\".\"SOURCE\" DROP CONSTRAINT \"PK_SOURCE\";"]);
}

#[test]
fn oracle_existing_primary_key_explicit_index_policy() {
    let options = structure_change_options(
        DatabaseType::Oracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true), existing_pk_column("V", "NUMBER", true, true)],
    );
    for (policy, columns, new_name, expected_add) in [
        ("keep", vec!["V", "ID"], None, Some("ALTER TABLE \"APP\".\"SOURCE\" ADD CONSTRAINT \"PK_SOURCE\" PRIMARY KEY (\"V\", \"ID\") USING INDEX \"APP\".\"ORIGINAL_IDX\";")),
        ("keep", vec!["V"], Some("SOURCE_V_IDX"), Some("ALTER TABLE \"APP\".\"SOURCE\" ADD CONSTRAINT \"PK_SOURCE\" PRIMARY KEY (\"V\") USING INDEX (CREATE UNIQUE INDEX \"APP\".\"SOURCE_V_IDX\" ON \"APP\".\"SOURCE\" (\"V\"));")),
        ("drop", vec!["V", "ID"], Some("SOURCE_V_ID_IDX"), Some("ALTER TABLE \"APP\".\"SOURCE\" ADD CONSTRAINT \"PK_SOURCE\" PRIMARY KEY (\"V\", \"ID\") USING INDEX (CREATE UNIQUE INDEX \"APP\".\"SOURCE_V_ID_IDX\" ON \"APP\".\"SOURCE\" (\"V\", \"ID\"));")),
        ("keep", vec![], None, None),
        ("drop", vec![], None, None),
    ] {
        let mut payload = serde_json::to_value(&options).unwrap();
        payload["primaryKeyChange"] = serde_json::json!({
            "name": "PK_SOURCE", "originalColumns": ["ID", "V"], "columns": columns,
            "oracleIndex": { "policy": policy, "owner": "APP", "name": "ORIGINAL_IDX", "newName": new_name }
        });
        let result = build_table_structure_change_sql(serde_json::from_value(payload).unwrap());
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        let mut expected = vec![format!("ALTER TABLE \"APP\".\"SOURCE\" DROP CONSTRAINT \"PK_SOURCE\" {} INDEX;", policy.to_uppercase())];
        if let Some(add) = expected_add { expected.push(add.to_string()); }
        assert_eq!(result.statements, expected);
    }
}

#[test]
fn oracle_existing_primary_key_rejects_unverified_index_plan() {
    let options = structure_change_options(
        DatabaseType::Oracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true), existing_pk_column("V", "NUMBER", false, false)],
    );
    let mut payload = serde_json::to_value(options).unwrap();
    payload["primaryKeyChange"] = serde_json::json!({
        "name": "PK_SOURCE", "originalColumns": ["ID"], "columns": ["V"],
        "oracleIndex": {"policy": "keep", "owner": "APP", "name": "PK_SOURCE", "newName": "SOURCE_V_IDX"}
    });
    for (pointer, value) in [
        ("/primaryKeyChange/oracleIndex", serde_json::Value::Null),
        ("/primaryKeyChange/oracleIndex/policy", serde_json::json!("cascade")),
        ("/primaryKeyChange/oracleIndex/owner", serde_json::json!("OTHER")),
        ("/primaryKeyChange/oracleIndex/name", serde_json::json!("")),
        ("/primaryKeyChange/oracleIndex/newName", serde_json::Value::Null),
        ("/primaryKeyChange/oracleIndex/newName", serde_json::json!("PK_SOURCE")),
        ("/primaryKeyChange/oracleIndex/newName", serde_json::json!("INVALID; DROP TABLE X")),
        ("/databaseType", serde_json::json!("oceanbase-oracle")),
    ] {
        let mut invalid = payload.clone();
        *invalid.pointer_mut(pointer).unwrap() = value;
        let result = build_table_structure_change_sql(serde_json::from_value(invalid).unwrap());
        assert!(result.statements.is_empty(), "{pointer}: {:?}", result.statements);
        assert!(!result.warnings.is_empty(), "{pointer}");
    }
}

#[test]
fn oracle_existing_primary_key_preserves_disabled_state_without_index() {
    let options = structure_change_options(
        DatabaseType::Oracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true), existing_pk_column("V", "NUMBER", true, true)],
    );
    let mut payload = serde_json::to_value(options).unwrap();
    payload["primaryKeyChange"] = serde_json::json!({
        "name":"PK_SOURCE", "originalColumns":["ID","V"], "columns":["V","ID"],
        "oracleIndex":{"policy":"none","owner":"APP","name":""},
        "oracleState":{"enabled":false,"validated":false,"deferrable":false,"initiallyDeferred":false,"rely":true}
    });
    let result = build_table_structure_change_sql(serde_json::from_value(payload).unwrap());
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec![
        "ALTER TABLE \"APP\".\"SOURCE\" DROP CONSTRAINT \"PK_SOURCE\";",
        "ALTER TABLE \"APP\".\"SOURCE\" ADD CONSTRAINT \"PK_SOURCE\" PRIMARY KEY (\"V\", \"ID\") NOT DEFERRABLE INITIALLY IMMEDIATE RELY DISABLE NOVALIDATE;",
    ]);
}

#[test]
fn oracle_existing_primary_key_preserves_deferred_state_with_nonunique_index() {
    let options = structure_change_options(
        DatabaseType::Oracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true), existing_pk_column("V", "NUMBER", true, true)],
    );
    let mut payload = serde_json::to_value(options).unwrap();
    payload["primaryKeyChange"] = serde_json::json!({
        "name":"PK_SOURCE", "originalColumns":["ID","V"], "columns":["V","ID"],
        "oracleIndex":{"policy":"drop","owner":"APP","name":"OLD_INDEX","newName":"NEW_INDEX"},
        "oracleState":{"enabled":true,"validated":true,"deferrable":true,"initiallyDeferred":true,"rely":false}
    });
    let result = build_table_structure_change_sql(serde_json::from_value(payload).unwrap());
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec![
        "ALTER TABLE \"APP\".\"SOURCE\" DROP CONSTRAINT \"PK_SOURCE\" DROP INDEX;",
        "ALTER TABLE \"APP\".\"SOURCE\" ADD CONSTRAINT \"PK_SOURCE\" PRIMARY KEY (\"V\", \"ID\") DEFERRABLE INITIALLY DEFERRED NORELY USING INDEX (CREATE INDEX \"APP\".\"NEW_INDEX\" ON \"APP\".\"SOURCE\" (\"V\", \"ID\")) ENABLE VALIDATE;",
    ]);
}

#[test]
fn oceanbase_existing_primary_key_rejects_invalid_or_combined_drafts() {
    let options = structure_change_options(
        DatabaseType::OceanbaseOracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true), existing_pk_column("V", "NUMBER", false, false)],
    );
    let mut payload = serde_json::to_value(options).unwrap();
    payload["primaryKeyChange"] =
        serde_json::json!({ "name": "PK_SOURCE", "originalColumns": ["ID"], "columns": ["V"] });
    for (pointer, value) in [
        ("/databaseType", serde_json::json!("oracle")),
        ("/databaseType", serde_json::json!("saphana")),
        ("/databaseType", serde_json::json!("mysql")),
        ("/primaryKeyChange/name", serde_json::json!("")),
        ("/primaryKeyChange/columns", serde_json::json!(["V", "V"])),
        ("/primaryKeyChange/columns", serde_json::json!(["UNKNOWN"])),
        ("/primaryKeyChange/originalColumns", serde_json::json!(["V"])),
        ("/columns/0/comment", serde_json::json!("changed comment")),
        ("/columns/1/markedForDrop", serde_json::json!(true)),
    ] {
        let mut invalid = payload.clone();
        *invalid.pointer_mut(pointer).unwrap() = value;
        let result = build_table_structure_change_sql(serde_json::from_value(invalid).unwrap());
        assert!(result.statements.is_empty(), "{pointer}: {:?}", result.statements);
        assert!(!result.warnings.is_empty(), "{pointer}");
    }
}

#[test]
fn oceanbase_existing_primary_key_unchanged_order_is_a_noop() {
    let mut options = structure_change_options(
        DatabaseType::OceanbaseOracle,
        Some("APP"),
        "SOURCE",
        vec![existing_pk_column("ID", "NUMBER", true, true)],
    );
    options.primary_key_change = Some(ExistingPrimaryKeyChange {
        name: "PK_SOURCE".to_string(),
        original_columns: vec!["ID".to_string()],
        columns: vec!["ID".to_string()],
        oracle_index: None,
        oracle_state: None,
    });
    let result = build_table_structure_change_sql(options);
    assert!(result.statements.is_empty());
    assert!(result.warnings.is_empty());
}

#[test]
fn mysql_table_engine_change_generates_alter_table() {
    let mut options = structure_change_options(DatabaseType::Mysql, Some("dbx_test"), "remote_orders", Vec::new());
    options.mysql_engine = Some("FEDERATED".to_string());

    let result = build_table_structure_change_sql(options);

    assert!(result.warnings.is_empty());
    assert_eq!(result.statements, vec!["ALTER TABLE `remote_orders` ENGINE = FEDERATED;"]);
}

#[test]
fn saphana_table_structure_uses_add_drop_and_alter_syntax() {
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SapHana,
        Some("APP"),
        "users",
        vec![column("new_col")],
    ));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE \"APP\".\"users\" ADD (\"new_col\" varchar(255));"]);

    let mut renamed = column("display_name");
    renamed.data_type = "NVARCHAR(100)".to_string();
    renamed.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SapHana,
        Some("APP"),
        "users",
        vec![renamed],
    ));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec![
            "RENAME COLUMN \"APP\".\"users\".\"name\" TO \"display_name\";",
            "ALTER TABLE \"APP\".\"users\" ALTER (\"display_name\" NVARCHAR(100));",
        ]
    );

    let mut commented = column("name");
    commented.comment = "用户名称".to_string();
    commented.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        comment: Some(String::new()),
        ..Default::default()
    });
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SapHana,
        Some("APP"),
        "users",
        vec![commented],
    ));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["COMMENT ON COLUMN \"APP\".\"users\".\"name\" IS '用户名称';"]);

    let mut cleared = column("name");
    cleared.comment = String::new();
    cleared.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        comment: Some("用户名称".to_string()),
        ..Default::default()
    });
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SapHana,
        Some("APP"),
        "users",
        vec![cleared],
    ));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["COMMENT ON COLUMN \"APP\".\"users\".\"name\" IS NULL;"]);
}

#[test]
fn transwarp_table_comments_use_inceptor_syntax() {
    let mut options =
        structure_change_options(DatabaseType::Transwarp, Some("analytics"), "users", vec![column("name")]);
    options.table_comment = Some("Owner's table".to_string());
    let created = build_create_table_sql(options.clone());
    assert!(created.warnings.is_empty(), "{:?}", created.warnings);
    assert!(created.statements[0].ends_with("COMMENT 'Owner''s table';"));
    options.columns.clear();
    options.original_table_comment = Some("old".to_string());
    let changed = build_table_structure_change_sql(options);
    assert!(changed.warnings.is_empty(), "{:?}", changed.warnings);
    assert_eq!(changed.statements, vec!["ALTER TABLE `users` SET TBLPROPERTIES ('comment' = 'Owner''s table');"]);
}

#[test]
fn transwarp_create_table_supports_partition_bucket_storage_and_transactions() {
    let mut options = structure_change_options(
        DatabaseType::Transwarp,
        Some("analytics"),
        "events",
        vec![column("id"), column("day")],
    );
    options.table_comment = Some("Daily events".to_string());
    options.transwarp_create = Some(super::types::TranswarpCreateTableOptions {
        partition_columns: vec!["day".to_string()],
        bucket_columns: vec!["id".to_string()],
        bucket_count: Some(2),
        storage_format: Some("ORC".to_string()),
        transactional: true,
    });
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    let sql = &result.statements[0];
    assert!(sql.contains("COMMENT 'Daily events' PARTITIONED BY (`day`"), "{sql}");
    assert!(
        sql.contains("CLUSTERED BY (`id`) INTO 2 BUCKETS STORED AS ORC TBLPROPERTIES ('transactional'='true');"),
        "{sql}"
    );
}

#[test]
fn transwarp_create_table_rejects_invalid_transaction_options() {
    let mut options =
        structure_change_options(DatabaseType::Transwarp, Some("analytics"), "events", vec![column("id")]);
    options.transwarp_create = Some(super::types::TranswarpCreateTableOptions {
        transactional: true,
        storage_format: Some("PARQUET".to_string()),
        ..Default::default()
    });
    let result = build_create_table_sql(options);
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("ORC")));
}

#[test]
fn transwarp_uses_verified_mysql_style_column_ddl_without_constraints() {
    let mut original = column("name");
    original.data_type = "varchar(64)".to_string();
    original.is_nullable = true;
    original.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(64)".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let mut renamed = original.clone();
    renamed.name = "display_name".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Transwarp,
        Some("analytics"),
        "users",
        vec![renamed],
    ));

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `users` CHANGE `name` `display_name` varchar(64);"]);
}

#[test]
fn transwarp_adds_and_modifies_columns_with_live_verified_syntax() {
    let added = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Transwarp,
        Some("analytics"),
        "users",
        vec![column("note")],
    ));
    assert!(added.warnings.is_empty(), "{:?}", added.warnings);
    assert_eq!(added.statements, vec!["ALTER TABLE `users` ADD COLUMNS (`note` varchar(255));"]);

    let mut changed = column("note");
    changed.data_type = "varchar(40)".to_string();
    changed.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let modified = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Transwarp,
        Some("analytics"),
        "users",
        vec![changed],
    ));
    assert!(modified.warnings.is_empty(), "{:?}", modified.warnings);
    assert_eq!(modified.statements, vec!["ALTER TABLE `users` CHANGE `note` `note` varchar(40);"]);

    let mut dropped = column("note");
    dropped.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(40)".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    dropped.marked_for_drop = true;
    let unsupported = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Transwarp,
        Some("analytics"),
        "users",
        vec![dropped],
    ));
    assert!(unsupported.statements.is_empty());
    assert!(unsupported.warnings.iter().any(|warning| warning.contains("Dropping columns is not supported")));
}

#[test]
fn sqlite_autoincrement_normalizes_integer_aliases_to_exact_integer() {
    let mut id = column("id");
    id.data_type = "bigint".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let options = structure_change_options(DatabaseType::Sqlite, None, "items", vec![id, column("value")]);
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements[0],
        "CREATE TABLE \"items\" (\n  \"id\" INTEGER PRIMARY KEY AUTOINCREMENT,\n  \"value\" varchar(255)\n);"
    );
}

#[test]
fn sqlite_autoincrement_rejects_composite_primary_keys_and_non_integer_types() {
    let mut a = column("a");
    a.data_type = "int".to_string();
    a.is_primary_key = true;
    a.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    let mut b = column("b");
    b.data_type = "int".to_string();
    b.is_primary_key = true;

    let options = structure_change_options(DatabaseType::Sqlite, None, "items", vec![a, b]);
    let result = build_create_table_sql(options);
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|w| w.contains("composite primary keys")), "{:?}", result.warnings);

    let mut text_id = column("id");
    text_id.data_type = "text".to_string();
    text_id.is_primary_key = true;
    text_id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    let options = structure_change_options(DatabaseType::Sqlite, None, "items2", vec![text_id]);
    let result = build_create_table_sql(options);
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|w| w.contains("must use an integer type")), "{:?}", result.warnings);
}

#[test]
fn starrocks_create_table_preserves_native_column_types() {
    let types = [
        "BIGINT",
        "DATETIME",
        "LARGEINT",
        "DECIMAL(18,4)",
        "ARRAY<INT>",
        "MAP<INT, INT>",
        "STRUCT<name VARCHAR(64), amount DECIMAL(18,2)>",
    ];
    let columns = types
        .iter()
        .enumerate()
        .map(|(index, data_type)| {
            let mut col = column(&format!("c{index}"));
            col.data_type = data_type.to_string();
            col
        })
        .collect();
    let mut options = structure_change_options(DatabaseType::StarRocks, None, "test2", columns);
    options.table_comment = Some("test".to_string());
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements.len(), 1);
    for (index, data_type) in types.iter().enumerate() {
        assert!(result.statements[0].contains(&format!("`c{index}` {data_type}")), "{}", result.statements[0]);
    }
    assert!(!result.statements[0].to_lowercase().contains("unsigned"));
    assert!(!result.statements[0].to_lowercase().contains("timestamp"));
}

#[test]
fn mysql_create_table_includes_engine_before_comment() {
    let mut options = structure_change_options(DatabaseType::Mysql, Some("dbx_test"), "archive", vec![column("id")]);
    options.mysql_engine = Some("MyISAM".to_string());
    options.table_comment = Some("remote archive".to_string());

    let result = build_create_table_sql(options);

    assert!(result.warnings.is_empty());
    assert_eq!(
        result.statements[0],
        "CREATE TABLE `archive` (\n  `id` varchar(255)\n) ENGINE = MyISAM COMMENT = 'remote archive';"
    );
}

#[test]
fn mysql_table_engine_rejects_non_mysql_and_unsafe_values() {
    let mut postgres = structure_change_options(DatabaseType::Postgres, Some("public"), "users", Vec::new());
    postgres.mysql_engine = Some("InnoDB".to_string());
    let postgres_result = build_table_structure_change_sql(postgres);
    assert!(postgres_result.statements.is_empty());
    assert_eq!(
        postgres_result.warnings,
        vec!["Changing the table engine is supported only for native MySQL connections."]
    );

    let mut mysql = structure_change_options(DatabaseType::Mysql, None, "users", Vec::new());
    mysql.mysql_engine = Some("InnoDB; DROP TABLE users".to_string());
    let mysql_result = build_table_structure_change_sql(mysql);
    assert!(mysql_result.statements.is_empty());
    assert_eq!(mysql_result.warnings, vec!["MySQL table engine contains invalid characters."]);
}

fn index(name: &str, columns: &[&str]) -> EditableStructureIndex {
    EditableStructureIndex {
        id: name.to_string(),
        name: name.to_string(),
        columns: columns.iter().map(|column| column.to_string()).collect(),
        is_unique: false,
        is_primary: false,
        filter: String::new(),
        index_type: String::new(),
        included_columns: Vec::new(),
        column_opclasses: Vec::new(),
        comment: String::new(),
        concurrently: false,
        original: None,
        oracle_original_missing: false,
        marked_for_drop: false,
    }
}

fn existing_index(name: &str, columns: &[&str], is_unique: bool) -> EditableStructureIndex {
    let mut index = index(name, columns);
    index.is_unique = is_unique;
    index.original = Some(IndexInfo {
        name: name.to_string(),
        columns: columns.iter().map(|column| column.to_string()).collect(),
        is_unique,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });
    index
}

/// A unique index that is the object *behind* a UNIQUE constraint (Dameng's "virtual" index,
/// `ALL_CONSTRAINTS.CONSTRAINT_TYPE = 'U'`), as opposed to a standalone ("real") unique index
/// created with `CREATE UNIQUE INDEX`, which `existing_index(.., true)` still models.
fn constraint_backed_unique_index(name: &str, columns: &[&str]) -> EditableStructureIndex {
    let mut index = existing_index(name, columns, true);
    index.original.as_mut().unwrap().constraint_backed = true;
    index
}

fn existing_primary_index(name: &str, columns: &[&str]) -> EditableStructureIndex {
    let mut index = existing_index(name, columns, true);
    index.is_primary = true;
    index.original.as_mut().unwrap().is_primary = true;
    index
}

fn index_change_options(
    database_type: DatabaseType,
    schema: Option<&str>,
    index: EditableStructureIndex,
) -> TableStructureSqlOptions {
    TableStructureSqlOptions {
        database_type: Some(database_type),
        driver_profile: None,
        schema: schema.map(str::to_string),
        table_name: "USERS".to_string(),
        columns: Vec::new(),
        indexes: vec![index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    }
}

fn foreign_key(name: &str, column: &str, ref_table: &str, ref_column: &str) -> EditableStructureForeignKey {
    EditableStructureForeignKey {
        id: name.to_string(),
        name: name.to_string(),
        column: column.to_string(),
        ref_schema: String::new(),
        ref_table: ref_table.to_string(),
        ref_column: ref_column.to_string(),
        on_update: String::new(),
        on_delete: String::new(),
        original: None,
        marked_for_drop: false,
    }
}

fn trigger(name: &str, timing: &str, event: &str, statement: &str) -> EditableStructureTrigger {
    EditableStructureTrigger {
        id: name.to_string(),
        name: name.to_string(),
        oracle_exact: None,
        timing: timing.to_string(),
        event: event.to_string(),
        statement: statement.to_string(),
        enabled: None,
        original: None,
        marked_for_drop: false,
    }
}

#[test]
fn builds_mysql_column_and_index_changes() {
    let mut renamed = column("display_name");
    renamed.data_type = "varchar(120)".to_string();
    renamed.is_nullable = false;
    renamed.default_value = "guest".to_string();
    renamed.comment = "Shown name".to_string();
    renamed.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(80)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });
    let mut email = column("email");
    email.is_nullable = false;
    let mut old_index = index("idx_old", &["name"]);
    old_index.marked_for_drop = true;
    old_index.original = Some(IndexInfo {
        name: "idx_old".to_string(),
        columns: vec!["name".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });
    let mut email_index = index("uniq_users_email", &["email"]);
    email_index.is_unique = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![renamed, email],
        indexes: vec![old_index, email_index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` CHANGE COLUMN `name` `display_name` varchar(120) NOT NULL DEFAULT 'guest' COMMENT 'Shown name';",
            "ALTER TABLE `users` ADD COLUMN `email` varchar(255) NOT NULL;",
            "DROP INDEX `idx_old` ON `users`;",
            "CREATE UNIQUE INDEX `uniq_users_email` ON `users` (`email`);",
        ]
    );
}

#[test]
fn mysql_rebuild_index_uses_one_alter_table() {
    let mut changed = existing_index("userId", &["userId", "cylId", "isClose"], false);
    changed.columns.push("isEmpty".to_string());
    changed.index_type = "BTREE".to_string();
    changed.original.as_mut().unwrap().index_type = Some("BTREE".to_string());
    let mut options = index_change_options(DatabaseType::Mysql, Some("dbx12441_native"), changed);
    options.table_name = "ls_station_delivery_staff_stock_log".to_string();

    let result = build_table_structure_change_sql(options);

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec![
        "ALTER TABLE `ls_station_delivery_staff_stock_log` DROP INDEX `userId`, ADD INDEX `userId` USING BTREE (`userId`, `cylId`, `isClose`, `isEmpty`);"
    ]);
}

#[test]
fn mysql_rebuild_index_preserves_definition_types() {
    for (index_type, unique, definition) in [
        ("", false, "INDEX `idx`"),
        ("btree", false, "INDEX `idx` USING BTREE"),
        ("HASH", false, "INDEX `idx` USING HASH"),
        ("BTREE", true, "UNIQUE INDEX `idx` USING BTREE"),
        ("", true, "UNIQUE INDEX `idx`"),
        ("FULLTEXT", false, "FULLTEXT INDEX `idx`"),
        ("SPATIAL", false, "SPATIAL INDEX `idx`"),
        ("RTREE", false, "SPATIAL INDEX `idx`"),
    ] {
        let mut changed = existing_index("idx", &["old_key"], false);
        changed.columns = vec!["second".to_string(), "first".to_string()];
        changed.index_type = index_type.to_string();
        changed.is_unique = unique;
        changed.comment = "owner's index".to_string();
        let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, None, changed));

        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        assert_eq!(
            result.statements,
            vec![format!(
                "ALTER TABLE `USERS` DROP INDEX `idx`, ADD {definition} (`second`, `first`) COMMENT 'owner''s index';"
            )]
        );
    }
}

#[test]
fn mysql_rebuild_index_preserves_quoted_names_and_functional_keys() {
    let expression = "((lower(`email`)))";
    let mut changed = existing_index("old`idx", &["email"], false);
    changed.name = "new`idx".to_string();
    // Parenthesized plain identifiers keep their existing quoting behavior;
    // only wrapped functional key parts are treated as SQL expressions.
    changed.columns = vec!["a`b".to_string(), "name(10)".to_string(), expression.to_string()];
    let mut options = index_change_options(DatabaseType::Mysql, Some("db`name"), changed);
    options.table_name = "table`name".to_string();
    let result = build_table_structure_change_sql(options);

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec![format!(
            "ALTER TABLE `table``name` DROP INDEX `old``idx`, ADD INDEX `new``idx` (`a``b`, `name(10)`, {expression});"
        )]
    );
}

#[test]
fn mysql_rebuild_index_rejects_empty_replacement_without_drop() {
    for (name, columns) in [(" ", vec!["email"]), ("idx", vec![]), ("idx", vec![" ", ""])] {
        let mut changed = existing_index("idx", &["email"], false);
        changed.name = name.to_string();
        changed.columns = columns.into_iter().map(str::to_string).collect();
        let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, None, changed));

        assert!(result.statements.is_empty(), "{:?}", result.statements);
        assert!(!result.warnings.is_empty());
    }
}

#[test]
fn mysql_rebuild_index_keeps_noop_primary_and_capability_guards() {
    let unchanged = existing_index("idx", &["email"], false);
    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, None, unchanged));
    assert!(result.statements.is_empty());
    assert!(result.warnings.is_empty());

    let mut primary = existing_primary_index("PRIMARY", &["id"]);
    primary.columns.push("email".to_string());
    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, None, primary));
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("cannot be edited")));

    let mut changed = existing_index("idx", &["email"], false);
    changed.columns.push("id".to_string());
    let mut options = index_change_options(DatabaseType::Mysql, None, changed);
    options.driver_profile = Some("starrocks".to_string());
    let mut warnings = Vec::new();
    assert!(super::indexes::build_index_sql(&options, &mut warnings).is_empty());
    assert!(warnings.iter().any(|warning| warning.contains("Editing existing indexes is not supported")));
    let result = build_table_structure_change_sql(options);
    assert!(result.statements.is_empty());
    assert!(!result.warnings.is_empty());
}

#[test]
fn mysql_rebuild_index_ignores_stale_concurrently_flag_with_real_change() {
    let mut changed = existing_index("idx", &["email"], false);
    changed.concurrently = true;
    changed.comment = "new comment".to_string();
    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, None, changed));

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `USERS` DROP INDEX `idx`, ADD INDEX `idx` (`email`) COMMENT 'new comment';"]
    );
}

#[test]
fn mysql_dialect_other_engines_keep_standalone_rebuilds() {
    for database_type in [DatabaseType::Goldendb, DatabaseType::Sundb, DatabaseType::Databend] {
        let mut changed = existing_index("idx", &["email"], false);
        changed.is_unique = true;
        let result = build_table_structure_change_sql(index_change_options(database_type, None, changed));

        assert!(result.warnings.is_empty(), "{database_type:?}: {:?}", result.warnings);
        assert_eq!(
            result.statements,
            vec!["DROP INDEX `idx` ON `USERS`;", "CREATE UNIQUE INDEX `idx` ON `USERS` (`email`);",],
            "{database_type:?}"
        );
    }
}

#[test]
fn dameng_replaces_same_name_index_before_validating_uniqueness() {
    let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    changed.name = "  IDX_USERS_EMAIL  ".to_string();
    changed.is_unique = true;

    let mut options = index_change_options(DatabaseType::Dameng, Some("SYSDBA"), changed);
    options.table_name = "DBX_6002_USERS".to_string();
    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE OR REPLACE UNIQUE INDEX \"IDX_USERS_EMAIL\" ON \"SYSDBA\".\"DBX_6002_USERS\" (\"EMAIL\");"]
    );
}

#[test]
fn dameng_unique_index_column_change_drops_and_readds_constraint() {
    // #7959: the original index is the one behind a UNIQUE constraint. Editing its columns
    // while keeping it unique must go through ALTER TABLE ... DROP/ADD CONSTRAINT, not
    // CREATE OR REPLACE UNIQUE INDEX — Dameng rejects that with "no permission to drop index"
    // because the index is constraint-owned.
    let mut changed = constraint_backed_unique_index("IDX_USERS_EMAIL", &["EMAIL"]);
    changed.columns = vec!["EMAIL".to_string(), "TENANT_ID".to_string()];

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"APP\".\"USERS\" DROP CONSTRAINT \"IDX_USERS_EMAIL\";",
            "ALTER TABLE \"APP\".\"USERS\" ADD CONSTRAINT \"IDX_USERS_EMAIL\" UNIQUE (\"EMAIL\", \"TENANT_ID\");",
        ]
    );
}

#[test]
fn dameng_replaces_same_name_unique_index_with_normal_index() {
    let mut changed = constraint_backed_unique_index("IDX_USERS_EMAIL", &["EMAIL"]);
    changed.is_unique = false;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    // The original index backs a unique constraint (#7959): downgrading it to a plain index
    // has to drop that constraint first, then create an ordinary index — `CREATE OR REPLACE
    // INDEX` against a constraint-backed index is rejected by Dameng.
    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"APP\".\"USERS\" DROP CONSTRAINT \"IDX_USERS_EMAIL\";",
            "CREATE INDEX \"IDX_USERS_EMAIL\" ON \"APP\".\"USERS\" (\"EMAIL\");",
        ]
    );
}

#[test]
fn dameng_replaces_same_name_index_when_columns_change() {
    let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    changed.columns = vec!["LOGIN".to_string(), "EMAIL".to_string()];

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE OR REPLACE INDEX \"IDX_USERS_EMAIL\" ON \"APP\".\"USERS\" (\"LOGIN\", \"EMAIL\");"]
    );
}

#[test]
fn dameng_replaces_same_name_index_when_type_changes_to_bitmap() {
    let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    changed.index_type = "bitmap".to_string();

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE OR REPLACE BITMAP INDEX \"IDX_USERS_EMAIL\" ON \"APP\".\"USERS\" (\"EMAIL\");"]
    );
}

#[test]
fn dameng_replaces_same_name_index_without_unsupported_comment_clause() {
    let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    changed.comment = "New comment".to_string();
    changed.original.as_mut().unwrap().comment = Some("Old comment".to_string());

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE OR REPLACE INDEX \"IDX_USERS_EMAIL\" ON \"APP\".\"USERS\" (\"EMAIL\");"]
    );
}

#[test]
fn dameng_renamed_index_keeps_drop_then_create_path() {
    let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    changed.name = "IDX_USERS_LOGIN".to_string();

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "DROP INDEX \"APP\".\"IDX_USERS_EMAIL\";",
            "CREATE INDEX \"IDX_USERS_LOGIN\" ON \"APP\".\"USERS\" (\"EMAIL\");",
        ]
    );
}

#[test]
fn dameng_renamed_unique_index_uses_constraint_ddl_not_drop_index() {
    // Same root cause as #7959: a renamed constraint-backed index still has to go through
    // DROP/ADD CONSTRAINT rather than DROP INDEX, since DROP INDEX against a
    // constraint-backed index is rejected by Dameng regardless of whether the name changes.
    let mut changed = constraint_backed_unique_index("IDX_USERS_EMAIL", &["EMAIL"]);
    changed.name = "IDX_USERS_LOGIN".to_string();

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"APP\".\"USERS\" DROP CONSTRAINT \"IDX_USERS_EMAIL\";",
            "ALTER TABLE \"APP\".\"USERS\" ADD CONSTRAINT \"IDX_USERS_LOGIN\" UNIQUE (\"EMAIL\");",
        ]
    );
}

#[test]
fn dameng_standalone_unique_index_keeps_index_level_ddl() {
    // A unique index created with CREATE UNIQUE INDEX (Dameng's "real" index — which is also
    // what this editor emits for a new unique index) has no constraint behind it: it is absent
    // from ALL_CONSTRAINTS, so DROP CONSTRAINT would fail with "constraint does not exist".
    // Editing it must stay on the index-level path, otherwise DBX breaks the lifecycle of the
    // unique indexes it creates itself.
    let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], true);
    changed.columns = vec!["EMAIL".to_string(), "TENANT_ID".to_string()];

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE OR REPLACE UNIQUE INDEX \"IDX_USERS_EMAIL\" ON \"APP\".\"USERS\" (\"EMAIL\", \"TENANT_ID\");"]
    );

    let mut renamed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], true);
    renamed.name = "IDX_USERS_LOGIN".to_string();

    let renamed_result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), renamed));

    assert_eq!(renamed_result.warnings, Vec::<String>::new());
    assert_eq!(
        renamed_result.statements,
        vec![
            "DROP INDEX \"APP\".\"IDX_USERS_EMAIL\";",
            "CREATE UNIQUE INDEX \"IDX_USERS_LOGIN\" ON \"APP\".\"USERS\" (\"EMAIL\");",
        ]
    );
}

#[test]
fn dameng_dropping_constraint_backed_unique_index_drops_the_constraint() {
    // Deleting the index of #7959 is broken the same way: DROP INDEX is rejected for a
    // constraint-owned index, so the delete has to drop the constraint instead.
    let mut dropped = constraint_backed_unique_index("IDX_USERS_EMAIL", &["EMAIL"]);
    dropped.marked_for_drop = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), dropped));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"APP\".\"USERS\" DROP CONSTRAINT \"IDX_USERS_EMAIL\";"]);

    // A standalone unique index keeps DROP INDEX.
    let mut standalone = existing_index("IDX_USERS_EMAIL", &["EMAIL"], true);
    standalone.marked_for_drop = true;

    let standalone_result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), standalone));

    assert_eq!(standalone_result.warnings, Vec::<String>::new());
    assert_eq!(standalone_result.statements, vec!["DROP INDEX \"APP\".\"IDX_USERS_EMAIL\";"]);
}

#[test]
fn dameng_constraint_backed_unique_index_edit_reports_unusable_bitmap_type() {
    // BITMAP is honored by CREATE INDEX for Dameng, but a unique constraint always builds a
    // normal index behind itself, so the requested type cannot be carried over silently.
    let mut changed = constraint_backed_unique_index("IDX_USERS_EMAIL", &["EMAIL"]);
    changed.index_type = "bitmap".to_string();

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(
        result.warnings,
        vec![
            "Index type BITMAP is ignored for unique index \"IDX_USERS_EMAIL\": Dameng enforces it with a unique constraint, whose index cannot be a bitmap index."
                .to_string()
        ]
    );
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"APP\".\"USERS\" DROP CONSTRAINT \"IDX_USERS_EMAIL\";",
            "ALTER TABLE \"APP\".\"USERS\" ADD CONSTRAINT \"IDX_USERS_EMAIL\" UNIQUE (\"EMAIL\");",
        ]
    );
}

#[test]
fn dameng_constraint_backed_unique_index_edit_without_columns_emits_nothing() {
    // The empty-column guard of `build_create_index_statements`: dropping the constraint
    // without a valid replacement would silently delete it, so the edit is skipped entirely
    // and only `validate_draft`'s warning remains.
    let mut changed = constraint_backed_unique_index("IDX_USERS_EMAIL", &["EMAIL"]);
    changed.columns = vec!["  ".to_string()];

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), changed));

    assert_eq!(result.warnings, vec!["Index \"IDX_USERS_EMAIL\" needs at least one column.".to_string()]);
    assert!(result.statements.is_empty(), "{:?}", result.statements);
}

#[test]
fn dameng_primary_and_unchanged_indexes_keep_existing_behavior() {
    let unchanged = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    let unchanged_result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), unchanged));
    assert_eq!(unchanged_result.warnings, Vec::<String>::new());
    assert!(unchanged_result.statements.is_empty());

    let mut primary = existing_index("PK_USERS", &["ID"], true);
    primary.columns.push("TENANT_ID".to_string());
    primary.original.as_mut().unwrap().is_primary = true;
    let primary_result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), primary));
    assert!(primary_result.statements.is_empty());
    assert_eq!(primary_result.warnings, vec!["Primary index \"PK_USERS\" cannot be edited from this editor."]);
}

#[test]
fn dameng_new_and_dropped_indexes_do_not_use_or_replace() {
    let new_index = index("IDX_USERS_LOGIN", &["LOGIN"]);
    let new_result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), new_index));
    assert_eq!(new_result.warnings, Vec::<String>::new());
    assert_eq!(new_result.statements, vec!["CREATE INDEX \"IDX_USERS_LOGIN\" ON \"APP\".\"USERS\" (\"LOGIN\");"]);

    let mut dropped = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
    dropped.marked_for_drop = true;
    let drop_result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Dameng, Some("APP"), dropped));
    assert_eq!(drop_result.warnings, Vec::<String>::new());
    assert_eq!(drop_result.statements, vec!["DROP INDEX \"APP\".\"IDX_USERS_EMAIL\";"]);
}

#[test]
fn non_dameng_index_rebuilds_do_not_use_or_replace() {
    for database_type in [
        DatabaseType::Postgres,
        DatabaseType::Sqlite,
        DatabaseType::SqlServer,
        DatabaseType::Oracle,
        DatabaseType::Oscar,
        DatabaseType::H2,
        DatabaseType::Informix,
        DatabaseType::Iris,
    ] {
        let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
        changed.is_unique = true;
        if database_type == DatabaseType::Oracle {
            let original = changed.original.as_mut().unwrap();
            original.key_is_expression = vec![false];
            original.key_directions = vec!["ASC".to_string()];
            original.visibility = Some("VISIBLE".to_string());
            original.key_metadata_complete = true;
        }
        let result = build_table_structure_change_sql(index_change_options(database_type, None, changed));

        assert_eq!(result.warnings, Vec::<String>::new(), "database type: {database_type:?}");
        assert_eq!(result.statements.len(), 2, "database type: {database_type:?}");
        assert!(result.statements[0].starts_with("DROP INDEX "), "database type: {database_type:?}");
        assert!(result.statements[1].starts_with("CREATE UNIQUE INDEX "), "database type: {database_type:?}");
        assert!(
            result.statements.iter().all(|statement| !statement.contains("OR REPLACE")),
            "database type: {database_type:?}"
        );
    }
}

#[test]
fn builds_xugu_type_change_with_native_syntax() {
    let mut code = column("code");
    code.data_type = "bigint".to_string();
    code.original = Some(ColumnInfo {
        name: "code".to_string(),
        data_type: "integer".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Xugu),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "info_x".to_string(),
        column: code,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"info_x\" ALTER COLUMN \"code\" bigint;"]);

    let mut code = column("code");
    code.data_type = "bigint".to_string();
    code.original = Some(ColumnInfo {
        name: "code".to_string(),
        data_type: "integer".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Xugu),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "info_x".to_string(),
        columns: vec![code],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"info_x\" ALTER COLUMN \"code\" bigint;"]);

    let mut postgres_code = column("code");
    postgres_code.data_type = "integer".to_string();
    postgres_code.original = Some(ColumnInfo {
        name: "code".to_string(),
        data_type: "varchar(20)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let postgres_result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "info_x".to_string(),
        column: postgres_code,
    });

    assert_eq!(
        postgres_result.statements,
        vec!["ALTER TABLE \"public\".\"info_x\" ALTER COLUMN \"code\" TYPE integer USING \"code\"::integer;"]
    );
}

#[test]
fn oracle_dialect_indexes_without_oracle_family_metadata_keep_existing_rebuild_behavior() {
    for database_type in [DatabaseType::Iris, DatabaseType::Yashandb, DatabaseType::Xugu] {
        let mut changed = existing_index("IDX_USERS_EMAIL", &["EMAIL"], false);
        changed.is_unique = true;
        let result = build_table_structure_change_sql(index_change_options(database_type, None, changed));

        assert_eq!(result.warnings, Vec::<String>::new(), "{database_type:?}: {result:?}");
        assert_eq!(result.statements.len(), 2, "{database_type:?}: {result:?}");
        assert!(result.statements[0].starts_with("DROP INDEX "), "{database_type:?}: {result:?}");
        assert!(result.statements[1].starts_with("CREATE UNIQUE INDEX "), "{database_type:?}: {result:?}");
    }
}

#[test]
fn builds_postgres_explicit_type_cast_for_renamed_column() {
    let mut code = column("new code");
    code.data_type = "bigint".to_string();
    code.original = Some(ColumnInfo {
        name: "old code".to_string(),
        data_type: "character varying(20)".to_string(),
        is_nullable: true,
        column_default: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "items".to_string(),
        column: code,
    });

    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"items\" RENAME COLUMN \"old code\" TO \"new code\";",
            "ALTER TABLE \"public\".\"items\" ALTER COLUMN \"new code\" TYPE bigint USING \"new code\"::bigint;",
        ]
    );
}

#[test]
fn builds_postgres_atomic_type_change_with_existing_default() {
    let mut code = column("code");
    code.data_type = "varchar(20)".to_string();
    code.default_value = "7".to_string();
    code.original = Some(ColumnInfo {
        name: "code".to_string(),
        data_type: "integer".to_string(),
        is_nullable: true,
        column_default: Some("7".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "items".to_string(),
        column: code,
    });

    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"public\".\"items\" ALTER COLUMN \"code\" DROP DEFAULT, ALTER COLUMN \"code\" TYPE varchar(20) USING \"code\"::varchar(20), ALTER COLUMN \"code\" SET DEFAULT '7';"]
    );
}

#[test]
fn builds_postgres_type_change_that_drops_default() {
    let mut code = column("code");
    code.data_type = "bigint".to_string();
    code.original = Some(ColumnInfo {
        name: "code".to_string(),
        data_type: "character varying".to_string(),
        is_nullable: true,
        column_default: Some("'7'::character varying".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: None,
        table_name: "items".to_string(),
        column: code,
    });

    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"items\" ALTER COLUMN \"code\" DROP DEFAULT, ALTER COLUMN \"code\" TYPE bigint USING \"code\"::bigint;"]
    );
}

#[test]
fn builds_postgres_timestamp_precision_changes_without_losing_timezone_semantics() {
    let mut with_timezone = column("with_timezone");
    with_timezone.data_type = "timestamp(3) with time zone".to_string();
    with_timezone.original = Some(ColumnInfo {
        name: "with_timezone".to_string(),
        data_type: "timestamp(6) with time zone".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let with_timezone_result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "events".to_string(),
        column: with_timezone,
    });
    assert_eq!(
        with_timezone_result.statements,
        vec![
            r#"ALTER TABLE "public"."events" ALTER COLUMN "with_timezone" TYPE timestamp(3) with time zone USING "with_timezone"::timestamp(3) with time zone;"#
        ]
    );

    let mut without_timezone = column("without_timezone");
    without_timezone.data_type = "timestamp(3) without time zone".to_string();
    without_timezone.original = Some(ColumnInfo {
        name: "without_timezone".to_string(),
        data_type: "timestamp(6) without time zone".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let without_timezone_result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "events".to_string(),
        column: without_timezone,
    });
    assert_eq!(
        without_timezone_result.statements,
        vec![
            r#"ALTER TABLE "public"."events" ALTER COLUMN "without_timezone" TYPE timestamp(3) without time zone USING "without_timezone"::timestamp(3) without time zone;"#
        ]
    );
}

#[test]
fn builds_xugu_timezone_temporal_precision_in_final_ddl() {
    let mut local_time = column("local_time");
    local_time.data_type = "TIME(3) WITH TIME ZONE".to_string();
    let mut created_at = column("created_at");
    created_at.data_type = "TIMESTAMP(6) WITH TIME ZONE".to_string();
    let created = build_create_table_sql(structure_change_options(
        DatabaseType::Xugu,
        Some("public"),
        "events",
        vec![local_time, created_at],
    ));
    assert_eq!(
        created.statements,
        vec![
            r#"CREATE TABLE "public"."events" (
  "local_time" TIME(3) WITH TIME ZONE,
  "created_at" TIMESTAMP(6) WITH TIME ZONE
);"#
        ]
    );

    let mut altered_at = column("created_at");
    altered_at.data_type = "TIMESTAMP(6) WITH TIME ZONE".to_string();
    altered_at.original = Some(ColumnInfo {
        name: "created_at".to_string(),
        data_type: "TIMESTAMP".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let altered = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Xugu),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "events".to_string(),
        column: altered_at,
    });
    assert_eq!(
        altered.statements,
        vec![r#"ALTER TABLE "public"."events" ALTER COLUMN "created_at" TIMESTAMP(6) WITH TIME ZONE;"#]
    );
}

#[test]
fn builds_postgres_array_and_domain_type_casts_without_affecting_xugu() {
    let mut tags = column("tags");
    tags.data_type = "text[]".to_string();
    tags.original = Some(ColumnInfo {
        name: "tags".to_string(),
        data_type: "varchar(20)[]".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let postgres = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("catalog".to_string()),
        table_name: "items".to_string(),
        column: tags,
    });
    assert_eq!(
        postgres.statements,
        vec!["ALTER TABLE \"catalog\".\"items\" ALTER COLUMN \"tags\" TYPE text[] USING \"tags\"::text[];"]
    );

    let mut status = column("status");
    status.data_type = "catalog.status_domain".to_string();
    status.original = Some(ColumnInfo {
        name: "status".to_string(),
        data_type: "text".to_string(),
        is_nullable: true,
        ..Default::default()
    });
    let postgres = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("catalog".to_string()),
        table_name: "items".to_string(),
        column: status,
    });
    assert_eq!(
        postgres.statements,
        vec!["ALTER TABLE \"catalog\".\"items\" ALTER COLUMN \"status\" TYPE catalog.status_domain USING \"status\"::catalog.status_domain;"]
    );
}

#[test]
fn builds_mysql_unsigned_integer_column_with_length_before_attribute() {
    let mut score = column("score");
    score.data_type = "int unsigned(11)".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![score],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` ADD COLUMN `score` int(11) unsigned;"]);
}

#[test]
fn doris_table_editor_renames_column_without_mysql_change_syntax() {
    let mut renamed = column("dtp_flag_jt");
    renamed.data_type = "int".to_string();
    renamed.comment = "Group DTP".to_string();
    renamed.original = Some(ColumnInfo {
        name: "dtp_flag".to_string(),
        data_type: "int".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some("Group DTP".to_string()),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Doris),
        driver_profile: None,
        schema: Some("qybiprod".to_string()),
        table_name: "dim_prod_sp_vkorg".to_string(),
        columns: vec![renamed],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `dim_prod_sp_vkorg` RENAME COLUMN `dtp_flag` `dtp_flag_jt`;"]);
}

#[test]
fn doris_single_column_alter_renames_then_modifies_column_definition() {
    let mut renamed = column("dtp_flag_jt");
    renamed.data_type = "int".to_string();
    renamed.comment = "Group DTP".to_string();
    renamed.original = Some(ColumnInfo {
        name: "dtp_flag".to_string(),
        data_type: "int".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some("Division DTP".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Doris),
        driver_profile: None,
        schema: Some("qybiprod".to_string()),
        table_name: "dim_prod_sp_vkorg".to_string(),
        column: renamed,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `dim_prod_sp_vkorg` RENAME COLUMN `dtp_flag` `dtp_flag_jt`;",
            "ALTER TABLE `dim_prod_sp_vkorg` MODIFY COLUMN `dtp_flag_jt` int COMMENT 'Group DTP';",
        ]
    );
}

#[test]
fn dameng_integer_column_omits_mysql_display_width() {
    let mut age = column("age");
    age.data_type = "integer(11)".to_string();
    let mut amount = column("amount");
    amount.data_type = "number(10,0)".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "users".to_string(),
        columns: vec![age, amount],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" ADD (\"age\" INTEGER);",
            "ALTER TABLE \"SYSDBA\".\"users\" ADD (\"amount\" NUMBER(10,0));",
        ]
    );
}

#[test]
fn builds_highgo_foreign_key_changes_with_postgres_syntax() {
    let mut old_fk = foreign_key("orders_user_id_fkey", "user_id", "users", "id");
    old_fk.marked_for_drop = true;
    old_fk.original = Some(ForeignKeyInfo {
        name: "orders_user_id_fkey".to_string(),
        column: "user_id".to_string(),
        ref_schema: Some("public".to_string()),
        ref_table: "users".to_string(),
        ref_column: "id".to_string(),
        on_update: None,
        on_delete: None,
    });
    let mut new_fk = foreign_key("orders_account_id_fkey", "account_id", "accounts", "id");
    new_fk.ref_schema = "crm".to_string();
    new_fk.on_delete = "CASCADE".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Highgo),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: vec![old_fk, new_fk],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"orders\" DROP CONSTRAINT \"orders_user_id_fkey\";",
            "ALTER TABLE \"public\".\"orders\" ADD CONSTRAINT \"orders_account_id_fkey\" FOREIGN KEY (\"account_id\") REFERENCES \"crm\".\"accounts\" (\"id\") ON DELETE CASCADE;",
        ]
    );
}

#[test]
fn builds_informix_column_and_index_changes() {
    let mut renamed = column("display_name");
    renamed.data_type = "varchar(120)".to_string();
    renamed.is_nullable = false;
    renamed.default_value = "guest".to_string();
    renamed.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(80)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });
    let mut email = column("email");
    email.is_nullable = false;
    let mut old_col = column("old_col");
    old_col.marked_for_drop = true;
    old_col.original = Some(ColumnInfo {
        name: "old_col".to_string(),
        data_type: "varchar(20)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let mut old_index = index("idx_old", &["name"]);
    old_index.marked_for_drop = true;
    old_index.original = Some(IndexInfo {
        name: "idx_old".to_string(),
        columns: vec!["name".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });
    let mut email_index = index("uniq_users_email", &["email"]);
    email_index.is_unique = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Informix),
        driver_profile: None,
        schema: Some("gbasedbt".to_string()),
        table_name: "users".to_string(),
        columns: vec![renamed, email, old_col],
        indexes: vec![old_index, email_index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "RENAME COLUMN gbasedbt.users.name TO display_name;",
            "ALTER TABLE gbasedbt.users MODIFY (display_name varchar(120) NOT NULL DEFAULT 'guest');",
            "ALTER TABLE gbasedbt.users ADD (email varchar(255) NOT NULL);",
            "ALTER TABLE gbasedbt.users DROP (old_col);",
            "DROP INDEX gbasedbt.idx_old;",
            "CREATE UNIQUE INDEX uniq_users_email ON gbasedbt.users (email);",
        ]
    );
}

#[test]
fn oracle_does_not_generate_drop_sql_for_all_columns() {
    let mut id = column("id");
    id.marked_for_drop = true;
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "varchar2(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let mut name = column("name");
    name.marked_for_drop = true;
    name.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar2(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("DBX_TEST".to_string()),
        table_name: "test".to_string(),
        columns: vec![id, name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(
        result.warnings,
        vec![
            "Oracle does not allow dropping all columns from a table. Keep at least one column or drop the table instead."
        ]
    );
}

#[test]
fn oracle_timestamp_default_precedes_nullability_in_modify_sql() {
    let mut col = column("time");
    col.data_type = "TIMESTAMP(6)".to_string();
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.original = Some(ColumnInfo {
        name: "time".to_string(),
        data_type: "TIMESTAMP(6)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("DBX_TEST".to_string()),
        table_name: "test".to_string(),
        column: col,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"DBX_TEST\".\"test\" MODIFY (\"time\" TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP);"]
    );
}

#[test]
fn oracle_create_table_places_default_before_not_null() {
    // Oracle's column grammar is `col type [DEFAULT expr] [NOT NULL]`. Cloning a table whose
    // NOT NULL column carries a default used to emit `NOT NULL DEFAULT ...`, which the server
    // rejects with ORA-00907 (t8y2/dbx#9477).
    let mut id = column("ID");
    id.data_type = "NUMBER(10)".to_string();
    id.is_primary_key = true;
    let mut status = column("STATUS");
    status.data_type = "VARCHAR2(1 BYTE)".to_string();
    status.is_nullable = false;
    status.default_value = "'A'".to_string();
    let mut created_at = column("CREATED_AT");
    created_at.data_type = "DATE".to_string();
    created_at.is_nullable = false;
    created_at.default_value = "SYSDATE".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "ORDERS_COPY".to_string(),
        columns: vec![id, status, created_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(
        result.statements[0].contains("\"STATUS\" VARCHAR2(1 BYTE) DEFAULT 'A' NOT NULL"),
        "ddl: {}",
        result.statements[0]
    );
    assert!(result.statements[0].contains("CREATED_AT DATE DEFAULT SYSDATE NOT NULL"), "ddl: {}", result.statements[0]);
    assert!(!result.statements[0].contains("NOT NULL DEFAULT"), "ddl: {}", result.statements[0]);
}

#[test]
fn oracle_add_column_keeps_not_null_after_default() {
    // `ADD (...)` used to drop NOT NULL entirely for Oracle, so a column the user marked
    // not nullable was created nullable without any error (t8y2/dbx#11234).
    let cases = [
        (
            "QTY",
            "NUMBER(18,2)",
            false,
            "0",
            "ALTER TABLE \"HR\".\"orders\" ADD (\"QTY\" NUMBER(18,2) DEFAULT 0 NOT NULL);",
        ),
        ("CODE", "VARCHAR2(20)", false, "", "ALTER TABLE \"HR\".\"orders\" ADD (\"CODE\" VARCHAR2(20) NOT NULL);"),
        ("NOTE", "VARCHAR2(20)", true, "", "ALTER TABLE \"HR\".\"orders\" ADD (\"NOTE\" VARCHAR2(20));"),
    ];

    for (name, data_type, is_nullable, default_value, expected) in cases {
        let mut col = column(name);
        col.data_type = data_type.to_string();
        col.is_nullable = is_nullable;
        col.default_value = default_value.to_string();

        let result = build_table_structure_change_sql(structure_change_options(
            DatabaseType::Oracle,
            Some("HR"),
            "orders",
            vec![col],
        ));

        assert_eq!(result.warnings, Vec::<String>::new(), "{name}");
        assert_eq!(result.statements, vec![expected], "{name}");
    }
}

#[test]
fn oracle_create_table_preserves_character_length_units() {
    let mut byte_col = column("BYTE_COL");
    byte_col.data_type = "VARCHAR2(12 BYTE)".to_string();
    let mut char_col = column("CHAR_COL");
    char_col.data_type = "VARCHAR2(12 CHAR)".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("DBX_APP".to_string()),
        table_name: "DBX_ISSUE_4739".to_string(),
        columns: vec![byte_col, char_col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert!(result.statements[0].contains("BYTE_COL VARCHAR2(12 BYTE)"));
    assert!(result.statements[0].contains("CHAR_COL VARCHAR2(12 CHAR)"));
}

#[test]
fn oracle_create_table_uses_unquoted_identifiers_for_new_objects() {
    let mut user_id = column("user_id");
    user_id.data_type = "NUMBER".to_string();
    user_id.is_primary_key = true;
    user_id.comment = "identifier".to_string();
    let mut user_name = column("userName");
    user_name.data_type = "VARCHAR2(100)".to_string();
    let mut upper_id = column("USER_CODE");
    upper_id.data_type = "NUMBER".to_string();
    let mut dollar_id = column("ABC$01");
    dollar_id.data_type = "NUMBER".to_string();
    let mut hash_id = column("ABC#01");
    hash_id.data_type = "NUMBER".to_string();
    let idx = index("idx_user_id", &["user_id"]);

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "orders".to_string(),
        columns: vec![user_id, user_name, upper_id, dollar_id, hash_id],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: Some("user table".to_string()),
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements[0],
        "CREATE TABLE \"APP\".orders (\n  user_id NUMBER,\n  userName VARCHAR2(100),\n  USER_CODE NUMBER,\n  ABC$01 NUMBER,\n  ABC#01 NUMBER,\n  PRIMARY KEY (user_id)\n);"
    );
    assert!(result.statements.iter().any(|statement| statement == "COMMENT ON TABLE \"APP\".orders IS 'user table';"));
    assert!(result
        .statements
        .iter()
        .any(|statement| statement == "COMMENT ON COLUMN \"APP\".orders.user_id IS 'identifier';"));
    assert!(result
        .statements
        .iter()
        .any(|statement| statement == "CREATE INDEX idx_user_id ON \"APP\".orders (user_id);"));
}

#[test]
fn oracle_create_table_leaves_uppercase_regular_identifier_unquoted() {
    let mut user_id = column("USER_ID");
    user_id.data_type = "NUMBER".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: None,
        table_name: "USERS".to_string(),
        columns: vec![user_id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE TABLE USERS (\n  USER_ID NUMBER\n);".to_string()]);
}

#[test]
fn oracle_create_table_quotes_special_and_reserved_identifiers() {
    let mut special = column("user name");
    special.data_type = "VARCHAR2(100)".to_string();
    special.comment = "special".to_string();
    let mut escaped = column(r#"a"b"#);
    escaped.data_type = "VARCHAR2(100)".to_string();
    let mut select = column("SELECT");
    select.data_type = "VARCHAR2(100)".to_string();
    let mut from = column("FROM");
    from.data_type = "VARCHAR2(100)".to_string();
    let mut table = column("TABLE");
    table.data_type = "VARCHAR2(100)".to_string();
    let mut leading_digit = column("123column");
    leading_digit.data_type = "VARCHAR2(100)".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "order detail".to_string(),
        columns: vec![special, escaped, select, from, table, leading_digit],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    let ddl = &result.statements[0];
    assert!(ddl.starts_with("CREATE TABLE \"APP\".\"order detail\" ("));
    assert!(ddl.contains("\"user name\" VARCHAR2(100)"));
    assert!(ddl.contains("\"a\"\"b\" VARCHAR2(100)"));
    assert!(ddl.contains("\"SELECT\" VARCHAR2(100)"));
    assert!(ddl.contains("\"FROM\" VARCHAR2(100)"));
    assert!(ddl.contains("\"TABLE\" VARCHAR2(100)"));
    assert!(ddl.contains("\"123column\" VARCHAR2(100)"));
    assert!(result
        .statements
        .iter()
        .any(|statement| statement == "COMMENT ON COLUMN \"APP\".\"order detail\".\"user name\" IS 'special';"));
}

#[test]
fn oracle_create_table_distinguishes_new_and_referenced_foreign_key_identifiers() {
    let mut user_id = column("user_id");
    user_id.data_type = "NUMBER".to_string();
    let mut customer_fk = foreign_key("fk_orders_user", "user_id", "CamelCase", "UserName");
    customer_fk.ref_schema = "CaseSchema".to_string();
    let audit_trigger = trigger("auditTrigger", "BEFORE", "INSERT", "BEGIN\n  NULL;\nEND");

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "orders".to_string(),
        columns: vec![user_id],
        indexes: Vec::new(),
        foreign_keys: vec![customer_fk],
        triggers: vec![audit_trigger],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE \"APP\".orders (\n  user_id NUMBER\n);",
            "ALTER TABLE \"APP\".orders ADD CONSTRAINT fk_orders_user FOREIGN KEY (user_id) REFERENCES \"CaseSchema\".\"CamelCase\" (\"UserName\");",
            "CREATE OR REPLACE TRIGGER \"APP\".auditTrigger BEFORE INSERT ON \"APP\".orders\nFOR EACH ROW\nBEGIN\n  NULL;\nEND;",
        ]
    );
}

#[test]
fn oracle_create_table_extracts_single_line_trigger_source_into_the_body() {
    let mut id = column("id");
    id.data_type = "NUMBER".to_string();
    // Oracle returns ALL_SOURCE verbatim when a trigger is written on a single line, so the
    // declaration must be stripped before it is appended after `FOR EACH ROW`. t8y2/dbx#9731.
    let cloned_trigger = trigger(
        "DBX_V1_TRG_COPY_TRG1",
        "BEFORE",
        "INSERT",
        "TRIGGER dbx_v1_trg_bi BEFORE INSERT ON dbx_v1_trg FOR EACH ROW BEGIN NULL; END;",
    );

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "dbx_copy".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![cloned_trigger],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE \"APP\".dbx_copy (\n  \"id\" NUMBER\n);",
            "CREATE OR REPLACE TRIGGER \"APP\".DBX_V1_TRG_COPY_TRG1 BEFORE INSERT ON \"APP\".dbx_copy\nFOR EACH ROW\nBEGIN NULL; END;",
        ]
    );
}

#[test]
fn oracle_create_table_warns_instead_of_emitting_an_unparsed_trigger_declaration() {
    let mut id = column("id");
    id.data_type = "NUMBER".to_string();
    let unsplittable = trigger("odd_trg", "BEFORE", "INSERT", "TRIGGER odd_trg COMPOUND TRIGGER");

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "dbx_copy".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![unsplittable],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, vec!["CREATE TABLE \"APP\".dbx_copy (\n  \"id\" NUMBER\n);"]);
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("odd_trg"), "unexpected warning: {:?}", result.warnings);
}

#[test]
fn oracle_existing_quoted_identifiers_keep_exact_spelling() {
    let mut column = column("CamelCase");
    column.data_type = "NUMBER".to_string();
    column.original = Some(ColumnInfo {
        name: "CamelCase".to_string(),
        data_type: "VARCHAR2(100)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("CaseSchema".to_string()),
        table_name: "CaseTable".to_string(),
        columns: vec![column],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"CaseSchema\".\"CaseTable\" MODIFY (\"CamelCase\" NUMBER);".to_string()]
    );
}

#[test]
fn oracle_new_identifier_formatting_does_not_change_other_dialects() {
    for (database_type, expected) in [
        (DatabaseType::Postgres, "CREATE TABLE \"users\" (\n  \"user_id\" INTEGER\n);"),
        (DatabaseType::Mysql, "CREATE TABLE `users` (\n  `user_id` INTEGER\n);"),
        (DatabaseType::SqlServer, "CREATE TABLE [users] (\n  [user_id] INTEGER\n);"),
        (DatabaseType::Dameng, "CREATE TABLE \"users\" (\n  \"user_id\" INTEGER\n);"),
    ] {
        let mut user_id = column("user_id");
        user_id.data_type = "INTEGER".to_string();
        let result = build_create_table_sql(TableStructureSqlOptions {
            database_type: Some(database_type),
            driver_profile: None,
            schema: None,
            table_name: "users".to_string(),
            columns: vec![user_id],
            indexes: Vec::new(),
            foreign_keys: Vec::new(),
            triggers: Vec::new(),
            table_comment: None,
            original_table_comment: None,
            mysql_engine: None,
            mysql_auto_increment_value: None,
            transwarp_create: None,
            partitioned: false,
            foreign_table: false,
            is_gaussdb_m_mode: false,
            table_collation: None,
            primary_key_name: None,
            primary_key_change: None,
            oracle_constraint_changes: None,
            oracle_foreign_key_changes: None,
        });

        assert_eq!(result.warnings, Vec::<String>::new(), "{database_type:?}");
        assert_eq!(result.statements, vec![expected.to_string()], "{database_type:?}");
    }
}

#[test]
fn oracle_alter_column_preserves_character_length_unit() {
    let mut column = column("DISPLAY_NAME");
    column.data_type = "VARCHAR2(64 CHAR)".to_string();
    column.original = Some(ColumnInfo {
        name: "DISPLAY_NAME".to_string(),
        data_type: "VARCHAR2(64 BYTE)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("DBX_APP".to_string()),
        table_name: "DBX_ISSUE_4739".to_string(),
        column,
    });

    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"DBX_APP\".\"DBX_ISSUE_4739\" MODIFY (\"DISPLAY_NAME\" VARCHAR2(64 CHAR));"]
    );
}

#[test]
fn oracle_timestamp_precision_change_does_not_repeat_unchanged_nullability() {
    let mut col = column("time");
    col.data_type = "TIMESTAMP(9)".to_string();
    col.original = Some(ColumnInfo {
        name: "time".to_string(),
        data_type: "TIMESTAMP(6)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("DBX_TEST".to_string()),
        table_name: "test".to_string(),
        column: col,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"DBX_TEST\".\"test\" MODIFY (\"time\" TIMESTAMP(9));"]);
}

#[test]
fn iris_drop_index_includes_table_name() {
    let mut old_index = index("index_id", &["ID"]);
    old_index.marked_for_drop = true;
    old_index.original = Some(IndexInfo {
        name: "index_id".to_string(),
        columns: vec!["ID".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Iris),
        driver_profile: None,
        schema: Some("SQLUSER".to_string()),
        table_name: "tb_a".to_string(),
        columns: Vec::new(),
        indexes: vec![old_index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["DROP INDEX \"index_id\" ON TABLE \"SQLUSER\".\"tb_a\";"]);
}

#[test]
fn iris_ignores_comment_changes_but_keeps_supported_column_alters() {
    let mut renamed = column("DISPLAY_NAME");
    renamed.data_type = "VARCHAR(40)".to_string();
    renamed.is_nullable = true;
    renamed.default_value = "'after'".to_string();
    renamed.comment = "new description".to_string();
    renamed.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR(20)".to_string(),
        is_nullable: false,
        column_default: Some("before".to_string()),
        is_primary_key: false,
        extra: None,
        comment: Some("old description".to_string()),
        ..Default::default()
    });
    let mut created_at = column("CREATED_AT");
    created_at.data_type = "TIMESTAMP".to_string();
    created_at.default_value = "CURRENT_TIMESTAMP".to_string();
    created_at.comment = "creation time".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Iris),
        driver_profile: None,
        schema: Some("SQLUSER".to_string()),
        table_name: "DBX_ISSUE_1678".to_string(),
        columns: vec![renamed, created_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: Some("new table description".to_string()),
        original_table_comment: Some("old table description".to_string()),
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SQLUSER\".\"DBX_ISSUE_1678\" ALTER COLUMN \"NAME\" RENAME \"DISPLAY_NAME\";",
            "ALTER TABLE \"SQLUSER\".\"DBX_ISSUE_1678\" MODIFY (\"DISPLAY_NAME\" VARCHAR(40) DEFAULT 'after' NULL);",
            "ALTER TABLE \"SQLUSER\".\"DBX_ISSUE_1678\" ADD (\"CREATED_AT\" TIMESTAMP DEFAULT CURRENT_TIMESTAMP);",
        ]
    );
    assert_eq!(
        result.warnings,
        vec![
            "Column comments are not supported for iris from this editor; the comment change for \"NAME\" was ignored.",
            "Column comments are not supported for iris from this editor; the comment for \"CREATED_AT\" was ignored.",
            "Table comments are not supported for iris from this editor; the comment change was ignored.",
        ]
    );
    assert!(result.statements.iter().all(|statement| !statement.contains("COMMENT ON")));
}

#[test]
fn iris_comment_only_change_returns_warning_without_sql() {
    let mut name = column("NAME");
    name.comment = "new description".to_string();
    name.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some("old description".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Iris),
        driver_profile: None,
        schema: Some("SQLUSER".to_string()),
        table_name: "DBX_ISSUE_1678".to_string(),
        column: name,
    });

    assert!(result.statements.is_empty());
    assert_eq!(
        result.warnings,
        vec![
            "Column comments are not supported for iris from this editor; the comment change for \"NAME\" was ignored."
        ]
    );
}

#[test]
fn oracle_compatible_databases_keep_comment_on_sql() {
    for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
        let mut name = column("NAME");
        name.comment = "new description".to_string();
        name.original = Some(ColumnInfo {
            name: "NAME".to_string(),
            data_type: "varchar(255)".to_string(),
            is_nullable: true,
            column_default: None,
            is_primary_key: false,
            extra: None,
            comment: Some("old description".to_string()),
            ..Default::default()
        });

        let result = build_table_structure_change_sql(TableStructureSqlOptions {
            database_type: Some(database_type),
            driver_profile: None,
            schema: Some("APP".to_string()),
            table_name: "USERS".to_string(),
            columns: vec![name],
            indexes: Vec::new(),
            foreign_keys: Vec::new(),
            triggers: Vec::new(),
            table_comment: Some("new table description".to_string()),
            original_table_comment: Some("old table description".to_string()),
            mysql_engine: None,
            mysql_auto_increment_value: None,
            transwarp_create: None,
            partitioned: false,
            foreign_table: false,
            is_gaussdb_m_mode: false,
            table_collation: None,
            primary_key_name: None,
            primary_key_change: None,
            oracle_constraint_changes: None,
            oracle_foreign_key_changes: None,
        });

        assert_eq!(result.warnings, Vec::<String>::new(), "{database_type:?}");
        assert_eq!(
            result.statements,
            vec![
                "COMMENT ON COLUMN \"APP\".\"USERS\".\"NAME\" IS 'new description';",
                "COMMENT ON TABLE \"APP\".\"USERS\" IS 'new table description';",
            ],
            "{database_type:?}"
        );
    }
}

#[test]
fn mysql_create_index_with_comment() {
    let mut col = column("name");
    col.data_type = "varchar(120)".to_string();
    let mut idx = index("idx_users_name", &["name"]);
    idx.comment = "Search index".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` ADD COLUMN `name` varchar(120);",
            "CREATE INDEX `idx_users_name` ON `users` (`name`) COMMENT 'Search index';",
        ]
    );
}

#[test]
fn manticoresearch_builds_create_table_sql_only() {
    let mut title = column("title");
    title.data_type = "text".to_string();
    title.is_nullable = false;
    let mut views = column("views");
    views.data_type = "int".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![title, views],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE TABLE `materials` (\n  `title` text,\n  `views` int\n);"]);
}

#[test]
fn manticoresearch_builds_add_and_drop_column_sql() {
    let mut old_code = column("code");
    old_code.data_type = "string".to_string();
    old_code.marked_for_drop = true;
    old_code.original = Some(ColumnInfo {
        name: "code".to_string(),
        data_type: "string".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut name = column("name");
    name.data_type = "string".to_string();
    name.extra =
        Some(ColumnExtra { manticore_attribute: Some(true), manticore_indexed: Some(true), ..Default::default() });
    let mut resource = column("resource");
    resource.data_type = "json".to_string();
    resource.extra = Some(ColumnExtra { manticore_secondary_index: Some(true), ..Default::default() });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![old_code, name, resource],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `materials` DROP COLUMN `code`;",
            "ALTER TABLE `materials` ADD COLUMN `name` string attribute indexed;",
            "ALTER TABLE `materials` ADD COLUMN `resource` json secondary_index='1';",
        ]
    );
}

#[test]
fn gbase8a_uses_limited_mysql_ddl() {
    let mut renamed = column("display_email");
    renamed.data_type = "varchar(255)".to_string();
    renamed.original = Some(ColumnInfo {
        name: "email".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let new_col = column("nickname");
    let mut old_col = column("old_col");
    old_col.marked_for_drop = true;
    old_col.original = Some(ColumnInfo {
        name: "old_col".to_string(),
        data_type: "varchar(20)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let mut index = index("idx_users_email", &["display_email"]);
    index.original = Some(IndexInfo {
        name: "idx_users_email".to_string(),
        columns: vec!["email".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Gbase),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![renamed, new_col, old_col],
        indexes: vec![index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` CHANGE COLUMN `email` `display_email` varchar(255);",
            "ALTER TABLE `users` ADD COLUMN `nickname` varchar(255);",
            "ALTER TABLE `users` DROP COLUMN `old_col`;",
        ]
    );
    assert_eq!(
        result.warnings,
        vec!["Editing existing indexes is not supported for gbase from this editor.".to_string()]
    );
}

#[test]
fn gbase8a_allows_mysql_style_column_reorder() {
    let mut id = column("id");
    id.original_position = Some(0);
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut name = column("name");
    name.original_position = Some(1);
    name.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut email = column("email");
    email.original_position = Some(2);
    email.original = Some(ColumnInfo {
        name: "email".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Gbase),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![id, email, name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) AFTER `email`;"]);
}

// Regression test for issue #8003: GBase 8s is Informix-compatible, not
// MySQL-compatible like the rest of the `Gbase` family (GBase 8a), and was
// generating backtick-quoted MySQL DDL that real GBase 8s servers reject
// outright with a syntax error. Verified against a live GBase 8s 8.8 instance:
// the MySQL-style output below (backticks, bare `datetime`) fails to execute,
// while unquoted identifiers plus an Informix-qualified `datetime year to
// second` type succeed.
#[test]
fn gbase8s_uses_informix_ddl_not_mysql() {
    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Gbase8s),
        driver_profile: None,
        schema: Some("gbasedbt".to_string()),
        table_name: "issue8003_repro".to_string(),
        columns: vec![
            {
                let mut id = column("id");
                id.data_type = "int".to_string();
                id.is_primary_key = true;
                id
            },
            {
                let mut created_at = column("created_at");
                created_at.data_type = "datetime year to second".to_string();
                created_at.is_nullable = true;
                created_at
            },
        ],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE gbasedbt.issue8003_repro (\n  id int,\n  created_at datetime year to second,\n  PRIMARY KEY (id)\n);"]
    );
    // The MySQL-family driver_profile-less case must be unaffected.
    for statement in &result.statements {
        assert!(!statement.contains('`'), "GBase 8s DDL must not use MySQL backtick quoting: {statement}");
    }
}

#[test]
fn gbase_without_driver_profile_still_uses_mysql_ddl() {
    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Gbase),
        driver_profile: None,
        schema: None,
        table_name: "issue8003_repro".to_string(),
        columns: vec![{
            let mut id = column("id");
            id.data_type = "int".to_string();
            id.is_primary_key = true;
            id
        }],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE TABLE `issue8003_repro` (\n  `id` int,\n  PRIMARY KEY (`id`)\n);"]);
}

#[test]
fn manticoresearch_does_not_drop_id_column() {
    let mut id = column("id");
    id.data_type = "bigint".to_string();
    id.marked_for_drop = true;
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "bigint".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(result.warnings, vec!["Manticore Search id column cannot be dropped from this editor."]);
}

#[test]
fn manticoresearch_warns_when_existing_column_properties_change() {
    let mut name = column("name");
    name.data_type = "string".to_string();
    name.extra = Some(ColumnExtra {
        manticore_indexed: Some(true),
        manticore_stored: Some(true),
        manticore_attribute: Some(true),
        ..Default::default()
    });
    name.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "string".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut resource = column("resource");
    resource.data_type = "json".to_string();
    resource.extra = Some(ColumnExtra { manticore_secondary_index: Some(true), ..Default::default() });
    resource.original = Some(ColumnInfo {
        name: "resource".to_string(),
        data_type: "json".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut old_resource = column("old_resource");
    old_resource.data_type = "json".to_string();
    old_resource.extra = Some(ColumnExtra::default());
    old_resource.original = Some(ColumnInfo {
        name: "old_resource".to_string(),
        data_type: "json".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("secondary_index='1'".to_string()),
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![name, resource, old_resource],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(
        result.warnings,
        vec![
            "Editing existing columns is not supported for manticoresearch yet.",
            "Editing existing columns is not supported for manticoresearch yet.",
            "Editing existing columns is not supported for manticoresearch yet.",
        ]
    );
}

#[test]
fn manticoresearch_ignores_mysql_column_options() {
    let mut title = column("title");
    title.data_type = "text".to_string();
    title.is_nullable = false;
    title.is_primary_key = true;
    title.default_value = "'untitled'".to_string();
    title.comment = "Title text".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![title],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE TABLE `materials` (\n  `title` text\n);"]);
}

#[test]
fn manticoresearch_builds_text_column_properties() {
    let mut title = column("title");
    title.data_type = "text".to_string();
    title.extra =
        Some(ColumnExtra { manticore_indexed: Some(true), manticore_stored: Some(true), ..Default::default() });
    let mut sku = column("sku");
    sku.data_type = "string".to_string();
    sku.extra =
        Some(ColumnExtra { manticore_indexed: Some(true), manticore_attribute: Some(true), ..Default::default() });
    let mut name = column("name");
    name.data_type = "string".to_string();
    name.extra = Some(ColumnExtra {
        manticore_indexed: Some(true),
        manticore_stored: Some(true),
        manticore_attribute: Some(true),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![title, sku, name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE `materials` (\n  `title` text stored indexed,\n  `sku` string attribute indexed,\n  `name` string stored attribute indexed\n);"
        ]
    );
}

#[test]
fn manticoresearch_builds_json_secondary_index_property() {
    let mut metadata = column("metadata");
    metadata.data_type = "json".to_string();
    metadata.extra = Some(ColumnExtra { manticore_secondary_index: Some(true), ..Default::default() });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ManticoreSearch),
        driver_profile: None,
        schema: None,
        table_name: "materials".to_string(),
        columns: vec![metadata],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE TABLE `materials` (\n  `metadata` json secondary_index='1'\n);"]);
}

#[test]
fn mysql_create_unique_index_with_comment_and_btree() {
    let mut idx = index("uniq_users_email", &["email"]);
    idx.is_unique = true;
    idx.index_type = "BTREE".to_string();
    idx.comment = "Unique email index".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: Vec::new(),
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE UNIQUE INDEX `uniq_users_email` USING BTREE ON `users` (`email`) COMMENT 'Unique email index';",]
    );
}

#[test]
fn mysql_create_functional_index_preserves_key_part_syntax() {
    let functional_key_part = "((case when (`STATUS` = _utf8mb4'online') then _utf8mb4'online' else NULL end))";
    let mut idx = index("test_UNIQUE", &["attr", "attr2", functional_key_part]);
    idx.is_unique = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "test".to_string(),
        columns: Vec::new(),
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![format!("CREATE UNIQUE INDEX `test_UNIQUE` ON `test` (`attr`, `attr2`, {functional_key_part});")]
    );
}

#[test]
fn mysql_add_timestamp_column_drops_invalid_precision() {
    let mut created_at = column("created_at");
    created_at.data_type = "timestamp(255)".to_string();
    created_at.default_value = "CURRENT_TIMESTAMP".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![created_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` ADD COLUMN `created_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP;"]
    );
}

#[test]
fn mysql_add_timestamp_column_preserves_valid_precision() {
    let mut created_at = column("created_at");
    created_at.data_type = "timestamp(3)".to_string();
    created_at.default_value = "CURRENT_TIMESTAMP(3)".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![created_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` ADD COLUMN `created_at` timestamp(3) NULL DEFAULT CURRENT_TIMESTAMP(3);"]
    );
}

#[test]
fn builds_postgres_create_table_with_comments_and_index() {
    let mut id = column("id");
    id.data_type = "integer".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    let mut name = column("name");
    name.data_type = "text".to_string();
    name.comment = "Display name".to_string();
    let mut idx = index("idx_users_name", &["name"]);
    idx.index_type = "gin".to_string();
    idx.comment = "search".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "users".to_string(),
        columns: vec![id, name],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE \"public\".\"users\" (\n  \"id\" integer,\n  \"name\" text,\n  PRIMARY KEY (\"id\")\n);",
            "COMMENT ON COLUMN \"public\".\"users\".\"name\" IS 'Display name';",
            "CREATE INDEX \"idx_users_name\" ON \"public\".\"users\" USING GIN (\"name\");",
            "COMMENT ON INDEX \"idx_users_name\" IS 'search';",
        ]
    );
}

#[test]
fn quotes_expression_like_new_index_columns_without_provenance() {
    let expression_like_column = "COALESCE(height, '-1'::integer::double precision)";
    let idx = index("idx_expression_like_column", &[expression_like_column]);

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Kingbase),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "tankong_data".to_string(),
        columns: vec![column(expression_like_column)],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements.iter().any(|statement| statement.contains(&format!("(\"{expression_like_column}\")"))));
}

#[test]
fn preserves_key_provenance_when_rebuilding_an_untouched_postgres_index() {
    // PR #6312 review: a quoted column identifier can legitimately contain whitespace, `(`,
    // or `::` (e.g. PostgreSQL metadata returning the ordinary column name `order item`
    // through a.attname). Regenerating an *unedited* existing index (e.g. only its uniqueness
    // changed) must trust the original snapshot's real per-key provenance rather than guessing
    // from characters, so a weirdly-named real column stays quoted and only the genuine
    // expression key part stays bare.
    let expression_key_part = "COALESCE(height, '-1'::integer::double precision)";
    let mut changed = existing_index("uq_weird_columns", &["order item", "a(b)", "a::b", expression_key_part], false);
    changed.is_unique = true;
    changed.original.as_mut().unwrap().key_is_expression = vec![false, false, false, true];

    let result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 2);
    assert!(result.statements[0].starts_with("DROP INDEX "));
    assert_eq!(
        result.statements[1],
        format!(
            "CREATE UNIQUE INDEX \"uq_weird_columns\" ON \"public\".\"USERS\" (\"order item\", \"a(b)\", \"a::b\", {expression_key_part});"
        )
    );
}

#[test]
fn preserves_key_provenance_by_ordinal_position_not_first_text_match() {
    // PR #6312 review (round 2): provenance must stay tied to each key part's original ordinal
    // slot, not be re-derived by scanning for the first original key part with matching text. Two
    // key parts sharing identical text with different provenance (a pathological but real case —
    // e.g. a genuine expression key part and a real column whose name happens to equal that same
    // text) must not let the first one's provenance leak onto the second.
    let mut changed = existing_index("idx_dup", &["dup", "dup"], false);
    changed.is_unique = true;
    changed.original.as_mut().unwrap().key_is_expression = vec![true, false];

    let result =
        build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 2);
    assert!(result.statements[0].starts_with("DROP INDEX "));
    assert_eq!(result.statements[1], "CREATE UNIQUE INDEX \"idx_dup\" ON \"public\".\"USERS\" (dup, \"dup\");");
}

#[test]
fn create_table_trims_table_name_whitespace_for_all_statements() {
    let mut id = column("id");
    id.data_type = "integer".to_string();
    let idx = index("idx_users_id", &["id"]);

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "  users  ".to_string(),
        columns: vec![id],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE `users` (\n  `id` integer\n);", "CREATE INDEX `idx_users_id` ON `users` (`id`);",]
    );
}

#[test]
fn warns_for_sqlite_unsafe_column_changes() {
    let mut col = column("name");
    col.data_type = "text".to_string();
    col.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(80)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Sqlite),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(
        result.warnings,
        vec!["SQLite cannot safely alter existing column \"name\" without rebuilding the table."]
    );
}

#[test]
fn qualifies_attached_sqlite_table_and_index_changes() {
    let mut email = column("email");
    email.data_type = "text".to_string();
    let mut old_index = index("idx_users_old", &["email"]);
    old_index.marked_for_drop = true;
    old_index.original = Some(IndexInfo {
        name: "idx_users_old".to_string(),
        columns: vec!["email".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });
    let email_index = index("idx_users_email", &["email"]);

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Sqlite),
        driver_profile: None,
        schema: Some("analytics".to_string()),
        table_name: "users".to_string(),
        columns: vec![email],
        indexes: vec![old_index, email_index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"analytics\".\"users\" ADD COLUMN \"email\" text;",
            "DROP INDEX \"analytics\".\"idx_users_old\";",
            "CREATE INDEX \"analytics\".\"idx_users_email\" ON \"users\" (\"email\");",
        ]
    );

    let connection = rusqlite::Connection::open_in_memory().unwrap();
    connection
        .execute_batch(
            "ATTACH DATABASE ':memory:' AS analytics;
             CREATE TABLE main.users(id INTEGER);
             CREATE TABLE analytics.users(id INTEGER);
             CREATE INDEX analytics.idx_users_old ON users(id);",
        )
        .unwrap();
    connection.execute_batch(&result.statements.join("\n")).unwrap();
    let main_columns = connection
        .prepare("PRAGMA main.table_info('users')")
        .unwrap()
        .query_map([], |row| row.get::<_, String>("name"))
        .unwrap()
        .collect::<Result<Vec<_>, _>>()
        .unwrap();
    let attached_columns = connection
        .prepare("PRAGMA analytics.table_info('users')")
        .unwrap()
        .query_map([], |row| row.get::<_, String>("name"))
        .unwrap()
        .collect::<Result<Vec<_>, _>>()
        .unwrap();
    let attached_indexes = connection
        .prepare("PRAGMA analytics.index_list('users')")
        .unwrap()
        .query_map([], |row| row.get::<_, String>("name"))
        .unwrap()
        .collect::<Result<Vec<_>, _>>()
        .unwrap();
    assert_eq!(main_columns, vec!["id"]);
    assert_eq!(attached_columns, vec!["id", "email"]);
    assert_eq!(attached_indexes, vec!["idx_users_email"]);
}

#[test]
fn builds_rqlite_changes_with_sqlite_dialect() {
    let mut email = column("email");
    email.data_type = "text".to_string();
    email.is_nullable = false;
    let mut email_index = index("idx_users_email", &["email"]);
    email_index.filter = "email IS NOT NULL".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Rqlite),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![email],
        indexes: vec![email_index],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"users\" ADD COLUMN \"email\" text NOT NULL;",
            "CREATE INDEX \"idx_users_email\" ON \"users\" (\"email\") WHERE email IS NOT NULL;",
        ]
    );
}

#[test]
fn builds_kingbase_add_column_without_column_keyword() {
    let mut flag = column("flag");
    flag.data_type = "varchar(100)".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Kingbase),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "dw_bill_info_copy".to_string(),
        columns: vec![flag],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"dbo\".\"dw_bill_info_copy\" ADD \"flag\" varchar(100);"]);
}

#[test]
fn builds_mysql_column_reorder_statements() {
    let mut id = column("id");
    id.data_type = "int".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    id.original_position = Some(0);
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "int".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: true,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut email = column("email");
    email.original_position = Some(2);
    email.original = Some(ColumnInfo {
        name: "email".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut name = column("display_name");
    name.id = "name".to_string();
    name.data_type = "varchar(120)".to_string();
    name.original_position = Some(1);
    name.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(80)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![id, email, name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` CHANGE COLUMN `name` `display_name` varchar(120) AFTER `email`;"]
    );
}

#[test]
fn mysql_add_column_before_existing_column_does_not_reorder_shifted_column() {
    let mut deleted = column("deleted");
    deleted.original_position = Some(0);
    deleted.original = Some(ColumnInfo {
        name: "deleted".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let new_column = column("sss");

    let mut tenant_id = column("tenant_id");
    tenant_id.data_type = "bigint".to_string();
    tenant_id.is_nullable = false;
    tenant_id.default_value = "0".to_string();
    tenant_id.comment = "tenant id".to_string();
    tenant_id.original_position = Some(1);
    tenant_id.original = Some(ColumnInfo {
        name: "tenant_id".to_string(),
        data_type: "bigint".to_string(),
        is_nullable: false,
        column_default: Some("0".to_string()),
        is_primary_key: false,
        extra: None,
        comment: Some("tenant id".to_string()),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "infra_api_error_log".to_string(),
        columns: vec![deleted, new_column, tenant_id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `infra_api_error_log` ADD COLUMN `sss` varchar(255) AFTER `deleted`;"]
    );
}

#[test]
fn mysql_existing_column_reorder_does_not_reorder_columns_shifted_by_prior_move() {
    let mut id = column("id");
    id.original_position = Some(0);
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut name = column("name");
    name.original_position = Some(1);
    name.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut email = column("email");
    email.original_position = Some(2);
    email.original = Some(ColumnInfo {
        name: "email".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![id, email, name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) AFTER `email`;"]);
}

#[test]
fn mysql_moving_first_column_to_end_uses_single_reorder_statement() {
    let mut col_0 = column("col_0");
    col_0.data_type = "int(11)".to_string();
    col_0.is_nullable = false;
    col_0.original_position = Some(0);
    col_0.original = Some(ColumnInfo {
        name: "col_0".to_string(),
        data_type: "int(11)".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut col_1 = column("col_1");
    col_1.original_position = Some(1);
    col_1.original = Some(ColumnInfo {
        name: "col_1".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut col_2 = column("col_2");
    col_2.original_position = Some(2);
    col_2.original = Some(ColumnInfo {
        name: "col_2".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut col_3 = column("col_3");
    col_3.original_position = Some(3);
    col_3.original = Some(ColumnInfo {
        name: "col_3".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col_1, col_2, col_3, col_0],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `col_0` int(11) NOT NULL AFTER `col_3`;"]);
}

#[test]
fn builds_sql_server_quoted_column_and_index_statements() {
    let mut email = column("email");
    email.data_type = "nvarchar(255)".to_string();
    email.is_nullable = false;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "users".to_string(),
        columns: vec![email],
        indexes: vec![index("idx_users_email", &["email"])],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE [dbo].[users] ADD [email] nvarchar(255) NOT NULL;",
            "CREATE INDEX [idx_users_email] ON [dbo].[users] ([email]);",
        ]
    );
}

#[test]
fn sqlserver_strips_mysql_display_width_from_fixed_integer_types() {
    let mut id = column("id");
    id.data_type = "int(11)".to_string();
    id.is_nullable = false;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "users".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[users] ADD [id] int NOT NULL;"]);
}

#[test]
fn sqlserver_strips_scale_from_float() {
    let mut amount = column("amount");
    amount.data_type = "float(10,2)".to_string();
    amount.is_nullable = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: vec![amount],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[orders] ADD [amount] float;"]);
}

#[test]
fn sqlserver_preserves_float_mantissa_bits() {
    let mut value = column("value");
    value.data_type = "float(53)".to_string();
    value.is_nullable = false;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "measurements".to_string(),
        columns: vec![value],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[measurements] ADD [value] float(53) NOT NULL;"]);
}

#[test]
fn sqlserver_default_changes_drop_old_constraints_with_isolated_batches() {
    let mut sku = column("sku");
    sku.data_type = "nvarchar(64)".to_string();
    sku.default_value = "new sku".to_string();
    sku.original = Some(ColumnInfo {
        name: "sku".to_string(),
        data_type: "nvarchar(64)".to_string(),
        is_nullable: true,
        column_default: Some("'old sku'".to_string()),
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut active = column("active");
    active.data_type = "bit".to_string();
    active.is_nullable = false;
    active.default_value = "1".to_string();
    active.original = Some(ColumnInfo {
        name: "active".to_string(),
        data_type: "bit".to_string(),
        is_nullable: false,
        column_default: Some("0".to_string()),
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("core".to_string()),
        table_name: "products".to_string(),
        columns: vec![sku, active],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 4);

    let sku_drop = &result.statements[0];
    let active_drop = &result.statements[2];
    let sku_var = sku_drop.strip_prefix("DECLARE ").unwrap().split_once(" NVARCHAR(MAX);").unwrap().0;
    let active_var = active_drop.strip_prefix("DECLARE ").unwrap().split_once(" NVARCHAR(MAX);").unwrap().0;
    assert_ne!(sku_var, "@sql");
    assert_ne!(active_var, "@sql");
    assert_ne!(sku_var, active_var);

    for (sql, column_name) in [(sku_drop, "sku"), (active_drop, "active")] {
        assert!(sql.contains("SELECT TOP (1)"));
        assert!(sql.contains(" + QUOTENAME(dc.name) FROM sys.default_constraints AS dc WHERE "));
        assert!(sql.contains("OBJECT_ID(N'[core].[products]')"));
        assert!(sql.contains(&format!("N'{column_name}', 'ColumnId'")));
        assert!(sql.contains(" IF "));
        assert!(!sql.contains("]'FROM"));
        assert!(!sql.contains("constraintsWHERE"));
    }

    assert_eq!(
        result.statements[1],
        "ALTER TABLE [core].[products] ADD CONSTRAINT [DF_products_sku] DEFAULT N'new sku' FOR [sku];"
    );
    assert_eq!(
        result.statements[3],
        "ALTER TABLE [core].[products] ADD CONSTRAINT [DF_products_active] DEFAULT 1 FOR [active];"
    );
}

#[test]
fn sqlserver_type_change_preserves_existing_default_constraint() {
    let mut check_value = column("check_value");
    check_value.data_type = "decimal(18,2)".to_string();
    check_value.is_nullable = false;
    check_value.default_value = "0".to_string();
    check_value.original = Some(ColumnInfo {
        name: "check_value".to_string(),
        data_type: "int".to_string(),
        is_nullable: false,
        column_default: Some("0".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "issue_3714".to_string(),
        column: check_value,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 1);
    let sql = &result.statements[0];
    let capture = sql.find("= dc.name").unwrap();
    let drop = sql.find("DROP CONSTRAINT").unwrap();
    let alter = sql.find("ALTER COLUMN [check_value] decimal(18,2) NOT NULL").unwrap();
    let restore = sql.rfind("ADD CONSTRAINT").unwrap();
    assert!(capture < drop && drop < alter && alter < restore);
    assert!(sql.contains("= dc.definition"));
    assert!(sql.contains("QUOTENAME(@dbx_default_sql_"));
    assert!(sql.contains("+ N' DEFAULT ' + @dbx_default_sql_"));
    assert!(sql.contains("+ N' FOR [check_value]'"));
}

#[test]
fn sqlserver_type_and_default_change_drops_before_alter_and_adds_new_default() {
    let mut quantity = column("quantity");
    quantity.data_type = "decimal(12,3)".to_string();
    quantity.is_nullable = false;
    quantity.default_value = "1.5".to_string();
    quantity.original = Some(ColumnInfo {
        name: "quantity".to_string(),
        data_type: "int".to_string(),
        is_nullable: false,
        column_default: Some("0".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "inventory".to_string(),
        column: quantity,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 3);
    assert!(result.statements[0].contains("DROP CONSTRAINT"));
    assert_eq!(result.statements[1], "ALTER TABLE [dbo].[inventory] ALTER COLUMN [quantity] decimal(12,3) NOT NULL;");
    assert_eq!(
        result.statements[2],
        "ALTER TABLE [dbo].[inventory] ADD CONSTRAINT [DF_inventory_quantity] DEFAULT 1.5 FOR [quantity];"
    );
}

#[test]
fn sqlserver_generated_default_constraint_escapes_identifiers_and_unicode_values() {
    let mut owner = column("owner]id");
    owner.data_type = "nvarchar(40)".to_string();
    owner.default_value = "中文'值".to_string();
    owner.original = Some(ColumnInfo {
        name: "owner]id".to_string(),
        data_type: "nvarchar(40)".to_string(),
        is_nullable: true,
        column_default: Some("N'旧值'".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "order]s".to_string(),
        column: owner,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 2);
    assert!(result.statements[0].contains("OBJECT_ID(N'[dbo].[order]]s]')"));
    assert_eq!(
        result.statements[1],
        "ALTER TABLE [dbo].[order]]s] ADD CONSTRAINT [DF_order]]s_owner]]id] DEFAULT N'中文''值' FOR [owner]]id];"
    );
}

#[test]
fn sqlserver_rename_and_nullability_change_restores_default_on_new_column_name() {
    let mut renamed = column("is_enabled");
    renamed.data_type = "bit".to_string();
    renamed.is_nullable = false;
    renamed.default_value = "1".to_string();
    renamed.original = Some(ColumnInfo {
        name: "enabled".to_string(),
        data_type: "bit".to_string(),
        is_nullable: true,
        column_default: Some("1".to_string()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "settings".to_string(),
        column: renamed,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 2);
    assert_eq!(result.statements[0], "EXEC sp_rename '[dbo].[settings].[enabled]', 'is_enabled', 'COLUMN';");
    assert!(result.statements[1].contains("N'is_enabled', 'ColumnId'"));
    assert!(result.statements[1].contains("ALTER COLUMN [is_enabled] bit NOT NULL"));
    assert!(result.statements[1].contains("FOR [is_enabled]"));
}

#[test]
fn sqlserver_type_change_without_default_keeps_direct_alter_behavior() {
    let mut value = column("value");
    value.data_type = "bigint".to_string();
    value.is_nullable = false;
    value.original = Some(ColumnInfo {
        name: "value".to_string(),
        data_type: "int".to_string(),
        is_nullable: false,
        column_default: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "metrics".to_string(),
        column: value,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[metrics] ALTER COLUMN [value] bigint NOT NULL;"]);
}

#[test]
fn sqlserver_unchanged_foreign_key_does_not_warn_when_saving_other_changes() {
    let mut email = column("email");
    email.data_type = "nvarchar(255)".to_string();
    email.is_nullable = false;

    let mut user_fk = foreign_key("fk_orders_user_id", "user_id", "users", "id");
    user_fk.ref_schema = "dbo".to_string();
    user_fk.original = Some(ForeignKeyInfo {
        name: "fk_orders_user_id".to_string(),
        column: "user_id".to_string(),
        ref_schema: Some("dbo".to_string()),
        ref_table: "users".to_string(),
        ref_column: "id".to_string(),
        on_update: None,
        on_delete: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: vec![email],
        indexes: Vec::new(),
        foreign_keys: vec![user_fk],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[orders] ADD [email] nvarchar(255) NOT NULL;"]);
}

#[test]
fn sqlserver_add_column_with_identity() {
    let mut id = column("id");
    id.data_type = "int".to_string();
    id.is_nullable = false;
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(10), increment: Some(2) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[orders] ADD [id] int NOT NULL IDENTITY(10, 2);"]);
}

#[test]
fn sqlserver_legacy_column_comment_change_uses_legacy_extended_properties() {
    let mut category_id = column("CategoryID");
    category_id.comment = "test".to_string();
    category_id.original = Some(ColumnInfo {
        name: "CategoryID".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: Some("sqlserver-legacy".to_string()),
        schema: Some("dbo".to_string()),
        table_name: "Categories".to_string(),
        columns: vec![category_id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 1);
    assert!(result.statements[0].starts_with("IF @@MICROSOFTVERSION / 16777216 >= 9 EXEC (N'"));
    assert!(result.statements[0].contains("::fn_listextendedproperty"));
    assert!(result.statements[0].contains("EXEC sp_addextendedproperty"));
    assert!(result.statements[0].contains("EXEC sys.sp_addextendedproperty"));
}

#[test]
fn dameng_add_column_with_identity() {
    let mut id = column("ID");
    id.data_type = "INT".to_string();
    id.is_nullable = false;
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(10), increment: Some(2) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "TEST".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"TEST\" ADD (\"ID\" INT IDENTITY(10, 2));"]);
}

#[test]
fn dameng_uppercases_lowercase_column_type() {
    let mut status = column("STATUS");
    status.data_type = "varchar(50)".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "TEST".to_string(),
        columns: vec![status],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    // A lower-case type keyword must not reach the DDL: Dameng would store it
    // as a USER-DEFINED type instead of the built-in VARCHAR (issue #7343).
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"TEST\" ADD (\"STATUS\" VARCHAR(50));"]);
}

#[test]
fn dameng_rejects_identity_on_incompatible_type() {
    let mut column = column("CODE");
    column.data_type = "VARCHAR(255)".to_string();
    column.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "TEST".to_string(),
        columns: vec![column],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(
        result.warnings,
        vec!["Dameng identity column \"CODE\" must use tinyint, smallint, int, integer, bigint, number, numeric, or decimal/dec with scale 0."]
    );
}

#[test]
fn sqlserver_rejects_identity_on_incompatible_type() {
    let mut column = column("test");
    column.data_type = "varchar(255)".to_string();
    column.is_nullable = false;
    column.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("core".to_string()),
        table_name: "products".to_string(),
        columns: vec![column],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(
        result.warnings,
        vec!["SQL Server identity column \"test\" must use tinyint, smallint, int, bigint, or decimal/numeric with scale 0."]
    );
}

#[test]
fn sqlserver_foreign_key_edits_generate_alter_statements() {
    let mut user_fk = foreign_key("fk_orders_user_id", "user_id", "accounts", "id");
    user_fk.ref_schema = "dbo".to_string();
    user_fk.on_delete = "CASCADE".to_string();
    user_fk.on_update = "RESTRICT".to_string();
    user_fk.original = Some(ForeignKeyInfo {
        name: "fk_orders_user_id".to_string(),
        column: "user_id".to_string(),
        ref_schema: Some("dbo".to_string()),
        ref_table: "users".to_string(),
        ref_column: "id".to_string(),
        on_update: None,
        on_delete: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: vec![user_fk],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE [dbo].[orders] DROP CONSTRAINT [fk_orders_user_id];",
            "ALTER TABLE [dbo].[orders] ADD CONSTRAINT [fk_orders_user_id] FOREIGN KEY ([user_id]) REFERENCES [dbo].[accounts] ([id]) ON DELETE CASCADE ON UPDATE NO ACTION;"
        ]
    );
}

#[test]
fn sqlserver_unchanged_identity_extra_does_not_mark_existing_column_changed() {
    let mut id = column("id");
    id.data_type = "int".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "int".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: true,
        extra: Some("IDENTITY(1,1)".to_string()),
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn dameng_unchanged_identity_extra_does_not_mark_existing_column_changed() {
    let mut id = column("ID");
    id.data_type = "INT".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    id.original = Some(ColumnInfo {
        name: "ID".to_string(),
        data_type: "INT".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: true,
        extra: Some("identity".to_string()),
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "TEST".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn dameng_enables_identity_on_existing_not_null_column() {
    let mut id = existing_pk_column("ID", "INT", false, false);
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(10), increment: Some(2) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"TEST\" ADD COLUMN \"ID\" IDENTITY(10, 2);"]);
}

#[test]
fn dameng_makes_existing_column_not_null_before_enabling_identity() {
    let mut id = column("ID");
    id.data_type = "INT".to_string();
    id.is_nullable = false;
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    id.original = Some(ColumnInfo {
        name: "ID".to_string(),
        data_type: "INT".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"TEST\" MODIFY (\"ID\" INT NOT NULL);",
            "ALTER TABLE \"SYSDBA\".\"TEST\" ADD COLUMN \"ID\" IDENTITY(1, 1);",
        ]
    );
}

#[test]
fn dameng_disables_identity_on_existing_column() {
    let mut id = existing_pk_column("ID", "INT", false, false);
    id.extra = Some(ColumnExtra::default());
    id.original.as_mut().unwrap().extra = Some("IDENTITY(10, 2)".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"TEST\" DROP IDENTITY;"]);
}

#[test]
fn dameng_moves_identity_with_drop_before_add_regardless_of_column_order() {
    let mut target = existing_pk_column("TARGET_ID", "BIGINT", false, false);
    target.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(100), increment: Some(5) }),
        ..Default::default()
    });

    let mut source = existing_pk_column("SOURCE_ID", "INT", false, false);
    source.extra = Some(ColumnExtra::default());
    source.original.as_mut().unwrap().extra = Some("IDENTITY(1, 1)".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![target, source],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"TEST\" DROP IDENTITY;",
            "ALTER TABLE \"SYSDBA\".\"TEST\" ADD COLUMN \"TARGET_ID\" IDENTITY(100, 5);",
        ]
    );
}

#[test]
fn dameng_rejects_identity_on_incompatible_existing_column() {
    let mut code = column("CODE");
    code.data_type = "VARCHAR(255)".to_string();
    code.is_nullable = false;
    code.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    code.original = Some(ColumnInfo {
        name: "CODE".to_string(),
        data_type: "VARCHAR(255)".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![code],
    ));

    assert!(result.statements.is_empty());
    assert_eq!(
        result.warnings,
        vec!["Dameng identity column \"CODE\" must use tinyint, smallint, int, integer, bigint, number, numeric, or decimal/dec with scale 0."]
    );
}

#[test]
fn dameng_rejects_zero_increment_when_enabling_existing_identity() {
    let mut id = existing_pk_column("ID", "INT", false, false);
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(0) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![id],
    ));

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Dameng identity column \"ID\" increment cannot be 0."]);
}

#[test]
fn dameng_rejects_changing_existing_identity_parameters() {
    let mut id = existing_pk_column("ID", "INT", false, false);
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(10), increment: Some(3) }),
        ..Default::default()
    });
    id.original.as_mut().unwrap().extra = Some("IDENTITY(10, 2)".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "TEST",
        vec![id],
    ));

    assert!(result.statements.is_empty());
    assert_eq!(
        result.warnings,
        vec![
            "Changing Dameng IDENTITY seed or increment for existing column \"ID\" is not supported from this editor."
        ]
    );
}

#[test]
fn oracle_does_not_adopt_dameng_existing_identity_ddl() {
    let mut id = existing_pk_column("ID", "NUMBER(10)", false, false);
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oracle,
        Some("APP"),
        "USERS",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn dameng_rejects_adding_second_identity_column() {
    let mut existing = column("ID");
    existing.data_type = "INT".to_string();
    existing.is_nullable = false;
    existing.is_primary_key = true;
    existing.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    existing.original = Some(ColumnInfo {
        name: "ID".to_string(),
        data_type: "INT".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: true,
        extra: Some("identity".to_string()),
        comment: None,
        ..Default::default()
    });
    let mut added = column("SEQ");
    added.data_type = "BIGINT".to_string();
    added.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "TEST".to_string(),
        columns: vec![existing, added],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(result.warnings, vec!["Dameng tables can have only one identity column."]);
}

#[test]
fn sqlserver_existing_column_identity_change_warns_without_unchanged_foreign_key_warning() {
    let mut id = column("id");
    id.data_type = "int".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    id.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "int".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: true,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let mut user_fk = foreign_key("fk_orders_user_id", "user_id", "users", "id");
    user_fk.ref_schema = "dbo".to_string();
    user_fk.original = Some(ForeignKeyInfo {
        name: "fk_orders_user_id".to_string(),
        column: "user_id".to_string(),
        ref_schema: Some("dbo".to_string()),
        ref_table: "users".to_string(),
        ref_column: "id".to_string(),
        on_update: None,
        on_delete: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: vec![id],
        indexes: Vec::new(),
        foreign_keys: vec![user_fk],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(
        result.warnings,
        vec!["Changing SQL Server IDENTITY for existing column \"id\" is not supported from this editor."]
    );
}

#[cfg(feature = "duckdb-sidecar")]
#[test]
fn builds_duckdb_create_table_statements() {
    let mut name = column("name");
    name.data_type = "VARCHAR".to_string();
    name.is_nullable = false;
    let mut created_at = column("created_at");
    created_at.data_type = "TIMESTAMP".to_string();
    created_at.default_value = "current_timestamp".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::DuckDb),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![name, created_at],
        indexes: vec![index("idx_events_name", &["name"])],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE \"events\" (\n  \"name\" VARCHAR NOT NULL,\n  \"created_at\" TIMESTAMP DEFAULT current_timestamp\n);",
            "CREATE INDEX \"idx_events_name\" ON \"events\" (\"name\");",
        ]
    );
}

#[cfg(feature = "duckdb-sidecar")]
fn existing_duckdb_column(name: &str) -> EditableStructureColumn {
    let mut existing = column(name);
    existing.original = Some(ColumnInfo {
        name: name.to_string(),
        data_type: existing.data_type.clone(),
        is_nullable: existing.is_nullable,
        column_default: None,
        ..Default::default()
    });
    existing
}

#[cfg(feature = "duckdb-sidecar")]
#[test]
fn duckdb_column_rename_generates_quoted_sql() {
    let mut renamed = existing_duckdb_column("old_name");
    renamed.name = "new_name".to_string();

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::DuckDb, None, "events", vec![renamed]));

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec![r#"ALTER TABLE "events" RENAME COLUMN "old_name" TO "new_name";"#]);
}

#[cfg(feature = "duckdb-sidecar")]
#[test]
fn duckdb_column_rename_quotes_special_identifiers() {
    let mut renamed = existing_duckdb_column("old \"code\"");
    renamed.name = "select value".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::DuckDb,
        None,
        "event log",
        vec![renamed],
    ));

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec![r#"ALTER TABLE "event log" RENAME COLUMN "old ""code""" TO "select value";"#]);
}

#[cfg(feature = "duckdb-sidecar")]
#[test]
fn duckdb_column_rename_ignores_unchanged_columns() {
    let unchanged = existing_duckdb_column("event_id");

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::DuckDb,
        None,
        "events",
        vec![unchanged],
    ));

    assert!(result.statements.is_empty());
    assert!(result.warnings.is_empty());
}

#[cfg(feature = "duckdb-sidecar")]
#[test]
fn duckdb_column_rename_with_unsupported_attribute_change_fails_closed() {
    let mut changed = existing_duckdb_column("event_id");
    changed.name = "renamed_id".to_string();
    changed.data_type = "BIGINT".to_string();
    changed.is_nullable = false;
    changed.default_value = "42".to_string();

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::DuckDb, None, "events", vec![changed]));

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Editing existing columns is not supported for duckdb yet."]);
}

#[test]
fn builds_clickhouse_nullable_comment_and_reorder_statements() {
    let mut source = column("source");
    source.data_type = "String".to_string();
    source.is_nullable = true;
    source.comment = "traffic source".to_string();
    let mut status = column("status");
    status.data_type = "Nullable(String)".to_string();
    status.is_nullable = false;
    status.comment = "current status".to_string();
    status.original = Some(ColumnInfo {
        name: "status".to_string(),
        data_type: "Nullable(String)".to_string(),
        is_nullable: true,
        column_default: Some("'pending'".to_string()),
        is_primary_key: false,
        extra: None,
        comment: Some("old status".to_string()),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::ClickHouse),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![source, status],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"events\" ADD COLUMN \"source\" Nullable(String);",
            "ALTER TABLE \"events\" COMMENT COLUMN \"source\" 'traffic source';",
            "ALTER TABLE \"events\" MODIFY COLUMN \"status\" REMOVE DEFAULT;",
            "ALTER TABLE \"events\" MODIFY COLUMN \"status\" String;",
            "ALTER TABLE \"events\" COMMENT COLUMN \"status\" 'current status';",
        ]
    );
}

#[test]
fn builds_h2_schema_qualified_existing_column_statements() {
    let mut name = column("DISPLAY_NAME");
    name.id = "name".to_string();
    name.data_type = "VARCHAR(120)".to_string();
    name.is_nullable = false;
    name.default_value = "guest".to_string();
    name.comment = "Display name".to_string();
    name.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR(80)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::H2),
        driver_profile: None,
        schema: Some("PUBLIC".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![name],
        indexes: vec![index("IDX_USERS_DISPLAY_NAME", &["DISPLAY_NAME"])],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"NAME\" RENAME TO \"DISPLAY_NAME\";",
            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"DISPLAY_NAME\" SET DATA TYPE VARCHAR(120);",
            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"DISPLAY_NAME\" SET NOT NULL;",
            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"DISPLAY_NAME\" SET DEFAULT 'guest';",
            "COMMENT ON COLUMN \"PUBLIC\".\"USERS\".\"DISPLAY_NAME\" IS 'Display name';",
            "CREATE INDEX \"IDX_USERS_DISPLAY_NAME\" ON \"PUBLIC\".\"USERS\" (\"DISPLAY_NAME\");",
        ]
    );
}

#[test]
fn builds_postgres_alter_table_add_primary_key() {
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", false, true)],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" ADD PRIMARY KEY (\"id\");"]);
}

#[test]
fn postgres_adds_named_primary_key_when_requested() {
    let mut options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", false, true)],
    );
    options.primary_key_name = Some("users_pkey".to_string());

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"public\".\"users\" ADD CONSTRAINT \"users_pkey\" PRIMARY KEY (\"id\");"]
    );
}

#[test]
fn mysql_adds_named_primary_key_when_requested() {
    let mut options = structure_change_options(
        DatabaseType::Mysql,
        Some("dbx_test"),
        "users",
        vec![existing_pk_column("id", "int", false, true)],
    );
    options.primary_key_name = Some("users_pk".to_string());

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` ADD CONSTRAINT `users_pk` PRIMARY KEY (`id`);"]);
}

#[test]
fn mysql_primary_key_replacement_stays_anonymous_even_with_primary_key_name() {
    let mut old_pk = existing_pk_column("old_id", "int", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("new_id", "int", false, true);
    new_pk.id = "new_id".to_string();
    let mut options = structure_change_options(DatabaseType::Mysql, Some("dbx_test"), "users", vec![old_pk, new_pk]);
    options.primary_key_name = Some("users_pk".to_string());

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` DROP PRIMARY KEY;", "ALTER TABLE `users` ADD PRIMARY KEY (`new_id`);",]
    );
}

#[test]
fn postgres_primary_key_replacement_keeps_persisted_name_despite_primary_key_name() {
    let mut old_pk = existing_pk_column("id", "integer", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("asdas", "integer", false, true);
    new_pk.id = "new_asdas".to_string();
    let mut options = structure_change_options(DatabaseType::Postgres, Some("public"), "test", vec![old_pk, new_pk]);
    options.indexes = vec![existing_primary_index("test_pk", &["id"])];
    options.primary_key_name = Some("should_be_ignored".to_string());

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"test\" DROP CONSTRAINT \"test_pk\";",
            "ALTER TABLE \"public\".\"test\" ADD CONSTRAINT \"test_pk\" PRIMARY KEY (\"asdas\");",
        ]
    );
}

#[test]
fn blank_primary_key_name_keeps_anonymous_form() {
    let mut options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", false, true)],
    );
    options.primary_key_name = Some("   ".to_string());

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" ADD PRIMARY KEY (\"id\");"]);
}

#[test]
fn create_table_includes_named_primary_key() {
    let mut options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", false, true)],
    );
    options.primary_key_name = Some("users_pkey".to_string());

    let result = build_create_table_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE \"public\".\"users\" (\n  \"id\" integer,\n  CONSTRAINT \"users_pkey\" PRIMARY KEY (\"id\")\n);"]
    );
}

#[test]
fn create_table_ignores_primary_key_name_for_sqlite() {
    let mut options = structure_change_options(
        DatabaseType::Sqlite,
        None,
        "users",
        vec![existing_pk_column("id", "integer", false, true)],
    );
    options.primary_key_name = Some("users_pkey".to_string());

    let result = build_create_table_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(!result.statements[0].contains("CONSTRAINT"), "{}", result.statements[0]);
    assert!(result.statements[0].contains("PRIMARY KEY"), "{}", result.statements[0]);
}

#[test]
fn postgres_replaces_custom_named_primary_key_without_renaming_it() {
    let mut old_pk = existing_pk_column("id", "integer", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("asdas", "integer", false, true);
    new_pk.id = "new_asdas".to_string();
    let mut options = structure_change_options(DatabaseType::Postgres, Some("public"), "test", vec![old_pk, new_pk]);
    options.indexes = vec![existing_primary_index("test_pk", &["id"])];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"test\" DROP CONSTRAINT \"test_pk\";",
            "ALTER TABLE \"public\".\"test\" ADD CONSTRAINT \"test_pk\" PRIMARY KEY (\"asdas\");",
        ]
    );
}

#[test]
fn postgres_preserves_quoted_primary_key_name_for_composite_replacement() {
    let mut old_pk = existing_pk_column("legacy_id", "integer", true, false);
    old_pk.id = "legacy_id".to_string();
    let mut tenant_id = existing_pk_column("tenant_id", "integer", false, true);
    tenant_id.id = "tenant_id".to_string();
    let mut code = existing_pk_column("code", "text", false, true);
    code.id = "code".to_string();
    let mut options =
        structure_change_options(DatabaseType::Postgres, Some("public"), "memberships", vec![old_pk, tenant_id, code]);
    options.indexes = vec![existing_primary_index("Mixed Case PK", &["legacy_id"])];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"memberships\" DROP CONSTRAINT \"Mixed Case PK\";",
            "ALTER TABLE \"public\".\"memberships\" ADD CONSTRAINT \"Mixed Case PK\" PRIMARY KEY (\"tenant_id\", \"code\");",
        ]
    );
}

#[test]
fn postgres_rejects_primary_key_change_without_persisted_name_metadata() {
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", true, false)],
    ));

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("primary key constraint name"));
    assert!(result.warnings[0].contains("Refresh"));
}

#[test]
fn postgres_rejects_conflicting_persisted_primary_key_name_metadata() {
    let mut options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", true, false)],
    );
    options.indexes =
        vec![existing_primary_index("users_pk_a", &["id"]), existing_primary_index("users_pk_b", &["id"])];

    let result = build_table_structure_change_sql(options);

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("primary key constraint name"));
    assert!(result.warnings[0].contains("Refresh"));
}

#[test]
fn builds_dameng_alter_table_add_primary_key() {
    // DM8: ADD [CONSTRAINT name] PRIMARY KEY — anonymous form matches DBeaver/MySQL-style editors.
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![existing_pk_column("id", "INT", false, true)],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"id\");"]);
}

#[test]
fn builds_dameng_composite_primary_key_in_draft_order() {
    let mut tenant_id = existing_pk_column("tenant_id", "INT", false, true);
    tenant_id.id = "tenant_id".to_string();
    let mut code = existing_pk_column("code", "VARCHAR(50)", false, true);
    code.id = "code".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![tenant_id, code],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"tenant_id\", \"code\");"]);
}

#[test]
fn dameng_reordering_unchanged_composite_primary_key_does_not_emit_primary_key_ddl() {
    let mut tenant_id = existing_pk_column("tenant_id", "INT", true, true);
    tenant_id.id = "tenant_id".to_string();
    tenant_id.original_position = Some(0);
    let mut code = existing_pk_column("code", "VARCHAR(50)", true, true);
    code.id = "code".to_string();
    code.original_position = Some(1);

    // Dameng reordering is local-only. Moving these columns must not recreate the key
    // merely because the draft order changed.
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![code, tenant_id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements.is_empty());
}

#[test]
fn dameng_adds_new_primary_key_column_before_adding_constraint() {
    let mut code = column("code");
    code.data_type = "VARCHAR(50)".to_string();
    code.is_nullable = false;
    code.is_primary_key = true;

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![code],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" ADD (\"code\" VARCHAR(50));",
            "ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"code\");",
        ]
    );
}

#[test]
fn builds_dameng_alter_table_drop_primary_key() {
    // DM8 official: DROP PRIMARY KEY [RESTRICT|CASCADE]; default RESTRICT (no CASCADE from editor).
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![existing_pk_column("id", "INT", true, false)],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"users\" DROP PRIMARY KEY;"]);
}

#[test]
fn builds_dameng_alter_table_change_primary_key() {
    // DBeaver/Navicat-style modify: drop existing key then add the new one (never ADD without DROP).
    let mut old_pk = existing_pk_column("id", "INT", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("code", "VARCHAR(50)", false, true);
    new_pk.id = "new_code".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![old_pk, new_pk],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" DROP PRIMARY KEY;",
            "ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"code\");",
        ]
    );
}

#[test]
fn builds_sqlserver_alter_table_add_primary_key() {
    // T-SQL accepts an anonymous `ADD PRIMARY KEY`; the server names the constraint.
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SqlServer,
        Some("dbo"),
        "users",
        vec![existing_pk_column("id", "INT", false, true)],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[users] ADD PRIMARY KEY ([id]);"]);
}

#[test]
fn sqlserver_replaces_primary_key_by_persisted_constraint_name() {
    let mut old_pk = existing_pk_column("id", "INT", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("code", "VARCHAR(50)", false, true);
    new_pk.id = "new_code".to_string();
    let mut options = structure_change_options(DatabaseType::SqlServer, Some("dbo"), "users", vec![old_pk, new_pk]);
    options.indexes = vec![existing_primary_index("PK_users", &["id"])];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE [dbo].[users] DROP CONSTRAINT [PK_users];",
            "ALTER TABLE [dbo].[users] ADD CONSTRAINT [PK_users] PRIMARY KEY ([code]);",
        ]
    );
}

#[test]
fn builds_sqlserver_alter_table_drop_primary_key() {
    let mut options = structure_change_options(
        DatabaseType::SqlServer,
        Some("dbo"),
        "users",
        vec![existing_pk_column("id", "INT", true, false)],
    );
    options.indexes = vec![existing_primary_index("PK_users", &["id"])];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[users] DROP CONSTRAINT [PK_users];"]);
}

#[test]
fn dameng_validates_new_primary_key_column_before_replacing_existing_key() {
    let mut old_pk = existing_pk_column("id", "INT", true, false);
    old_pk.id = "old_id".to_string();
    let mut code = existing_pk_column("code", "VARCHAR(50)", false, true);
    code.id = "new_code".to_string();
    code.original.as_mut().unwrap().is_nullable = true;

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![old_pk, code],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" MODIFY (\"code\" VARCHAR(50) NOT NULL);",
            "ALTER TABLE \"SYSDBA\".\"users\" DROP PRIMARY KEY;",
            "ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"code\");",
        ]
    );
}

#[test]
fn dameng_blocks_dropping_former_primary_key_column() {
    let mut id = existing_pk_column("id", "INT", true, false);
    id.marked_for_drop = true;
    let name = existing_pk_column("name", "VARCHAR(50)", false, false);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![id, name],
    ));

    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("Primary key column")));
}

#[test]
fn oracle_sets_not_null_before_adding_primary_key() {
    for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
        let mut id = existing_pk_column("id", "NUMBER", false, true);
        id.original.as_mut().unwrap().is_nullable = true;

        let result =
            build_table_structure_change_sql(structure_change_options(database_type, Some("HR"), "users", vec![id]));

        assert_eq!(result.warnings, Vec::<String>::new());
        assert_eq!(
            result.statements,
            vec![
                "ALTER TABLE \"HR\".\"users\" MODIFY (\"id\" NUMBER NOT NULL);",
                "ALTER TABLE \"HR\".\"users\" ADD PRIMARY KEY (\"id\");",
            ]
        );
    }
}

#[test]
fn oracle_adds_composite_primary_key_in_draft_order() {
    for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
        let mut tenant_id = existing_pk_column("tenant_id", "NUMBER", false, true);
        tenant_id.id = "tenant_id".to_string();
        let mut code = existing_pk_column("code", "VARCHAR2(50)", false, true);
        code.id = "code".to_string();

        let result = build_table_structure_change_sql(structure_change_options(
            database_type,
            Some("HR"),
            "users",
            vec![code, tenant_id],
        ));

        assert_eq!(result.warnings, Vec::<String>::new());
        assert_eq!(result.statements, vec!["ALTER TABLE \"HR\".\"users\" ADD PRIMARY KEY (\"code\", \"tenant_id\");"]);
    }
}

#[test]
fn oracle_adds_new_primary_key_column_before_adding_constraint() {
    for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
        let mut code = column("code");
        code.data_type = "VARCHAR2(50)".to_string();
        code.is_nullable = false;
        code.is_primary_key = true;

        let result =
            build_table_structure_change_sql(structure_change_options(database_type, Some("HR"), "users", vec![code]));

        assert_eq!(result.warnings, Vec::<String>::new());
        assert_eq!(
            result.statements,
            vec![
                "ALTER TABLE \"HR\".\"users\" ADD (\"code\" VARCHAR2(50));",
                "ALTER TABLE \"HR\".\"users\" ADD PRIMARY KEY (\"code\");",
            ]
        );
    }
}

#[test]
fn oracle_rejects_existing_primary_key_changes_without_partial_sql() {
    for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
        let uncheck = vec![
            existing_pk_column("id", "NUMBER", true, false),
            existing_pk_column("name", "VARCHAR2(50)", false, false),
        ];
        let replacement = vec![
            existing_pk_column("id", "NUMBER", true, false),
            existing_pk_column("code", "VARCHAR2(50)", false, true),
            existing_pk_column("name", "VARCHAR2(50)", false, false),
        ];
        let second_key = vec![
            existing_pk_column("id", "NUMBER", true, true),
            existing_pk_column("code", "VARCHAR2(50)", false, true),
            existing_pk_column("name", "VARCHAR2(50)", false, false),
        ];

        for (case, columns) in [("uncheck", uncheck), ("replacement", replacement), ("second key", second_key)] {
            let mut options = structure_change_options(database_type, Some("HR"), "users", columns);
            options.indexes = vec![index("idx_users_name", &["name"])];

            let result = build_table_structure_change_sql(options);

            assert!(result.statements.is_empty(), "{case} must not emit partial SQL: {:?}", result.statements);
            assert_eq!(result.warnings.len(), 1, "unexpected {case} warnings: {:?}", result.warnings);
            assert!(
                result.warnings[0].contains("Changing primary keys"),
                "unexpected {case} warning: {:?}",
                result.warnings
            );
        }
    }
}

#[test]
fn oracle_compatible_engines_do_not_inherit_oracle_primary_key_add() {
    for database_type in [DatabaseType::Yashandb, DatabaseType::Xugu, DatabaseType::Iris] {
        let columns = vec![
            existing_pk_column("id", "NUMBER", false, true),
            existing_pk_column("name", "VARCHAR2(50)", false, false),
        ];
        let mut options = structure_change_options(database_type, Some("APP"), "users", columns);
        options.indexes = vec![index("idx_users_name", &["name"])];

        let result = build_table_structure_change_sql(options);

        assert!(result.statements.is_empty(), "{database_type:?} must not emit partial SQL: {:?}", result.statements);
        assert_eq!(result.warnings.len(), 1, "unexpected {database_type:?} warnings: {:?}", result.warnings);
        assert!(result.warnings[0].contains("Adding primary keys"));
    }
}

#[test]
fn oracle_uncheck_primary_key_and_drop_column_does_not_emit_drop_column() {
    // alter_primary_key is false for Oracle: unchecking PK must not unlock DROP COLUMN without a PK drop.
    let mut id = existing_pk_column("id", "NUMBER", true, false);
    id.marked_for_drop = true;
    let name = existing_pk_column("name", "VARCHAR2(50)", false, false);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oracle,
        Some("HR"),
        "users",
        vec![id, name],
    ));

    assert!(
        !result.statements.iter().any(|sql| sql.to_ascii_uppercase().contains("DROP COLUMN")),
        "must not DROP COLUMN former PK without DROP PRIMARY KEY; got {:?}",
        result.statements
    );
    assert!(
        !result.statements.iter().any(|sql| sql.to_ascii_uppercase().contains("PRIMARY KEY")),
        "Oracle must not emit partial PK DDL; got {:?}",
        result.statements
    );
    assert!(
        result.warnings.iter().any(|w| w.contains("primary key") || w.contains("Primary key")),
        "expected primary-key related warning; got {:?}",
        result.warnings
    );
}

#[test]
fn sqlserver_uncheck_primary_key_and_drop_column_does_not_emit_drop_column() {
    let mut id = existing_pk_column("id", "int", true, false);
    id.marked_for_drop = true;
    let name = existing_pk_column("name", "nvarchar(50)", false, false);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SqlServer,
        Some("dbo"),
        "users",
        vec![id, name],
    ));

    assert!(
        !result.statements.iter().any(|sql| sql.to_ascii_uppercase().contains("DROP COLUMN")),
        "must not DROP COLUMN former PK without PK drop; got {:?}",
        result.statements
    );
    assert!(result.warnings.iter().any(|w| w.contains("primary key") || w.contains("Primary key")));
}

#[test]
fn sqlserver_drop_column_removes_default_constraint_first() {
    let cases = [
        (Some("dbo"), Some("((0))"), "[dbo].[orders]", true),
        (None, Some("((0))"), "[orders]", true),
        (Some("dbo"), Some("NULL"), "[dbo].[orders]", false),
        (Some("dbo"), None, "[dbo].[orders]", false),
    ];

    for (schema, column_default, table, drops_default) in cases {
        let mut big = column("big");
        big.data_type = "bigint".to_string();
        big.is_nullable = false;
        big.marked_for_drop = true;
        big.original = Some(ColumnInfo {
            name: "big".to_string(),
            data_type: "bigint".to_string(),
            is_nullable: false,
            column_default: column_default.map(str::to_string),
            ..Default::default()
        });

        let mut expected = Vec::new();
        if drops_default {
            let drop_default = build_sqlserver_drop_default_constraint_sql(table, "big");
            assert!(drop_default.contains(&format!("OBJECT_ID(N'{table}')")), "{drop_default}");
            expected.push(drop_default);
        }
        expected.push(format!("ALTER TABLE {table} DROP COLUMN [big];"));

        let batch = build_table_structure_change_sql(structure_change_options(
            DatabaseType::SqlServer,
            schema,
            "orders",
            vec![big.clone()],
        ));
        assert_eq!(batch.warnings, Vec::<String>::new());
        assert_eq!(batch.statements, expected, "schema {schema:?}, default {column_default:?}");

        let single = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
            database_type: Some(DatabaseType::SqlServer),
            driver_profile: None,
            schema: schema.map(str::to_string),
            table_name: "orders".to_string(),
            column: big,
        });
        assert_eq!(single.warnings, Vec::<String>::new());
        assert_eq!(single.statements, expected, "schema {schema:?}, default {column_default:?}");
    }
}

#[test]
fn dameng_set_not_null_before_add_primary_key() {
    // DM8: PK columns must be NOT NULL; DM auto-adds NOT NULL but clients still MODIFY first.
    // Order: column MODIFY NOT NULL, then ADD PRIMARY KEY.
    let mut id = existing_pk_column("id", "INT", false, true);
    id.original.as_mut().unwrap().is_nullable = true;
    // is_nullable stays false (set when marking PK) so MODIFY ... NOT NULL is emitted.

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" MODIFY (\"id\" INT NOT NULL);",
            "ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"id\");",
        ]
    );
}

#[test]
fn dameng_blocks_dropping_active_primary_key_column() {
    // Keep a non-PK column so we do not hit the "cannot drop all columns" guard first.
    let mut id = existing_pk_column("id", "INT", true, true);
    id.marked_for_drop = true;
    let name = existing_pk_column("name", "VARCHAR(50)", false, false);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![id, name],
    ));

    assert!(!result.statements.iter().any(|sql| sql.contains("DROP COLUMN")));
    assert!(result.warnings.iter().any(|w| w.contains("Primary key column")));
}

#[test]
fn dameng_does_not_mutate_primary_key_when_active_key_column_is_marked_for_drop() {
    let mut id = existing_pk_column("id", "INT", true, true);
    id.marked_for_drop = true;
    let code = existing_pk_column("code", "VARCHAR(50)", false, true);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![id, code],
    ));

    assert!(result.statements.is_empty(), "invalid draft must not emit partial PK DDL: {:?}", result.statements);
    assert!(result.warnings.iter().any(|warning| warning.contains("Primary key column")));
}

#[test]
fn builds_postgres_alter_table_drop_primary_key() {
    let mut options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![existing_pk_column("id", "integer", true, false)],
    );
    options.indexes = vec![existing_primary_index("users_pkey", &["id"])];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" DROP CONSTRAINT \"users_pkey\";"]);
}

#[test]
fn builds_mysql_alter_table_change_primary_key() {
    let mut old_pk = existing_pk_column("id", "int", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("uuid", "varchar(36)", false, true);
    new_pk.id = "new_uuid".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "users",
        vec![old_pk, new_pk],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` DROP PRIMARY KEY;", "ALTER TABLE `users` ADD PRIMARY KEY (`uuid`);",]
    );
}

#[test]
fn mysql_coalesces_auto_increment_primary_key_migration() {
    let mut old_pk = existing_pk_column("campaign_rel_id", "bigint(20)", true, false);
    old_pk.id = "old_campaign_rel_id".to_string();

    let mut id = existing_pk_column("id", "bigint(20)", false, true);
    id.id = "new_id".to_string();
    id.comment = "自增主键".to_string();
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let mut options = structure_change_options(DatabaseType::Mysql, None, "tbl_gy_campaign_rel", vec![old_pk, id]);
    options.indexes = vec![existing_index("campaign_rel_id_UNIQUE", &["campaign_rel_id"], true)];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `tbl_gy_campaign_rel` DROP PRIMARY KEY, MODIFY COLUMN `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增主键', ADD PRIMARY KEY (`id`);"
        ]
    );
}

#[test]
fn mysql_coalesces_new_auto_increment_primary_key_column() {
    let mut old_pk = existing_pk_column("legacy_id", "bigint", true, false);
    old_pk.id = "old_legacy_id".to_string();

    let mut id = column("id");
    id.data_type = "bigint".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "users",
        vec![old_pk, id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` DROP PRIMARY KEY, ADD COLUMN `id` bigint NOT NULL AUTO_INCREMENT, ADD PRIMARY KEY (`id`);"
        ]
    );
}

#[test]
fn mysql_stable_primary_key_auto_increment_changes_keep_column_only_alter() {
    let mut enable = existing_pk_column("id", "bigint", true, true);
    enable.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let enabled =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "users", vec![enable]));
    assert_eq!(enabled.warnings, Vec::<String>::new());
    assert_eq!(enabled.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `id` bigint NOT NULL AUTO_INCREMENT;"]);

    let mut disable = existing_pk_column("id", "bigint", true, true);
    disable.extra = Some(ColumnExtra::default());
    disable.original.as_mut().unwrap().extra = Some("auto_increment".to_string());

    let disabled =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "users", vec![disable]));
    assert_eq!(disabled.warnings, Vec::<String>::new());
    assert_eq!(disabled.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `id` bigint NOT NULL;"]);
}

#[test]
fn mysql_coalesces_migration_away_from_existing_auto_increment_primary_key() {
    let mut old_pk = existing_pk_column("id", "bigint", true, false);
    old_pk.id = "old_id".to_string();
    old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());

    let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);
    new_pk.id = "new_external_id".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "users",
        vec![old_pk, new_pk],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    // The old key column keeps its AUTO_INCREMENT checkbox in the draft, but MySQL refuses an
    // auto column that no longer leads a key, so the flag is cleared in the same statement.
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` DROP PRIMARY KEY, MODIFY COLUMN `id` bigint NOT NULL, ADD PRIMARY KEY (`external_id`);"
        ]
    );
}

/// Regression for #7973: swapping the primary key onto another column left the previous
/// AUTO_INCREMENT key column untouched, so the coalesced ALTER failed with
/// `ERROR 1075 Incorrect table definition; there can be only one auto column ...`.
#[test]
fn mysql_clears_auto_increment_on_column_replaced_by_new_auto_increment_primary_key() {
    let mut old_pk = existing_pk_column("ID", "bigint unsigned", true, false);
    old_pk.id = "old_id".to_string();
    old_pk.comment = "自增ID".to_string();
    old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    let old_original = old_pk.original.as_mut().unwrap();
    old_original.extra = Some("auto_increment".to_string());
    old_original.comment = Some("自增ID".to_string());

    let mut new_pk = existing_pk_column("ProjectID", "bigint", false, true);
    new_pk.id = "project_id".to_string();
    new_pk.comment = "对应project表的主键ID".to_string();
    new_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    new_pk.original.as_mut().unwrap().comment = Some("对应project表的主键ID".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "issue7973_repro",
        vec![old_pk, new_pk],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `issue7973_repro` DROP PRIMARY KEY, MODIFY COLUMN `ID` bigint unsigned NOT NULL COMMENT '自增ID', MODIFY COLUMN `ProjectID` bigint NOT NULL AUTO_INCREMENT COMMENT '对应project表的主键ID', ADD PRIMARY KEY (`ProjectID`);"
        ]
    );
}

/// A surviving secondary index still keys the column, so AUTO_INCREMENT stays legal there
/// and must not be stripped just because the primary key moved elsewhere.
#[test]
fn mysql_keeps_auto_increment_when_a_kept_index_still_leads_with_the_column() {
    let mut old_pk = existing_pk_column("id", "bigint", true, false);
    old_pk.id = "old_id".to_string();
    old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());

    let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);
    new_pk.id = "new_external_id".to_string();

    let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![old_pk, new_pk]);
    options.indexes = vec![existing_index("idx_users_id", &["id"], false)];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` DROP PRIMARY KEY, ADD PRIMARY KEY (`external_id`);"]);
}

/// An index the same draft edits is rebuilt as DROP + CREATE *after* the column DDL, so it
/// cannot excuse the AUTO_INCREMENT flag: the DROP INDEX would hit ERROR 1075 itself.
#[test]
fn mysql_clears_auto_increment_when_the_only_covering_index_is_rebuilt_by_the_same_draft() {
    let mut old_pk = existing_pk_column("id", "bigint", true, false);
    old_pk.id = "old_id".to_string();
    old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());

    let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);
    new_pk.id = "new_external_id".to_string();

    let mut rebuilt_index = existing_index("idx_users_id", &["id"], false);
    rebuilt_index.is_unique = true;

    let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![old_pk, new_pk]);
    options.indexes = vec![rebuilt_index];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` DROP PRIMARY KEY, MODIFY COLUMN `id` bigint NOT NULL, ADD PRIMARY KEY (`external_id`);",
            "ALTER TABLE `users` DROP INDEX `idx_users_id`, ADD UNIQUE INDEX `idx_users_id` (`id`);",
        ]
    );
}

/// The covering index is matched by persisted names on both sides, so a draft that swaps two
/// column names cannot credit one column's index to the other.
#[test]
fn mysql_index_cover_does_not_follow_a_column_name_swap() {
    let mut old_pk = existing_pk_column("id", "bigint", true, false);
    old_pk.id = "old_id".to_string();
    old_pk.name = "legacy_id".to_string();
    old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());

    // Takes over the name the surviving index was built on, but not the index itself.
    let mut renamed = existing_pk_column("tenant_id", "bigint", false, false);
    renamed.id = "tenant".to_string();
    renamed.name = "id".to_string();

    let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);
    new_pk.id = "new_external_id".to_string();

    let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![old_pk, renamed, new_pk]);
    options.indexes = vec![existing_index("idx_users_tenant_id", &["tenant_id"], false)];

    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    // Only the second statement is what this test is about: the auto column lost AUTO_INCREMENT
    // even though `idx_users_tenant_id` leads with a column *named* `id` in the draft. The
    // separate rename statement, and the order the two renames run in, are pre-existing
    // name-swap behavior unrelated to this fix.
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` CHANGE COLUMN `tenant_id` `id` bigint NOT NULL;",
            "ALTER TABLE `users` DROP PRIMARY KEY, CHANGE COLUMN `id` `legacy_id` bigint NOT NULL, ADD PRIMARY KEY (`external_id`);",
        ]
    );
}

#[test]
fn mysql_coalesces_renamed_auto_increment_primary_key_column() {
    let mut old_pk = existing_pk_column("campaign_rel_id", "bigint", true, false);
    old_pk.id = "old_campaign_rel_id".to_string();

    let mut id = existing_pk_column("id", "bigint", false, true);
    id.id = "new_id".to_string();
    id.original.as_mut().unwrap().name = "legacy_id".to_string();
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "users",
        vec![old_pk, id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` DROP PRIMARY KEY, CHANGE COLUMN `legacy_id` `id` bigint NOT NULL AUTO_INCREMENT, ADD PRIMARY KEY (`id`);"
        ]
    );
}

#[test]
fn mysql_coalesces_composite_primary_key_around_auto_increment_column() {
    for (auto_first, has_supporting_index, expected_primary_key) in
        [(true, false, "`id`, `tenant_id`"), (false, false, "`tenant_id`, `id`"), (false, true, "`tenant_id`, `id`")]
    {
        let mut old_pk = existing_pk_column("legacy_id", "bigint", true, false);
        old_pk.id = "old_legacy_id".to_string();

        let mut id = existing_pk_column("id", "bigint", false, true);
        id.id = "new_id".to_string();
        id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

        let mut tenant_id = existing_pk_column("tenant_id", "bigint", false, true);
        tenant_id.id = "new_tenant_id".to_string();

        let columns = if auto_first { vec![old_pk, id, tenant_id] } else { vec![old_pk, tenant_id, id] };
        let mut options = structure_change_options(DatabaseType::Mysql, None, "users", columns);
        if has_supporting_index {
            options.indexes = vec![existing_index("uniq_users_id", &["id"], true)];
        }

        let result = build_table_structure_change_sql(options);

        assert_eq!(result.warnings, Vec::<String>::new());
        assert_eq!(result.statements.len(), 1);
        assert_eq!(
            result.statements[0],
            format!(
                "ALTER TABLE `users` DROP PRIMARY KEY, MODIFY COLUMN `id` bigint NOT NULL AUTO_INCREMENT, ADD PRIMARY KEY ({expected_primary_key});"
            )
        );
    }
}

#[test]
fn mysql_compatible_database_keeps_existing_primary_key_statement_sequence() {
    let mut old_pk = existing_pk_column("legacy_id", "bigint", true, false);
    old_pk.id = "old_legacy_id".to_string();

    let mut id = existing_pk_column("id", "bigint", false, true);
    id.id = "new_id".to_string();
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Goldendb,
        None,
        "users",
        vec![old_pk, id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` MODIFY COLUMN `id` bigint NOT NULL AUTO_INCREMENT;",
            "ALTER TABLE `users` DROP PRIMARY KEY;",
            "ALTER TABLE `users` ADD PRIMARY KEY (`id`);",
        ]
    );
}

#[test]
fn gaussdb_m_mode_keeps_existing_primary_key_statement_sequence() {
    let mut old_pk = existing_pk_column("legacy_id", "bigint", true, false);
    old_pk.id = "old_legacy_id".to_string();

    let mut id = existing_pk_column("id", "bigint", false, true);
    id.id = "new_id".to_string();
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let mut options = structure_change_options(DatabaseType::Gaussdb, None, "users", vec![old_pk, id]);
    options.is_gaussdb_m_mode = true;
    let result = build_table_structure_change_sql(options);

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` MODIFY COLUMN `id` bigint NOT NULL AUTO_INCREMENT;",
            "ALTER TABLE `users` DROP PRIMARY KEY;",
            "ALTER TABLE `users` ADD PRIMARY KEY (`id`);",
        ]
    );
}

#[test]
fn builds_no_statements_when_primary_key_unchanged() {
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        None,
        "users",
        vec![existing_pk_column("id", "integer", true, true)],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements.is_empty());
}

#[test]
fn rename_only_primary_key_column_does_not_emit_primary_key_ddl() {
    let mut id = existing_pk_column("id_new", "integer", true, true);
    id.original.as_mut().unwrap().name = "id".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Dameng,
        Some("SYSDBA"),
        "users",
        vec![id],
    ));

    // Membership is tracked by draft id, so rename alone is not a PK change.
    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(!result.statements.iter().any(|sql| sql.contains("PRIMARY KEY")));
}

#[test]
fn warns_sqlite_cannot_alter_primary_key() {
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Sqlite,
        None,
        "users",
        vec![existing_pk_column("id", "integer", false, true)],
    ));

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("primary key"));
}

#[test]
fn sqlserver_requires_persisted_constraint_name_and_fails_closed_without_it() {
    // Dropping the persisted primary key needs its constraint name from the index metadata
    // (server-generated names have no rule); without it, emit no partial SQL (no ADD-only) and
    // ask the user to refresh the structure (issue #10758).
    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::SqlServer,
        Some("dbo"),
        "users",
        vec![existing_pk_column("id", "int", true, false)],
    ));

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("SQL Server primary key constraint name"));
    assert!(result.warnings[0].contains("Refresh"));
}

#[test]
fn mysql_create_table_with_auto_increment() {
    let mut col = column("id");
    col.data_type = "int".to_string();
    col.is_nullable = false;
    col.is_primary_key = true;
    col.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 1);
    assert!(result.statements[0].contains("AUTO_INCREMENT"));
}

#[test]
fn mysql_create_table_keeps_column_charset_collation_and_comment() {
    let mut name = column("name");
    name.data_type = "varchar(255)".to_string();
    name.character_set = "gbk".to_string();
    name.collation = "gbk_bin".to_string();
    name.comment = "测试".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: Some("User accounts".to_string()),
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE `users` (\n  `name` varchar(255) CHARACTER SET `gbk` COLLATE `gbk_bin` COMMENT '测试'\n) COMMENT = 'User accounts';"
        ]
    );
}

#[test]
fn mysql_compatible_databases_do_not_emit_mysql_column_charset_clauses() {
    for database_type in [DatabaseType::StarRocks, DatabaseType::Databend, DatabaseType::Gbase] {
        let mut name = column("name");
        name.data_type = "varchar(255)".to_string();
        name.character_set = "utf8mb4".to_string();
        name.collation = "utf8mb4_bin".to_string();

        let result = build_create_table_sql(TableStructureSqlOptions {
            database_type: Some(database_type),
            driver_profile: None,
            schema: None,
            table_name: "users".to_string(),
            columns: vec![name],
            indexes: Vec::new(),
            foreign_keys: Vec::new(),
            triggers: Vec::new(),
            table_comment: None,
            original_table_comment: None,
            mysql_engine: None,
            mysql_auto_increment_value: None,
            transwarp_create: None,
            partitioned: false,
            foreign_table: false,
            is_gaussdb_m_mode: false,
            table_collation: None,
            primary_key_name: None,
            primary_key_change: None,
            oracle_constraint_changes: None,
            oracle_foreign_key_changes: None,
        });

        assert_eq!(result.warnings, Vec::<String>::new());
        assert!(!result.statements[0].contains("CHARACTER SET"));
        assert!(!result.statements[0].contains("COLLATE"));
    }
}

#[test]
fn mysql_create_table_with_on_update_current_timestamp() {
    let mut col = column("updated_at");
    col.data_type = "timestamp".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("ON UPDATE CURRENT_TIMESTAMP"));
}

#[test]
fn mysql_create_table_carries_temporal_precision_into_current_timestamp_clauses() {
    let mut col = column("updated_at");
    col.data_type = "datetime(3)".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });

    let result = build_create_table_sql(structure_change_options(DatabaseType::Mysql, None, "users", vec![col]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE `users` (\n  `updated_at` datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3)\n);"]
    );
}

#[test]
fn mysql_create_table_keeps_explicit_zero_temporal_precision_in_current_timestamp_clauses() {
    let mut col = column("updated_at");
    col.data_type = "datetime(0)".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });

    let result = build_create_table_sql(structure_change_options(DatabaseType::Mysql, None, "users", vec![col]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE `users` (\n  `updated_at` datetime(0) NOT NULL DEFAULT CURRENT_TIMESTAMP(0) ON UPDATE CURRENT_TIMESTAMP(0)\n);"]
    );
}

#[test]
fn mysql_single_column_alter_carries_temporal_precision_into_current_timestamp_clauses() {
    let mut col = column("updated_at");
    col.data_type = "datetime(3)".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });
    col.original = Some(ColumnInfo {
        name: "updated_at".to_string(),
        data_type: "datetime".to_string(),
        is_nullable: false,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        column: col,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `updated_at` datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3);"]
    );
}

#[test]
fn mysql_single_column_alter_resaving_precision_column_keeps_temporal_precision() {
    let mut col = column("updated_at");
    col.data_type = "datetime(3)".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP(3)".to_string();
    col.comment = "updated".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });
    col.original = Some(ColumnInfo {
        name: "updated_at".to_string(),
        data_type: "datetime(3)".to_string(),
        is_nullable: false,
        column_default: Some("CURRENT_TIMESTAMP(3)".to_string()),
        is_primary_key: false,
        extra: Some("on update CURRENT_TIMESTAMP(3)".to_string()),
        comment: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        column: col,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `updated_at` datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT 'updated';"]
    );
}

#[test]
fn mysql_current_timestamp_clauses_stay_bare_without_column_precision() {
    let mut col = column("updated_at");
    col.data_type = "timestamp".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });

    let result = build_create_table_sql(structure_change_options(DatabaseType::Mysql, None, "users", vec![col]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE `users` (\n  `updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP\n);"]
    );

    let mut col = column("updated_at");
    col.data_type = "datetime(7)".to_string();
    col.is_nullable = false;
    col.default_value = "CURRENT_TIMESTAMP".to_string();
    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });

    let result = build_create_table_sql(structure_change_options(DatabaseType::Mysql, None, "users", vec![col]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE `users` (\n  `updated_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP\n);"]
    );
}

#[test]
fn postgres_create_table_with_identity() {
    let mut col = column("id");
    col.data_type = "integer".to_string();
    col.is_nullable = false;
    col.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity { generation: Some("BY DEFAULT".to_string()), seed: None, increment: None }),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("GENERATED BY DEFAULT AS IDENTITY"));
}

#[test]
fn postgres_alter_column_identity_generation_always_to_by_default() {
    let mut id = existing_pk_column("id", "integer", true, true);
    id.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity { generation: Some("BY DEFAULT".to_string()), seed: None, increment: None }),
        ..Default::default()
    });
    id.original.as_mut().unwrap().extra = Some(
        "generated always as identity (start with 1 increment by 1 minvalue 1 maxvalue 2147483647 cache 1 no cycle)"
            .to_string(),
    );

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET GENERATED BY DEFAULT;"]
    );
}

#[test]
fn postgres_alter_column_identity_generation_by_default_to_always() {
    let mut id = existing_pk_column("id", "integer", true, true);
    id.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity { generation: Some("ALWAYS".to_string()), seed: None, increment: None }),
        ..Default::default()
    });
    id.original.as_mut().unwrap().extra = Some("generated by default as identity".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET GENERATED ALWAYS;"]);
}

#[test]
fn postgres_alter_column_identity_seed_and_increment() {
    let mut id = existing_pk_column("id", "integer", true, true);
    id.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity {
            generation: Some("BY DEFAULT".to_string()),
            seed: Some(100),
            increment: Some(5),
        }),
        ..Default::default()
    });
    id.original.as_mut().unwrap().extra = Some("generated by default as identity (start with 1 increment by 1 minvalue 1 maxvalue 2147483647 cache 1 no cycle)".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" RESTART WITH 100;",
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET INCREMENT BY 5;",
        ]
    );
}

#[test]
fn postgres_alter_column_identity_generation_and_sequence_options_together() {
    let mut id = existing_pk_column("id", "integer", true, true);
    id.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity {
            generation: Some("BY DEFAULT".to_string()),
            seed: Some(100),
            increment: Some(2),
        }),
        ..Default::default()
    });
    id.original.as_mut().unwrap().extra = Some(
        "generated always as identity (start with 1 increment by 1 minvalue 1 maxvalue 2147483647 cache 1 no cycle)"
            .to_string(),
    );

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET GENERATED BY DEFAULT;",
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" RESTART WITH 100;",
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET INCREMENT BY 2;",
        ]
    );
}

#[test]
fn postgres_enable_identity_on_existing_column() {
    let mut id = column("id");
    id.data_type = "integer".to_string();
    id.is_nullable = true;
    id.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity { generation: Some("ALWAYS".to_string()), seed: Some(10), increment: Some(2) }),
        ..Default::default()
    });
    id.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "integer".to_string(),
        is_nullable: true,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id.clone()],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET NOT NULL;",
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" ADD GENERATED ALWAYS AS IDENTITY (START WITH 10 INCREMENT BY 2);",
        ]
    );

    let single = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "users".to_string(),
        column: id,
    });
    assert_eq!(
        single.statements,
        vec![
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" SET NOT NULL;",
            "ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" ADD GENERATED ALWAYS AS IDENTITY (START WITH 10 INCREMENT BY 2);",
        ]
    );
}

#[test]
fn postgres_disable_identity_on_existing_column() {
    let mut id = existing_pk_column("id", "integer", true, true);
    id.extra = Some(ColumnExtra::default());
    id.original.as_mut().unwrap().extra = Some("generated always as identity".to_string());

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" ALTER COLUMN \"id\" DROP IDENTITY;"]);
}

#[test]
fn postgres_unchanged_identity_emits_no_statements() {
    let mut id = existing_pk_column("id", "integer", true, true);
    id.extra = Some(ColumnExtra {
        identity: Some(ColumnIdentity { generation: Some("ALWAYS".to_string()), seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    id.original.as_mut().unwrap().extra = Some(
        "generated always as identity (start with 1 increment by 1 minvalue 1 maxvalue 2147483647 cache 1 no cycle)"
            .to_string(),
    );

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "users",
        vec![id],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn dameng_create_table_with_identity() {
    let mut col = column("ID");
    col.data_type = "INT".to_string();
    col.is_nullable = false;
    col.is_primary_key = true;
    col.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(100), increment: Some(5) }),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("\"ID\" INT IDENTITY(100, 5)"), "ddl: {}", result.statements[0]);
    assert!(result.statements[0].contains("PRIMARY KEY (\"ID\")"), "ddl: {}", result.statements[0]);
}

#[test]
fn dameng_create_table_preserves_character_length_units() {
    let mut name = column("NAME");
    name.data_type = "VARCHAR2(255 CHAR)".to_string();
    let mut code = column("CODE");
    code.data_type = "VARCHAR(64 BYTE)".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![name, code],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("\"NAME\" VARCHAR2(255 CHAR)"), "ddl: {}", result.statements[0]);
    assert!(result.statements[0].contains("\"CODE\" VARCHAR(64 BYTE)"), "ddl: {}", result.statements[0]);
}

#[test]
fn dameng_alter_column_preserves_character_length_unit() {
    let mut name = column("NAME");
    name.data_type = "VARCHAR2(64 BYTE)".to_string();
    name.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR2(64 CHAR)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"USERS\" MODIFY (\"NAME\" VARCHAR2(64 BYTE));"]);
}

#[test]
fn dameng_rename_column_uses_alter_column_rename_to() {
    let mut renamed = column("NAME");
    renamed.name = "NEW_NAME".to_string();
    renamed.data_type = "VARCHAR2(64)".to_string();
    renamed.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR2(64)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![renamed],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"SYSDBA\".\"USERS\" ALTER COLUMN \"NAME\" RENAME TO \"NEW_NAME\";"]
    );
}

#[test]
fn dameng_rejects_multiple_identity_columns() {
    let mut first = column("ID");
    first.data_type = "INT".to_string();
    first.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });
    let mut second = column("SEQ");
    second.data_type = "BIGINT".to_string();
    second.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![first, second],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Dameng tables can have only one identity column."]);
}

#[test]
fn dameng_rejects_zero_identity_increment() {
    let mut col = column("ID");
    col.data_type = "INT".to_string();
    col.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(0) }),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Dameng),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Dameng identity column \"ID\" increment cannot be 0."]);
}

#[test]
fn sqlserver_create_table_with_identity() {
    let mut col = column("id");
    col.data_type = "int".to_string();
    col.is_nullable = false;
    col.extra = Some(ColumnExtra {
        auto_increment: Some(true),
        identity: Some(ColumnIdentity { generation: None, seed: Some(100), increment: Some(5) }),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("IDENTITY(100, 5)"));
}

#[test]
fn mysql_quotes_datetime_literal_default() {
    let mut col = column("created_at");
    col.data_type = "datetime".to_string();
    col.default_value = "2024-01-01 00:00:00".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT '2024-01-01 00:00:00'"));
}

#[test]
fn mysql_does_not_quote_current_timestamp() {
    let mut col = column("updated_at");
    col.data_type = "timestamp".to_string();
    col.default_value = "CURRENT_TIMESTAMP".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT CURRENT_TIMESTAMP"));
    assert!(!result.statements[0].contains("DEFAULT 'CURRENT_TIMESTAMP'"));
}

#[test]
fn mysql_does_not_quote_temporal_function_with_parens() {
    let mut col = column("created_at");
    col.data_type = "datetime".to_string();
    col.default_value = "NOW()".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT NOW()"));
}

#[test]
fn mysql_date_literal_default_is_quoted() {
    let mut col = column("birth_date");
    col.data_type = "date".to_string();
    col.default_value = "2000-01-01".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT '2000-01-01'"));
}

#[test]
fn mysql_time_literal_default_is_quoted() {
    let mut col = column("start_time");
    col.data_type = "time".to_string();
    col.default_value = "09:00:00".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "shifts".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT '09:00:00'"));
}

#[test]
fn non_temporal_types_are_not_quoted() {
    let mut col = column("score");
    col.data_type = "int".to_string();
    col.default_value = "0".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "games".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT 0"));
    assert!(!result.statements[0].contains("DEFAULT '0'"));
}

#[test]
fn postgres_timestamp_literal_is_quoted() {
    let mut col = column("logged_at");
    col.data_type = "timestamp".to_string();
    col.default_value = "2024-06-01 12:00:00".to_string();
    col.original = Some(ColumnInfo {
        name: "logged_at".to_string(),
        data_type: "timestamp".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "events".to_string(),
        column: col,
    });

    assert!(result.statements.iter().any(|s| s.contains("SET DEFAULT '2024-06-01 12:00:00'")));
}

#[test]
fn mysql_single_column_alter_quotes_datetime_literal() {
    let mut col = column("created_at");
    col.data_type = "datetime".to_string();
    col.default_value = "2024-01-01 00:00:00".to_string();
    col.original = Some(ColumnInfo {
        name: "created_at".to_string(),
        data_type: "datetime".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        column: col,
    });

    assert!(result.statements.iter().any(|s| s.contains("DEFAULT '2024-01-01 00:00:00'")));
}

#[test]
fn mysql_single_generated_column_change_is_blocked_without_expression_metadata() {
    let mut generated = column("total");
    generated.data_type = "decimal(14,2)".to_string();
    generated.extra = Some(ColumnExtra::default());
    generated.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("STORED GENERATED".to_string()),
        comment: None,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "products".to_string(),
        column: generated,
    });

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("generation expression could not be loaded"));
}

#[test]
fn builds_mysql_foreign_key_changes() {
    let mut existing = foreign_key("fk_orders_users", "user_id", "users", "id");
    existing.on_delete = "CASCADE".to_string();
    existing.original = Some(ForeignKeyInfo {
        name: "fk_orders_users_old".to_string(),
        column: "customer_id".to_string(),
        ref_schema: None,
        ref_table: "customers".to_string(),
        ref_column: "id".to_string(),
        on_update: None,
        on_delete: Some("RESTRICT".to_string()),
    });

    let mut dropped = foreign_key("fk_orders_accounts", "account_id", "accounts", "id");
    dropped.marked_for_drop = true;
    dropped.original = Some(ForeignKeyInfo {
        name: "fk_orders_accounts".to_string(),
        column: "account_id".to_string(),
        ref_schema: None,
        ref_table: "accounts".to_string(),
        ref_column: "id".to_string(),
        on_update: None,
        on_delete: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: vec![existing, dropped],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `orders` DROP FOREIGN KEY `fk_orders_users_old`;",
            "ALTER TABLE `orders` ADD CONSTRAINT `fk_orders_users` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE;",
            "ALTER TABLE `orders` DROP FOREIGN KEY `fk_orders_accounts`;",
        ]
    );
}

#[test]
fn builds_mysql_composite_foreign_key() {
    let composite = foreign_key("fk_order_items_product", "tenant_id, product_id", "products", "tenant_id, id");

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "order_items".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: vec![composite],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `order_items` ADD CONSTRAINT `fk_order_items_product` FOREIGN KEY (`tenant_id`, `product_id`) REFERENCES `products` (`tenant_id`, `id`);",
        ]
    );
}

#[test]
fn builds_oracle_foreign_key_with_supported_actions() {
    let mut customer_id = column("CUSTOMER_ID");
    customer_id.data_type = "NUMBER(19)".to_string();
    let mut customer_fk = foreign_key("ORDERS_COPY_FK1", "CUSTOMER_ID", "CUSTOMERS", "ID");
    customer_fk.ref_schema = "CRM".to_string();
    customer_fk.on_update = "NO ACTION".to_string();
    customer_fk.on_delete = "CASCADE".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("HR".to_string()),
        table_name: "ORDERS_COPY".to_string(),
        columns: vec![customer_id],
        indexes: Vec::new(),
        foreign_keys: vec![customer_fk],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements[1],
        "ALTER TABLE \"HR\".ORDERS_COPY ADD CONSTRAINT ORDERS_COPY_FK1 FOREIGN KEY (CUSTOMER_ID) REFERENCES \"CRM\".\"CUSTOMERS\" (\"ID\") ON DELETE CASCADE;"
    );
}

#[test]
fn builds_oracle_foreign_key_replacement() {
    let mut customer_fk = foreign_key("ORDERS_FK1", "CUSTOMER_ID", "CUSTOMERS", "ID");
    customer_fk.on_delete = "SET NULL".to_string();
    customer_fk.original = Some(ForeignKeyInfo {
        name: "ORDERS_FK_OLD".to_string(),
        column: "CUSTOMER_ID".to_string(),
        ref_schema: Some("CRM".to_string()),
        ref_table: "CUSTOMERS".to_string(),
        ref_column: "ID".to_string(),
        on_update: None,
        on_delete: Some("NO ACTION".to_string()),
    });
    customer_fk.ref_schema = "CRM".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("HR".to_string()),
        table_name: "ORDERS".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: vec![customer_fk],
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"HR\".\"ORDERS\" DROP CONSTRAINT \"ORDERS_FK_OLD\";",
            "ALTER TABLE \"HR\".\"ORDERS\" ADD CONSTRAINT \"ORDERS_FK1\" FOREIGN KEY (\"CUSTOMER_ID\") REFERENCES \"CRM\".\"CUSTOMERS\" (\"ID\") ON DELETE SET NULL;",
        ]
    );
}

#[test]
fn builds_mysql_trigger_changes() {
    let mut existing = trigger("orders_bu", "BEFORE", "UPDATE", "BEGIN\n  SET NEW.updated_at = NOW();\nEND");
    existing.original = Some(TriggerInfo {
        name: "orders_bu".to_string(),
        event: "UPDATE".to_string(),
        timing: "BEFORE".to_string(),
        statement: Some("SET NEW.updated_at = CURRENT_TIMESTAMP".to_string()),
        condition: None,
        enabled: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "DROP TRIGGER `orders_bu`;",
            "CREATE TRIGGER `orders_bu` BEFORE UPDATE ON `orders` FOR EACH ROW\nBEGIN\n  SET NEW.updated_at = NOW();\nEND;",
        ]
    );
}

#[test]
fn builds_sqlserver_trigger_with_multiple_events() {
    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![trigger("orders_audit", "AFTER", "INSERT, UPDATE", "BEGIN\n  SET NOCOUNT ON;\nEND")],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TRIGGER [dbo].[orders_audit] ON [dbo].[orders] AFTER INSERT, UPDATE AS\nBEGIN\n  SET NOCOUNT ON;\nEND;"
        ]
    );
}

#[test]
fn rebuilds_changed_sqlserver_trigger_from_complete_metadata_source() {
    let mut existing = trigger(
        "orders_audit",
        "AFTER",
        "INSERT, UPDATE",
        "CREATE TRIGGER dbo.orders_audit ON dbo.orders AFTER INSERT, UPDATE AS BEGIN SET NOCOUNT ON; INSERT INTO audit_log VALUES (1); END",
    );
    existing.original = Some(TriggerInfo {
        name: "orders_audit".to_string(),
        event: "INSERT, UPDATE".to_string(),
        timing: "AFTER".to_string(),
        statement: Some(
            "CREATE TRIGGER dbo.orders_audit ON dbo.orders AFTER INSERT, UPDATE AS BEGIN SET NOCOUNT ON; INSERT INTO audit_log VALUES (0); END"
                .to_string(),
        ),
        condition: None,
        enabled: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "DROP TRIGGER [dbo].[orders_audit];",
            "CREATE TRIGGER [dbo].[orders_audit] ON [dbo].[orders] AFTER INSERT, UPDATE AS\nBEGIN SET NOCOUNT ON; INSERT INTO audit_log VALUES (1); END;"
        ]
    );
}

#[test]
fn sqlserver_trigger_edit_restores_disabled_state() {
    let mut existing =
        trigger("orders_audit", "AFTER", "INSERT", "BEGIN SET NOCOUNT ON; INSERT INTO audit_log VALUES (1); END");
    existing.original = Some(TriggerInfo {
        name: "orders_audit".to_string(),
        event: "INSERT".to_string(),
        timing: "AFTER".to_string(),
        statement: Some("CREATE TRIGGER dbo.orders_audit ON dbo.orders AFTER INSERT AS PRINT 'old'".to_string()),
        condition: None,
        enabled: Some(false),
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::SqlServer),
        driver_profile: None,
        schema: Some("dbo".to_string()),
        table_name: "orders".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        partitioned: false,
        foreign_table: false,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(
        result.statements.last().map(String::as_str),
        Some("DISABLE TRIGGER [dbo].[orders_audit] ON [dbo].[orders];")
    );
}

#[test]
fn unchanged_postgres_trigger_does_not_block_column_rename() {
    let mut renamed = column("display_name");
    renamed.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    let mut existing = trigger("users_audit", "AFTER", "UPDATE", "EXECUTE FUNCTION audit_users()");
    existing.original = Some(TriggerInfo {
        name: "users_audit".to_string(),
        event: "UPDATE".to_string(),
        timing: "AFTER".to_string(),
        statement: Some("EXECUTE FUNCTION audit_users()".to_string()),
        condition: None,
        enabled: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "users".to_string(),
        columns: vec![renamed],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" RENAME COLUMN \"name\" TO \"display_name\";"]);
}

#[test]
fn changed_postgres_trigger_remains_unsupported() {
    let mut existing = trigger("users_audit", "AFTER", "INSERT", "EXECUTE FUNCTION audit_users()");
    existing.original = Some(TriggerInfo {
        name: "users_audit".to_string(),
        event: "UPDATE".to_string(),
        timing: "AFTER".to_string(),
        statement: Some("EXECUTE FUNCTION audit_users()".to_string()),
        condition: None,
        enabled: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "users".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Editing triggers is not supported for postgres from this editor."]);
}

fn trigger_change_sql(
    database_type: DatabaseType,
    schema: &str,
    table_name: &str,
    triggers: Vec<EditableStructureTrigger>,
) -> TableStructureSqlResult {
    build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(database_type),
        driver_profile: None,
        schema: Some(schema.to_string()),
        table_name: table_name.to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers,
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    })
}

fn existing_trigger(
    name: &str,
    timing: &str,
    event: &str,
    statement: &str,
    enabled: Option<bool>,
) -> EditableStructureTrigger {
    let mut existing = trigger(name, timing, event, statement);
    existing.enabled = enabled;
    existing.original = Some(TriggerInfo {
        name: name.to_string(),
        event: event.to_string(),
        timing: timing.to_string(),
        statement: Some(statement.to_string()),
        condition: None,
        enabled,
    });
    existing
}

#[test]
fn oracle_trigger_enabled_toggle_emits_alter_trigger() {
    let mut disable = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN NULL; END;", Some(true));
    disable.enabled = Some(false);
    let mut enable = existing_trigger("ORDERS_CHECK", "BEFORE EACH ROW", "UPDATE", "BEGIN NULL; END;", Some(false));
    enable.enabled = Some(true);

    let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![disable, enable]);

    assert_eq!(
        result.statements,
        vec!["ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;", "ALTER TRIGGER \"APP\".\"ORDERS_CHECK\" ENABLE;",]
    );
    assert!(result.warnings.is_empty());
}

#[test]
fn oracle_trigger_body_edit_restores_disabled_state() {
    let mut existing = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN NULL; END;", Some(false));
    existing.statement = "BEGIN\n  DBMS_OUTPUT.PUT_LINE('x');\nEND;".to_string();

    let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![existing]);

    assert_eq!(
        result.statements,
        vec![
            "CREATE OR REPLACE TRIGGER \"APP\".\"ORDERS_AUDIT\" AFTER INSERT ON \"APP\".\"ORDERS\"\nFOR EACH ROW\nBEGIN\n  DBMS_OUTPUT.PUT_LINE('x');\nEND;",
            "ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;",
        ]
    );
}

#[test]
fn rejects_editing_oracle_trigger_with_unstructured_source() {
    let source =
        "TRIGGER ORDERS_AUDIT\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\nWHEN (NEW.STATUS = 'OPEN')\nBEGIN NULL; END;";
    let mut edited = existing_trigger("ORDERS_AUDIT", "BEFORE EACH ROW", "INSERT", source, Some(true));
    edited.event = "INSERT OR UPDATE".to_string();
    let mut renamed = existing_trigger("ORDERS_CHECK", "BEFORE EACH ROW", "INSERT", source, Some(true));
    renamed.name = "ORDERS_CHECK_V2".to_string();

    let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![edited, renamed]);

    assert!(result.statements.is_empty(), "unexpected statements: {:?}", result.statements);
    assert_eq!(
        result.warnings,
        vec![
            "Editing existing Oracle trigger \"ORDERS_AUDIT\" requires its complete source definition.",
            "Editing existing Oracle trigger \"ORDERS_CHECK\" requires its complete source definition.",
        ]
    );
}

#[test]
fn oracle_trigger_with_unstructured_source_can_still_toggle_enabled() {
    let source =
        "TRIGGER ORDERS_AUDIT\nBEFORE INSERT ON ORDERS\nFOR EACH ROW\nWHEN (NEW.STATUS = 'OPEN')\nBEGIN NULL; END;";
    let mut existing = existing_trigger("ORDERS_AUDIT", "BEFORE EACH ROW", "INSERT", source, Some(true));
    existing.enabled = Some(false);

    let result = trigger_change_sql(DatabaseType::Oracle, "APP", "ORDERS", vec![existing]);

    assert_eq!(result.statements, vec!["ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;"]);
    assert!(result.warnings.is_empty());
}

#[test]
fn creates_dameng_trigger() {
    let result = trigger_change_sql(
        DatabaseType::Dameng,
        "APP",
        "ORDERS",
        vec![trigger("ORDERS_AUDIT", "BEFORE EACH ROW", "INSERT OR UPDATE", "BEGIN\n  NULL;\nEND;")],
    );

    assert_eq!(
        result.statements,
        vec![
            "CREATE OR REPLACE TRIGGER \"APP\".\"ORDERS_AUDIT\" BEFORE INSERT OR UPDATE ON \"APP\".\"ORDERS\"\nFOR EACH ROW\nBEGIN\n  NULL;\nEND;"
        ]
    );
    assert!(result.warnings.is_empty());
}

#[test]
fn dameng_trigger_edit_rebuilds_with_create_or_replace() {
    let mut existing = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN\n  NULL;\nEND;", Some(true));
    existing.statement = "BEGIN\n  DBMS_OUTPUT.PUT_LINE('x');\nEND;".to_string();

    let result = trigger_change_sql(DatabaseType::Dameng, "APP", "ORDERS", vec![existing]);

    assert_eq!(
        result.statements,
        vec![
            "CREATE OR REPLACE TRIGGER \"APP\".\"ORDERS_AUDIT\" AFTER INSERT ON \"APP\".\"ORDERS\"\nFOR EACH ROW\nBEGIN\n  DBMS_OUTPUT.PUT_LINE('x');\nEND;"
        ]
    );
    assert!(result.warnings.is_empty());
}

#[test]
fn dameng_statement_trigger_keeps_statement_level_timing() {
    // 达梦字典只给裸 BEFORE 时代表语句级(未写 FOR EACH),重建不能改成行级触发器。
    let mut existing = existing_trigger("ORDERS_AUDIT", "BEFORE", "INSERT", "BEGIN\n  NULL;\nEND;", Some(true));
    existing.statement = "BEGIN\n  DBMS_OUTPUT.PUT_LINE('x');\nEND;".to_string();

    let result = trigger_change_sql(DatabaseType::Dameng, "APP", "ORDERS", vec![existing]);

    assert_eq!(
        result.statements,
        vec![
            "CREATE OR REPLACE TRIGGER \"APP\".\"ORDERS_AUDIT\" BEFORE INSERT ON \"APP\".\"ORDERS\"\nBEGIN\n  DBMS_OUTPUT.PUT_LINE('x');\nEND;"
        ]
    );
    assert!(result.warnings.is_empty());
}

#[test]
fn dameng_trigger_enabled_toggle_emits_alter_trigger() {
    let mut existing = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN NULL; END;", Some(true));
    existing.enabled = Some(false);

    let result = trigger_change_sql(DatabaseType::Dameng, "APP", "ORDERS", vec![existing]);

    assert_eq!(result.statements, vec!["ALTER TRIGGER \"APP\".\"ORDERS_AUDIT\" DISABLE;"]);
    assert!(result.warnings.is_empty());
}

#[test]
fn rejects_editing_dameng_trigger_with_when_condition() {
    let mut existing = existing_trigger("ORDERS_AUDIT", "BEFORE EACH ROW", "INSERT", "BEGIN NULL; END;", Some(true));
    if let Some(original) = existing.original.as_mut() {
        original.condition = Some("NEW.STATUS = 'OPEN'".to_string());
    }
    existing.statement = "BEGIN\n  NULL;\nEND;".to_string();

    let result = trigger_change_sql(DatabaseType::Dameng, "APP", "ORDERS", vec![existing]);

    assert!(result.statements.is_empty(), "unexpected statements: {:?}", result.statements);
    assert_eq!(
        result.warnings,
        vec!["Editing existing Dameng trigger \"ORDERS_AUDIT\" requires its complete source definition."]
    );
}

#[test]
fn drops_existing_dameng_trigger() {
    let mut existing = existing_trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN NULL; END;", Some(true));
    existing.marked_for_drop = true;

    let result = trigger_change_sql(DatabaseType::Dameng, "APP", "ORDERS", vec![existing]);

    assert_eq!(result.statements, vec!["DROP TRIGGER \"APP\".\"ORDERS_AUDIT\";"]);
    assert!(result.warnings.is_empty());
}

#[test]
fn sqlserver_trigger_enabled_toggle_emits_enable_disable_trigger() {
    let mut disable = existing_trigger("orders_audit", "AFTER", "INSERT", "BEGIN SET NOCOUNT ON; END", Some(true));
    disable.enabled = Some(false);
    let mut enable = existing_trigger("orders_check", "AFTER", "UPDATE", "BEGIN SET NOCOUNT ON; END", Some(false));
    enable.enabled = Some(true);

    let result = trigger_change_sql(DatabaseType::SqlServer, "dbo", "orders", vec![disable, enable]);

    assert_eq!(
        result.statements,
        vec![
            "DISABLE TRIGGER [dbo].[orders_audit] ON [dbo].[orders];",
            "ENABLE TRIGGER [dbo].[orders_check] ON [dbo].[orders];",
        ]
    );
    assert!(result.warnings.is_empty());
}

#[test]
fn allows_editing_existing_oracle_trigger() {
    let mut existing = trigger(
        "DBX_TRIGGER_4320_AUDIT",
        "AFTER EACH ROW",
        "INSERT OR UPDATE OR DELETE",
        "DECLARE\n  v_event VARCHAR2(10);\nBEGIN\n  v_event := CASE WHEN INSERTING THEN 'INSERT' WHEN UPDATING THEN 'UPDATE' ELSE 'DELETE' END;\nEND;",
    );
    existing.original = Some(TriggerInfo {
        name: "DBX_TRIGGER_4320_AUDIT".to_string(),
        event: "INSERT OR UPDATE OR DELETE".to_string(),
        timing: "AFTER EACH ROW".to_string(),
        statement: Some("BEGIN\n  NULL;\nEND;".to_string()),
        condition: None,
        enabled: None,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "DBX_TRIGGER_4320".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(
        result.statements,
        vec![
            "CREATE OR REPLACE TRIGGER \"APP\".\"DBX_TRIGGER_4320_AUDIT\" AFTER INSERT OR UPDATE OR DELETE ON \"APP\".\"DBX_TRIGGER_4320\"\nFOR EACH ROW\nDECLARE\n  v_event VARCHAR2(10);\nBEGIN\n  v_event := CASE WHEN INSERTING THEN 'INSERT' WHEN UPDATING THEN 'UPDATE' ELSE 'DELETE' END;\nEND;"
        ]
    );
    assert!(result.warnings.is_empty());
}

#[test]
fn builds_oracle_statement_trigger_without_row_clause() {
    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "ORDERS".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![trigger("ORDERS_AUDIT", "BEFORE STATEMENT", "UPDATE OF STATUS", "BEGIN\n  NULL;\nEND;\n/")],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE OR REPLACE TRIGGER \"APP\".\"ORDERS_AUDIT\" BEFORE UPDATE OF STATUS ON \"APP\".\"ORDERS\"\nBEGIN\n  NULL;\nEND;",
        ]
    );
}

#[test]
fn drops_existing_oracle_trigger_without_reconstructing_it() {
    let mut existing = trigger("ORDERS_AUDIT", "AFTER EACH ROW", "INSERT", "BEGIN\n  NULL;\nEND;");
    existing.original = Some(TriggerInfo {
        name: "ORDERS_AUDIT".to_string(),
        event: "INSERT".to_string(),
        timing: "AFTER EACH ROW".to_string(),
        statement: Some("BEGIN\n  NULL;\nEND;".to_string()),
        condition: None,
        enabled: None,
    });
    existing.marked_for_drop = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "ORDERS".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![existing],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["DROP TRIGGER \"APP\".\"ORDERS_AUDIT\";"]);
}

#[test]
fn rejects_unsupported_oracle_compound_trigger_shape() {
    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oracle),
        driver_profile: None,
        schema: Some("APP".to_string()),
        table_name: "ORDERS".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: vec![trigger("ORDERS_CT", "COMPOUND", "UPDATE", "BEGIN\n  NULL;\nEND;")],
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Unsupported Oracle trigger timing \"COMPOUND\"."]);
}

#[test]
fn mysql_varchar_default_is_quoted() {
    let mut col = column("name");
    col.data_type = "varchar(255)".to_string();
    col.default_value = "hello".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT 'hello'"));
    assert!(!result.statements[0].contains("DEFAULT hello "));
}

#[test]
fn mysql_char_default_is_quoted() {
    let mut col = column("code");
    col.data_type = "char(10)".to_string();
    col.default_value = "abc".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "items".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT 'abc'"));
}

#[test]
fn mysql_text_default_is_quoted() {
    let mut col = column("description");
    col.data_type = "text".to_string();
    col.default_value = "default value".to_string();

    // MariaDB accepts a literal default on TEXT; MySQL refuses it (see
    // `mysql_literal_default_on_blob_text_json_geometry_is_refused`).
    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: Some("mariadb".to_string()),
        schema: None,
        table_name: "products".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT 'default value'"));
}

#[test]
fn mysql_enum_default_is_quoted() {
    let mut col = column("status");
    col.data_type = "enum('active','inactive')".to_string();
    col.default_value = "active".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT 'active'"));
}

#[test]
fn mysql_int_default_is_not_quoted() {
    let mut col = column("score");
    col.data_type = "int".to_string();
    col.default_value = "100".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "games".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("DEFAULT 100"));
    assert!(!result.statements[0].contains("DEFAULT '100'"));
}

#[test]
fn postgres_varchar_default_is_quoted() {
    let mut col = column("label");
    col.data_type = "varchar(100)".to_string();
    col.default_value = "test label".to_string();
    col.original = Some(ColumnInfo {
        name: "label".to_string(),
        data_type: "varchar(100)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: None,
        table_name: "items".to_string(),
        column: col,
    });

    assert!(result.statements.iter().any(|s| s.contains("SET DEFAULT 'test label'")));
}

#[test]
fn postgres_empty_string_default_is_not_quoted_again() {
    let mut col = column("sku");
    col.data_type = "character varying".to_string();
    col.default_value = "''".to_string();
    col.original = Some(ColumnInfo {
        name: "sku".to_string(),
        data_type: "character varying".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("core".to_string()),
        table_name: "products".to_string(),
        column: col,
    });

    assert_eq!(result.statements, vec!["ALTER TABLE \"core\".\"products\" ALTER COLUMN \"sku\" SET DEFAULT '';"]);
}

#[test]
fn postgres_string_default_cast_matches_plain_literal() {
    let mut col = column("category");
    col.data_type = "character varying".to_string();
    col.default_value = "''".to_string();
    col.original = Some(ColumnInfo {
        name: "category".to_string(),
        data_type: "character varying".to_string(),
        is_nullable: true,
        column_default: Some("''::character varying".to_string()),
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("core".to_string()),
        table_name: "products".to_string(),
        column: col,
    });

    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn postgres_integer_default_is_not_quoted() {
    let mut col = column("stock");
    col.data_type = "integer".to_string();
    col.default_value = "0".to_string();
    col.original = Some(ColumnInfo {
        name: "stock".to_string(),
        data_type: "integer".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: Some(String::new()),
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("core".to_string()),
        table_name: "products".to_string(),
        column: col,
    });

    assert_eq!(result.statements, vec!["ALTER TABLE \"core\".\"products\" ALTER COLUMN \"stock\" SET DEFAULT 0;"]);
}

#[test]
fn mysql_character_column_add_with_charset_collation() {
    let mut col = column("name");
    col.data_type = "varchar(255)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` ADD COLUMN `name` varchar(255) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci`;"
        ]
    );
}

#[test]
fn single_column_alter_builder_generates_add_for_new_mysql_column() {
    let mut col = column("category");
    col.id = "ddl-preview:new:category".to_string();
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_general_ci".to_string();
    col.comment = "所属类别".to_string();

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "apis".to_string(),
        column: col,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `apis` ADD COLUMN `category` varchar(50) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_general_ci` COMMENT '所属类别';"
        ]
    );
}

#[test]
fn single_column_alter_builder_preserves_mysql_generated_expression_for_add_preview() {
    let mut col = column("total");
    col.id = "ddl-preview:existing:total".to_string();
    col.data_type = "int".to_string();
    col.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "int".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`quantity` * `price`) STORED".to_string()),
        comment: None,
        character_set: None,
        collation: None,
    });
    col.original_position = None;

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "orders".to_string(),
        column: col,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `orders` ADD COLUMN `total` int GENERATED ALWAYS AS (`quantity` * `price`) STORED;"]
    );
}

#[test]
fn single_column_alter_builder_keeps_existing_column_without_position_as_edit() {
    let mut col = column("id");
    col.data_type = "INTEGER".to_string();
    col.original = Some(ColumnInfo {
        name: "id".to_string(),
        data_type: "SMALLINT".to_string(),
        is_nullable: true,
        ..Default::default()
    });

    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
        database_type: Some(DatabaseType::DuckDb),
        driver_profile: None,
        schema: None,
        table_name: "issue_9980".to_string(),
        column: col,
    });

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Editing existing columns is not supported for duckdb yet."]);
}

#[test]
fn mysql_numeric_column_omits_charset_collation_in_column_definition() {
    let mut col = column("score");
    col.data_type = "int".to_string();
    // Even if charset/collation are set on the editable column, they must NOT
    // appear in the DDL because int does not accept CHARACTER SET or COLLATE.
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "games".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements.len() == 1);
    let sql = &result.statements[0];
    assert!(!sql.contains("CHARACTER SET"));
    assert!(!sql.contains("COLLATE"));
    assert!(sql.contains("int"));
}

#[test]
fn mysql_numeric_column_ignores_charset_collation_in_change_detection() {
    // When an existing INT column has no original character_set / collation but
    // the editable draft carries stale values, the column should NOT be flagged
    // as having an attribute change.
    let mut col = column("score");
    col.data_type = "int".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();
    col.original = Some(ColumnInfo {
        name: "score".to_string(),
        data_type: "int".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "games".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    // No ALTER should be emitted — charset/collation changes on
    // non-character columns are no-ops.
    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn mysql_character_column_detects_charset_collation_change() {
    let mut col = column("name");
    col.data_type = "varchar(255)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();
    col.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci`;"]
    );
}

#[test]
fn mysql_character_column_preserves_charset_collation_on_other_change() {
    // Changing the default value on a character column should still
    // re-emit the charset/collation clauses so they are not lost.
    let mut col = column("name");
    col.data_type = "varchar(255)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();
    col.default_value = "guest".to_string();
    col.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(255)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_unicode_ci".to_string()),
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci` DEFAULT 'guest';"]
    );
}

#[test]
fn goldendb_character_column_keeps_charset_collation_when_default_changes() {
    let mut name = column("name");
    name.data_type = "varchar(64)".to_string();
    name.default_value = "guest".to_string();
    name.character_set = "utf8mb4".to_string();
    name.collation = "utf8mb4_bin".to_string();
    name.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(64)".to_string(),
        is_nullable: true,
        column_default: Some("member".to_string()),
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_bin".to_string()),
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Goldendb,
        Some("app"),
        "users",
        vec![name],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(64) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_bin` DEFAULT 'guest';"]
    );
}
#[test]
fn mysql_inherited_column_charset_is_omitted_from_generated_ddl() {
    // MySQL reports the effective collation of every character column, so a column
    // that simply inherits the table default looks identical to one that spells the
    // same collation out. Introspection keeps those values (the editor needs them to
    // show the column's current charset), and the redundant clauses are dropped here,
    // while generating the DDL.
    let mut col = column("note");
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_0900_ai_ci".to_string();
    col.comment = "Free-form note".to_string();
    col.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_0900_ai_ci".to_string()),
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: Some("utf8mb4_0900_ai_ci".to_string()),
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `note` varchar(50) COMMENT 'Free-form note';"]
    );
}

#[test]
fn mysql_explicit_column_charset_survives_the_table_default_comparison() {
    // A column whose collation differs from the table default must keep its clauses:
    // MODIFY COLUMN replaces the whole definition, so dropping them would silently
    // convert the column to the table's default character set.
    let mut col = column("name");
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();
    col.comment = "Display name".to_string();
    col.original = Some(ColumnInfo {
        name: "name".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_unicode_ci".to_string()),
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: Some("utf8mb4_0900_ai_ci".to_string()),
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` MODIFY COLUMN `name` varchar(50) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci` COMMENT 'Display name';"
        ]
    );
}

#[test]
fn mysql_inherited_column_charset_does_not_register_as_a_change() {
    // The original snapshot is normalized together with the draft, so a column left
    // untouched by the user never looks like a charset edit and produces no ALTER.
    let mut col = column("note");
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_0900_ai_ci".to_string();
    col.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_0900_ai_ci".to_string()),
    });
    col.original_position = Some(0);

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: Some("utf8mb4_0900_ai_ci".to_string()),
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn mysql_collation_switched_away_from_the_table_default_is_emitted() {
    let mut col = column("note");
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_bin".to_string();
    col.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_0900_ai_ci".to_string()),
    });
    col.original_position = Some(0);

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: Some("utf8mb4_0900_ai_ci".to_string()),
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `users` MODIFY COLUMN `note` varchar(50) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_bin`;"]
    );
}

#[test]
fn mysql_column_charset_switched_to_the_table_default_drops_the_clause() {
    // Omitting the clauses is equivalent to writing the table default out, so a column
    // moved onto the table default still converts — it just does so implicitly.
    let mut col = column("note");
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_0900_ai_ci".to_string();
    col.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("latin1".to_string()),
        collation: Some("latin1_bin".to_string()),
    });
    col.original_position = Some(0);

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: Some("utf8mb4_0900_ai_ci".to_string()),
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `note` varchar(50);"]);
}

#[test]
fn mysql_column_charset_is_kept_when_the_table_default_is_unknown() {
    // Without a table default there is nothing to compare against, so the real values
    // reported by MySQL are written out rather than guessed away.
    let mut col = column("note");
    col.data_type = "varchar(50)".to_string();
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_0900_ai_ci".to_string();
    col.comment = "Free-form note".to_string();
    col.original = Some(ColumnInfo {
        name: "note".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        character_set: Some("utf8mb4".to_string()),
        collation: Some("utf8mb4_0900_ai_ci".to_string()),
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![col],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `users` MODIFY COLUMN `note` varchar(50) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_0900_ai_ci` COMMENT 'Free-form note';"
        ]
    );
}

#[test]
fn mysql_create_table_omits_inherited_column_charset() {
    let mut inherited = column("note");
    inherited.data_type = "varchar(50)".to_string();
    inherited.character_set = "utf8mb4".to_string();
    inherited.collation = "utf8mb4_0900_ai_ci".to_string();
    let mut explicit = column("name");
    explicit.data_type = "varchar(50)".to_string();
    explicit.character_set = "utf8mb4".to_string();
    explicit.collation = "utf8mb4_unicode_ci".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "users".to_string(),
        columns: vec![inherited, explicit],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: Some("utf8mb4_0900_ai_ci".to_string()),
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE `users` (\n  `note` varchar(50),\n  `name` varchar(50) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci`\n);"
        ]
    );
}

#[test]
fn mysql_generated_column_preserves_expression_when_modified() {
    let mut generated = column("total");
    generated.data_type = "decimal(14,2)".to_string();
    generated.is_nullable = false;
    generated.comment = "Computed total".to_string();
    generated.extra = Some(ColumnExtra::default());
    generated.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * `quantity`) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    generated.original_position = Some(0);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "products",
        vec![generated],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` MODIFY COLUMN `total` decimal(14,2) GENERATED ALWAYS AS (`price` * `quantity`) STORED NOT NULL COMMENT 'Computed total';"
        ]
    );
}

#[test]
fn mysql_unchanged_generated_column_is_not_modified_with_other_columns() {
    let mut generated = column("total");
    generated.data_type = "decimal(12,2)".to_string();
    generated.extra = Some(ColumnExtra::default());
    generated.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("STORED GENERATED".to_string()),
        comment: None,
        ..Default::default()
    });
    generated.original_position = Some(0);

    let mut status = column("status");
    status.data_type = "varchar(50)".to_string();
    status.comment = "状态1".to_string();
    status.original = Some(ColumnInfo {
        name: "status".to_string(),
        data_type: "varchar(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    status.original_position = Some(1);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "product_info",
        vec![generated, status],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `product_info` MODIFY COLUMN `status` varchar(50) COMMENT '状态1';"]
    );
}

#[test]
fn mysql_generated_column_change_is_blocked_without_expression_metadata() {
    let mut generated = column("total");
    generated.data_type = "decimal(14,2)".to_string();
    generated.extra = Some(ColumnExtra::default());
    generated.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("STORED GENERATED".to_string()),
        comment: None,
        ..Default::default()
    });
    generated.original_position = Some(0);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Mysql,
        None,
        "products",
        vec![generated],
    ));

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("generation expression could not be loaded"));
}

#[test]
fn postgres_generated_column_extra_shape_is_not_an_mysql_extra_change() {
    // PostgreSQL-family introspection reports generated columns in the same
    // `generated always as (...) stored` shape, but the structure editor of
    // those dialects never parses it into `extra.generated`. The MySQL-only
    // generated-column diff must not flag these columns as changed.
    let mut total = column("total");
    total.data_type = "numeric(12,2)".to_string();
    total.extra = Some(ColumnExtra::default());
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "numeric(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("generated always as (price * quantity) stored".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Postgres,
        None,
        "products",
        vec![total],
    ));

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(result.warnings, Vec::<String>::new());
}

#[test]
fn mysql_add_column_with_generated_expression_stored() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * `quantity`".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` ADD COLUMN `total` decimal(14,2) GENERATED ALWAYS AS (`price` * `quantity`) STORED;"
        ]
    );
}

#[test]
fn mysql_add_column_with_generated_expression_defaults_to_virtual() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated { expression: "`price` * `quantity`".to_string(), storage: None }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` ADD COLUMN `total` decimal(14,2) GENERATED ALWAYS AS (`price` * `quantity`) VIRTUAL;"
        ]
    );
}

#[test]
fn mysql_modify_generated_column_expression_change() {
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * `quantity` * 2".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * `quantity`) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` MODIFY COLUMN `total` decimal(12,2) GENERATED ALWAYS AS (`price` * `quantity` * 2) STORED;"
        ]
    );
}

#[test]
fn mysql_modify_generated_column_storage_change() {
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * `quantity`".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * `quantity`) VIRTUAL".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    // MySQL rejects switching a generated column between VIRTUAL and STORED
    // in place; the DDL is still emitted but a warning explains the rejection.
    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("cannot switch a generated column between VIRTUAL and STORED"));
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` MODIFY COLUMN `total` decimal(12,2) GENERATED ALWAYS AS (`price` * `quantity`) STORED;"
        ]
    );
}

#[test]
fn mysql_generated_column_removed_becomes_plain_column() {
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    // An explicit empty expression removes the generated-column attribute.
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated { expression: String::new(), storage: None }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * `quantity`) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `products` MODIFY COLUMN `total` decimal(12,2);"]);
}

#[test]
fn mysql_plain_column_becomes_generated() {
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * `quantity`".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` MODIFY COLUMN `total` decimal(12,2) GENERATED ALWAYS AS (`price` * `quantity`) STORED;"
        ]
    );
}

#[test]
fn mysql_unchanged_generated_column_with_explicit_values_is_not_modified() {
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    // Explicitly echoing the introspected definition must not register a change.
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * `quantity`".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * `quantity`) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn mysql_generated_column_comparison_ignores_case_and_whitespace() {
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "  `PRICE`  *   `quantity`  ".to_string(),
            storage: Some("stored".to_string()),
        }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * `quantity`) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn mysql_generated_expression_with_wrapping_parentheses_is_normalized() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "(`price` * `quantity`)".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` ADD COLUMN `total` decimal(14,2) GENERATED ALWAYS AS (`price` * `quantity`) STORED;"
        ]
    );
}

#[test]
fn mysql_generated_literal_case_change_is_detected() {
    // MySQL stores string literals verbatim, so editing only the case of a
    // literal is a real change and must not be swallowed by the
    // case-insensitive comparison of keywords and identifiers.
    let mut flag = column("flag");
    flag.data_type = "varchar(3)".to_string();
    flag.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "if(`status`, 'yes', 'No')".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    flag.original = Some(ColumnInfo {
        name: "flag".to_string(),
        data_type: "varchar(3)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (IF(`status`, 'Yes', 'No')) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    flag.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![flag]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `products` MODIFY COLUMN `flag` varchar(3) GENERATED ALWAYS AS (if(`status`, 'yes', 'No')) STORED;"
        ]
    );
}

#[test]
fn mysql_generated_keyword_case_change_is_ignored_but_literal_is_not() {
    // Keyword/identifier case differences must stay invisible (drivers may
    // rewrite them), while the literal keeps its exact spelling.
    let mut flag = column("flag");
    flag.data_type = "varchar(3)".to_string();
    flag.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "  IF(`status`,   'Yes', 'No')".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    flag.original = Some(ColumnInfo {
        name: "flag".to_string(),
        data_type: "varchar(3)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (if(`status`, 'Yes', 'No')) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    flag.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![flag]));

    // Only whitespace and keyword case differ → no statement.
    assert_eq!(result.statements, Vec::<String>::new());
}

#[test]
fn mysql_generated_wrapping_parentheses_typed_by_hand_do_not_modify() {
    // The renderer strips one layer of wrapping parentheses; edit detection
    // compares with the same contract, so re-typing them is not a change and
    // must not emit a no-op MODIFY (a STORED rebuild is not free).
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "(price * qty)".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(12,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (price * qty) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.statements, Vec::<String>::new());
    assert_eq!(result.warnings, Vec::<String>::new());
}

#[test]
fn mysql_generated_double_quoted_literal_case_change_is_detected() {
    // MySQL treats double quotes as string quotes unless ANSI_QUOTES is on;
    // either way the quoted text must keep its exact spelling in comparisons.
    let mut flag = column("flag");
    flag.data_type = "varchar(3)".to_string();
    flag.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "IF(`status`, \"yes\", 'No')".to_string(),
            storage: Some("STORED".to_string()),
        }),
        ..Default::default()
    });
    flag.original = Some(ColumnInfo {
        name: "flag".to_string(),
        data_type: "varchar(3)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (IF(`status`, \"Yes\", 'No')) STORED".to_string()),
        comment: None,
        ..Default::default()
    });
    flag.original_position = Some(0);

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![flag]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements.len(), 1);
    assert!(result.statements[0].contains("\"yes\""));
}

#[test]
fn mysql_plain_to_virtual_generated_warns() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(14,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * 2".to_string(),
            storage: Some("VIRTUAL".to_string()),
        }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("only allows converting a plain column into a STORED generated column"));
}

#[test]
fn mysql_generated_storage_switch_warns() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(14,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * 2) VIRTUAL".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated { expression: "`price` * 2".to_string(), storage: Some("STORED".to_string()) }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("cannot switch a generated column between VIRTUAL and STORED"));
}

#[test]
fn mysql_virtual_to_plain_warns() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(14,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: Some("GENERATED ALWAYS AS (`price` * 2) VIRTUAL".to_string()),
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);
    total.extra = Some(ColumnExtra { ..Default::default() });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert!(result.warnings.iter().any(|warning| warning.contains("removing a VIRTUAL generated attribute")));
}

#[test]
fn mysql_plain_to_stored_generated_and_back_do_not_warn() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.original = Some(ColumnInfo {
        name: "total".to_string(),
        data_type: "decimal(14,2)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });
    total.original_position = Some(0);
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated { expression: "`price` * 2".to_string(), storage: Some("STORED".to_string()) }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements.iter().any(|statement| statement.contains("GENERATED ALWAYS AS (`price` * 2) STORED")));
}

#[test]
fn mysql_empty_generated_expression_warns_and_omits_clause() {
    let mut total = column("total");
    total.data_type = "decimal(14,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated { expression: "   ".to_string(), storage: Some("STORED".to_string()) }),
        ..Default::default()
    });

    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "products", vec![total]));

    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("expression is empty"));
    assert_eq!(result.statements, vec!["ALTER TABLE `products` ADD COLUMN `total` decimal(14,2);"]);
}

#[test]
fn mysql_create_table_with_generated_column() {
    let mut price = column("price");
    price.data_type = "decimal(10,2)".to_string();
    let mut total = column("total");
    total.data_type = "decimal(12,2)".to_string();
    total.extra = Some(ColumnExtra {
        generated: Some(ColumnGenerated {
            expression: "`price` * 2".to_string(),
            storage: Some("VIRTUAL".to_string()),
        }),
        ..Default::default()
    });

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "products".to_string(),
        columns: vec![price, total],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
        foreign_table: false,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE `products` (\n  `price` decimal(10,2),\n  `total` decimal(12,2) GENERATED ALWAYS AS (`price` * 2) VIRTUAL\n);"
        ]
    );
}

// ---- Oscar (神通) ----
// 神通 v7 是 Oracle 兼容方言,且实测支持 ALTER TABLE DROP/ADD PRIMARY KEY(与 Dameng 一致,
// 不同于 Oracle)。DDL 生成走 StructureDialect::Oscar,与 Dameng 共享 Oracle-like 分支。
// 这些测试锁定 issue #5505 的核心场景:建表/改列/主键/索引/注释,防回归。

#[test]
fn oscar_create_table_with_primary_key_and_comments() {
    let mut id = column("ID");
    id.data_type = "NUMBER(10)".to_string();
    id.is_nullable = false;
    id.is_primary_key = true;
    let mut name = column("NAME");
    name.data_type = "VARCHAR2(100)".to_string();
    name.is_nullable = false;
    name.comment = "name col".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oscar),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "USERS".to_string(),
        columns: vec![id, name],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: Some("user table".to_string()),
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("CREATE TABLE \"SYSDBA\".\"USERS\""), "ddl: {}", result.statements[0]);
    // Oracle 风格:PK 在表定义末尾单独声明;PK 列省略 NOT NULL(主键隐含),非 PK 非空列显式 NOT NULL。
    assert!(result.statements[0].contains("\"ID\" NUMBER(10),"), "ddl: {}", result.statements[0]);
    assert!(result.statements[0].contains("\"NAME\" VARCHAR2(100) NOT NULL,"), "ddl: {}", result.statements[0]);
    assert!(result.statements[0].contains("PRIMARY KEY (\"ID\")"), "ddl: {}", result.statements[0]);
    assert!(
        result.statements.iter().any(|s| s == "COMMENT ON TABLE \"SYSDBA\".\"USERS\" IS 'user table';"),
        "comments: {:?}",
        result.statements
    );
    assert!(
        result.statements.iter().any(|s| s == "COMMENT ON COLUMN \"SYSDBA\".\"USERS\".\"NAME\" IS 'name col';"),
        "comments: {:?}",
        result.statements
    );
}

#[test]
fn oscar_add_column_with_comment() {
    let mut age = column("AGE");
    age.data_type = "NUMBER(3)".to_string();
    age.is_nullable = true;
    age.comment = "age col".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oscar,
        Some("SYSDBA"),
        "users",
        vec![age],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    // Oracle 风格:ADD 用圆括号包裹列定义,可空列省略 NULL 关键字。
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" ADD (\"AGE\" NUMBER(3));",
            "COMMENT ON COLUMN \"SYSDBA\".\"users\".\"AGE\" IS 'age col';",
        ]
    );
}

#[test]
fn oscar_alter_existing_column_modify_type_and_nullability() {
    let mut name = column("NAME");
    name.data_type = "VARCHAR2(100)".to_string();
    name.is_nullable = false;
    name.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR2(50)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oscar,
        Some("SYSDBA"),
        "users",
        vec![name],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    // 神通 MODIFY 语法差异:类型变更与可空性变更需拆成两条(带括号的 MODIFY 不允许 NULL/NOT NULL)。
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" MODIFY (\"NAME\" VARCHAR2(100));",
            "ALTER TABLE \"SYSDBA\".\"users\" MODIFY \"NAME\" NOT NULL;",
        ]
    );
}

#[test]
fn oscar_alter_only_nullability_emits_single_unparenthesized_modify() {
    // 只改可空性(类型不变):应只生成一条不带括号的 MODIFY col NOT NULL,不重复发类型变更。
    let mut name = column("NAME");
    name.data_type = "VARCHAR2(100)".to_string();
    name.is_nullable = false;
    name.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR2(100)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oscar,
        Some("SYSDBA"),
        "users",
        vec![name],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"users\" MODIFY \"NAME\" NOT NULL;"]);
}

#[test]
fn oscar_alter_only_default_keeps_parenthesized_modify() {
    // 只改默认值(类型与可空性不变):带括号的 MODIFY 允许 DEFAULT,不触发可空性单独语句。
    let mut name = column("NAME");
    name.data_type = "VARCHAR2(100)".to_string();
    name.is_nullable = true;
    name.default_value = "'guest'".to_string();
    name.original = Some(ColumnInfo {
        name: "NAME".to_string(),
        data_type: "VARCHAR2(100)".to_string(),
        is_nullable: true,
        column_default: None,
        is_primary_key: false,
        extra: None,
        comment: None,
        ..Default::default()
    });

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oscar,
        Some("SYSDBA"),
        "users",
        vec![name],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"SYSDBA\".\"users\" MODIFY (\"NAME\" VARCHAR2(100) DEFAULT 'guest');"]
    );
}

#[test]
fn oscar_drop_and_readd_primary_key() {
    // 神通实测支持 ALTER TABLE DROP/ADD PRIMARY KEY(与 Dameng 一致)。
    let mut old_pk = existing_pk_column("id", "INT", true, false);
    old_pk.id = "old_id".to_string();
    let mut new_pk = existing_pk_column("code", "VARCHAR(50)", false, true);
    new_pk.id = "new_code".to_string();

    let result = build_table_structure_change_sql(structure_change_options(
        DatabaseType::Oscar,
        Some("SYSDBA"),
        "users",
        vec![old_pk, new_pk],
    ));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE \"SYSDBA\".\"users\" DROP PRIMARY KEY;",
            "ALTER TABLE \"SYSDBA\".\"users\" ADD PRIMARY KEY (\"code\");",
        ]
    );
}

#[test]
fn oscar_drop_index_with_schema_qualifier() {
    let mut idx = index("DBX_PROBE_IDX", &["NAME"]);
    idx.marked_for_drop = true;
    idx.original = Some(IndexInfo {
        name: "DBX_PROBE_IDX".to_string(),
        columns: vec!["NAME".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oscar),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "users".to_string(),
        columns: Vec::new(),
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["DROP INDEX \"SYSDBA\".\"DBX_PROBE_IDX\";"]);
}

#[test]
fn oscar_table_comment_uses_comment_on_table() {
    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Oscar),
        driver_profile: None,
        schema: Some("SYSDBA".to_string()),
        table_name: "users".to_string(),
        columns: Vec::new(),
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: Some("new comment".to_string()),
        original_table_comment: Some("old comment".to_string()),
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["COMMENT ON TABLE \"SYSDBA\".\"users\" IS 'new comment';"]);
}

#[test]
fn postgres_existing_index_concurrent_request_rejected() {
    let mut idx = existing_index("idx_users_email", &["email"], false);
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    // Fail closed: a concurrent request on an existing index is refused up
    // front. No DROP INDEX and no plain (blocking) CREATE INDEX may be
    // generated behind the caller's back.
    assert_eq!(
        result.warnings,
        vec![
            "CREATE INDEX CONCURRENTLY is only supported for newly created indexes. Editing an existing index \"idx_users_email\" with Concurrent enabled is not supported."
        ]
    );
    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
}

#[test]
fn postgres_existing_index_concurrent_flag_with_real_change_still_rejected() {
    // The concurrent flag combined with a real edit (renamed index) must still
    // be rejected rather than rebuilt the regular way.
    let mut idx = existing_index("idx_users_email", &["email"], false);
    idx.name = "idx_users_email_new".to_string();
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings.len(), 1);
    assert!(result.warnings[0].contains("only supported for newly created indexes"));
    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
}

#[test]
fn postgres_default_index_keeps_plain_create_index() {
    let idx = index("idx_users_email", &["email"]);
    assert!(!idx.concurrently);

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]);
}

#[test]
fn postgres_concurrent_index_emits_concurrently() {
    let mut idx = index("idx_users_email", &["email"]);
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE INDEX CONCURRENTLY \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]
    );
}

#[test]
fn postgres_partitioned_parent_concurrent_request_rejected() {
    let mut idx = index("idx_users_email", &["email"]);
    idx.concurrently = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "USERS".to_string(),
        columns: Vec::new(),
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: true,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    // Fail closed: PostgreSQL rejects CREATE INDEX CONCURRENTLY on a
    // partitioned parent, so the request is refused up front instead of
    // downgrading to a blocking CREATE INDEX.
    assert_eq!(
        result.warnings,
        vec![
            "CREATE INDEX CONCURRENTLY is not supported on PostgreSQL partitioned parent tables. Create indexes concurrently on individual partitions and attach them separately."
        ]
    );
    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
}

#[test]
fn postgres_partitioned_parent_plain_index_unchanged() {
    let idx = index("idx_users_email", &["email"]);

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "USERS".to_string(),
        columns: Vec::new(),
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: true,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]);
}

#[test]
fn postgres_partitioned_option_defaults_to_false() {
    let json = serde_json::json!({
        "databaseType": "postgres",
        "schema": "public",
        "tableName": "users",
        "columns": [],
        "indexes": [],
        "foreignKeys": [],
        "triggers": [],
        "tableComment": null,
        "originalTableComment": null,
    });
    let options: TableStructureSqlOptions = serde_json::from_value(json).unwrap();
    assert!(!options.partitioned);
}

#[test]
fn postgres_create_table_partitioned_concurrent_request_rejected() {
    // The new-table path (`build_create_table_sql`) is a separate entry point
    // and must refuse partitioned-parent concurrent requests the same way.
    let mut idx = index("idx_events_id", &["id"]);
    idx.concurrently = true;

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "events".to_string(),
        columns: vec![column("id")],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: true,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(
        result.warnings,
        vec![
            "CREATE INDEX CONCURRENTLY is not supported on PostgreSQL partitioned parent tables. Create indexes concurrently on individual partitions and attach them separately."
        ]
    );
    assert!(result.statements.is_empty(), "no statements may be generated, got: {:?}", result.statements);
}

#[test]
fn mysql_stale_concurrently_flag_is_ignored() {
    // Non-PostgreSQL engines cannot request a concurrent build at all; a stale
    // or forged `concurrently` flag must not error and must not alter the SQL.
    let mut idx = index("idx_users_email", &["email"]);
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE INDEX `idx_users_email` ON `USERS` (`email`);"]);
}

#[test]
fn mysql_existing_index_with_stale_concurrently_flag_ignored() {
    // An existing-index edit on a non-PostgreSQL engine is driven by the actual
    // field changes; a stale concurrently flag alone must not force a rebuild.
    let idx = existing_index("idx_users_email", &["email"], false);
    let mut changed = idx;
    changed.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Mysql, Some("public"), changed));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements.is_empty(), "no rebuild for a flag-only change, got: {:?}", result.statements);
}

#[test]
fn postgres_concurrent_unique_index() {
    let mut idx = index("uniq_users_email", &["email"]);
    idx.is_unique = true;
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec!["CREATE UNIQUE INDEX CONCURRENTLY \"uniq_users_email\" ON \"public\".\"USERS\" (\"email\");"]
    );
}

#[test]
fn postgres_concurrent_partial_index_keeps_where_clause() {
    let mut idx = index("idx_users_active", &["status"]);
    idx.filter = "status = 'active'".to_string();
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE INDEX CONCURRENTLY \"idx_users_active\" ON \"public\".\"USERS\" (\"status\") WHERE status = 'active';"
        ]
    );
}

#[test]
fn postgres_concurrent_include_index() {
    let mut idx = index("idx_users_email", &["email"]);
    idx.included_columns = vec!["name".to_string(), "created_at".to_string()];
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE INDEX CONCURRENTLY \"idx_users_email\" ON \"public\".\"USERS\" (\"email\") INCLUDE (\"name\", \"created_at\");"
        ]
    );
}

#[test]
fn postgres_concurrent_index_with_using_and_comment() {
    let mut idx = index("idx_users_name", &["name"]);
    idx.index_type = "gin".to_string();
    idx.comment = "search".to_string();
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE INDEX CONCURRENTLY \"idx_users_name\" ON \"public\".\"USERS\" USING GIN (\"name\");",
            "COMMENT ON INDEX \"idx_users_name\" IS 'search';",
        ]
    );
}

#[test]
fn postgres_create_table_concurrent_index() {
    let mut id = column("id");
    id.data_type = "integer".to_string();
    id.is_nullable = false;
    let mut idx = index("idx_users_name", &["name"]);
    idx.concurrently = true;

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Postgres),
        driver_profile: None,
        schema: Some("public".to_string()),
        table_name: "users".to_string(),
        columns: vec![id],
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(
        result.statements,
        vec![
            "CREATE TABLE \"public\".\"users\" (\n  \"id\" integer NOT NULL\n);",
            "CREATE INDEX CONCURRENTLY \"idx_users_name\" ON \"public\".\"users\" (\"name\");",
        ]
    );
}

#[test]
fn postgres_serde_missing_concurrently_field_defaults_to_false() {
    let json = serde_json::json!({
        "id": "idx_users_email",
        "name": "idx_users_email",
        "columns": ["email"],
        "isUnique": false,
        "isPrimary": false,
        "filter": "",
        "indexType": "",
        "includedColumns": [],
        "comment": "",
        "markedForDrop": false,
    });
    let index: EditableStructureIndex = serde_json::from_value(json).unwrap();
    assert!(!index.concurrently);
}

#[test]
fn postgres_serde_concurrently_field_roundtrip() {
    let json = serde_json::json!({
        "id": "idx_users_email",
        "name": "idx_users_email",
        "columns": ["email"],
        "isUnique": false,
        "isPrimary": false,
        "filter": "",
        "indexType": "",
        "includedColumns": [],
        "comment": "",
        "concurrently": true,
        "markedForDrop": false,
    });
    let index: EditableStructureIndex = serde_json::from_value(json).unwrap();
    assert!(index.concurrently);
}

#[test]
fn kingbase_concurrent_flag_is_ignored() {
    let mut idx = index("idx_users_email", &["email"]);
    idx.concurrently = true;

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Kingbase, Some("public"), idx));

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"]);
}

#[test]
fn pg_family_concurrent_flag_is_ignored() {
    for database_type in [
        DatabaseType::Gaussdb,
        DatabaseType::OpenGauss,
        DatabaseType::Highgo,
        DatabaseType::Uxdb,
        DatabaseType::Vastbase,
        DatabaseType::Kwdb,
        DatabaseType::Firebird,
    ] {
        let mut idx = index("idx_users_email", &["email"]);
        idx.concurrently = true;
        let result = build_table_structure_change_sql(index_change_options(database_type, Some("public"), idx));
        assert_eq!(result.warnings, Vec::<String>::new());
        assert_eq!(
            result.statements,
            vec!["CREATE INDEX \"idx_users_email\" ON \"public\".\"USERS\" (\"email\");"],
            "{database_type:?} must not emit CONCURRENTLY"
        );
    }
}

#[test]
fn firebird_column_default_precedes_not_null() {
    let mut col = column("raiz");
    col.data_type = "varchar(20)".to_string();
    col.is_nullable = false;
    col.default_value = "'ECF'".to_string();

    assert_eq!(
        super::column_format::column_definition(StructureDialect::Postgres, &col, Some(DatabaseType::Firebird)),
        "\"raiz\" varchar(20) DEFAULT 'ECF' NOT NULL"
    );
}

#[test]
fn non_postgres_concurrent_flag_is_ignored() {
    for database_type in [DatabaseType::Mysql, DatabaseType::Sqlite, DatabaseType::SqlServer] {
        let mut idx = index("idx_users_email", &["email"]);
        idx.concurrently = true;
        let result = build_table_structure_change_sql(index_change_options(database_type, None, idx));
        assert_eq!(result.warnings, Vec::<String>::new());
        let statements = result.statements.join("\n");
        assert!(
            !statements.contains("CONCURRENTLY"),
            "{database_type:?} must not emit CONCURRENTLY, got: {statements}"
        );
    }
}

// ---------------------------------------------------------------------------
// GaussDB M-mode index tests
// ---------------------------------------------------------------------------

fn gaussdb_m_options(columns: Vec<EditableStructureColumn>) -> TableStructureSqlOptions {
    TableStructureSqlOptions {
        database_type: Some(DatabaseType::Gaussdb),
        driver_profile: None,
        schema: None,
        table_name: "USERS".to_string(),
        columns,
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: true,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    }
}

fn gaussdb_m_index(name: &str, columns: &[&str]) -> EditableStructureIndex {
    EditableStructureIndex {
        id: name.to_string(),
        name: name.to_string(),
        columns: columns.iter().map(|c| c.to_string()).collect(),
        is_unique: false,
        is_primary: false,
        filter: String::new(),
        index_type: String::new(),
        included_columns: Vec::new(),
        column_opclasses: Vec::new(),
        comment: String::new(),
        concurrently: false,
        original: None,
        oracle_original_missing: false,
        marked_for_drop: false,
    }
}

fn gaussdb_m_existing_index(
    name: &str,
    columns: &[&str],
    is_unique: bool,
    index_type: Option<&str>,
) -> EditableStructureIndex {
    let mut idx = gaussdb_m_index(name, columns);
    idx.is_unique = is_unique;
    idx.index_type = index_type.unwrap_or("").to_string();
    idx.original = Some(IndexInfo {
        name: name.to_string(),
        columns: columns.iter().map(|c| c.to_string()).collect(),
        is_unique,
        is_primary: false,
        filter: None,
        index_type: index_type.map(|s| s.to_string()),
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![],
        constraint_backed: false,
    });
    idx
}

#[test]
fn gaussdb_m_create_index_uses_backtick_quoting() {
    let mut options = gaussdb_m_options(vec![column("id")]);
    options.indexes = vec![gaussdb_m_index("idx_email", &["email"])];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("CREATE INDEX `idx_email` ON `USERS`"));
    assert!(sql.contains("(`email`)"));
}

#[test]
fn gaussdb_m_create_unique_index() {
    let mut options = gaussdb_m_options(vec![column("id")]);
    let mut idx = gaussdb_m_index("idx_email", &["email"]);
    idx.is_unique = true;
    options.indexes = vec![idx];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("CREATE UNIQUE INDEX `idx_email` ON `USERS`"));
}

#[test]
fn gaussdb_m_create_index_with_ubtree_using_clause() {
    let mut options = gaussdb_m_options(vec![column("id")]);
    let mut idx = gaussdb_m_index("idx_email", &["email"]);
    idx.index_type = "UBTREE".to_string();
    options.indexes = vec![idx];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    // GaussDB M-mode maps UBTREE/BTREE to USING UBTREE
    assert!(sql.contains("USING UBTREE"), "Expected USING UBTREE, got: {sql}");
}

#[test]
fn gaussdb_m_create_index_with_btree_also_emits_ubtree() {
    let mut options = gaussdb_m_options(vec![column("id")]);
    let mut idx = gaussdb_m_index("idx_email", &["email"]);
    idx.index_type = "BTREE".to_string();
    options.indexes = vec![idx];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    // BTREE in the DB is also rendered as USING UBTREE for GaussDB M
    assert!(sql.contains("USING UBTREE"), "Expected USING UBTREE, got: {sql}");
}

#[test]
fn gaussdb_m_create_index_with_comment() {
    let mut options = gaussdb_m_options(vec![column("id")]);
    let mut idx = gaussdb_m_index("idx_email", &["email"]);
    idx.comment = "index comment".to_string();
    options.indexes = vec![idx];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("COMMENT 'index comment'"));
}

#[test]
fn gaussdb_m_drop_index_does_not_use_on_table() {
    let mut idx = gaussdb_m_existing_index("idx_email", &["email"], false, None);
    idx.marked_for_drop = true;
    let options = gaussdb_m_options(vec![column("id")]);
    let options = TableStructureSqlOptions { indexes: vec![idx], ..options };
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    // GaussDB M-mode must NOT use MySQL-style "DROP INDEX ... ON table"
    assert!(!sql.contains("ON `USERS`"), "Must not use MySQL ON clause: {sql}");
    // Must use PostgreSQL-style "DROP INDEX name"
    assert!(sql.contains("DROP INDEX `idx_email`"), "Expected DROP INDEX without ON: {sql}");
}

#[test]
fn gaussdb_m_rebuild_index_drops_and_creates() {
    let mut idx = gaussdb_m_existing_index("idx_email", &["email"], false, None);
    idx.columns = vec!["email".to_string(), "name".to_string()]; // change: add column
    let options = gaussdb_m_options(vec![column("id")]);
    let options = TableStructureSqlOptions { indexes: vec![idx], ..options };
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("DROP INDEX `idx_email`"), "Must drop old index: {sql}");
    assert!(sql.contains("CREATE INDEX `idx_email` ON `USERS`"), "Must recreate index: {sql}");
    assert!(sql.contains("(`email`, `name`)"), "Must include new column: {sql}");
}

#[test]
fn gaussdb_m_create_index_with_composite_columns() {
    let mut options = gaussdb_m_options(vec![column("id")]);
    options.indexes = vec![gaussdb_m_index("idx_name_email", &["last_name", "first_name", "email"])];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("(`last_name`, `first_name`, `email`)"));
}

#[test]
fn gaussdb_m_create_prefix_index_quotes_column_before_length() {
    let mut options = gaussdb_m_options(vec![column("email")]);
    options.indexes = vec![gaussdb_m_index("idx_email", &["email(10)"])];
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("(`email`(10))"), "Expected prefix length outside the quoted identifier: {sql}");
    assert!(!sql.contains("`email(10)`"), "Prefix length must not be quoted as part of the identifier: {sql}");
}

#[test]
fn gaussdb_m_create_table_uses_backtick_quoting() {
    let cols = vec![column("id"), column("name")];
    let mut options = gaussdb_m_options(cols);
    options.indexes = vec![gaussdb_m_index("idx_name", &["name"])];
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(sql.contains("CREATE TABLE `USERS`"));
    assert!(sql.contains("`id` varchar(255)"));
    assert!(sql.contains("`name` varchar(255)"));
    assert!(sql.contains("CREATE INDEX `idx_name` ON `USERS`"));
}

#[test]
fn gaussdb_m_create_table_does_not_add_charset_or_collation() {
    let mut col = column("name");
    col.character_set = "utf8mb4".to_string();
    col.collation = "utf8mb4_unicode_ci".to_string();
    let options = gaussdb_m_options(vec![col]);
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    // GaussDB M must NOT emit MySQL CHARACTER SET/COLLATE clauses
    assert!(!sql.contains("CHARACTER SET"), "Must not emit CHARACTER SET: {sql}");
    assert!(!sql.contains("COLLATE"), "Must not emit COLLATE: {sql}");
}

#[test]
fn gaussdb_m_create_table_comment_uses_mysql_syntax() {
    let options = TableStructureSqlOptions {
        table_comment: Some("User accounts table".to_string()),
        original_table_comment: None,
        ..gaussdb_m_options(vec![column("id")])
    };
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    // GaussDB M uses MySQL-style inline COMMENT = '...'
    assert!(sql.contains("COMMENT = 'User accounts table'"), "Expected MySQL-style comment, got: {sql}");
}

#[test]
fn gaussdb_m_rebuild_index_changing_type_from_btree_to_ubtree() {
    let mut idx = gaussdb_m_existing_index("idx_email", &["email"], false, Some("BTREE"));
    idx.index_type = "UBTREE".to_string();
    let options = gaussdb_m_options(vec![column("id")]);
    let options = TableStructureSqlOptions { indexes: vec![idx], ..options };
    let result = build_table_structure_change_sql(options);
    assert_eq!(result.warnings, Vec::<String>::new());
    let sql = result.statements.join("\n");
    assert!(sql.contains("DROP INDEX `idx_email`"));
    assert!(sql.contains("USING UBTREE"));
}

#[test]
fn gaussdb_m_rebuild_index_unchanged_type_does_not_rebuild() {
    // When the index type from SHOW INDEX is "BTREE" and the user doesn't
    // change it, the editor should send "BTREE" back (which maps to
    // USING UBTREE in SQL). But since normalized_index_type("BTREE") ==
    // "BTREE" and original.index_type == Some("BTREE"), they match — no rebuild.
    let mut idx = gaussdb_m_existing_index("idx_email", &["email"], false, Some("BTREE"));
    idx.index_type = "BTREE".to_string(); // same type
                                          // No columns — just test the index itself has no change
    let options = TableStructureSqlOptions {
        database_type: Some(DatabaseType::Gaussdb),
        driver_profile: None,
        schema: None,
        table_name: "USERS".to_string(),
        columns: Vec::new(),
        indexes: vec![idx],
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: true,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    };
    let result = build_table_structure_change_sql(options);
    assert!(result.warnings.is_empty());
    assert!(result.statements.is_empty(), "Expected no DDL for unchanged index, got: {:?}", result.statements);
}

#[test]
fn gaussdb_m_create_table_with_primary_key() {
    let mut pk_col = column("id");
    pk_col.is_primary_key = true;
    pk_col.is_nullable = false;
    pk_col.data_type = "bigint".to_string();
    let options = gaussdb_m_options(vec![pk_col]);
    let result = build_create_table_sql(options);
    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(sql.contains("PRIMARY KEY (`id`)"));
}

#[test]
fn mysql_create_table_nullable_timestamp_without_default_gets_explicit_null() {
    // A second (or later) MySQL TIMESTAMP column that is nullable but has no
    // DEFAULT must carry an explicit NULL keyword — otherwise MySQL either
    // silently rewrites it to NOT NULL or, with the still-common
    // explicit_defaults_for_timestamp=OFF server default, rejects it outright
    // with ERROR 1067 (42000): Invalid default value. See issue #7416.
    let mut created_at = column("created_at");
    created_at.data_type = "timestamp".to_string();
    created_at.is_nullable = false;

    let mut updated_at = column("updated_at");
    updated_at.data_type = "timestamp".to_string();
    updated_at.is_nullable = true;

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "u7_game_order_step".to_string(),
        columns: vec![created_at, updated_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("`updated_at` timestamp NULL"));
    assert!(!result.statements[0].contains("`updated_at` timestamp NULL DEFAULT"));
}

#[test]
fn mysql_create_table_nullable_timestamp_with_default_still_gets_explicit_null() {
    // Even with an explicit DEFAULT, MySQL still needs the NULL keyword to
    // keep the column nullable — omitting it silently produces NOT NULL.
    let mut updated_at = column("updated_at");
    updated_at.data_type = "timestamp".to_string();
    updated_at.is_nullable = true;
    updated_at.default_value = "CURRENT_TIMESTAMP".to_string();

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![updated_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(result.statements[0].contains("`updated_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP"));
}

#[test]
fn mysql_create_table_nullable_datetime_does_not_gain_null_keyword() {
    // DATETIME is not subject to MySQL's TIMESTAMP-specific implicit-default
    // quirk; the fix must not touch it.
    let mut updated_at = column("updated_at");
    updated_at.data_type = "datetime".to_string();
    updated_at.is_nullable = true;

    let result = build_create_table_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "events".to_string(),
        columns: vec![updated_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert!(!result.statements[0].contains("NULL"));
}

#[test]
fn mysql_add_column_nullable_timestamp_without_default_gets_explicit_null() {
    // The ADD COLUMN / MODIFY COLUMN / CHANGE COLUMN path shares
    // column_definition() with CREATE TABLE and must carry the same fix.
    let mut updated_at = column("updated_at");
    updated_at.data_type = "timestamp".to_string();
    updated_at.is_nullable = true;

    let result = build_table_structure_change_sql(TableStructureSqlOptions {
        database_type: Some(DatabaseType::Mysql),
        driver_profile: None,
        schema: None,
        table_name: "u7_game_order_step".to_string(),
        columns: vec![updated_at],
        indexes: Vec::new(),
        foreign_keys: Vec::new(),
        triggers: Vec::new(),
        table_comment: None,
        original_table_comment: None,
        mysql_engine: None,
        mysql_auto_increment_value: None,
        transwarp_create: None,
        partitioned: false,
        foreign_table: false,
        is_gaussdb_m_mode: false,
        table_collation: None,
        primary_key_name: None,
        primary_key_change: None,
        oracle_constraint_changes: None,
        oracle_foreign_key_changes: None,
    });

    assert_eq!(result.warnings, Vec::<String>::new());
    assert_eq!(result.statements, vec!["ALTER TABLE `u7_game_order_step` ADD COLUMN `updated_at` timestamp NULL;"]);
}

// ── PostgreSQL operator class tests ──

#[test]
fn postgres_gin_index_with_explicit_opclass_generates_opclass_in_ddl() {
    let mut idx = index("idx_name_trgm", &["name"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("gin_trgm_ops".to_string())];

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(sql.contains(r#""name" gin_trgm_ops"#), "Expected opclass in DDL, got: {sql}");
    assert!(sql.contains("USING GIN"), "Expected USING GIN, got: {sql}");
}

#[test]
fn postgres_index_opclass_from_original_when_editable_empty() {
    // When the editable side has no opclass, fall back to original matching.
    let mut idx = index("idx_name_trgm", &["name"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![]; // empty: fall back to original
    idx.original = Some(IndexInfo {
        name: "idx_name_trgm".to_string(),
        columns: vec!["name".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: Some("gin".to_string()),
        included_columns: None,
        comment: None,
        key_is_expression: vec![false],
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![Some("gin_trgm_ops".to_string())],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(sql.contains(r#""name" gin_trgm_ops"#), "Expected opclass from original, got: {sql}");
}

#[test]
fn postgres_index_no_rebuild_when_original_has_opclass_and_edit_is_identical() {
    // When the edited index matches the original (including opclass), no rebuild.
    let mut idx = index("idx_name_trgm", &["name"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("gin_trgm_ops".to_string())];
    idx.original = Some(IndexInfo {
        name: "idx_name_trgm".to_string(),
        columns: vec!["name".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: Some("gin".to_string()),
        included_columns: None,
        comment: None,
        key_is_expression: vec![false],
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![Some("gin_trgm_ops".to_string())],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    assert!(result.statements.is_empty(), "Expected no rebuild for unchanged index, got: {:?}", result.statements);
}

#[test]
fn postgres_index_rebuild_when_opclass_changed() {
    // When opclass changes, the index should be rebuilt.
    let mut idx = index("idx_name_trgm", &["name"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("gin_trgm_ops".to_string())];
    idx.original = Some(IndexInfo {
        name: "idx_name_trgm".to_string(),
        columns: vec!["name".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: Some("gin".to_string()),
        included_columns: None,
        comment: None,
        key_is_expression: vec![false],
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![None], // was default, now gin_trgm_ops
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    assert!(!result.statements.is_empty(), "Expected rebuild when opclass changes");
    let sql = result.statements.join("\n");
    assert!(sql.contains("DROP INDEX"), "Expected DROP INDEX, got: {sql}");
    assert!(sql.contains("gin_trgm_ops"), "Expected new opclass in DDL, got: {sql}");
}

#[test]
fn postgres_gin_varchar_no_opclass_warns() {
    let mut idx = index("idx_name_search", &["name"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![];

    let mut options = index_change_options(DatabaseType::Postgres, Some("public"), idx);
    // Add a varchar column for the warning to match against.
    options.columns.push(EditableStructureColumn {
        id: "col_name".to_string(),
        name: "name".to_string(),
        data_type: "character varying(255)".to_string(),
        is_nullable: true,
        default_value: String::new(),
        comment: String::new(),
        is_primary_key: false,
        extra: None,
        original: None,
        original_position: None,
        marked_for_drop: false,
        character_set: String::new(),
        collation: String::new(),
    });

    let result = build_table_structure_change_sql(options);

    assert!(
        result.warnings.iter().any(|w| w.contains("operator class") && w.contains("idx_name_search")),
        "Expected opclass warning for GIN+varchar, got: {:?}",
        result.warnings
    );
}

#[test]
fn postgres_gin_text_column_with_explicit_opclass_no_warning() {
    let mut idx = index("idx_body_search", &["body"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("gin_trgm_ops".to_string())];

    let mut options = index_change_options(DatabaseType::Postgres, Some("public"), idx);
    options.columns.push(EditableStructureColumn {
        id: "col_body".to_string(),
        name: "body".to_string(),
        data_type: "text".to_string(),
        is_nullable: true,
        default_value: String::new(),
        comment: String::new(),
        is_primary_key: false,
        extra: None,
        original: None,
        original_position: None,
        marked_for_drop: false,
        character_set: String::new(),
        collation: String::new(),
    });

    let result = build_table_structure_change_sql(options);

    assert!(
        !result.warnings.iter().any(|w| w.contains("operator class")),
        "Expected NO warning when opclass is set, got: {:?}",
        result.warnings
    );
}

#[test]
fn postgres_expression_index_appends_opclass() {
    // The per-column `pg_get_indexdef(indexrelid, colno, pretty)` returns only the
    // bare expression (PostgreSQL sets `attrsOnly = (colno != 0)`, so the
    // opclass/COLLATE/DESC block is skipped — see `ruleutils.c` and the note on
    // `list_indexes_with_sql`). The opclass is read separately from `indclass`
    // into `column_opclasses`, so the generator must append it to an expression
    // key just like a real column.
    let mut idx = index("idx_lower_email", &["lower(email)"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("gin_trgm_ops".to_string())];
    idx.original = Some(IndexInfo {
        name: "idx_lower_email".to_string(),
        columns: vec!["lower(email)".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: Some("gin".to_string()),
        included_columns: None,
        comment: None,
        key_is_expression: vec![true],
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![None],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(sql.contains("lower(email) gin_trgm_ops"), "Expression should have opclass appended, got: {sql}");
}

#[test]
fn postgres_jsonb_gin_with_jsonb_path_ops() {
    let mut idx = index("idx_metadata", &["metadata"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("jsonb_path_ops".to_string())];

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(sql.contains(r#""metadata" jsonb_path_ops"#), "Expected jsonb_path_ops in DDL, got: {sql}");
    assert!(sql.contains("USING GIN"), "Expected USING GIN, got: {sql}");
}

#[test]
fn postgres_expression_index_opclass_round_trips_from_indclass() {
    // Real PostgreSQL introspection: the expression text from
    // `pg_get_indexdef(indexrelid, colno, false)` is the BARE expression
    // (`attrsOnly = (colno != 0)` drops the opclass block — see `ruleutils.c`).
    // The opclass is read separately from `pg_index.indclass` (schema-qualified)
    // into `column_opclasses`, so the generator appends it to the bare expression
    // rather than expecting it to be embedded in the text.
    let mut idx = index("idx_lower_email_trgm", &["lower(email)"]);
    idx.index_type = "GIN".to_string();
    idx.column_opclasses = vec![Some("public.gin_trgm_ops".to_string())];
    idx.original = Some(IndexInfo {
        name: "idx_lower_email_trgm_old".to_string(), // different name → forces rebuild
        columns: vec!["lower(email)".to_string()],
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: Some("gin".to_string()),
        included_columns: None,
        comment: None,
        key_is_expression: vec![true],
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        column_opclasses: vec![Some("public.gin_trgm_ops".to_string())],
        constraint_backed: false,
    });

    let result = build_table_structure_change_sql(index_change_options(DatabaseType::Postgres, Some("public"), idx));

    assert!(result.warnings.is_empty());
    let sql = result.statements.join("\n");
    assert!(
        sql.contains("lower(email) public.gin_trgm_ops"),
        "Expected bare expression + schema-qualified opclass, got: {sql}"
    );
    // The bare expression text no longer carries the opclass, so it cannot be duplicated.
    assert!(!sql.contains("gin_trgm_ops gin_trgm_ops"), "Opclass must not be duplicated, got: {sql}");
}

fn partition_options(
    database_type: DatabaseType,
    schema: Option<&str>,
    table_name: &str,
    operations: Vec<TablePartitionOperation>,
) -> TablePartitionSqlOptions {
    TablePartitionSqlOptions {
        database_type: Some(database_type),
        driver_profile: None,
        schema: schema.map(str::to_string),
        table_name: table_name.to_string(),
        operations,
    }
}

fn partition_operation(
    kind: TablePartitionOperationKind,
    name: &str,
    bound: Option<TablePartitionBoundDraft>,
) -> TablePartitionOperation {
    TablePartitionOperation {
        id: format!("op:{name}"),
        kind,
        parent_schema: String::new(),
        parent_table: String::new(),
        schema: String::new(),
        name: name.to_string(),
        bound,
        concurrently: false,
    }
}

#[test]
fn partition_create_uses_partition_of_with_each_bound_kind() {
    let range = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "sales_2025",
            Some(TablePartitionBoundDraft::Range {
                from: vec!["'2025-01-01'".to_string()],
                to: vec!["'2026-01-01'".to_string()],
            }),
        )],
    ));
    assert!(range.warnings.is_empty(), "{:?}", range.warnings);
    assert_eq!(
        range.statements,
        vec!["CREATE TABLE \"public\".\"sales_2025\" PARTITION OF \"public\".\"sales\" FOR VALUES FROM ('2025-01-01') TO ('2026-01-01');"]
    );

    let list = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "events",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "events_ab",
            Some(TablePartitionBoundDraft::List { values: vec!["'a'".to_string(), "'b'".to_string()] }),
        )],
    ));
    assert_eq!(
        list.statements,
        vec!["CREATE TABLE \"public\".\"events_ab\" PARTITION OF \"public\".\"events\" FOR VALUES IN ('a', 'b');"]
    );

    let hash = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "h",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "h0",
            Some(TablePartitionBoundDraft::Hash { modulus: 2, remainder: 0 }),
        )],
    ));
    assert_eq!(
        hash.statements,
        vec!["CREATE TABLE \"public\".\"h0\" PARTITION OF \"public\".\"h\" FOR VALUES WITH (MODULUS 2, REMAINDER 0);"]
    );

    let default = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "sales_default",
            Some(TablePartitionBoundDraft::Default),
        )],
    ));
    assert_eq!(
        default.statements,
        vec!["CREATE TABLE \"public\".\"sales_default\" PARTITION OF \"public\".\"sales\" DEFAULT;"]
    );
}

#[test]
fn partition_attach_detach_and_drop_generate_explicit_statements() {
    let attach = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Attach,
            "sales_2025",
            Some(TablePartitionBoundDraft::Range {
                from: vec!["MINVALUE".to_string()],
                to: vec!["'2025-01-01'".to_string()],
            }),
        )],
    ));
    assert_eq!(
        attach.statements,
        vec!["ALTER TABLE \"public\".\"sales\" ATTACH PARTITION \"public\".\"sales_2025\" FOR VALUES FROM (MINVALUE) TO ('2025-01-01');"]
    );

    let detach = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(TablePartitionOperationKind::Detach, "sales_2024", None)],
    ));
    assert_eq!(detach.statements, vec!["ALTER TABLE \"public\".\"sales\" DETACH PARTITION \"public\".\"sales_2024\";"]);

    let mut concurrent = partition_operation(TablePartitionOperationKind::Detach, "sales_2024", None);
    concurrent.concurrently = true;
    let detach_concurrently = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![concurrent],
    ));
    assert_eq!(
        detach_concurrently.statements,
        vec!["ALTER TABLE \"public\".\"sales\" DETACH PARTITION \"public\".\"sales_2024\" CONCURRENTLY;"]
    );

    let drop = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(TablePartitionOperationKind::Drop, "sales_2024", None)],
    ));
    assert_eq!(drop.statements, vec!["DROP TABLE \"public\".\"sales_2024\";"]);
}

#[test]
fn partition_operation_can_target_an_explicit_parent_and_schema() {
    // Detaching the partition currently being edited: the parent is not the
    // edited table, and the child lives in another schema.
    let mut detach = partition_operation(TablePartitionOperationKind::Detach, "sales_2024", None);
    detach.parent_schema = "analytics".to_string();
    detach.parent_table = "sales".to_string();
    detach.schema = "archive".to_string();

    let result = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales_2024",
        vec![detach],
    ));

    assert_eq!(
        result.statements,
        vec!["ALTER TABLE \"analytics\".\"sales\" DETACH PARTITION \"archive\".\"sales_2024\";"]
    );
}

#[test]
fn partition_operations_are_refused_for_non_postgres() {
    let result = build_table_partition_operation_sql(partition_options(
        DatabaseType::Mysql,
        Some("db"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "sales_2025",
            Some(TablePartitionBoundDraft::Default),
        )],
    ));

    assert!(result.statements.is_empty());
    assert_eq!(result.warnings, vec!["Partition operations are not supported for this database engine.".to_string()]);
}

#[test]
fn partition_operations_are_supported_for_kingbase() {
    let result = build_table_partition_operation_sql(partition_options(
        DatabaseType::Kingbase,
        Some("public"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "sales_2025",
            Some(TablePartitionBoundDraft::Default),
        )],
    ));

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE \"public\".\"sales_2025\" PARTITION OF \"public\".\"sales\" DEFAULT;"]
    );
}

#[test]
fn partition_operations_warn_on_malformed_bounds() {
    let mismatched = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "sales_x",
            Some(TablePartitionBoundDraft::Range {
                from: vec!["1".to_string()],
                to: vec!["2".to_string(), "3".to_string()],
            }),
        )],
    ));
    assert!(mismatched.statements.is_empty());
    assert!(mismatched.warnings[0].contains("RANGE partition bound"));

    let bad_hash = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "h",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "h9",
            Some(TablePartitionBoundDraft::Hash { modulus: 2, remainder: 2 }),
        )],
    ));
    assert!(bad_hash.statements.is_empty());
    assert!(bad_hash.warnings[0].contains("HASH partition bound"));

    let detach_with_bound = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("public"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Detach,
            "sales_2024",
            Some(TablePartitionBoundDraft::Default),
        )],
    ));
    assert!(detach_with_bound.statements.is_empty());
    assert!(detach_with_bound.warnings[0].contains("must not carry a bound"));
}

#[test]
fn partition_operation_quotes_identifiers() {
    let result = build_table_partition_operation_sql(partition_options(
        DatabaseType::Postgres,
        Some("we\"ird"),
        "sales",
        vec![partition_operation(
            TablePartitionOperationKind::Create,
            "part\"1",
            Some(TablePartitionBoundDraft::Default),
        )],
    ));
    assert_eq!(
        result.statements,
        vec!["CREATE TABLE \"we\"\"ird\".\"part\"\"1\" PARTITION OF \"we\"\"ird\".\"sales\" DEFAULT;"]
    );
}

#[test]
fn create_partitioned_table_appends_partition_by_clause() {
    let column = EditableStructureColumn {
        id: "sold_on".to_string(),
        name: "sold_on".to_string(),
        data_type: "date".to_string(),
        is_nullable: false,
        default_value: String::new(),
        comment: String::new(),
        is_primary_key: false,
        extra: None,
        original: None,
        original_position: None,
        marked_for_drop: false,
        character_set: String::new(),
        collation: String::new(),
    };
    let options = structure_change_options(DatabaseType::Postgres, Some("public"), "sales", vec![column]);

    let result = build_create_partitioned_table_sql(
        options,
        TablePartitionDefinition {
            kind: PgPartitionKind::Range,
            columns: vec!["sold_on".to_string()],
            expression: String::new(),
        },
    );

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements.len(), 1);
    assert!(
        result.statements[0].ends_with(") PARTITION BY RANGE (\"sold_on\");"),
        "unexpected statement: {}",
        result.statements[0]
    );
}

#[test]
fn create_partitioned_table_uses_expression_and_multi_column_keys() {
    let options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "events",
        vec![column("region"), column("occurred_at")],
    );
    let expression = build_create_partitioned_table_sql(
        options,
        TablePartitionDefinition {
            kind: PgPartitionKind::Hash,
            columns: Vec::new(),
            expression: "abs(id)".to_string(),
        },
    );
    assert!(expression.statements[0].ends_with(") PARTITION BY HASH (abs(id));"), "{}", expression.statements[0]);

    let options = structure_change_options(
        DatabaseType::Postgres,
        Some("public"),
        "events",
        vec![column("region"), column("occurred_at")],
    );
    let multi = build_create_partitioned_table_sql(
        options,
        TablePartitionDefinition {
            kind: PgPartitionKind::List,
            columns: vec!["region".to_string(), "occurred_at".to_string()],
            expression: String::new(),
        },
    );
    assert!(
        multi.statements[0].ends_with(") PARTITION BY LIST (\"region\", \"occurred_at\");"),
        "{}",
        multi.statements[0]
    );
}

#[test]
fn create_partitioned_table_requires_a_key_and_postgres() {
    let options = structure_change_options(DatabaseType::Postgres, Some("public"), "events", vec![column("id")]);
    let missing_key = build_create_partitioned_table_sql(
        options,
        TablePartitionDefinition { kind: PgPartitionKind::Range, columns: Vec::new(), expression: String::new() },
    );
    assert!(missing_key.statements.is_empty());
    assert!(missing_key.warnings[0].contains("at least one column"));

    let options = structure_change_options(DatabaseType::Mysql, Some("db"), "events", vec![column("id")]);
    let mysql = build_create_partitioned_table_sql(
        options,
        TablePartitionDefinition {
            kind: PgPartitionKind::Range,
            columns: vec!["id".to_string()],
            expression: String::new(),
        },
    );
    assert!(mysql.statements.is_empty());
    assert_eq!(mysql.warnings, vec!["Partitioning is not supported for this database engine.".to_string()]);
}

#[test]
fn create_partitioned_table_is_supported_for_kingbase() {
    let options = structure_change_options(DatabaseType::Kingbase, Some("public"), "events", vec![column("region")]);
    let result = build_create_partitioned_table_sql(
        options,
        TablePartitionDefinition {
            kind: PgPartitionKind::List,
            columns: vec!["region".to_string()],
            expression: String::new(),
        },
    );

    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].ends_with(") PARTITION BY LIST (\"region\");"), "{}", result.statements[0]);
}

#[test]
fn starrocks_35_create_primary_key_uses_native_clauses() {
    let mut id = column("id");
    id.data_type = "bigint(20)".into();
    id.is_primary_key = true;
    let mut options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![id, column("value")]);
    options.table_comment = Some("owner's events".into());
    let result = build_create_table_sql_for_version(options.clone(), Some("3.5.0 abc123"));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["CREATE TABLE `events` (\n  `id` bigint(20) NOT NULL,\n  `value` varchar(255)\n) PRIMARY KEY (`id`) COMMENT 'owner''s events' DISTRIBUTED BY HASH (`id`);"]);
    options.database_type = Some(DatabaseType::Mysql);
    options.driver_profile = Some("starrocks".into());
    assert_eq!(build_create_table_sql_for_version(options.clone(), Some("3.5.0")).statements, result.statements);
    options.driver_profile = None;
    let mysql = build_create_table_sql_for_version(options, Some("8.0.0"));
    assert!(mysql.warnings.is_empty());
    assert!(mysql.statements[0].contains(",\n  PRIMARY KEY (`id`)\n) COMMENT ="));
    assert!(!mysql.statements[0].contains("DISTRIBUTED"));
}

#[test]
fn starrocks_distribution_uses_server_version() {
    let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![column("id")]);
    for (version, suffix) in [
        (None, "HASH (`id`) BUCKETS 10;"),
        (Some("5.1.0"), "HASH (`id`) BUCKETS 10;"),
        (Some("2.5.6"), "HASH (`id`) BUCKETS 10;"),
        (Some("2.5.7"), "HASH (`id`);"),
        (Some("3.0.0"), "HASH (`id`);"),
        (Some("StarRocks version 3.5.0"), "RANDOM;"),
    ] {
        let result = build_create_table_sql_for_version(options.clone(), version);
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        assert!(result.statements[0].ends_with(suffix), "{}", result.statements[0]);
    }
}

#[test]
fn starrocks_places_primary_keys_before_value_columns() {
    let mut id = column("id");
    id.is_primary_key = true;
    let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![column("value"), id]);
    let result = build_create_table_sql_for_version(options, Some("3.5.0"));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    let sql = &result.statements[0];
    assert!(sql.find("`id` varchar").unwrap() < sql.find("`value` varchar").unwrap());
    assert!(sql.contains(") PRIMARY KEY (`id`)"));
}

fn starrocks_layout_options(granularity: StarRocksTimeGranularity) -> CreateTableDialectOptions {
    CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            partition: None,
            time_partition: Some(StarRocksTimePartition {
                column_id: "ts".into(),
                granularity,
                interval: None,
                additional_column_ids: vec![],
            }),
            distribution: StarRocksDistribution::Hash,
            distribution_column_ids: vec!["id".into()],
            sort_column_ids: vec![],
            bucket_count: Some(8),
        }),
    }
}

fn starrocks_partitioned_table_options() -> TableStructureSqlOptions {
    let mut id = column("id");
    id.data_type = "bigint".into();
    id.is_primary_key = true;
    let mut ts = column("ts");
    ts.data_type = "datetime".into();
    ts.is_primary_key = true;
    let mut options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![id, ts]);
    options.table_comment = Some("events".into());
    options
}

#[test]
fn starrocks_time_partition_preserves_clause_order_and_column_identity() {
    for (granularity, unit) in [
        (StarRocksTimeGranularity::Year, "year"),
        (StarRocksTimeGranularity::Month, "month"),
        (StarRocksTimeGranularity::Day, "day"),
    ] {
        let mut options = starrocks_partitioned_table_options();
        // Column ID stays stable through a rename, including quoted identifiers.
        options.columns[1].name = "event`time".into();
        let result =
            build_create_table_sql_with_dialect_options(options, Some("3.5.0"), starrocks_layout_options(granularity));
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        assert_eq!(result.statements.len(), 1);
        assert!(result.statements[0].ends_with(&format!(") PRIMARY KEY (`id`, `event``time`) COMMENT 'events' PARTITION BY date_trunc('{unit}', `event``time`) DISTRIBUTED BY HASH (`id`) BUCKETS 8;")), "{}", result.statements[0]);
    }
}

#[test]
fn starrocks_rejects_invalid_partition_columns_and_versions() {
    let settings = starrocks_layout_options(StarRocksTimeGranularity::Month);
    for version in [None, Some("5.1.0"), Some("3.0.0")] {
        let result = build_create_table_sql_with_dialect_options(
            starrocks_partitioned_table_options(),
            version,
            settings.clone(),
        );
        assert!(result.statements.is_empty());
        assert!(result.warnings.iter().any(|warning| warning.contains("confirmed server version")));
    }
    for change in ["drop", "type", "primary"] {
        let mut options = starrocks_partitioned_table_options();
        match change {
            "drop" => options.columns[1].marked_for_drop = true,
            "type" => options.columns[1].data_type = "varchar(255)".into(),
            _ => options.columns[1].is_primary_key = false,
        }
        let result = build_create_table_sql_with_dialect_options(options, Some("3.5.0"), settings.clone());
        assert!(result.statements.is_empty(), "{change}");
        assert!(!result.warnings.is_empty());
    }
}

#[test]
fn starrocks_validates_hash_keys_and_bucket_count() {
    for case in ["missing", "empty", "duplicate", "type", "primary", "zero", "overflow"] {
        let mut options = starrocks_partitioned_table_options();
        let mut settings = starrocks_layout_options(StarRocksTimeGranularity::Day);
        let sr = settings.starrocks.as_mut().unwrap();
        sr.time_partition = None;
        match case {
            "missing" => sr.distribution_column_ids = vec!["removed".into()],
            "empty" => sr.distribution_column_ids.clear(),
            "duplicate" => sr.distribution_column_ids = vec!["id".into(), "id".into()],
            "type" => options.columns[0].data_type = "json".into(),
            "primary" => {
                options.columns[1].is_primary_key = false;
                sr.distribution_column_ids = vec!["ts".into()];
            }
            "zero" => sr.bucket_count = Some(0),
            _ => sr.bucket_count = Some(u32::MAX),
        }
        let result = build_create_table_sql_with_dialect_options(options, Some("3.5.0"), settings);
        assert!(result.statements.is_empty(), "{case}");
        assert!(!result.warnings.is_empty());
    }
}

#[test]
fn starrocks_random_distribution_requires_duplicate_table_and_supported_version() {
    let settings = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions { distribution: StarRocksDistribution::Random, ..Default::default() }),
    };
    let mut options = starrocks_partitioned_table_options();
    assert!(build_create_table_sql_with_dialect_options(options.clone(), Some("3.5.0"), settings.clone())
        .statements
        .is_empty());
    for column in &mut options.columns {
        column.is_primary_key = false;
    }
    assert!(build_create_table_sql_with_dialect_options(options.clone(), Some("3.0.0"), settings.clone())
        .statements
        .is_empty());
    let result = build_create_table_sql_with_dialect_options(options, Some("3.5.0"), settings);
    assert!(result.warnings.is_empty());
    assert!(result.statements[0].ends_with("DISTRIBUTED BY RANDOM;"));
}

#[test]
fn starrocks_settings_cannot_leak_into_mysql() {
    let mut options = starrocks_partitioned_table_options();
    options.database_type = Some(DatabaseType::Mysql);
    let result = build_create_table_sql_with_dialect_options(
        options,
        Some("8.0"),
        starrocks_layout_options(StarRocksTimeGranularity::Month),
    );
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("require a StarRocks connection")));
}

#[test]
fn starrocks_builds_multicolumn_value_and_list_partitions() {
    let options =
        structure_change_options(DatabaseType::StarRocks, None, "events", vec![column("city"), column("channel")]);
    let values = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            partition: Some(StarRocksPartitionOptions::Values { column_ids: vec!["city".into(), "channel".into()] }),
            ..Default::default()
        }),
    };
    let result = build_create_table_sql_with_dialect_options(options.clone(), Some("3.5.0"), values);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].contains("PARTITION BY (`city`, `channel`) DISTRIBUTED BY RANDOM"));
    let list = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            partition: Some(StarRocksPartitionOptions::List {
                column_ids: vec!["city".into(), "channel".into()],
                partitions: vec![StarRocksListPartition {
                    name: "p`east".into(),
                    values: vec![vec!["Xi'an".into(), "web".into()], vec!["Shanghai".into(), "store".into()]],
                }],
            }),
            ..Default::default()
        }),
    };
    let result = build_create_table_sql_with_dialect_options(options, Some("3.5.0"), list);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].contains("PARTITION BY LIST (`city`, `channel`) (\n  PARTITION `p``east` VALUES IN (('Xi''an', 'web'), ('Shanghai', 'store'))\n)"));
}

#[test]
fn starrocks_builds_range_bounds_and_validates_arity() {
    let mut options = starrocks_partitioned_table_options();
    // Intentionally interleaved primary and value columns: SQL reorders without changing membership.
    options.columns.insert(1, column("payload"));
    let settings = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            partition: Some(StarRocksPartitionOptions::Range {
                column_ids: vec!["ts".into(), "id".into()],
                partitions: vec![StarRocksRangePartition {
                    name: "p2026".into(),
                    lower: vec!["2026-01-01".into(), "0".into()],
                    upper: vec!["2027-01-01".into(), "0".into()],
                }],
            }),
            ..Default::default()
        }),
    };
    let result = build_create_table_sql_with_dialect_options(options.clone(), Some("3.5.0"), settings.clone());
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].contains(
        "PARTITION BY RANGE (`ts`, `id`) (\n  PARTITION `p2026` VALUES [('2026-01-01', '0'), ('2027-01-01', '0'))\n)"
    ));
    assert!(
        result.statements[0].find("`ts` datetime").unwrap() < result.statements[0].find("`payload` varchar").unwrap()
    );
    let mut invalid = settings;
    if let Some(StarRocksPartitionOptions::Range { partitions, .. }) =
        invalid.starrocks.as_mut().unwrap().partition.as_mut()
    {
        partitions[0].upper.pop();
    }
    assert!(build_create_table_sql_with_dialect_options(options, Some("3.5.0"), invalid).statements.is_empty());
}

#[test]
fn starrocks_time_slice_and_mixed_partitions_are_version_and_type_checked() {
    let options = starrocks_partitioned_table_options();
    let mut settings = starrocks_layout_options(StarRocksTimeGranularity::Day);
    let time = settings.starrocks.as_mut().unwrap().time_partition.as_mut().unwrap();
    time.interval = Some(7);
    time.additional_column_ids = vec!["id".into()];
    let result = build_create_table_sql_with_dialect_options(options.clone(), Some("3.5.0"), settings.clone());
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].contains("PARTITION BY time_slice(`ts`, INTERVAL 7 day), `id` DISTRIBUTED"));
    assert!(build_create_table_sql_with_dialect_options(options.clone(), Some("3.3.0"), settings.clone())
        .statements
        .is_empty());
    let mut invalid = options;
    invalid.columns[1].data_type = "date".into();
    assert!(build_create_table_sql_with_dialect_options(invalid, Some("3.5.0"), settings).statements.is_empty());
}

#[test]
fn starrocks_rejects_duplicate_list_values_and_incompatible_partition_types() {
    let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![column("city")]);
    let list = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            partition: Some(StarRocksPartitionOptions::List {
                column_ids: vec!["city".into()],
                partitions: vec![StarRocksListPartition {
                    name: "p1".into(),
                    values: vec![vec!["Beijing".into()], vec!["Beijing".into()]],
                }],
            }),
            ..Default::default()
        }),
    };
    assert!(build_create_table_sql_with_dialect_options(options.clone(), Some("3.5.0"), list).statements.is_empty());
    let range = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            partition: Some(StarRocksPartitionOptions::Range {
                column_ids: vec!["city".into()],
                partitions: vec![StarRocksRangePartition {
                    name: "p1".into(),
                    lower: vec!["a".into()],
                    upper: vec!["z".into()],
                }],
            }),
            ..Default::default()
        }),
    };
    assert!(build_create_table_sql_with_dialect_options(options, Some("3.5.0"), range).statements.is_empty());
}

#[test]
fn starrocks_sort_columns_preserve_priority_and_allow_non_primary_columns() {
    let mut options = starrocks_partitioned_table_options();
    options.columns[1].is_primary_key = false;
    options.columns[1].name = "event`time".into();
    let settings = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions {
            sort_column_ids: vec!["ts".into(), "id".into()],
            ..Default::default()
        }),
    };
    let result = build_create_table_sql_with_dialect_options(options, Some("3.5.0"), settings);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].ends_with("DISTRIBUTED BY HASH (`id`) ORDER BY (`event``time`, `id`);"));
}

#[test]
fn starrocks_sort_validates_version_identity_and_primary_table_types() {
    for case in ["old", "unknown", "missing", "duplicate", "type", "dropped"] {
        let mut options = starrocks_partitioned_table_options();
        let mut ids = vec!["ts".into()];
        let version = match case {
            "old" => Some("2.5.0"),
            "unknown" => None,
            _ => Some("3.5.0"),
        };
        match case {
            "missing" => ids = vec!["missing".into()],
            "duplicate" => ids.push("ts".into()),
            "type" => {
                options.columns[1].is_primary_key = false;
                options.columns[1].data_type = "decimal(10,2)".into();
            }
            "dropped" => options.columns[1].marked_for_drop = true,
            _ => {}
        }
        let settings = CreateTableDialectOptions {
            postgres_foreign_table: None,
            starrocks: Some(StarRocksCreateOptions { sort_column_ids: ids, ..Default::default() }),
        };
        let result = build_create_table_sql_with_dialect_options(options, version, settings);
        assert!(result.statements.is_empty(), "{case}");
        assert!(!result.warnings.is_empty(), "{case}");
    }
}

#[test]
fn starrocks_duplicate_sort_requires_33_and_allows_decimal() {
    let mut options = starrocks_partitioned_table_options();
    for column in &mut options.columns {
        column.is_primary_key = false;
    }
    options.columns[1].data_type = "decimal(10,2)".into();
    let settings = CreateTableDialectOptions {
        postgres_foreign_table: None,
        starrocks: Some(StarRocksCreateOptions { sort_column_ids: vec!["ts".into()], ..Default::default() }),
    };
    let old = build_create_table_sql_with_dialect_options(options.clone(), Some("3.2.0"), settings.clone());
    assert!(old.statements.is_empty());
    let result = build_create_table_sql_with_dialect_options(options, Some("3.5.0"), settings);
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert!(result.statements[0].ends_with("DISTRIBUTED BY RANDOM ORDER BY (`ts`);"));
}

#[test]
fn starrocks_default_presets_keep_literals_and_function_expressions() {
    for (data_type, default_value) in [
        ("int", "'0'"),
        ("decimal(10,2)", "'1'"),
        ("boolean", "'false'"),
        ("date", "1970-01-01"),
        ("datetime", "CURRENT_TIMESTAMP"),
        ("varchar(36)", "(uuid())"),
        ("largeint", "(uuid_numeric())"),
        ("varchar(20)", "''"),
    ] {
        let mut options = starrocks_partitioned_table_options();
        options.columns[1].is_primary_key = false;
        options.columns[1].data_type = data_type.into();
        options.columns[1].default_value = default_value.into();
        let result = build_create_table_sql_for_version(options, Some("3.5.0"));
        assert!(result.warnings.is_empty(), "{data_type}: {:?}", result.warnings);
        let expected = if data_type == "date" { format!("'{default_value}'") } else { default_value.into() };
        assert!(result.statements[0].contains(&format!("DEFAULT {expected}")), "{data_type}: {}", result.statements[0]);
    }
}

fn starrocks_alter_context() -> StarRocksAlterOptions {
    StarRocksAlterOptions {
        server_version: Some("3.5.0".into()),
        model: Some("primary".into()),
        key_columns: vec!["id".into()],
        distribution_columns: vec!["id".into()],
        ..Default::default()
    }
}

#[test]
fn starrocks_alter_combines_schema_changes_after_native_rename_and_comments() {
    let mut value = existing_pk_column("value", "varchar(100)", false, false);
    value.name = "new`value".into();
    value.comment = "new comment".into();
    value.default_value = "hello".into();
    value.original.as_mut().unwrap().column_default = Some("hello".into());
    value.original.as_mut().unwrap().data_type = "varchar(50)".into();
    let mut added = column("more");
    added.data_type = "int".into();
    let mut options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![value, added]);
    options.table_comment = Some("table comment".into());
    let result = build_table_structure_change_sql_with_context(options, Some(starrocks_alter_context()));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements.len(), 3);
    assert_eq!(result.statements[0], "ALTER TABLE `events` RENAME COLUMN `value` TO `new``value`;");
    assert!(result.statements[1].contains("COMMENT = 'table comment'"));
    assert!(result.statements[2].contains("MODIFY COLUMN `new``value` varchar(100) NOT NULL DEFAULT 'hello' COMMENT 'new comment', ADD COLUMN `more` int NULL COMMENT '';"));
    assert!(!result.statements.join(" ").contains("CHANGE COLUMN"));
}

#[test]
fn starrocks_alter_rejects_existing_default_changes_without_partial_sql() {
    for (data_type, original_default, new_default) in [
        ("decimal(7, 0)", None, "'0'"),
        ("decimal(7, 0)", Some("'0'"), "'1'"),
        ("datetime", None, "CURRENT_TIMESTAMP"),
        ("datetime", Some("CURRENT_TIMESTAMP"), ""),
    ] {
        let mut value = existing_pk_column("value", data_type, false, false);
        value.original.as_mut().unwrap().column_default = original_default.map(String::from);
        value.default_value = new_default.into();
        value.comment = "also changed".into();
        let mut options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![value]);
        options.table_comment = Some("must not partially execute".into());
        let result = build_table_structure_change_sql_with_context(options, Some(starrocks_alter_context()));
        assert!(result.statements.is_empty(), "{data_type}: {:?}", result.statements);
        assert!(
            result.warnings.iter().any(|warning| warning.contains("cannot change the default value")),
            "{:?}",
            result.warnings
        );
    }
}

#[test]
fn starrocks_alter_preserves_existing_defaults_during_other_changes() {
    for (data_type, default_value) in [("decimal(7, 0)", "'0'"), ("datetime", "CURRENT_TIMESTAMP")] {
        let mut value = existing_pk_column("value", data_type, false, false);
        value.original.as_mut().unwrap().column_default = Some(default_value.into());
        value.default_value = default_value.into();
        value.is_nullable = true;
        let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![value]);
        let result = build_table_structure_change_sql_with_context(options, Some(starrocks_alter_context()));
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        assert!(result.statements[0].contains(&format!("NULL DEFAULT {default_value}")), "{:?}", result.statements);
    }
}

#[test]
fn starrocks_add_column_rejects_uuid_generators_without_partial_sql() {
    for default_value in ["(uuid())", "uuid()", " ( UUID ( ) ) ", "(uuid_numeric())", "((UUID_NUMERIC()))"] {
        let mut value = column("dad");
        value.data_type =
            if default_value.to_ascii_lowercase().contains("numeric") { "largeint" } else { "varchar(255)" }.into();
        value.default_value = default_value.into();
        let mut options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![value]);
        options.table_comment = Some("must not partially execute".into());
        let result = build_table_structure_change_sql_with_context(options, Some(starrocks_alter_context()));
        assert!(result.statements.is_empty(), "{default_value}: {:?}", result.statements);
        assert!(
            result.warnings.iter().any(|warning| warning.contains("does not support uuid()")),
            "{:?}",
            result.warnings
        );
    }
}

#[test]
fn starrocks_add_column_keeps_type_specific_defaults() {
    for (data_type, default_value) in [
        ("decimal(7, 0)", "'0'"),
        ("datetime", "CURRENT_TIMESTAMP"),
        ("varchar(255)", "'uuid()'"),
        ("varchar(255)", "NULL"),
    ] {
        let mut value = column("value");
        value.data_type = data_type.into();
        value.default_value = default_value.into();
        let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![value]);
        let result = build_table_structure_change_sql_with_context(options, Some(starrocks_alter_context()));
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        let expected_default =
            if default_value == "NULL" { String::new() } else { format!(" DEFAULT {default_value}") };
        assert!(
            result.statements[0].contains(&format!("ADD COLUMN `value` {data_type} NULL{expected_default} COMMENT")),
            "{:?}",
            result.statements
        );
    }
}

#[test]
fn starrocks_alter_comment_only_does_not_redefine_primary_column() {
    let mut key = existing_pk_column("id", "bigint", true, true);
    key.comment = "owner's id".into();
    let mut options = structure_change_options(DatabaseType::Mysql, None, "events", vec![key]);
    options.driver_profile = Some("starrocks".into());
    let result = build_table_structure_change_sql_with_context(options, Some(starrocks_alter_context()));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `events` MODIFY COLUMN `id` COMMENT 'owner''s id';"]);
}

#[test]
fn starrocks_alter_rejects_unsupported_changes_without_partial_plan() {
    for case in ["primary", "nullable", "missing", "aggregate", "old_rename", "partition", "drop"] {
        let mut value = existing_pk_column("value", "int", false, false);
        let mut context = starrocks_alter_context();
        match case {
            "primary" => value.is_primary_key = true,
            "nullable" => value.original.as_mut().unwrap().is_nullable = true,
            "missing" => {
                context.model = None;
                value.default_value = "0".into();
            }
            "aggregate" => {
                context.model = Some("aggregate".into());
                value.data_type = "bigint".into();
            }
            "old_rename" => {
                context.server_version = Some("3.3.1".into());
                value.name = "renamed".into();
            }
            "partition" => {
                context.partition_columns.push("value".into());
                value.data_type = "bigint".into();
            }
            "drop" => {
                context.distribution_columns.push("value".into());
                value.marked_for_drop = true;
            }
            _ => {}
        }
        let mut options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![value]);
        options.table_comment = Some("would otherwise succeed".into());
        let result = build_table_structure_change_sql_with_context(options, Some(context));
        assert!(result.statements.is_empty(), "{case}: {:?}", result.statements);
        assert!(!result.warnings.is_empty(), "{case}");
    }
}

#[test]
fn starrocks_duplicate_key_alter_preserves_key_and_allows_not_null_to_null() {
    let mut value = existing_pk_column("key1", "varchar(100)", false, false);
    value.data_type = "varchar(200)".into();
    value.is_nullable = true;
    let mut context = starrocks_alter_context();
    context.model = Some("duplicate".into());
    context.key_columns = vec!["key1".into()];
    let result = build_table_structure_change_sql_with_context(
        structure_change_options(DatabaseType::StarRocks, None, "events", vec![value]),
        Some(context),
    );
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `events` MODIFY COLUMN `key1` varchar(200) KEY NULL COMMENT '';"]);
}

#[test]
fn starrocks_existing_layout_changes_use_native_sql_and_quote_values() {
    let options = structure_change_options(
        DatabaseType::StarRocks,
        None,
        "events",
        vec![existing_pk_column("id", "bigint", true, true)],
    );
    let context: StarRocksAlterOptions = serde_json::from_value(serde_json::json!({
        "serverVersion": "3.5.0", "model": "duplicate", "keyColumns": ["id"],
        "layout": { "distribution": { "method": "hash", "columns": ["id"], "buckets": 12 } }
    }))
    .unwrap();
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `events` DISTRIBUTED BY HASH(`id`) BUCKETS 12;"]);
    let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![]);
    let context: StarRocksAlterOptions = serde_json::from_value(serde_json::json!({
        "serverVersion": "3.5.0", "model": "duplicate", "partitionKind": "list", "partitionColumns": ["city", "channel"],
        "layout": { "partitions": [{ "kind": "addList", "name": "p`new", "values": [["O'Brien", "app"]] }, { "kind": "replicas", "name": "*", "replicas": 2 }] }
    })).unwrap();
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `events` ADD PARTITION `p``new` VALUES IN (('O''Brien', 'app'));",
            "ALTER TABLE `events` MODIFY PARTITION (*) SET (\"replication_num\" = \"2\");"
        ]
    );
}

#[test]
fn starrocks_layout_blocks_conflicting_jobs_invalid_buckets_and_model() {
    for (version, model, buckets, edited, colocated) in [
        ("3.1.9", "duplicate", 8, false, false),
        ("3.5.0", "primary", 8, false, false),
        ("3.5.0", "duplicate", 0, false, false),
        ("3.5.0", "duplicate", 8, true, false),
        ("3.5.0", "duplicate", 8, false, true),
    ] {
        let mut column = existing_pk_column("value", "varchar(20)", false, false);
        if edited {
            column.name = "new_value".into();
        }
        let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![column]);
        let context: StarRocksAlterOptions = serde_json::from_value(serde_json::json!({
            "serverVersion": version, "model": model, "colocated": colocated,
            "layout": { "distribution": { "method": "random", "buckets": buckets } }
        }))
        .unwrap();
        let result = build_table_structure_change_sql_with_context(options, Some(context));
        assert!(!result.warnings.is_empty(), "{version} {model}");
        assert!(result.statements.is_empty());
    }
}

#[test]
fn starrocks_default_buckets_are_patch_version_gated() {
    for (version, supported) in [("3.5.7", false), ("3.5.8", true), ("4.0.0", false), ("4.0.1", true)] {
        let options = structure_change_options(
            DatabaseType::StarRocks,
            None,
            "events",
            vec![existing_pk_column("id", "bigint", true, true)],
        );
        let context: StarRocksAlterOptions = serde_json::from_value(serde_json::json!({
            "serverVersion": version, "model": "primary", "keyColumns": ["id"],
            "distribution": { "method": "hash", "columns": ["id"], "buckets": 8 },
            "layout": { "distribution": { "method": "hash", "columns": ["id"], "buckets": 12, "defaultOnly": true } }
        }))
        .unwrap();
        let result = build_table_structure_change_sql_with_context(options, Some(context));
        assert_eq!(result.warnings.is_empty(), supported, "{version} {:?}", result.warnings);
        if supported {
            assert_eq!(result.statements, vec!["ALTER TABLE `events` DISTRIBUTED BY HASH(`id`) DEFAULT BUCKETS 12;"]);
        }
    }
}

#[test]
fn starrocks_manual_range_and_partition_drop_sql() {
    let options = structure_change_options(DatabaseType::StarRocks, None, "events", vec![]);
    let context: StarRocksAlterOptions = serde_json::from_value(serde_json::json!({
        "serverVersion": "3.5.0", "model": "duplicate", "partitionKind": "range", "partitionColumns": ["dt"],
        "layout": { "partitions": [{ "kind": "addRange", "name": "p2", "lower": ["2026-01-01"], "upper": ["2026-02-01"] }, { "kind": "drop", "name": "p1" }] }
    })).unwrap();
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `events` ADD PARTITION `p2` VALUES [('2026-01-01'), ('2026-02-01'));",
            "ALTER TABLE `events` DROP PARTITION `p1`;"
        ]
    );
}

#[test]
fn starrocks_automatic_bucket_scaling_blocks_distribution_but_not_partition_management() {
    let options = structure_change_options(
        DatabaseType::StarRocks,
        None,
        "events",
        vec![existing_pk_column("id", "bigint", false, false)],
    );
    let mut context: StarRocksAlterOptions = serde_json::from_value(serde_json::json!({
        "serverVersion": "3.5.0", "model": "duplicate", "automaticBucketScaling": true,
        "layout": { "distribution": { "method": "hash", "columns": ["id"], "buckets": 16 } }
    }))
    .unwrap();
    let result = build_table_structure_change_sql_with_context(options.clone(), Some(context.clone()));
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("automatic bucket scaling")));
    context.layout = Some(
        serde_json::from_value(
            serde_json::json!({ "partitions": [{ "kind": "replicas", "name": "*", "replicas": 2 }] }),
        )
        .unwrap(),
    );
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `events` MODIFY PARTITION (*) SET (\"replication_num\" = \"2\");"]);
}

fn starrocks_reorder_fixture() -> (TableStructureSqlOptions, StarRocksAlterOptions) {
    let mut columns = vec![
        existing_pk_column("id", "bigint", false, false),
        existing_pk_column("price", "decimal(7, 0)", false, false),
        existing_pk_column("name", "varchar(500)", false, false),
    ];
    for (index, column) in columns.iter_mut().enumerate() {
        column.original_position = Some(index);
    }
    columns.swap(1, 2);
    let options = structure_change_options(DatabaseType::StarRocks, None, "test4", columns);
    let context = StarRocksAlterOptions {
        server_version: Some("3.5.0".into()),
        model: Some("duplicate".into()),
        key_columns: vec!["id".into()],
        column_names: vec!["id".into(), "price".into(), "name".into()],
        position_column_order: true,
        ..Default::default()
    };
    (options, context)
}

#[test]
fn starrocks_reorders_values_with_position_clauses_not_sort_keys() {
    let (options, context) = starrocks_reorder_fixture();
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `test4` MODIFY COLUMN `name` varchar(500) NOT NULL COMMENT '' AFTER `id`;"]
    );
    assert!(result.statements.iter().all(|sql| !sql.contains("ORDER BY")));
}

#[test]
fn starrocks_reorder_guards_complete_schema_primary_keys_and_combined_add_drop() {
    for case in ["primary", "missing_column", "missing_position", "add", "drop"] {
        let (mut options, mut context) = starrocks_reorder_fixture();
        if matches!(case, "missing_column" | "drop") {
            let mut extra = existing_pk_column("extra", "int", false, false);
            extra.original_position = Some(3);
            options.columns.push(extra);
            context.column_names.push("extra".into());
        }
        match case {
            "primary" => context.model = Some("primary".into()),
            "missing_column" => {
                options.columns.pop();
            }
            "missing_position" => options.columns[1].original_position = None,
            "add" => options.columns.push(column("more")),
            "drop" => options.columns.last_mut().unwrap().marked_for_drop = true,
            _ => unreachable!(),
        }
        let result = build_table_structure_change_sql_with_context(options, Some(context));
        assert!(result.statements.is_empty(), "{case} {:?}", result.statements);
        assert!(!result.warnings.is_empty(), "{case}");
    }
}

#[test]
fn starrocks_reorders_partition_keys_preserving_key_identity_and_sort_keys() {
    let mut day = existing_pk_column("day", "datetime", false, false);
    day.is_nullable = true;
    day.original.as_mut().unwrap().is_nullable = true;
    day.original_position = Some(0);
    let mut id = existing_pk_column("id", "varchar(255)", false, false);
    id.original_position = Some(1);
    let mut name = existing_pk_column("name", "varchar(500)", false, false);
    name.is_nullable = true;
    name.original.as_mut().unwrap().is_nullable = true;
    name.original_position = Some(2);
    let columns = [day, id, name];
    let context = StarRocksAlterOptions {
        server_version: Some("3.5.0".into()),
        model: Some("duplicate".into()),
        key_columns: vec!["day".into(), "id".into()],
        partition_columns: vec!["day".into(), "id".into()],
        column_names: vec!["day".into(), "id".into(), "name".into()],
        sort_columns: Some(vec!["id".into(), "day".into()]),
        position_column_order: true,
        ..Default::default()
    };
    // Metadata's primary-key flag is false for Duplicate Key tables: use DDL key membership.
    // Keys may swap positions, but values cannot precede or split the key prefix.
    let options = structure_change_options(
        DatabaseType::StarRocks,
        None,
        "test4",
        [1, 0, 2].map(|index| columns[index].clone()).to_vec(),
    );
    let result = build_table_structure_change_sql_with_context(options, Some(context.clone()));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec!["ALTER TABLE `test4` MODIFY COLUMN `id` varchar(255) KEY NOT NULL COMMENT '' FIRST;"]
    );
    for order in [[0, 2, 1], [2, 1, 0], [1, 2, 0]] {
        let options = structure_change_options(
            DatabaseType::StarRocks,
            None,
            "test4",
            order.map(|index| columns[index].clone()).to_vec(),
        );
        let result = build_table_structure_change_sql_with_context(options, Some(context.clone()));
        assert!(result.statements.is_empty());
        assert!(result.warnings.iter().any(|warning| warning.contains("must precede all value columns")));
    }
}

#[test]
fn starrocks_reorders_around_generated_partition_sources_in_both_directions() {
    let mut day = existing_pk_column("day", "datetime", false, false);
    day.is_nullable = true;
    day.original.as_mut().unwrap().is_nullable = true;
    let id = existing_pk_column("id", "varchar(255)", false, false);
    let name = existing_pk_column("name", "varchar(500)", false, false);
    for day_first in [false, true] {
        let mut columns = if day_first {
            vec![day.clone(), id.clone(), name.clone()]
        } else {
            vec![id.clone(), day.clone(), name.clone()]
        };
        for (index, column) in columns.iter_mut().enumerate() {
            column.original_position = Some(index);
        }
        let names: Vec<_> = columns.iter().map(|column| column.name.clone()).collect();
        let context = StarRocksAlterOptions {
            server_version: Some("3.5.0".into()),
            model: Some("duplicate".into()),
            key_columns: names[..2].to_vec(),
            partition_columns: vec!["day".into(), "id".into()],
            partition_expression_columns: vec!["DAY".into()],
            column_names: names,
            sort_columns: Some(vec!["id".into(), "day".into()]),
            position_column_order: true,
            ..Default::default()
        };
        columns.swap(0, 1);
        let options = structure_change_options(DatabaseType::StarRocks, None, "test4", columns);
        let result = build_table_structure_change_sql_with_context(options.clone(), Some(context.clone()));
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        let placement = if day_first { "FIRST" } else { "AFTER `day`" };
        assert_eq!(
            result.statements,
            vec![format!("ALTER TABLE `test4` MODIFY COLUMN `id` varchar(255) KEY NOT NULL COMMENT '' {placement};")]
        );

        let mut blocked = context;
        blocked.partition_expression_columns.push("id".into());
        let result = build_table_structure_change_sql_with_context(options, Some(blocked));
        assert!(result.statements.is_empty());
        assert!(result.warnings.iter().any(|warning| warning.contains("partition-expression source")));
    }
}

#[test]
fn starrocks_reorder_preserves_renames_but_blocks_definition_changes() {
    let (mut options, context) = starrocks_reorder_fixture();
    options.columns[1].name = "new`name".into();
    let result = build_table_structure_change_sql_with_context(options.clone(), Some(context.clone()));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(
        result.statements,
        vec![
            "ALTER TABLE `test4` RENAME COLUMN `name` TO `new``name`;",
            "ALTER TABLE `test4` MODIFY COLUMN `new``name` varchar(500) NOT NULL COMMENT '' AFTER `id`;"
        ]
    );
    options.columns[1].data_type = "varchar(600)".into();
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("separately")));
}

#[test]
fn starrocks_reorder_is_opt_in_and_unchanged_order_is_clean() {
    let (options, mut context) = starrocks_reorder_fixture();
    context.position_column_order = false;
    let result = build_table_structure_change_sql_with_context(options.clone(), Some(context.clone()));
    assert!(result.statements.is_empty());
    assert!(result.warnings.is_empty());
    context.position_column_order = true;
    let mut options = options;
    options.columns.sort_by_key(|column| column.original_position);
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.statements.is_empty());
    assert!(result.warnings.is_empty());
}

#[test]
fn starrocks_position_moves_preserve_protected_anchors_and_column_definitions() {
    let names = ["id", "x", "bucket", "y", "z"];
    let mut columns: Vec<_> = names
        .iter()
        .enumerate()
        .map(|(index, name)| {
            let mut column = existing_pk_column(name, "varchar(500)", false, false);
            column.original_position = Some(index);
            column
        })
        .collect();
    let desired = [0, 4, 2, 3, 1].map(|index| columns[index].clone()).to_vec();
    let options = structure_change_options(DatabaseType::StarRocks, None, "t", desired);
    let context = StarRocksAlterOptions {
        model: Some("duplicate".into()),
        key_columns: vec!["id".into()],
        distribution_columns: vec!["bucket".into()],
        column_names: names.iter().map(|name| name.to_string()).collect(),
        position_column_order: true,
        ..Default::default()
    };
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `t` MODIFY COLUMN `z` varchar(500) NOT NULL COMMENT '' AFTER `id`, MODIFY COLUMN `x` varchar(500) NOT NULL COMMENT '' AFTER `y`;"]);
    columns.swap(0, 2);
    let options = structure_change_options(DatabaseType::StarRocks, None, "t", columns);
    let context = StarRocksAlterOptions {
        model: Some("duplicate".into()),
        distribution_columns: vec!["id".into(), "bucket".into()],
        column_names: names.iter().map(|name| name.to_string()).collect(),
        position_column_order: true,
        ..Default::default()
    };
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.statements.is_empty());
    assert!(!result.warnings.is_empty());
}

#[test]
fn starrocks_legacy_order_by_reordering_is_rejected() {
    let (options, mut context) = starrocks_reorder_fixture();
    context.reorder_columns = true;
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("legacy")));
}

#[test]
fn starrocks_sort_keys_are_explicit_and_separate_from_column_order() {
    let (mut options, mut context) = starrocks_reorder_fixture();
    options.columns.sort_by_key(|column| column.original_position);
    context.sort_column_names = Some(vec!["id".into(), "name".into()]);
    let result = build_table_structure_change_sql_with_context(options.clone(), Some(context.clone()));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);
    assert_eq!(result.statements, vec!["ALTER TABLE `test4` ORDER BY (`id`, `name`);"]);
    options.columns.swap(1, 2);
    let result = build_table_structure_change_sql_with_context(options, Some(context));
    assert!(result.statements.is_empty());
    assert!(result.warnings.iter().any(|warning| warning.contains("separately")));
}

#[test]
fn starrocks_sort_key_validation_guards_models_types_versions_and_full_schema() {
    for case in ["all", "empty", "repeat", "missing", "old", "primary_decimal", "aggregate_nonkey", "unknown"] {
        let (mut options, mut context) = starrocks_reorder_fixture();
        options.columns.sort_by_key(|column| column.original_position);
        context.position_column_order = false;
        context.sort_column_names = Some(vec!["id".into(), "name".into()]);
        match case {
            "all" => context.sort_column_names = Some(vec!["id".into(), "name".into(), "price".into()]),
            "empty" => context.sort_column_names = Some(vec![]),
            "repeat" => context.sort_column_names = Some(vec!["id".into(), "id".into()]),
            "missing" => context.sort_column_names = Some(vec!["absent".into()]),
            "old" => context.server_version = Some("3.2.9".into()),
            "primary_decimal" => {
                context.model = Some("primary".into());
                context.sort_column_names = Some(vec!["price".into()]);
            }
            "aggregate_nonkey" => context.model = Some("aggregate".into()),
            "unknown" => context.model = None,
            _ => unreachable!(),
        }
        let result = build_table_structure_change_sql_with_context(options, Some(context));
        assert!(result.statements.is_empty(), "{case} {:?}", result.statements);
        assert!(!result.warnings.is_empty(), "{case}");
    }
    for model in ["primary", "aggregate", "unique"] {
        let (mut options, mut context) = starrocks_reorder_fixture();
        options.columns.sort_by_key(|column| column.original_position);
        context.position_column_order = false;
        context.model = Some(model.into());
        context.sort_column_names = Some(vec!["id".into()]);
        let result = build_table_structure_change_sql_with_context(options, Some(context));
        assert!(result.warnings.is_empty(), "{model} {:?}", result.warnings);
        assert_eq!(result.statements, vec!["ALTER TABLE `test4` ORDER BY (`id`);"]);
    }
}

#[test]
fn mysql_literal_default_on_blob_text_json_geometry_is_refused() {
    // (data type, default, driver profile, expected DEFAULT clause; None means refused)
    let cases: &[(&str, &str, Option<&str>, Option<&str>)] = &[
        ("text", "''", None, None),
        ("TEXT", "x", None, None),
        ("mediumtext", "''", None, None),
        ("longtext", "a(b)", None, None),
        ("blob", "abc", None, None),
        ("json", "{}", None, None),
        ("geometry", "x", None, None),
        ("text", "('')", None, Some("DEFAULT ('')")),
        ("json", "(json_object())", None, Some("DEFAULT (json_object())")),
        ("text", "''", Some("mariadb"), Some("DEFAULT ''")),
        ("text", "", None, Some("`note` text NOT NULL")),
        ("text", "NULL", None, Some("`note` text NOT NULL")),
        ("varchar(255)", "''", None, Some("DEFAULT ''")),
        ("char(10)", "abc", None, Some("DEFAULT 'abc'")),
    ];
    for (data_type, default_value, driver_profile, expected) in cases {
        let mut note = column("note");
        note.data_type = data_type.to_string();
        note.is_nullable = false;
        note.default_value = default_value.to_string();
        let mut options = structure_change_options(DatabaseType::Mysql, None, "t", vec![note.clone()]);
        options.driver_profile = driver_profile.map(str::to_string);
        let added = build_table_structure_change_sql(options.clone());
        let created = build_create_table_sql(options);
        note.id = "ddl-preview:new:note".to_string();
        let single = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
            database_type: Some(DatabaseType::Mysql),
            driver_profile: driver_profile.map(str::to_string),
            schema: None,
            table_name: "t".to_string(),
            column: note,
        });
        let case = format!("{data_type} DEFAULT {default_value:?} ({driver_profile:?})");
        match expected {
            None => {
                let warning = format!(
                    "MySQL does not allow a literal default on {} column \"note\". Remove the default, or on MySQL 8.0.13 or later use an expression default such as ('').",
                    data_type.to_ascii_lowercase()
                );
                assert_eq!(added.warnings, vec![warning.clone()], "{case}");
                assert_eq!(created.warnings, vec![warning.clone()], "{case}");
                assert!(created.statements.is_empty(), "{case}: {:?}", created.statements);
                assert_eq!(single.warnings, vec![warning], "{case}");
                assert!(single.statements.is_empty(), "{case}: {:?}", single.statements);
            }
            Some(clause) => {
                for result in [&added, &created, &single] {
                    assert!(result.warnings.is_empty(), "{case}: {:?}", result.warnings);
                    assert_eq!(result.statements.len(), 1, "{case}: {:?}", result.statements);
                    assert!(result.statements[0].contains(clause), "{case}: {}", result.statements[0]);
                }
            }
        }
    }
}

#[test]
fn mysql_literal_default_check_only_covers_defaults_the_draft_emits() {
    // MySQL 8.0.13+ reports an expression default on TEXT this way. Leaving it
    // unchanged must not block an unrelated edit to the column.
    let mut kept = existing_pk_column("note", "text", false, false);
    kept.original.as_mut().unwrap().column_default = Some("_utf8mb4\\'\\'".to_string());
    kept.default_value = "_utf8mb4\\'\\'".to_string();
    kept.is_nullable = true;
    let result = build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "t", vec![kept]));
    assert!(result.warnings.is_empty(), "{:?}", result.warnings);

    // Turning a VARCHAR with a literal default into TEXT would carry the
    // literal into the MODIFY statement.
    let mut retyped = existing_pk_column("note", "varchar(255)", false, false);
    retyped.original.as_mut().unwrap().column_default = Some("".to_string());
    retyped.data_type = "text".to_string();
    retyped.default_value = "''".to_string();
    let result =
        build_table_structure_change_sql(structure_change_options(DatabaseType::Mysql, None, "t", vec![retyped]));
    assert_eq!(
        result.warnings,
        vec!["MySQL does not allow a literal default on text column \"note\". Remove the default, or on MySQL 8.0.13 or later use an expression default such as ('').".to_string()]
    );
}

#[test]
fn mysql_create_table_start_value() {
    let mut col = column("id");
    col.data_type = "BIGINT".to_string();
    col.is_primary_key = true;
    col.is_nullable = false;
    col.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![col]);
    options.mysql_engine = Some("InnoDB".to_string());
    options.table_comment = Some("example".to_string());
    let default_result = build_create_table_sql(options.clone());
    assert!(default_result.warnings.is_empty());
    assert!(!default_result.statements[0].contains("AUTO_INCREMENT ="));
    for value in ["1", "66", "9007199254740993", "18446744073709551615"] {
        options.mysql_auto_increment_value = Some(value.to_string());
        let result = build_create_table_sql(options.clone());
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        assert_eq!(result.statements.len(), 1);
        assert!(result.statements[0].contains(&format!("ENGINE = InnoDB AUTO_INCREMENT = {value} COMMENT = 'example'")));
    }
    for value in ["", "0", "01", "-1", "1.5", "1e3", "18446744073709551616", "1; DROP TABLE users", " 66"] {
        options.mysql_auto_increment_value = Some(value.to_string());
        let result = build_create_table_sql(options.clone());
        assert!(result.statements.is_empty(), "{value}");
        assert!(!result.warnings.is_empty(), "{value}");
    }
    options.mysql_auto_increment_value = Some("66".to_string());
    options.driver_profile = Some("doris".to_string());
    assert!(build_create_table_sql(options.clone()).statements.is_empty());
    options.driver_profile = Some("tidb".to_string());
    let tidb_result = build_create_table_sql(options.clone());
    assert!(tidb_result.warnings.is_empty());
    assert!(tidb_result.statements.iter().any(|sql| sql.contains("AUTO_INCREMENT = 66")));
    options.driver_profile = None;
    options.columns[0].extra = None;
    assert!(build_create_table_sql(options).statements.is_empty());
}

fn mysql_auto_increment_create_options() -> TableStructureSqlOptions {
    let mut id = column("id");
    id.data_type = "INT".to_string();
    id.is_nullable = false;
    id.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
    let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![id, column("name")]);
    options.mysql_engine = Some("InnoDB".to_string());
    options
}

#[test]
fn mysql_create_auto_increment_requires_one_column_and_a_supporting_key() {
    for start in [None, Some("6".to_string())] {
        let mut options = mysql_auto_increment_create_options();
        options.mysql_auto_increment_value = start;
        let result = build_create_table_sql(options.clone());
        assert!(result.statements.is_empty());
        assert!(result.warnings.iter().any(|warning| warning.contains("supporting index")));
        options.columns[0].is_primary_key = true;
        assert!(build_create_table_sql(options.clone()).warnings.is_empty());
        options.columns[1].extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
        let result = build_create_table_sql(options.clone());
        assert!(result.statements.is_empty());
        assert!(result.warnings.iter().any(|warning| warning.contains("only one")));
        options.columns[1].marked_for_drop = true;
        assert!(build_create_table_sql(options).warnings.is_empty());
    }
}

#[test]
fn mysql_create_auto_increment_inlines_ordinary_and_unique_supporting_indexes_once() {
    for unique in [false, true] {
        let mut options = mysql_auto_increment_create_options();
        options.mysql_auto_increment_value = Some("6".to_string());
        let mut supporting = index("key`id", &["id", "name"]);
        supporting.is_unique = unique;
        supporting.index_type = "BTREE".to_string();
        supporting.comment = "id's sequence".to_string();
        options.indexes = vec![supporting, index("name_lookup", &["name"])];
        let result = build_create_table_sql(options);
        assert!(result.warnings.is_empty(), "{:?}", result.warnings);
        assert_eq!(result.statements.len(), 2);
        let unique_prefix = if unique { "UNIQUE " } else { "" };
        assert!(
            result.statements[0].contains(&format!(
                "{unique_prefix}INDEX `key``id` USING BTREE (`id`, `name`) COMMENT 'id''s sequence'"
            )),
            "{:?}",
            result.statements
        );
        assert!(result.statements[0].contains("AUTO_INCREMENT = 6"));
        assert!(result.statements[1].contains("name_lookup"));
        assert!(!result.statements[1].contains("key``id"));
    }
}

#[test]
fn mysql_create_auto_increment_checks_key_order_and_ignores_dropped_or_unsuitable_indexes() {
    let mut options = mysql_auto_increment_create_options();
    options.indexes = vec![index("wrong_order", &["name", "id"])];
    assert!(build_create_table_sql(options.clone()).statements.is_empty());
    options.mysql_engine = Some("MyISAM".to_string());
    assert!(build_create_table_sql(options.clone()).warnings.is_empty());
    options.mysql_engine = None; // default InnoDB behavior
    options.indexes[0].columns = vec!["id".to_string()];
    options.indexes[0].marked_for_drop = true;
    assert!(build_create_table_sql(options.clone()).statements.is_empty());
    options.indexes[0].marked_for_drop = false;
    for kind in ["FULLTEXT", "SPATIAL", "RTREE"] {
        options.indexes[0].index_type = kind.to_string();
        assert!(build_create_table_sql(options.clone()).statements.is_empty());
    }
    options.indexes.clear();
    options.columns[0].is_primary_key = true;
    options.columns[1].is_primary_key = true;
    options.columns.swap(0, 1);
    assert!(build_create_table_sql(options.clone()).statements.is_empty());
    options.indexes.push(index("support", &["id"]));
    assert!(build_create_table_sql(options).warnings.is_empty());
}