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.3 KB
Raw Blame
use dbx_core::models::connection::DatabaseType;
use dbx_core::schema_diff::TableSchemaDetail;
use dbx_core::schema_diff::{prepare_schema_diff, SchemaDiffPreparationOptions, SchemaDiffTableMapping};
use dbx_core::types::{ColumnInfo, ForeignKeyInfo, IndexInfo, TableInfo};

fn table(name: &str) -> TableInfo {
    TableInfo {
        name: name.to_string(),
        table_type: "BASE TABLE".to_string(),
        valid: None,
        comment: None,
        parent_schema: None,
        parent_name: None,
    }
}

fn column(name: &str, data_type: &str) -> ColumnInfo {
    ColumnInfo { name: name.to_string(), data_type: data_type.to_string(), ..Default::default() }
}

fn index(name: &str, columns: &[&str]) -> IndexInfo {
    IndexInfo {
        owner: None,
        key_directions: Vec::new(),
        visibility: None,
        key_metadata_complete: false,
        name: name.to_string(),
        columns: columns.iter().map(|column| (*column).to_string()).collect(),
        is_unique: false,
        is_primary: false,
        filter: None,
        index_type: None,
        included_columns: None,
        comment: None,
        key_is_expression: Vec::new(),
        column_opclasses: Vec::new(),
        key_options: Vec::new(),
        constraint_backed: false,
    }
}

fn foreign_key(name: &str, column: &str, ref_table: &str, ref_column: &str) -> ForeignKeyInfo {
    ForeignKeyInfo {
        name: name.to_string(),
        column: column.to_string(),
        ref_schema: None,
        ref_table: ref_table.to_string(),
        ref_column: ref_column.to_string(),
        on_update: None,
        on_delete: None,
    }
}

fn detail(
    name: &str,
    columns: Vec<ColumnInfo>,
    indexes: Vec<IndexInfo>,
    foreign_keys: Vec<ForeignKeyInfo>,
) -> TableSchemaDetail {
    TableSchemaDetail { name: name.to_string(), columns, indexes, foreign_keys, triggers: Vec::new(), ddl: None }
}

fn options(
    source_tables: Vec<TableInfo>,
    target_tables: Vec<TableInfo>,
    source_details: Vec<TableSchemaDetail>,
    target_details: Vec<TableSchemaDetail>,
) -> SchemaDiffPreparationOptions {
    SchemaDiffPreparationOptions {
        source_tables,
        target_tables,
        source_details,
        target_details,
        database_type: DatabaseType::Postgres,
        ..Default::default()
    }
}

#[test]
fn keeps_case_sensitive_matching_by_default() {
    let result = prepare_schema_diff(options(
        vec![table("USER")],
        vec![table("user")],
        vec![detail("USER", vec![column("ID", "int")], Vec::new(), Vec::new())],
        vec![detail("user", vec![column("id", "int")], Vec::new(), Vec::new())],
    ));

    assert_eq!(result.diffs.len(), 2);
    assert!(result.diffs.iter().any(|diff| diff.diff_type == "added" && diff.name == "USER"));
    assert!(result.diffs.iter().any(|diff| diff.diff_type == "removed" && diff.name == "user"));
}

#[test]
fn matches_table_column_index_and_foreign_key_references_case_insensitively() {
    let mut options = options(
        vec![table("USER_INFO"), table("USER_ACCESS")],
        vec![table("user_info"), table("user_access")],
        vec![
            detail("USER_INFO", vec![column("ID", "int")], Vec::new(), Vec::new()),
            detail(
                "USER_ACCESS",
                vec![column("USER_ID", "int")],
                vec![index("idx_user_id", &["USER_ID"])],
                vec![foreign_key("fk_user_info", "USER_ID", "USER_INFO", "ID")],
            ),
        ],
        vec![
            detail("user_info", vec![column("id", "int")], Vec::new(), Vec::new()),
            detail(
                "user_access",
                vec![column("user_id", "int")],
                vec![index("idx_user_id", &["user_id"])],
                vec![foreign_key("fk_user_info", "user_id", "user_info", "id")],
            ),
        ],
    );
    options.ignore_table_name_case = true;
    options.ignore_column_name_case = true;

    let result = prepare_schema_diff(options);

    assert!(
        result.diffs.is_empty(),
        "case-only table, column, index, and foreign-key references should not diff: {result:?}"
    );
}

#[test]
fn keeps_table_and_column_case_options_independent() {
    let base = || {
        options(
            vec![table("USER")],
            vec![table("user")],
            vec![detail("USER", vec![column("ID", "int")], Vec::new(), Vec::new())],
            vec![detail("user", vec![column("id", "int")], Vec::new(), Vec::new())],
        )
    };

    let mut table_only = base();
    table_only.ignore_table_name_case = true;
    let table_only_result = prepare_schema_diff(table_only);
    assert_eq!(table_only_result.diffs.len(), 1);
    assert_eq!(table_only_result.diffs[0].diff_type, "modified");
    assert_eq!(table_only_result.diffs[0].columns.as_ref().unwrap().len(), 2);

    let mut column_only = base();
    column_only.ignore_column_name_case = true;
    let column_only_result = prepare_schema_diff(column_only);
    assert_eq!(column_only_result.diffs.len(), 2);
    assert!(column_only_result.diffs.iter().all(|diff| diff.diff_type == "added" || diff.diff_type == "removed"));
}

#[test]
fn ignores_case_when_comparing_column_order() {
    let mut options = options(
        vec![table("orders")],
        vec![table("orders")],
        vec![detail("orders", vec![column("ID", "int"), column("NAME", "text")], Vec::new(), Vec::new())],
        vec![detail("orders", vec![column("id", "int"), column("name", "text")], Vec::new(), Vec::new())],
    );
    options.ignore_column_name_case = true;
    options.compare_column_order = true;

    assert!(prepare_schema_diff(options).diffs.is_empty());
}

#[test]
fn explicit_table_mappings_take_precedence_over_case_insensitive_matching() {
    let mut options = options(
        vec![table("source_a")],
        vec![table("SOURCE_A"), table("target_b")],
        vec![detail("source_a", vec![column("id", "int")], Vec::new(), Vec::new())],
        vec![
            detail("SOURCE_A", vec![column("id", "int")], Vec::new(), Vec::new()),
            detail("target_b", vec![column("id", "int")], Vec::new(), Vec::new()),
        ],
    );
    options.ignore_table_name_case = true;
    options.table_mappings =
        vec![SchemaDiffTableMapping { source_table: "source_a".to_string(), target_table: "target_b".to_string() }];

    let result = prepare_schema_diff(options);

    assert_eq!(result.diffs.len(), 1);
    assert_eq!(result.diffs[0].diff_type, "removed");
    assert_eq!(result.diffs[0].name, "SOURCE_A");
}

#[test]
fn exact_table_matches_take_precedence_over_case_insensitive_candidates() {
    let mut options = options(
        vec![table("foo"), table("FOO")],
        vec![table("FOO")],
        vec![detail("foo", Vec::new(), Vec::new(), Vec::new()), detail("FOO", Vec::new(), Vec::new(), Vec::new())],
        vec![detail("FOO", Vec::new(), Vec::new(), Vec::new())],
    );
    options.ignore_table_name_case = true;

    let result = prepare_schema_diff(options);

    assert_eq!(result.diffs.len(), 1);
    assert_eq!(result.diffs[0].diff_type, "added");
    assert_eq!(result.diffs[0].name, "foo");
}

#[test]
fn does_not_match_ambiguous_case_insensitive_table_candidates() {
    let mut options = options(
        vec![table("uSeR")],
        vec![table("User"), table("USER")],
        vec![detail("uSeR", Vec::new(), Vec::new(), Vec::new())],
        vec![detail("User", Vec::new(), Vec::new(), Vec::new()), detail("USER", Vec::new(), Vec::new(), Vec::new())],
    );
    options.ignore_table_name_case = true;

    let result = prepare_schema_diff(options);

    assert_eq!(result.diffs.len(), 3);
    assert!(result.diffs.iter().any(|diff| diff.diff_type == "added" && diff.name == "uSeR"));
    assert_eq!(result.diffs.iter().filter(|diff| diff.diff_type == "removed").count(), 2);
}

#[test]
fn case_only_matches_do_not_trigger_table_or_column_rename_detection() {
    let mut options = options(
        vec![table("User")],
        vec![table("user")],
        vec![detail("User", vec![column("ID", "int")], Vec::new(), Vec::new())],
        vec![detail("user", vec![column("id", "int")], Vec::new(), Vec::new())],
    );
    options.ignore_table_name_case = true;
    options.ignore_column_name_case = true;
    options.detect_renames = true;
    options.detect_table_renames = true;

    let result = prepare_schema_diff(options);

    assert!(result.diffs.is_empty());
    assert!(result.rename_candidates.is_empty());
}

#[test]
fn preserves_original_identifiers_in_case_insensitive_matches() {
    let mut options = options(
        vec![table("USER_INFO")],
        vec![table("user_info")],
        vec![detail("USER_INFO", vec![column("ID", "bigint")], Vec::new(), Vec::new())],
        vec![detail("user_info", vec![column("id", "int")], Vec::new(), Vec::new())],
    );
    options.ignore_table_name_case = true;
    options.ignore_column_name_case = true;

    let result = prepare_schema_diff(options);
    let table_diff = &result.diffs[0];
    let column_diff = &table_diff.columns.as_ref().unwrap()[0];

    assert_eq!(table_diff.name, "USER_INFO");
    assert_eq!(table_diff.target_name.as_deref(), Some("user_info"));
    assert_eq!(column_diff.name, "ID");
    assert_eq!(column_diff.source.as_ref().unwrap().name, "ID");
    assert_eq!(column_diff.target.as_ref().unwrap().name, "id");
    assert!(result.sync_sql.contains("ALTER COLUMN \"id\" TYPE bigint"));
    assert!(!result.sync_sql.contains("ALTER COLUMN \"ID\" TYPE bigint"));
}