github/dbx
4
0 Fork 0
mirror of https://github.com/t8y2/dbx.git synced 2026-11-15 06:51:27 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
bc00431834850955931a17d69571122530ab5ff8
dbx/crates/dbx-sql/src/table_structure_sql/column_alter.rs
T

1059 lines
47 KiB
Rust
Raw Blame History

use super::column_format::{
clickhouse_column_type, column_data_type, column_definition, has_dameng_identity,
is_dameng_identity_compatible_type, is_mysql_character_data_type, original_is_mysql_generated_column,
original_mysql_generated_clause,
};
use super::columns::build_drop_column_sql;
use super::comments::build_sqlserver_column_comment_sql_for_profile;
use super::dialect::{capabilities_for, database_label, StructureDialect};
use super::types::{EditableStructureColumn, SingleColumnAlterSqlOptions, TableStructureSqlResult};
use super::util::{
clean, format_default_for_sql, is_protected_manticore_id_column, normalize_default, original_comment,
original_default, qualified_table, quote_ident, quote_string,
};
use crate::table_structure_sql::ColumnExtra;
pub fn build_single_column_alter_sql(options: SingleColumnAlterSqlOptions) -> TableStructureSqlResult {
let capabilities = capabilities_for(options.database_type, options.driver_profile.as_deref());
let dialect = capabilities.dialect;
let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
let database_label = database_label(options.database_type);
let mut warnings = Vec::new();
let mut statements = Vec::new();
if options.column.marked_for_drop {
let Some(original) = &options.column.original else {
warnings.push("No original column info available.".to_string());
return TableStructureSqlResult { statements, warnings };
};
if !capabilities.drop_column {
warnings.push(format!("Dropping columns is not supported for {database_label} from this editor."));
return TableStructureSqlResult { statements, warnings };
}
if original.is_primary_key {
warnings.push(format!("Primary key column \"{}\" cannot be dropped from this editor.", original.name));
return TableStructureSqlResult { statements, warnings };
}
if is_protected_manticore_id_column(dialect, &original.name) {
warnings.push("Manticore Search id column cannot be dropped from this editor.".to_string());
return TableStructureSqlResult { statements, warnings };
}
statements.push(build_drop_column_sql(dialect, &table, &original.name));
return TableStructureSqlResult { statements, warnings };
}
let Some(original) = &options.column.original else {
warnings.push(
"This column has no original state — ALTER statements are only available for existing columns.".to_string(),
);
return TableStructureSqlResult { statements, warnings };
};
if !has_existing_column_attribute_change(&options.column) && !has_column_extra_change(&options.column) {
warnings.push("No changes detected for this column.".to_string());
return TableStructureSqlResult { statements, warnings };
}
let has_rename = options.column.name != original.name;
let has_comment_change = clean(&options.column.comment) != original_comment(&options.column);
let has_attribute_change = options.column.data_type.trim() != original.data_type.trim()
|| options.column.is_nullable != original.is_nullable
|| normalize_default(Some(&options.column.default_value)) != original_default(&options.column)
|| (has_comment_change && capabilities.comment)
|| (is_mysql_character_data_type(&options.column.data_type)
&& (options.column.character_set.trim() != original.character_set.as_deref().unwrap_or("")
|| options.column.collation.trim() != original.collation.as_deref().unwrap_or("")));
if has_comment_change && !capabilities.comment {
warnings.push(format!(
"Column comments are not supported for {database_label} from this editor; the comment change for \"{}\" was ignored.",
original.name
));
}
if has_rename && !capabilities.rename_column {
warnings.push(format!("Renaming columns is not supported for {database_label} from this editor."));
}
if has_attribute_change && !capabilities.alter_existing_column && dialect != StructureDialect::Sqlite {
warnings.push(format!("Editing existing columns is not supported for {database_label} yet."));
}
if (has_rename && !capabilities.rename_column)
|| (has_attribute_change && !capabilities.alter_existing_column && dialect != StructureDialect::Sqlite)
{
return TableStructureSqlResult { statements, warnings };
}
if dialect == StructureDialect::Mysql
&& original_is_mysql_generated_column(&options.column)
&& original_mysql_generated_clause(&options.column).is_none()
{
warnings.push(format!(
"Column \"{}\" is generated, but its generation expression could not be loaded; no ALTER statement was generated to avoid removing the generated-column definition.",
original.name
));
return TableStructureSqlResult { statements, warnings };
}
if !has_rename && !has_attribute_change && !has_column_extra_change(&options.column) {
return TableStructureSqlResult { statements, warnings };
}
match dialect {
StructureDialect::Mysql => statements.extend(build_mysql_existing_column_sql(&table, &options.column, "")),
StructureDialect::Doris => statements.extend(build_doris_existing_column_sql(&table, &options.column, "")),
StructureDialect::Postgres => statements.extend(build_postgres_existing_column_sql(&table, &options.column)),
StructureDialect::Oracle => {
if options.database_type == Some(crate::models::connection::DatabaseType::Iris) {
statements.extend(build_iris_existing_column_sql(&table, &options.column));
} else if options.database_type == Some(crate::models::connection::DatabaseType::Xugu) {
statements.extend(build_xugu_existing_column_sql(&table, &options.column));
} else {
statements.extend(build_oracle_like_existing_column_sql(dialect, &table, &options.column))
}
}
StructureDialect::Dameng => {
statements.extend(build_dameng_existing_column_sql(&table, &options.column, true, &mut warnings))
}
StructureDialect::Oscar => statements.extend(build_oscar_existing_column_sql(dialect, &table, &options.column)),
StructureDialect::H2 => statements.extend(build_h2_existing_column_sql(&table, &options.column)),
StructureDialect::ClickHouse => {
statements.extend(build_clickhouse_existing_column_sql(&table, &options.column, ""))
}
StructureDialect::Informix => statements.extend(build_informix_existing_column_sql(&table, &options.column)),
StructureDialect::SqlServer => statements.extend(build_sqlserver_existing_column_sql(
&table,
&options.column,
options.schema.as_deref(),
&options.table_name,
options.driver_profile.as_deref(),
&mut warnings,
)),
StructureDialect::Sqlite => {
statements.extend(build_sqlite_existing_column_sql(&table, &options.column, &mut warnings))
}
_ => warnings.push(format!("Editing existing columns is not supported for {database_label} yet.")),
}
TableStructureSqlResult { statements, warnings }
}
fn is_column_extra_empty(extra: &ColumnExtra) -> bool {
!extra.auto_increment.unwrap_or(false)
&& !extra.on_update_current_timestamp.unwrap_or(false)
&& extra.identity.is_none()
&& !extra.manticore_indexed.unwrap_or(false)
&& !extra.manticore_stored.unwrap_or(false)
&& !extra.manticore_attribute.unwrap_or(false)
&& !extra.manticore_secondary_index.unwrap_or(false)
}
fn original_manticore_extra_flags(extra: &str) -> (bool, bool, bool, bool) {
let lower = extra.to_lowercase();
let mut tokens = lower.split_whitespace();
let first = tokens.next();
let is_generated_column = first.is_some_and(|token| token == "generated")
|| matches!(first, Some("virtual" | "stored" | "persistent"))
&& tokens.next().is_some_and(|token| token == "generated");
if is_generated_column {
return (false, false, false, false);
}
(
lower.split_whitespace().any(|token| token == "indexed"),
lower.split_whitespace().any(|token| token == "stored"),
lower.split_whitespace().any(|token| token == "attribute"),
lower.contains("secondary_index='1'")
|| lower.contains("secondary_index=\"1\"")
|| lower.contains("secondary_index=1"),
)
}
fn original_has_auto_increment(extra: &str) -> bool {
let lower = extra.to_lowercase();
lower.contains("auto_increment") || lower.contains("autoincrement")
}
fn original_has_identity(extra: &str) -> bool {
extra.to_lowercase().contains("identity")
}
fn sqlserver_identity_values(extra: &str) -> Option<(Option<i64>, Option<i64>)> {
let lower = extra.to_lowercase();
let identity_index = lower.find("identity")?;
let after_identity = extra.get(identity_index + "identity".len()..)?.trim_start();
if !after_identity.starts_with('(') {
return Some((None, None));
}
let close_index = after_identity.find(')')?;
let args = &after_identity[1..close_index];
let mut parts = args.split(',').map(|part| part.trim().parse::<i64>().ok());
Some((parts.next().flatten(), parts.next().flatten()))
}
fn sqlserver_identity_matches_original(identity: &super::types::ColumnIdentity, original_extra: &str) -> bool {
let Some((original_seed, original_increment)) = sqlserver_identity_values(original_extra) else {
return false;
};
identity.seed.unwrap_or(1) == original_seed.unwrap_or(1)
&& identity.increment.unwrap_or(1) == original_increment.unwrap_or(1)
}
fn parse_i64_after_phrase(value: &str, lower: &str, phrase: &str) -> Option<i64> {
let start = lower.find(phrase)? + phrase.len();
let rest = value.get(start..)?.trim_start();
let token = rest.split(|ch: char| ch.is_whitespace() || ch == ')' || ch == ',').find(|part| !part.is_empty())?;
token.parse::<i64>().ok()
}
fn postgres_identity_values(extra: &str) -> Option<(String, Option<i64>, Option<i64>)> {
let lower = extra.to_lowercase();
let generation = if lower.contains("generated always as identity") {
"ALWAYS".to_string()
} else if lower.contains("generated by default as identity") {
"BY DEFAULT".to_string()
} else {
return None;
};
let seed = parse_i64_after_phrase(extra, &lower, "start with");
let increment = parse_i64_after_phrase(extra, &lower, "increment by");
Some((generation, seed, increment))
}
fn identity_matches_original(identity: &super::types::ColumnIdentity, original_extra: &str) -> bool {
if let Some((generation, original_seed, original_increment)) = postgres_identity_values(original_extra) {
return identity.generation.as_deref().unwrap_or("BY DEFAULT").eq_ignore_ascii_case(&generation)
&& identity.seed.unwrap_or(1) == original_seed.unwrap_or(1)
&& identity.increment.unwrap_or(1) == original_increment.unwrap_or(1);
}
sqlserver_identity_matches_original(identity, original_extra)
}
#[derive(Clone, Copy)]
enum DamengIdentityTransition {
None,
Add { seed: i64, increment: i64 },
Drop,
ParametersChanged,
}
fn dameng_identity_transition(column: &EditableStructureColumn) -> DamengIdentityTransition {
let Some(original) = &column.original else {
return DamengIdentityTransition::None;
};
let original_extra = original.extra.as_deref().unwrap_or("");
let original_identity = original_has_identity(original_extra);
let current_identity = has_dameng_identity(column);
match (original_identity, current_identity) {
(false, false) => DamengIdentityTransition::None,
(false, true) => {
let identity = column.extra.as_ref().and_then(|extra| extra.identity.as_ref());
DamengIdentityTransition::Add {
seed: identity.and_then(|identity| identity.seed).unwrap_or(1),
increment: identity.and_then(|identity| identity.increment).unwrap_or(1),
}
}
(true, false) => DamengIdentityTransition::Drop,
(true, true) => match column.extra.as_ref().and_then(|extra| extra.identity.as_ref()) {
Some(identity) if !identity_matches_original(identity, original_extra) => {
DamengIdentityTransition::ParametersChanged
}
_ => DamengIdentityTransition::None,
},
}
}
pub(super) fn dameng_drops_identity(column: &EditableStructureColumn) -> bool {
matches!(dameng_identity_transition(column), DamengIdentityTransition::Drop)
}
pub(super) fn validate_dameng_existing_identity_change(
column: &EditableStructureColumn,
warnings: &mut Vec<String>,
) -> bool {
match dameng_identity_transition(column) {
DamengIdentityTransition::Add { increment, .. } => {
if !is_dameng_identity_compatible_type(&column.data_type) {
warnings.push(format!(
"Dameng identity column \"{}\" must use tinyint, smallint, int, integer, bigint, number, numeric, or decimal/dec with scale 0.",
column.name
));
} else if column.is_nullable {
warnings.push(format!(
"Dameng identity column \"{}\" must be NOT NULL before identity can be enabled.",
column.name
));
} else if increment == 0 {
warnings.push(format!("Dameng identity column \"{}\" increment cannot be 0.", column.name));
} else {
return true;
}
false
}
DamengIdentityTransition::ParametersChanged => {
warnings.push(format!(
"Changing Dameng IDENTITY seed or increment for existing column \"{}\" is not supported from this editor.",
column.name
));
false
}
DamengIdentityTransition::None | DamengIdentityTransition::Drop => true,
}
}
pub(super) fn has_column_extra_change(column: &EditableStructureColumn) -> bool {
let Some(original) = &column.original else { return false };
let current_extra = column.extra.as_ref();
match (current_extra, original.extra.as_deref()) {
// Neither has extra → no change
(None, None | Some("")) => false,
// Current extra is empty (all None) → changed only if the original had effective extra
(Some(curr), None | Some("")) if is_column_extra_empty(curr) => false,
(Some(curr), Some(orig)) if is_column_extra_empty(curr) => {
let (indexed, stored, attribute, secondary_index) = original_manticore_extra_flags(orig);
let orig_lower = orig.to_lowercase();
original_has_auto_increment(orig)
|| orig_lower.contains("on update")
|| original_has_identity(orig)
|| indexed
|| stored
|| attribute
|| secondary_index
}
// Extra added or removed
(Some(_), None | Some("")) => true,
(None, Some(_)) => true,
// Both have extra → check auto_increment and on_update_current_timestamp flags
(Some(curr), Some(orig)) => {
let orig_lower = orig.to_lowercase();
let curr_has_ai = curr.auto_increment.unwrap_or(false);
let orig_has_identity = original_has_identity(orig);
let orig_has_ai = original_has_auto_increment(orig) || (orig_has_identity && curr_has_ai);
let curr_has_on_update = curr.on_update_current_timestamp.unwrap_or(false);
let orig_has_on_update = orig_lower.contains("on update");
let identity_changed = match (&curr.identity, orig_has_identity) {
(Some(identity), true) => !identity_matches_original(identity, orig),
(Some(_), false) => true,
(None, true) => !curr_has_ai,
(None, false) => false,
};
let curr_manticore = (
curr.manticore_indexed.unwrap_or(false),
curr.manticore_stored.unwrap_or(false),
curr.manticore_attribute.unwrap_or(false),
curr.manticore_secondary_index.unwrap_or(false),
);
let orig_manticore = original_manticore_extra_flags(orig);
curr_has_ai != orig_has_ai
|| curr_has_on_update != orig_has_on_update
|| identity_changed
|| curr_manticore != orig_manticore
}
}
}
pub(super) fn build_mysql_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
position_clause: &str,
) -> Vec<String> {
let operation = build_mysql_existing_column_clause(column, position_clause);
vec![format!("ALTER TABLE {table} {operation};")]
}
pub(super) fn build_mysql_existing_column_clause(column: &EditableStructureColumn, position_clause: &str) -> String {
let original_name = column.original.as_ref().map(|original| original.name.as_str()).unwrap_or(&column.name);
let operation = if column.name == original_name {
format!("MODIFY COLUMN {}", column_definition(StructureDialect::Mysql, column))
} else {
format!(
"CHANGE COLUMN {} {}",
quote_ident(StructureDialect::Mysql, original_name),
column_definition(StructureDialect::Mysql, column)
)
};
format!("{operation}{position_clause}")
}
pub(super) fn build_doris_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
position_clause: &str,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let mut current_column = column.clone();
if column.name != original.name {
// Doris follows its own lightweight schema-change grammar: no MySQL CHANGE and no TO keyword.
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} {};",
quote_ident(StructureDialect::Doris, &original.name),
quote_ident(StructureDialect::Doris, &column.name)
));
current_column.name = column.name.clone();
}
let type_changed = column.data_type.trim() != original.data_type.trim();
let nullable_changed = column.is_nullable != original.is_nullable;
let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
let comment_changed = clean(&column.comment) != original_comment(column);
if type_changed || nullable_changed || default_changed || comment_changed || !position_clause.is_empty() {
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {}{position_clause};",
column_definition(StructureDialect::Doris, &current_column)
));
}
statements
}
pub(super) fn build_postgres_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
build_postgres_like_existing_column_sql(table, column, false)
}
pub(super) fn build_xugu_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
// Xugu shares PostgreSQL's per-attribute ALTER flow, but its type clause omits TYPE entirely.
build_postgres_like_existing_column_sql(table, column, true)
}
fn build_postgres_like_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
use_xugu_type_syntax: bool,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let current_name = &column.name;
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote_ident(StructureDialect::Postgres, &original.name),
quote_ident(StructureDialect::Postgres, &column.name)
));
}
let type_changed = column.data_type.trim() != original.data_type.trim();
if type_changed {
let column_name = quote_ident(StructureDialect::Postgres, current_name);
let data_type = column_data_type(StructureDialect::Postgres, column);
if use_xugu_type_syntax {
statements.push(format!("ALTER TABLE {table} ALTER COLUMN {column_name} {data_type};"));
} else {
let current_default = normalize_default(Some(&column.default_value));
let mut alterations = Vec::new();
if !original_default(column).is_empty() {
alterations.push(format!("ALTER COLUMN {column_name} DROP DEFAULT"));
}
// PostgreSQL assignment casts do not cover many valid explicit conversions. USING keeps
// type changes generic for built-ins, arrays, and domains while still rejecting bad data.
alterations.push(format!("ALTER COLUMN {column_name} TYPE {data_type} USING {column_name}::{data_type}"));
if !current_default.is_empty() {
alterations.push(format!(
"ALTER COLUMN {column_name} SET DEFAULT {}",
format_default_for_sql(StructureDialect::Postgres, &column.data_type, &current_default)
));
}
// USING is not applied to defaults. Keeping all three actions in one ALTER TABLE makes
// an incompatible restored default fail atomically instead of leaving it dropped.
statements.push(format!("ALTER TABLE {table} {};", alterations.join(", ")));
}
}
if column.is_nullable != original.is_nullable {
let action = if column.is_nullable { "DROP NOT NULL" } else { "SET NOT NULL" };
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} {action};",
quote_ident(StructureDialect::Postgres, current_name)
));
}
if (!type_changed || use_xugu_type_syntax)
&& normalize_default(Some(&column.default_value)) != original_default(column)
{
let default_value = normalize_default(Some(&column.default_value));
let action = if default_value.is_empty() {
"DROP DEFAULT".to_string()
} else {
format!(
"SET DEFAULT {}",
format_default_for_sql(StructureDialect::Postgres, &column.data_type, &default_value)
)
};
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} {action};",
quote_ident(StructureDialect::Postgres, current_name)
));
}
if clean(&column.comment) != original_comment(column) {
let comment_value =
if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
statements.push(format!(
"COMMENT ON COLUMN {table}.{} IS {comment_value};",
quote_ident(StructureDialect::Postgres, current_name)
));
}
statements
}
pub(super) fn build_informix_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let dialect = StructureDialect::Informix;
let mut statements = Vec::new();
let mut current_name = original.name.clone();
if column.name != original.name {
statements.push(format!(
"RENAME COLUMN {table}.{} TO {};",
quote_ident(dialect, &original.name),
quote_ident(dialect, &column.name)
));
current_name = column.name.clone();
}
let type_changed = column.data_type.trim() != original.data_type.trim();
let nullable_changed = column.is_nullable != original.is_nullable;
let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
if type_changed || nullable_changed || default_changed {
let mut parts = vec![quote_ident(dialect, &current_name), column_data_type(dialect, column)];
if column.is_nullable {
parts.push("NULL".to_string());
} else {
parts.push("NOT NULL".to_string());
}
let default_value = normalize_default(Some(&column.default_value));
if !default_value.is_empty() {
parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
} else if default_changed {
parts.push("DEFAULT NULL".to_string());
}
statements.push(format!("ALTER TABLE {table} MODIFY ({});", parts.join(" ")));
}
statements
}
pub(super) fn build_oracle_like_existing_column_sql(
dialect: StructureDialect,
table: &str,
column: &EditableStructureColumn,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let mut current_name = original.name.clone();
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote_ident(dialect, &original.name),
quote_ident(dialect, &column.name)
));
current_name = column.name.clone();
}
let type_changed = column.data_type.trim() != original.data_type.trim();
let nullable_changed = column.is_nullable != original.is_nullable;
let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
if type_changed || nullable_changed || default_changed {
let data_type = column_data_type(dialect, column);
let mut parts = vec![quote_ident(dialect, &current_name), data_type];
let default_value = normalize_default(Some(&column.default_value));
if !default_value.is_empty() {
parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
} else if default_changed {
// User cleared the default — explicitly drop it.
parts.push("DEFAULT NULL".to_string());
}
if nullable_changed {
if column.is_nullable {
parts.push("NULL".to_string());
} else {
parts.push("NOT NULL".to_string());
}
}
statements.push(format!("ALTER TABLE {table} MODIFY ({});", parts.join(" ")));
}
if clean(&column.comment) != original_comment(column) {
let comment_value =
if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
statements
.push(format!("COMMENT ON COLUMN {table}.{} IS {comment_value};", quote_ident(dialect, &current_name)));
}
statements
}
pub(super) fn build_dameng_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
emit_identity_drop: bool,
warnings: &mut Vec<String>,
) -> Vec<String> {
let transition = dameng_identity_transition(column);
if !validate_dameng_existing_identity_change(column, warnings) {
return Vec::new();
}
let mut statements = Vec::new();
if emit_identity_drop && matches!(transition, DamengIdentityTransition::Drop) {
statements.push(format!("ALTER TABLE {table} DROP IDENTITY;"));
}
statements.extend(build_oracle_like_existing_column_sql(StructureDialect::Dameng, table, column));
if let DamengIdentityTransition::Add { seed, increment } = transition {
statements.push(format!(
"ALTER TABLE {table} ADD COLUMN {} IDENTITY({seed}, {increment});",
quote_ident(StructureDialect::Dameng, &column.name)
));
}
statements
}
pub(super) fn build_iris_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let dialect = StructureDialect::Oracle;
let mut statements = Vec::new();
let mut current_name = original.name.clone();
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} RENAME {};",
quote_ident(dialect, &original.name),
quote_ident(dialect, &column.name)
));
current_name = column.name.clone();
}
let type_changed = column.data_type.trim() != original.data_type.trim();
let nullable_changed = column.is_nullable != original.is_nullable;
let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
if type_changed || nullable_changed || default_changed {
let mut parts = vec![quote_ident(dialect, &current_name), column_data_type(dialect, column)];
let default_value = normalize_default(Some(&column.default_value));
if !default_value.is_empty() {
parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
} else if default_changed {
parts.push("DEFAULT NULL".to_string());
}
if nullable_changed {
parts.push(if column.is_nullable { "NULL".to_string() } else { "NOT NULL".to_string() });
}
statements.push(format!("ALTER TABLE {table} MODIFY ({});", parts.join(" ")));
}
statements
}
/// 神通 Oscar 的 ALTER 已有列 SQL。
///
/// 神通的 `ALTER TABLE ... MODIFY` 语法与 Oracle 有重要差异（实测 v7.0.8）：
/// 带圆括号的 `MODIFY (col TYPE [DEFAULT ...])` 不允许出现 `NULL`/`NOT NULL`，否则
/// parser 报 `syntax error at or near "NULL"`。要改可空性必须用不带括号、不带类型的
/// `MODIFY col NOT NULL` / `MODIFY col NULL` 单独一条。因此类型/默认值变更与可空性
/// 变更需拆成两条语句，而不能像 Oracle/Dameng 那样合并进单个 `MODIFY (...)`。
pub(super) fn build_oscar_existing_column_sql(
dialect: StructureDialect,
table: &str,
column: &EditableStructureColumn,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let mut current_name = original.name.clone();
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote_ident(dialect, &original.name),
quote_ident(dialect, &column.name)
));
current_name = column.name.clone();
}
let type_changed = column.data_type.trim() != original.data_type.trim();
let nullable_changed = column.is_nullable != original.is_nullable;
let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
// 类型或默认值变更：带括号的 MODIFY 只允许 "col TYPE [DEFAULT ...]"，不含 NULL/NOT NULL。
if type_changed || default_changed {
let data_type = column_data_type(dialect, column);
let mut parts = vec![quote_ident(dialect, &current_name), data_type];
let default_value = normalize_default(Some(&column.default_value));
if !default_value.is_empty() {
parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
} else if default_changed {
// User cleared the default — explicitly drop it. MODIFY (col DEFAULT NULL) 合法。
parts.push("DEFAULT NULL".to_string());
}
statements.push(format!("ALTER TABLE {table} MODIFY ({});", parts.join(" ")));
}
// 可空性变更：神通要求不带括号、不带类型的单独 MODIFY，否则 parser 报错。
if nullable_changed {
let nullability = if column.is_nullable { "NULL" } else { "NOT NULL" };
statements.push(format!("ALTER TABLE {table} MODIFY {} {};", quote_ident(dialect, &current_name), nullability));
}
if clean(&column.comment) != original_comment(column) {
let comment_value =
if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
statements
.push(format!("COMMENT ON COLUMN {table}.{} IS {comment_value};", quote_ident(dialect, &current_name)));
}
statements
}
pub(super) fn build_sqlserver_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
schema: Option<&str>,
table_name: &str,
driver_profile: Option<&str>,
warnings: &mut Vec<String>,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let dialect = StructureDialect::SqlServer;
let mut statements = Vec::new();
let mut current_name = original.name.clone();
let has_column_definition_change =
column.data_type.trim() != original.data_type.trim() || column.is_nullable != original.is_nullable;
let default_value = normalize_default(Some(&column.default_value));
let has_default_change = default_value != original_default(column);
let has_old_default = original
.column_default
.as_deref()
.is_some_and(|value| !value.trim().is_empty() && !value.trim().eq_ignore_ascii_case("null"));
if has_sqlserver_identity_change(column) {
warnings.push(format!(
"Changing SQL Server IDENTITY for existing column \"{}\" is not supported from this editor.",
original.name
));
}
// Rename column via sp_rename
if column.name != original.name {
let full_obj_path = format!("{table}.{}", quote_ident(dialect, &original.name));
statements.push(format!(
"EXEC sp_rename '{full_obj_path}', '{new_name}', 'COLUMN';",
full_obj_path = full_obj_path.replace('\'', "''"),
new_name = column.name.replace('\'', "''")
));
current_name = column.name.clone();
}
// SQL Server default constraints are separate objects that can block ALTER COLUMN.
// Preserve the exact constraint name and expression when the default itself is unchanged.
if has_column_definition_change && has_old_default && !has_default_change {
statements.push(build_sqlserver_alter_column_preserving_default_sql(
table,
&current_name,
&column_data_type(dialect, column),
column.is_nullable,
));
} else {
if has_column_definition_change && has_old_default {
statements.push(build_sqlserver_drop_default_constraint_sql(table, &current_name));
}
if has_column_definition_change {
let null_clause = if column.is_nullable { "NULL" } else { "NOT NULL" };
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} {} {null_clause};",
quote_ident(dialect, &current_name),
column_data_type(dialect, column)
));
}
}
// Default value changes via ADD/DROP CONSTRAINT.
if has_default_change {
if has_old_default && !has_column_definition_change {
statements.push(build_sqlserver_drop_default_constraint_sql(table, &current_name));
}
if !default_value.is_empty() {
let constraint_name = format!("DF_{}_{}", table_name.trim(), current_name.trim());
statements.push(format!(
"ALTER TABLE {table} ADD CONSTRAINT {} DEFAULT {} FOR {};",
quote_ident(dialect, &constraint_name),
format_default_for_sql(StructureDialect::SqlServer, &column.data_type, &default_value),
quote_ident(dialect, &current_name)
));
}
}
// Column comment changes via extended properties
if clean(&column.comment) != original_comment(column) {
statements.extend(build_sqlserver_column_comment_sql_for_profile(
table,
schema,
table_name,
&current_name,
&column.comment,
driver_profile,
));
}
statements
}
pub fn build_sqlserver_alter_column_preserving_default_sql(
table: &str,
column_name: &str,
data_type: &str,
is_nullable: bool,
) -> String {
let dialect = StructureDialect::SqlServer;
let sql_var = sqlserver_default_constraint_sql_var(table, column_name);
let name_var = format!("{sql_var}_name");
let definition_var = format!("{sql_var}_definition");
let table_literal = table.replace('\'', "''");
let column_literal = column_name.replace('\'', "''");
let quoted_column = quote_ident(dialect, column_name);
let quoted_column_literal = quoted_column.replace('\'', "''");
let null_clause = if is_nullable { "NULL" } else { "NOT NULL" };
format!(
"DECLARE {sql_var} NVARCHAR(MAX), {name_var} sysname, {definition_var} NVARCHAR(MAX); \
SELECT TOP (1) {name_var} = dc.name, {definition_var} = dc.definition \
FROM sys.default_constraints AS dc \
WHERE dc.parent_object_id = OBJECT_ID(N'{table_literal}') AND dc.parent_column_id = COLUMNPROPERTY(OBJECT_ID(N'{table_literal}'), N'{column_literal}', 'ColumnId'); \
IF {name_var} IS NOT NULL BEGIN SET {sql_var} = N'ALTER TABLE {table_literal} DROP CONSTRAINT ' + QUOTENAME({name_var}); EXEC sp_executesql {sql_var}; END; \
ALTER TABLE {table} ALTER COLUMN {quoted_column} {data_type} {null_clause}; \
IF {name_var} IS NOT NULL BEGIN SET {sql_var} = N'ALTER TABLE {table_literal} ADD CONSTRAINT ' + QUOTENAME({name_var}) + N' DEFAULT ' + {definition_var} + N' FOR {quoted_column_literal}'; EXEC sp_executesql {sql_var}; END;",
data_type = data_type,
)
}
pub fn build_sqlserver_drop_default_constraint_sql(table: &str, column_name: &str) -> String {
let sql_var = sqlserver_default_constraint_sql_var(table, column_name);
let table_literal = table.replace('\'', "''");
let column_literal = column_name.replace('\'', "''");
format!(
"DECLARE {sql_var} NVARCHAR(MAX); \
SELECT TOP (1) {sql_var} = N'ALTER TABLE {table_literal} DROP CONSTRAINT ' + QUOTENAME(dc.name) \
FROM sys.default_constraints AS dc \
WHERE dc.parent_object_id = OBJECT_ID(N'{table_literal}') AND dc.parent_column_id = COLUMNPROPERTY(OBJECT_ID(N'{table_literal}'), N'{column_literal}', 'ColumnId'); \
IF {sql_var} IS NOT NULL EXEC sp_executesql {sql_var};"
)
}
fn sqlserver_default_constraint_sql_var(table: &str, column_name: &str) -> String {
let mut hash = 0x811c_9dc5u32;
for byte in table.bytes().chain([0]).chain(column_name.bytes()) {
hash ^= u32::from(byte);
hash = hash.wrapping_mul(0x0100_0193);
}
format!("@dbx_default_sql_{hash:08x}")
}
fn has_sqlserver_identity_change(column: &EditableStructureColumn) -> bool {
let Some(original) = &column.original else {
return false;
};
let original_extra = original.extra.as_deref().unwrap_or("");
let original_identity = original_has_identity(original_extra);
let current_extra = column.extra.as_ref();
let current_identity =
current_extra.is_some_and(|extra| extra.auto_increment.unwrap_or(false) || extra.identity.is_some());
if current_identity != original_identity {
return true;
}
if !current_identity {
return false;
}
current_extra
.and_then(|extra| extra.identity.as_ref())
.is_some_and(|identity| !sqlserver_identity_matches_original(identity, original_extra))
}
pub(super) fn build_h2_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let mut current_name = original.name.clone();
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} RENAME TO {};",
quote_ident(StructureDialect::H2, &original.name),
quote_ident(StructureDialect::H2, &column.name)
));
current_name = column.name.clone();
}
if column.data_type.trim() != original.data_type.trim() {
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} SET DATA TYPE {};",
quote_ident(StructureDialect::H2, &current_name),
column_data_type(StructureDialect::H2, column)
));
}
if column.is_nullable != original.is_nullable {
let action = if column.is_nullable { "DROP NOT NULL" } else { "SET NOT NULL" };
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} {action};",
quote_ident(StructureDialect::H2, &current_name)
));
}
if normalize_default(Some(&column.default_value)) != original_default(column) {
let default_value = normalize_default(Some(&column.default_value));
let action = if default_value.is_empty() {
"DROP DEFAULT".to_string()
} else {
format!("SET DEFAULT {}", format_default_for_sql(StructureDialect::H2, &column.data_type, &default_value))
};
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} {action};",
quote_ident(StructureDialect::H2, &current_name)
));
}
if clean(&column.comment) != original_comment(column) {
let comment_value =
if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
statements.push(format!(
"COMMENT ON COLUMN {table}.{} IS {comment_value};",
quote_ident(StructureDialect::H2, &current_name)
));
}
statements
}
pub(super) fn build_clickhouse_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
position_clause: &str,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let mut current_name = original.name.clone();
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote_ident(StructureDialect::ClickHouse, &original.name),
quote_ident(StructureDialect::ClickHouse, &column.name)
));
current_name = column.name.clone();
}
let next_type = clickhouse_column_type(column);
if next_type != original.data_type.trim()
|| normalize_default(Some(&column.default_value)) != original_default(column)
{
let default_value = normalize_default(Some(&column.default_value));
if !default_value.is_empty() {
let default_sql = format_default_for_sql(StructureDialect::ClickHouse, &column.data_type, &default_value);
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {} {next_type} DEFAULT {default_sql}{position_clause};",
quote_ident(StructureDialect::ClickHouse, &current_name)
));
} else if !original_default(column).is_empty() {
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {} REMOVE DEFAULT;",
quote_ident(StructureDialect::ClickHouse, &current_name)
));
if next_type != original.data_type.trim() || !position_clause.is_empty() {
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {} {next_type}{position_clause};",
quote_ident(StructureDialect::ClickHouse, &current_name)
));
}
} else {
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {} {next_type}{position_clause};",
quote_ident(StructureDialect::ClickHouse, &current_name)
));
}
} else if !position_clause.is_empty() {
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {} {next_type}{position_clause};",
quote_ident(StructureDialect::ClickHouse, &current_name)
));
}
if clean(&column.comment) != original_comment(column) {
statements.push(format!(
"ALTER TABLE {table} COMMENT COLUMN {} {};",
quote_ident(StructureDialect::ClickHouse, &current_name),
quote_string(&clean(&column.comment))
));
}
statements
}
pub(super) fn build_sqlite_existing_column_sql(
table: &str,
column: &EditableStructureColumn,
warnings: &mut Vec<String>,
) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
// Tri-state: an unset auto_increment flag inherits the original value; only an
// explicit toggle (SQLite cannot add or drop AUTOINCREMENT without a rebuild)
// counts as an unsupported change.
let original_auto_increment = original.extra.as_deref().is_some_and(|extra| {
let lower = extra.to_ascii_lowercase();
lower.contains("auto_increment")
|| lower.contains("autoincrement")
|| lower.contains("identity")
|| lower.contains("serial")
});
let auto_increment_changed =
column.extra.as_ref().and_then(|e| e.auto_increment).is_some_and(|value| value != original_auto_increment);
let unsupported_change = column.data_type.trim() != original.data_type.trim()
|| column.is_nullable != original.is_nullable
|| normalize_default(Some(&column.default_value)) != original_default(column)
|| clean(&column.comment) != original_comment(column)
|| auto_increment_changed;
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote_ident(StructureDialect::Sqlite, &original.name),
quote_ident(StructureDialect::Sqlite, &column.name)
));
}
if unsupported_change {
warnings.push(format!(
"SQLite cannot safely alter existing column \"{}\" without rebuilding the table.",
original.name
));
}
statements
}
pub(super) fn build_questdb_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
let Some(original) = &column.original else {
return Vec::new();
};
let mut statements = Vec::new();
let current_name = &column.name;
if column.name != original.name {
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote_ident(StructureDialect::Questdb, &original.name),
quote_ident(StructureDialect::Questdb, &column.name)
));
}
if column.data_type.trim() != original.data_type.trim() {
statements.push(format!(
"ALTER TABLE {table} ALTER COLUMN {} TYPE {};",
quote_ident(StructureDialect::Questdb, current_name),
column_data_type(StructureDialect::Questdb, column)
));
}
statements
}
pub(super) fn has_existing_column_attribute_change(column: &EditableStructureColumn) -> bool {
let Some(original) = &column.original else {
return false;
};
column.name != original.name
|| column.data_type.trim() != original.data_type.trim()
|| column.is_nullable != original.is_nullable
|| normalize_default(Some(&column.default_value)) != original_default(column)
|| clean(&column.comment) != original_comment(column)
|| (is_mysql_character_data_type(&column.data_type)
&& (column.character_set.trim() != original.character_set.as_deref().unwrap_or("")
|| column.collation.trim() != original.collation.as_deref().unwrap_or("")))
}
Reference in new issue View Git Blame Copy Permalink