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
//! Product-specific ALTER strategies, independent of wire-compatible CREATE dialects.
use super::{
dialect::StructureDialect,
types::*,
util::{
clean, format_default_for_sql, normalize_default, original_comment, original_default, qualified_table,
quote_ident, quote_string,
},
};
use crate::models::connection::DatabaseType;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StarRocksAlterOptions {
pub server_version: Option<String>,
pub model: Option<String>,
#[serde(default)]
pub column_names: Vec<String>,
#[serde(default)]
pub reorder_columns: bool,
#[serde(default)]
pub position_column_order: bool,
pub sort_columns: Option<Vec<String>>,
pub sort_column_names: Option<Vec<String>>,
#[serde(default)]
pub key_columns: Vec<String>,
#[serde(default)]
pub partition_columns: Vec<String>,
#[serde(default)]
pub partition_expression_columns: Vec<String>,
#[serde(default)]
pub distribution_columns: Vec<String>,
pub distribution: Option<super::starrocks_layout::StarRocksDistributionChange>,
pub partition_kind: Option<String>,
#[serde(default)]
pub colocated: bool,
#[serde(default)]
pub automatic_bucket_scaling: bool,
pub layout: Option<super::starrocks_layout::StarRocksLayoutChanges>,
}
pub(super) fn is_starrocks(options: &TableStructureSqlOptions) -> bool {
!options.is_gaussdb_m_mode
&& (options.database_type == Some(DatabaseType::StarRocks)
|| (options.database_type == Some(DatabaseType::Mysql)
&& options.driver_profile.as_deref().is_some_and(|value| value.eq_ignore_ascii_case("starrocks"))))
}
trait AlterTableDialect {
fn build(&self, options: &TableStructureSqlOptions) -> TableStructureSqlResult;
}
pub(super) fn build(
options: &TableStructureSqlOptions,
context: Option<StarRocksAlterOptions>,
) -> TableStructureSqlResult {
StarRocksAlter(context.unwrap_or_default()).build(options)
}
struct StarRocksAlter(StarRocksAlterOptions);
impl AlterTableDialect for StarRocksAlter {
fn build(&self, options: &TableStructureSqlOptions) -> TableStructureSqlResult {
let mut warnings = super::validation::validate_draft(options);
let mut statements = Vec::new();
let mut changes = Vec::new();
let table = qualified_table(StructureDialect::Mysql, options.schema.as_deref(), &options.table_name);
let quote = |name: &str| quote_ident(StructureDialect::Mysql, name);
let version = super::create_dialect::parse_version(self.0.server_version.as_deref());
let at_least = |minimum| version.is_some_and(|current| current >= minimum);
let supported_model = matches!(self.0.model.as_deref(), Some("primary" | "duplicate"));
let contains = |names: &[String], name: &str| names.iter().any(|value| value.eq_ignore_ascii_case(name));
let locked = |column: &EditableStructureColumn| {
column.original.as_ref().is_some_and(|original| {
!supported_model
|| contains(&self.0.partition_columns, &original.name)
|| contains(&self.0.distribution_columns, &original.name)
|| (self.0.model.as_deref() == Some("primary") && contains(&self.0.key_columns, &original.name))
|| original.extra.as_deref().is_some_and(|extra| {
let lower = extra.to_ascii_lowercase();
lower.contains("auto_increment") || lower.contains("generated")
})
})
};
// Unchanged catalog indexes/constraints may be present, but cannot be edited through this strategy.
for index in &options.indexes {
if index.original.is_none() || index.marked_for_drop || super::indexes::has_existing_index_change(index) {
warnings.push("StarRocks index definitions cannot be changed from this editor.".into());
}
}
let foreign_sql = super::foreign_keys::build_foreign_key_sql(options, &mut warnings);
let trigger_sql = super::triggers::build_trigger_sql(options, &mut warnings);
if !foreign_sql.is_empty() || !trigger_sql.is_empty() {
warnings.push("StarRocks foreign keys and triggers cannot be changed from this editor.".into());
}
if options.mysql_engine.is_some() {
warnings.push("StarRocks does not support MySQL storage engine settings.".into());
}
for column in &options.columns {
if column.marked_for_drop && column.original.is_none() {
continue;
}
let Some(original) = &column.original else {
if !supported_model {
warnings.push(
"Adding StarRocks columns requires confirmed PRIMARY or DUPLICATE table metadata.".into(),
);
}
if column.is_primary_key
|| column.extra.as_ref().is_some_and(|extra| {
extra.auto_increment == Some(true) || extra.on_update_current_timestamp == Some(true)
})
{
warnings.push("New StarRocks columns cannot change keys or use MySQL extra properties.".into());
}
// CREATE accepts UUID generators, but ADD cannot backfill these varying defaults.
static UUID_DEFAULT: std::sync::LazyLock<regex::Regex> = std::sync::LazyLock::new(|| {
regex::Regex::new(r"(?i)^\s*\(*\s*uuid(?:_numeric)?\s*\(\s*\)\s*\)*\s*$").unwrap()
});
if UUID_DEFAULT.is_match(&column.default_value) {
warnings.push(format!("StarRocks ADD COLUMN '{}' does not support uuid() or uuid_numeric() defaults. Use a literal or NULL; UUID defaults are only available when creating a table.", column.name));
}
changes.push(format!("ADD COLUMN {}", definition(column, false)));
continue;
};
if column.is_primary_key != original.is_primary_key {
warnings.push("StarRocks key membership cannot be changed from this editor.".into());
}
if column.marked_for_drop {
if locked(column) || contains(&self.0.key_columns, &original.name) || original.is_primary_key {
warnings.push(format!("StarRocks key, partition, distribution or protected column '{}' cannot be dropped from this editor.", original.name));
}
changes.push(format!("DROP COLUMN {}", quote(&original.name)));
continue;
}
let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
if default_changed {
warnings.push(format!("StarRocks cannot change the default value of existing column '{}'. Set defaults when creating a table or adding a column.", original.name));
}
let definition_changed = !column.data_type.trim().eq_ignore_ascii_case(original.data_type.trim())
|| column.is_nullable != original.is_nullable
|| default_changed;
let comment_changed = clean(&column.comment) != original_comment(column);
if column.name != original.name {
if !at_least((3, 3, 2)) {
warnings.push("Renaming StarRocks columns requires confirmed version 3.3.2 or newer.".into());
}
if options.columns.iter().any(|other| {
other.id != column.id
&& (other.name.eq_ignore_ascii_case(&column.name)
|| other.original.as_ref().is_some_and(|old| old.name.eq_ignore_ascii_case(&column.name)))
}) {
warnings
.push("Rename StarRocks columns separately when names collide with original columns.".into());
}
if options
.columns
.iter()
.any(|other| other.original.is_none() && other.name.eq_ignore_ascii_case(&original.name))
{
warnings.push("StarRocks does not support reusing a renamed column name.".into());
}
statements.push(format!(
"ALTER TABLE {table} RENAME COLUMN {} TO {};",
quote(&original.name),
quote(&column.name)
));
}
if definition_changed {
if locked(column) {
warnings.push(format!("StarRocks column '{}' requires key/partition/aggregation metadata or is protected from definition changes.", original.name));
}
if original.is_nullable && !column.is_nullable {
warnings.push("StarRocks cannot change a nullable column to NOT NULL.".into());
}
changes.push(format!(
"MODIFY COLUMN {}",
definition(column, contains(&self.0.key_columns, &original.name))
));
}
// Comment-only ALTER is synchronous and must not resubmit a complete definition.
if comment_changed && !definition_changed {
statements.push(format!(
"ALTER TABLE {table} MODIFY COLUMN {} COMMENT {};",
quote(&column.name),
quote_string(&clean(&column.comment))
));
}
if column.extra.as_ref().is_some_and(|extra| {
extra.on_update_current_timestamp == Some(true)
|| (extra.auto_increment == Some(true)
&& !original.extra.as_deref().unwrap_or("").to_ascii_lowercase().contains("auto_increment"))
}) {
warnings.push("StarRocks column extra properties cannot be changed from this editor.".into());
}
}
if clean(options.table_comment.as_deref().unwrap_or(""))
!= clean(options.original_table_comment.as_deref().unwrap_or(""))
{
if !at_least((3, 1, 0)) {
warnings.push("StarRocks table comments require confirmed version 3.1 or newer.".into());
}
statements.push(format!(
"ALTER TABLE {table} COMMENT = {};",
quote_string(&clean(options.table_comment.as_deref().unwrap_or("")))
));
}
build_column_order(options, &self.0, &mut changes, &mut warnings);
if let Some(sort_columns) = &self.0.sort_column_names {
if !statements.is_empty() || !changes.is_empty() || self.0.layout.is_some() {
warnings.push("Save StarRocks sort-key changes separately from other table edits.".into());
}
validate_sort_columns(options, &self.0, sort_columns, &mut warnings);
changes.push(format!(
"ORDER BY ({})",
sort_columns
.iter()
.map(|name| quote_ident(StructureDialect::Mysql, name))
.collect::<Vec<_>>()
.join(", ")
));
}
// Submit one asynchronous schema-change job, after synchronous metadata changes.
if !changes.is_empty() {
statements.push(format!("ALTER TABLE {table} {};", changes.join(", ")));
}
let layout_statements = super::starrocks_layout::build(options, &self.0, &mut warnings);
if !layout_statements.is_empty() && !statements.is_empty() {
warnings.push("Save StarRocks layout operations separately from column and table-comment changes; wait for schema-change completion before the next operation.".into());
}
statements.extend(layout_statements);
if !warnings.is_empty() {
statements.clear();
}
TableStructureSqlResult { statements, warnings }
}
}
fn definition(column: &EditableStructureColumn, key: bool) -> String {
let mut parts = vec![quote_ident(StructureDialect::Mysql, &column.name), column.data_type.trim().to_string()];
if key {
parts.push("KEY".into());
}
parts.push(if column.is_nullable { "NULL" } else { "NOT NULL" }.into());
let default = normalize_default(Some(&column.default_value));
if !default.is_empty() {
let value = if default.starts_with('\'') && default.ends_with('\'') {
default
} else {
format_default_for_sql(StructureDialect::Mysql, &column.data_type, &default)
};
parts.push(format!("DEFAULT {value}"));
}
parts.push(format!("COMMENT {}", quote_string(&clean(&column.comment))));
parts.join(" ")
}
// Position clauses are unambiguous: never use ORDER BY to change column order.
fn build_column_order(
options: &TableStructureSqlOptions,
context: &StarRocksAlterOptions,
changes: &mut Vec<String>,
warnings: &mut Vec<String>,
) {
if context.reorder_columns {
warnings.push("The legacy StarRocks ORDER BY column-reorder path is disabled. Refresh the editor and backend before changing column order.".into());
return;
}
if !context.position_column_order {
return;
}
let existing: Vec<_> =
options.columns.iter().filter(|column| column.original.is_some() && !column.marked_for_drop).collect();
let mut original = existing.clone();
original.sort_by_key(|column| column.original_position.unwrap_or(usize::MAX));
original.extend(options.columns.iter().filter(|column| column.original.is_none() && !column.marked_for_drop));
let desired: Vec<_> = options.columns.iter().filter(|column| !column.marked_for_drop).collect();
if desired.iter().map(|column| &column.id).eq(original.iter().map(|column| &column.id)) {
return;
}
if context.model.as_deref() != Some("duplicate") {
warnings.push(
"Physical column reordering is currently supported only for confirmed StarRocks DUPLICATE tables.".into(),
);
}
if !changes.is_empty() || options.columns.iter().any(|column| column.original.is_none() || column.marked_for_drop) {
warnings.push(
"Save StarRocks column definition changes, additions and deletions separately from column reordering."
.into(),
);
}
let source: std::collections::HashSet<_> = context.column_names.iter().map(|name| name.to_lowercase()).collect();
let supplied: std::collections::HashSet<_> =
existing.iter().map(|column| column.original.as_ref().unwrap().name.to_lowercase()).collect();
let positions: std::collections::HashSet<_> =
existing.iter().filter_map(|column| column.original_position).collect();
if source.is_empty()
|| source.len() != context.column_names.len()
|| source != supplied
|| existing.len() != source.len()
|| positions.len() != existing.len()
{
warnings.push("StarRocks reordering requires all existing columns and their original positions; refresh table metadata first.".into());
}
let is_key = |column: &EditableStructureColumn| {
context.key_columns.iter().any(|key| key.eq_ignore_ascii_case(&column.original.as_ref().unwrap().name))
};
let mut saw_value = false;
for column in &existing {
if is_key(column) {
if saw_value {
warnings.push("StarRocks key columns must precede all value columns; key columns may be reordered among themselves.".into());
break;
}
} else {
saw_value = true;
}
}
let protected = |column: &EditableStructureColumn| {
let name = &column.original.as_ref().unwrap().name;
// Move other columns around expression sources: even a position-only MODIFY
// can be rejected when the source backs a hidden generated partition column.
context.partition_expression_columns.iter().any(|source| source.eq_ignore_ascii_case(name))
|| (!is_key(column)
&& context
.partition_columns
.iter()
.chain(&context.distribution_columns)
.any(|key| key.eq_ignore_ascii_case(name)))
|| column.original.as_ref().unwrap().extra.as_deref().is_some_and(|extra| {
let lower = extra.to_lowercase();
lower.contains("generated") || lower.contains("auto_increment")
})
};
if !original
.iter()
.filter(|column| column.original.is_some())
.filter(|column| protected(column))
.map(|column| &column.id)
.eq(existing.iter().filter(|column| protected(column)).map(|column| &column.id))
{
warnings.push("Keep StarRocks partition-expression source columns, non-key partition/distribution columns and generated/auto-increment columns in their original relative order.".into());
}
if !warnings.is_empty() {
return;
}
let mut simulated: Vec<_> = original.iter().map(|column| column.id.clone()).collect();
for (index, column) in existing.iter().enumerate() {
if protected(column) {
continue;
}
let position = simulated.iter().position(|id| id == &column.id).unwrap();
let predecessor = index.checked_sub(1).map(|previous| &existing[previous].id);
let current_predecessor = position.checked_sub(1).map(|previous| &simulated[previous]);
if current_predecessor == predecessor {
continue;
}
let placement = if index == 0 {
"FIRST".into()
} else {
format!("AFTER {}", quote_ident(StructureDialect::Mysql, &existing[index - 1].name))
};
changes.push(format!("MODIFY COLUMN {} {placement}", definition(column, is_key(column))));
simulated.remove(position);
let insert = predecessor.map(|id| simulated.iter().position(|value| value == id).unwrap() + 1).unwrap_or(0);
simulated.insert(insert, column.id.clone());
}
if !simulated.iter().eq(existing.iter().map(|column| &column.id)) {
warnings.push("This field order would require modifying a protected StarRocks column.".into());
}
}
fn validate_sort_columns(
options: &TableStructureSqlOptions,
context: &StarRocksAlterOptions,
names: &[String],
warnings: &mut Vec<String>,
) {
let version = super::create_dialect::parse_version(context.server_version.as_deref());
let primary = context.model.as_deref() == Some("primary");
if !matches!(context.model.as_deref(), Some("primary" | "duplicate" | "aggregate" | "unique"))
|| version.is_none_or(|version| version < if primary { (3, 0, 0) } else { (3, 3, 0) })
{
warnings.push("Changing StarRocks sort keys requires confirmed table metadata and version 3.0+ for PRIMARY or 3.3+ for other models.".into());
}
if names.is_empty() {
warnings.push("Select at least one StarRocks sort column.".into());
}
let selected: std::collections::HashSet<_> = names.iter().map(|name| name.to_lowercase()).collect();
let source: std::collections::HashSet<_> = context.column_names.iter().map(|name| name.to_lowercase()).collect();
if selected.len() != names.len() {
warnings.push("StarRocks sort columns must not repeat.".into());
}
if source.is_empty() || !selected.is_subset(&source) {
warnings.push("A sort column is missing. Refresh table metadata first.".into());
}
if selected == source {
warnings.push("Selecting every column is ambiguous with StarRocks schema reordering. Choose fewer columns for a sort-key change.".into());
}
if matches!(context.model.as_deref(), Some("aggregate" | "unique")) {
let keys: std::collections::HashSet<_> = context.key_columns.iter().map(|name| name.to_lowercase()).collect();
if selected != keys {
warnings.push("StarRocks AGGREGATE and UNIQUE sort keys must contain exactly all key columns.".into());
}
}
for name in names {
let Some(column) = options
.columns
.iter()
.find(|column| column.name == *name && column.original.is_some() && !column.marked_for_drop)
else {
warnings.push(format!("Sort column '{name}' is missing or newly added. Save column changes first."));
continue;
};
let base = column.data_type.split('(').next().unwrap_or("").trim().to_lowercase();
let valid = if primary {
matches!(
base.as_str(),
"boolean"
| "tinyint"
| "smallint"
| "int"
| "integer"
| "bigint"
| "largeint"
| "varchar"
| "string"
| "date"
| "datetime"
)
} else {
matches!(
base.as_str(),
"boolean"
| "tinyint"
| "smallint"
| "int"
| "integer"
| "bigint"
| "largeint"
| "float"
| "double"
| "decimal"
| "decimalv2"
| "decimal32"
| "decimal64"
| "decimal128"
| "decimal256"
| "char"
| "varchar"
| "string"
| "date"
| "datetime"
)
};
if !valid {
warnings.push(format!("Column '{name}' has an unsupported StarRocks sort-key type."));
}
}
}