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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
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());
}