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。

9.8 KB
Raw Blame
//! Structured StarRocks partitions: values are quoted data, never user-supplied SQL.
use super::create_options::*;
use super::dialect::StructureDialect;
use super::types::EditableStructureColumn;
use super::util::{quote_ident, quote_string};
use std::collections::HashSet;

fn ident(value: &str) -> String {
    quote_ident(StructureDialect::Mysql, value)
}
fn literal(value: &str) -> String {
    quote_string(&value.replace('\\', "\\\\"))
}
fn tuple(values: &[String]) -> String {
    values.iter().map(|value| literal(value)).collect::<Vec<_>>().join(", ")
}
fn base(column: &EditableStructureColumn) -> String {
    column.data_type.split('(').next().unwrap_or("").trim().to_ascii_lowercase()
}
fn integer(data_type: &str) -> bool {
    matches!(data_type, "tinyint" | "smallint" | "int" | "integer" | "bigint" | "largeint")
}
fn range_type(data_type: &str) -> bool {
    integer(data_type) || matches!(data_type, "date" | "datetime")
}
fn value_type(data_type: &str) -> bool {
    range_type(data_type) || matches!(data_type, "boolean" | "char" | "varchar" | "string")
}

fn validate_columns<'a>(
    ids: &[String],
    columns: &[&'a EditableStructureColumn],
    range: bool,
    warnings: &mut Vec<String>,
) -> Vec<&'a EditableStructureColumn> {
    let mut seen = HashSet::new();
    let has_pk = columns.iter().any(|column| column.is_primary_key);
    let mut selected = Vec::new();
    if ids.is_empty() {
        warnings.push("Select at least one StarRocks partition column.".into());
    }
    for id in ids {
        if !seen.insert(id) {
            warnings.push("Partition columns must not repeat.".into());
        }
        match columns.iter().find(|column| &column.id == id) {
            None => warnings.push("A partition column was removed. Select an existing column.".into()),
            Some(column) => {
                if if range { !range_type(&base(column)) } else { !value_type(&base(column)) } {
                    warnings
                        .push(format!("Column '{}' has an unsupported type for this partition strategy.", column.name));
                }
                if has_pk && !column.is_primary_key {
                    warnings.push("StarRocks partition columns must be included in the primary key. Review uniqueness before changing the primary key.".into());
                }
                selected.push(*column);
            }
        }
    }
    selected
}

fn validate_values(values: &[String], columns: &[&EditableStructureColumn], warnings: &mut Vec<String>) {
    if values.len() != columns.len() {
        warnings.push("Each partition value tuple must contain one value for each selected column.".into());
        return;
    }
    for (value, column) in values.iter().zip(columns) {
        let data_type = base(column);
        let valid = if integer(&data_type) {
            value.parse::<i128>().is_ok()
        } else if data_type == "boolean" {
            matches!(value.to_ascii_lowercase().as_str(), "true" | "false" | "0" | "1")
        } else if matches!(data_type.as_str(), "date" | "datetime") {
            !value.trim().is_empty()
        } else {
            !value.contains('\0')
        };
        if !valid {
            warnings.push(format!(
                "Invalid partition value for column '{}'. Enter a {} value without SQL quotes.",
                column.name, data_type
            ));
        }
    }
}

pub(super) fn validate(
    settings: &StarRocksCreateOptions,
    columns: &[&EditableStructureColumn],
    version: Option<(u32, u32, u32)>,
    warnings: &mut Vec<String>,
) {
    let at_least = |minimum| version.is_some_and(|value| value >= minimum);
    if settings.time_partition.is_some() && settings.partition.is_some() {
        warnings.push("Choose only one StarRocks partition strategy.".into());
    }
    if let Some(time) = &settings.time_partition {
        if !at_least((3, 1, 0)) {
            warnings.push("Time partitioning requires a confirmed server version of 3.1 or newer. Reconnect to refresh the version.".into());
        }
        let mut ids = vec![time.column_id.clone()];
        ids.extend(time.additional_column_ids.clone());
        let selected = validate_columns(&ids, columns, false, warnings);
        if let Some(column) = selected.first() {
            let data_type = base(column);
            if !matches!(data_type.as_str(), "date" | "datetime") {
                warnings.push("Time partition columns must use date or datetime.".into());
            }
            if (time.interval.is_some() || matches!(time.granularity, StarRocksTimeGranularity::Hour))
                && data_type != "datetime"
            {
                warnings.push("Hourly partitions and time_slice require a datetime column.".into());
            }
        }
        if time.interval.is_some_and(|interval| interval == 0 || interval > i32::MAX as u32) {
            warnings.push("Time partition interval must be a positive integer.".into());
        }
        if !time.additional_column_ids.is_empty() && !at_least((3, 4, 0)) {
            warnings.push("Mixed time and dimension partitions require StarRocks 3.4 or newer.".into());
        }
    }
    let Some(partition) = &settings.partition else {
        return;
    };
    let (ids, range) = match partition {
        StarRocksPartitionOptions::Values { column_ids } => (column_ids, false),
        StarRocksPartitionOptions::Range { column_ids, .. } => (column_ids, true),
        StarRocksPartitionOptions::List { column_ids, .. } => (column_ids, false),
    };
    if !range && !at_least((3, 1, 1)) {
        warnings.push("List and automatic value partitions require a confirmed StarRocks version of 3.1.1 or newer in this editor.".into());
    }
    let selected = validate_columns(ids, columns, range, warnings);
    let mut names = HashSet::new();
    let mut check_name = |name: &str, warnings: &mut Vec<String>| {
        if name.trim().is_empty() || name.contains('\0') || !names.insert(name.to_ascii_lowercase()) {
            warnings.push("Partition names must be non-empty and unique.".into());
        }
    };
    match partition {
        StarRocksPartitionOptions::Values { .. } => {}
        StarRocksPartitionOptions::Range { partitions, .. } => {
            if partitions.is_empty() {
                warnings.push("Add at least one range partition.".into());
            }
            for partition in partitions {
                check_name(&partition.name, warnings);
                validate_values(&partition.lower, &selected, warnings);
                validate_values(&partition.upper, &selected, warnings);
                if partition.lower == partition.upper {
                    warnings.push("A range partition's lower and upper bounds must differ.".into());
                }
            }
        }
        StarRocksPartitionOptions::List { partitions, .. } => {
            if partitions.is_empty() {
                warnings.push("Add at least one list partition.".into());
            }
            let mut tuples = HashSet::new();
            for partition in partitions {
                check_name(&partition.name, warnings);
                if partition.values.is_empty() {
                    warnings.push("Each list partition needs at least one value tuple.".into());
                }
                for values in &partition.values {
                    validate_values(values, &selected, warnings);
                    if !tuples.insert(values) {
                        warnings.push("List partition value tuples must not overlap or repeat.".into());
                    }
                }
            }
        }
    }
}

pub(super) fn render(settings: &StarRocksCreateOptions, columns: &[&EditableStructureColumn]) -> String {
    let name = |id: &String| {
        columns.iter().find(|column| &column.id == id).map(|column| ident(&column.name)).unwrap_or_default()
    };
    let names = |ids: &[String]| ids.iter().map(name).collect::<Vec<_>>().join(", ");
    if let Some(time) = &settings.time_partition {
        let expression = match time.interval {
            Some(interval) => {
                format!("time_slice({}, INTERVAL {interval} {})", name(&time.column_id), time.granularity.sql())
            }
            None => format!("date_trunc('{}', {})", time.granularity.sql(), name(&time.column_id)),
        };
        let extra = if time.additional_column_ids.is_empty() {
            String::new()
        } else {
            format!(", {}", names(&time.additional_column_ids))
        };
        return format!(" PARTITION BY {expression}{extra}");
    }
    match &settings.partition {
        None => String::new(),
        Some(StarRocksPartitionOptions::Values { column_ids }) => format!(" PARTITION BY ({})", names(column_ids)),
        Some(StarRocksPartitionOptions::Range { column_ids, partitions }) => {
            let definitions = partitions
                .iter()
                .map(|p| format!("PARTITION {} VALUES [({}), ({}))", ident(&p.name), tuple(&p.lower), tuple(&p.upper)))
                .collect::<Vec<_>>()
                .join(",\n  ");
            format!(" PARTITION BY RANGE ({}) (\n  {definitions}\n)", names(column_ids))
        }
        Some(StarRocksPartitionOptions::List { column_ids, partitions }) => {
            let definitions = partitions
                .iter()
                .map(|p| {
                    let values = p
                        .values
                        .iter()
                        .map(
                            |values| if column_ids.len() == 1 { tuple(values) } else { format!("({})", tuple(values)) },
                        )
                        .collect::<Vec<_>>()
                        .join(", ");
                    format!("PARTITION {} VALUES IN ({values})", ident(&p.name))
                })
                .collect::<Vec<_>>()
                .join(",\n  ");
            format!(" PARTITION BY LIST ({}) (\n  {definitions}\n)", names(column_ids))
        }
    }
}