Skip to content

armgit / dbx

Public Imported from GitHub
0

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

12.2 KB
Raw Blame
//! CREATE-only extension points. Existing ALTER dialects and wire options stay unchanged.
use super::create_options::{CreateTableDialectOptions, StarRocksCreateOptions, StarRocksDistribution};
use super::dialect::StructureDialect;
use super::types::{EditableStructureColumn, TableStructureSqlOptions};
use super::util::{clean, quote_ident, quote_string};
use crate::models::connection::DatabaseType;

pub(super) trait CreateTableDialect {
    fn validate(
        &self,
        _options: &TableStructureSqlOptions,
        _columns: &[&EditableStructureColumn],
        _warnings: &mut Vec<String>,
    ) {
    }
    fn primary_key_columns_first(&self) -> bool {
        false
    }
    fn supports_column_charset(&self) -> bool {
        true
    }
    fn primary_key_in_column_list(&self) -> bool {
        true
    }
    fn explicit_primary_key_not_null(&self) -> bool {
        false
    }
    fn handles_table_comment(&self) -> bool {
        false
    }
    fn after_columns(&self, _options: &TableStructureSqlOptions, _primary_key: &str) -> String {
        String::new()
    }
    fn partition_clause(&self, _columns: &[&EditableStructureColumn]) -> String {
        String::new()
    }
    fn sort_clause(&self, _columns: &[&EditableStructureColumn]) -> String {
        String::new()
    }
    fn after_partition(&self, _columns: &[&EditableStructureColumn], _primary_key: &str) -> String {
        String::new()
    }
}

struct GenericCreateTable {
    unexpected_starrocks_options: bool,
}
impl CreateTableDialect for GenericCreateTable {
    fn validate(
        &self,
        _options: &TableStructureSqlOptions,
        _columns: &[&EditableStructureColumn],
        warnings: &mut Vec<String>,
    ) {
        if self.unexpected_starrocks_options {
            warnings.push("StarRocks physical options require a StarRocks connection.".into());
        }
    }
}

pub(super) fn create_table_dialect(
    options: &TableStructureSqlOptions,
    server_version: Option<&str>,
    dialect_options: CreateTableDialectOptions,
) -> Box<dyn CreateTableDialect> {
    if !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(|profile| profile.eq_ignore_ascii_case("starrocks"))))
    {
        Box::new(StarRocksCreateTable {
            version: parse_version(server_version),
            settings: dialect_options.starrocks.unwrap_or_default(),
        })
    } else {
        Box::new(GenericCreateTable { unexpected_starrocks_options: dialect_options.starrocks.is_some() })
    }
}

pub(super) fn parse_version(raw: Option<&str>) -> Option<(u32, u32, u32)> {
    let normalized = raw?.trim().to_ascii_lowercase();
    let raw = normalized.as_str();
    let raw = raw
        .strip_prefix("starrocks version ")
        .or_else(|| raw.strip_prefix("starrocks "))
        .unwrap_or(raw)
        .trim_start_matches('v');
    let version = raw.split(|c: char| !c.is_ascii_digit() && c != '.').next()?;
    let mut parts = version.split('.');
    let result = (parts.next()?.parse().ok()?, parts.next()?.parse().ok()?, parts.next().unwrap_or("0").parse().ok()?);
    // Old cached VERSION() values identify MySQL, not this product.
    (result != (5, 1, 0)).then_some(result)
}

struct StarRocksCreateTable {
    settings: StarRocksCreateOptions,
    version: Option<(u32, u32, u32)>,
}

impl StarRocksCreateTable {
    fn at_least(&self, version: (u32, u32, u32)) -> bool {
        self.version.is_some_and(|current| current >= version)
    }
}

impl CreateTableDialect for StarRocksCreateTable {
    fn validate(
        &self,
        options: &TableStructureSqlOptions,
        columns: &[&EditableStructureColumn],
        warnings: &mut Vec<String>,
    ) {
        let has_primary_key = columns.iter().any(|column| column.is_primary_key);
        if !self.settings.sort_column_ids.is_empty() {
            let minimum = if has_primary_key { (3, 0, 0) } else { (3, 3, 0) };
            if !self.at_least(minimum) {
                warnings.push(format!("StarRocks custom sort columns require a confirmed server version of {}.{} or newer for this table model.", minimum.0, minimum.1));
            }
            let mut seen = std::collections::HashSet::new();
            for id in &self.settings.sort_column_ids {
                if !seen.insert(id) {
                    warnings.push("StarRocks sort columns must be unique.".into());
                }
                match columns.iter().find(|column| &column.id == id) {
                    None => warnings.push("A StarRocks sort column was removed. Select an existing column.".into()),
                    Some(column) if has_primary_key => {
                        let base = column.data_type.split('(').next().unwrap_or("").trim().to_ascii_lowercase();
                        if !matches!(
                            base.as_str(),
                            "boolean"
                                | "tinyint"
                                | "smallint"
                                | "int"
                                | "integer"
                                | "bigint"
                                | "largeint"
                                | "varchar"
                                | "string"
                                | "date"
                                | "datetime"
                        ) {
                            warnings.push(format!("StarRocks primary key table sort column '{}' must use boolean, integer, varchar, date or datetime.", column.name));
                        }
                    }
                    _ => {}
                }
            }
        }
        super::starrocks_partition::validate(&self.settings, columns, self.version, warnings);
        if self.settings.distribution == StarRocksDistribution::Random {
            if has_primary_key {
                warnings.push("StarRocks primary key tables require hash distribution.".into());
            }
            if !self.at_least((3, 1, 0)) {
                warnings
                    .push("StarRocks random distribution requires a confirmed server version of 3.1 or newer.".into());
            }
        }
        if self.settings.distribution == StarRocksDistribution::Hash {
            if self.settings.distribution_column_ids.is_empty() {
                warnings.push("Select at least one StarRocks hash distribution column.".into());
            }
            let mut seen = std::collections::HashSet::new();
            for id in &self.settings.distribution_column_ids {
                if !seen.insert(id) {
                    warnings.push("StarRocks hash distribution columns must be unique.".into());
                }
                match columns.iter().find(|column| &column.id == id) {
                    None => warnings
                        .push("A StarRocks hash distribution column was removed. Select an existing column.".into()),
                    Some(column) => {
                        let base = column.data_type.split('(').next().unwrap_or("").trim().to_ascii_lowercase();
                        if !matches!(
                            base.as_str(),
                            "tinyint"
                                | "smallint"
                                | "int"
                                | "integer"
                                | "bigint"
                                | "largeint"
                                | "date"
                                | "datetime"
                                | "char"
                                | "varchar"
                                | "string"
                        ) {
                            warnings.push(format!(
                                "StarRocks hash distribution column '{}' must use an integer, date or string type.",
                                column.name
                            ));
                        }
                        if has_primary_key && !column.is_primary_key {
                            warnings.push(
                                "StarRocks hash distribution columns must be included in the primary key.".into(),
                            );
                        }
                    }
                }
            }
        } else if !self.settings.distribution_column_ids.is_empty() {
            warnings.push("Explicit distribution columns require hash distribution.".into());
        }
        if self.settings.bucket_count.is_some_and(|count| count == 0 || count > i32::MAX as u32) {
            warnings.push("StarRocks bucket count must be a positive integer no greater than 2147483647.".into());
        }
        if options.mysql_engine.is_some() {
            warnings.push("StarRocks tables do not accept MySQL storage engine options.".to_string());
        }
        if options.foreign_keys.iter().any(|key| !key.marked_for_drop)
            || options.triggers.iter().any(|trigger| !trigger.marked_for_drop)
            || options.indexes.iter().any(|index| !index.marked_for_drop && !index.is_primary)
        {
            warnings.push("StarRocks CREATE TABLE does not support MySQL foreign keys, triggers or secondary index definitions from this editor.".to_string());
        }
        for column in columns {
            if column.extra.as_ref().is_some_and(|extra| extra.on_update_current_timestamp == Some(true)) {
                warnings.push(format!("StarRocks column '{}' does not support MySQL ON UPDATE clauses.", column.name));
            }
        }
    }
    fn primary_key_columns_first(&self) -> bool {
        true
    }
    fn supports_column_charset(&self) -> bool {
        false
    }
    fn primary_key_in_column_list(&self) -> bool {
        false
    }
    fn explicit_primary_key_not_null(&self) -> bool {
        true
    }
    fn handles_table_comment(&self) -> bool {
        true
    }
    fn after_columns(&self, options: &TableStructureSqlOptions, primary_key: &str) -> String {
        let mut suffix = String::new();
        if !primary_key.is_empty() {
            suffix.push_str(&format!(" PRIMARY KEY ({primary_key})"));
        }
        let comment = clean(options.table_comment.as_deref().unwrap_or(""));
        if !comment.is_empty() {
            suffix.push_str(&format!(" COMMENT {}", quote_string(&comment)));
        }
        suffix
    }
    fn partition_clause(&self, columns: &[&EditableStructureColumn]) -> String {
        super::starrocks_partition::render(&self.settings, columns)
    }
    fn sort_clause(&self, columns: &[&EditableStructureColumn]) -> String {
        if self.settings.sort_column_ids.is_empty() {
            return String::new();
        }
        let keys = self
            .settings
            .sort_column_ids
            .iter()
            .filter_map(|id| columns.iter().find(|column| &column.id == id))
            .map(|column| quote_ident(StructureDialect::Mysql, &column.name))
            .collect::<Vec<_>>()
            .join(", ");
        format!(" ORDER BY ({keys})")
    }
    fn after_partition(&self, columns: &[&EditableStructureColumn], primary_key: &str) -> String {
        let distribution = if self.settings.distribution == StarRocksDistribution::Hash {
            let keys = self
                .settings
                .distribution_column_ids
                .iter()
                .filter_map(|id| columns.iter().find(|column| &column.id == id))
                .map(|column| quote_ident(StructureDialect::Mysql, &column.name))
                .collect::<Vec<_>>()
                .join(", ");
            format!(" DISTRIBUTED BY HASH ({keys})")
        } else if self.settings.distribution == StarRocksDistribution::Random {
            " DISTRIBUTED BY RANDOM".into()
        } else if !primary_key.is_empty() {
            format!(" DISTRIBUTED BY HASH ({primary_key})")
        } else if self.at_least((3, 1, 0)) {
            " DISTRIBUTED BY RANDOM".to_string()
        } else {
            format!(" DISTRIBUTED BY HASH ({})", quote_ident(StructureDialect::Mysql, &columns[0].name))
        };
        // Automatic bucket counts are supported from 2.5.7 onward.
        if let Some(count) = self.settings.bucket_count {
            format!("{distribution} BUCKETS {count}")
        } else if self.at_least((2, 5, 7)) {
            distribution
        } else {
            format!("{distribution} BUCKETS 10")
        }
    }
}