diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue index 1d183976ee..244c0ab754 100644 --- a/apps/desktop/src/components/grid/DataGrid.vue +++ b/apps/desktop/src/components/grid/DataGrid.vue @@ -87,7 +87,7 @@ import type { BuildSingleColumnAlterSqlOptions } from "@/lib/tableStructureEdito import { buildTableSelectSql, quoteTableIdentifier } from "@/lib/tableSelectSql"; import { uuid } from "@/lib/utils"; import { resolveHeaderColumnType } from "@/lib/dataGridColumnType"; -import { canEditExistingTableRows, canUseKeylessRowPredicate, hiveTablePropertiesIndicateTransactional, isHiddenGridColumn, isTdengineExistingRowReadonlyColumn, usesSyntheticRowIdKey } from "@/lib/tableEditing"; +import { canEditExistingTableRows, canUseKeylessRowPredicate, hiveTablePropertiesIndicateTransactional, isClickHouseExistingRowReadonlyColumn, isHiddenGridColumn, isTdengineExistingRowReadonlyColumn, usesSyntheticRowIdKey } from "@/lib/tableEditing"; import { buildDataGridContextFilterCondition, buildDataGridCountSql, buildHiveTablePropertiesSql, type DataGridContextFilterMode } from "@/lib/dataGridSql"; import { buildVisibleTransposeRows, @@ -2784,6 +2784,8 @@ function canEditCellItem(item: RowItem | undefined, columnIndex: number): boolea if (!canEditRowItem(item) || !canEditColumn(columnIndex)) return false; if (!item?.isNew) { const column = props.result.columns[columnIndex] ?? ""; + const sourceColumn = props.sourceColumns?.[columnIndex] ?? column; + if (isClickHouseExistingRowReadonlyColumn(props.databaseType, sourceColumn, props.tableMeta?.primaryKeys ?? [], props.tableMeta?.columns ?? [])) return false; if (isTdengineExistingRowReadonlyColumn(props.databaseType, column, props.tableMeta?.columns ?? [])) return false; } return true; diff --git a/apps/desktop/src/composables/useDataGridEditor.ts b/apps/desktop/src/composables/useDataGridEditor.ts index fe29965060..2fe2fe4c34 100644 --- a/apps/desktop/src/composables/useDataGridEditor.ts +++ b/apps/desktop/src/composables/useDataGridEditor.ts @@ -9,6 +9,7 @@ import { useConnectionStore } from "@/stores/connectionStore"; import { useHistoryStore } from "@/stores/historyStore"; import type { ColumnInfo, DatabaseType } from "@/types/database"; import { DBX_NEO4J_ELEMENT_ID_COLUMN, DBX_ROWID_COLUMN } from "@/lib/tableEditing"; +import { effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect"; interface RowItem { id: number; @@ -174,6 +175,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { const deletedRowCount = computed(() => deletedRows.value.size); const pendingChangeCount = computed(() => dirtyRowCount.value + newRowCount.value + deletedRowCount.value); const hasPendingChanges = computed(() => pendingChangeCount.value > 0); + const resolvedDatabaseType = computed(() => databaseType.value ?? effectiveDatabaseTypeForConnection(connectionStore.getConfig(connectionId.value ?? ""))); // --- Transaction state --- const transactionActive = ref(false); @@ -181,7 +183,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { const saveError = ref(""); const hasBackendSaveTarget = computed(() => !!connectionId.value && !!tableMeta.value); - const useTransaction = computed(() => editable.value && supportsDataGridTransaction(databaseType.value) && (!!customSaveHandler?.value || hasBackendSaveTarget.value)); + const useTransaction = computed(() => editable.value && supportsDataGridTransaction(resolvedDatabaseType.value) && (!!customSaveHandler?.value || hasBackendSaveTarget.value)); if (hasPendingChanges.value && useTransaction.value) { transactionActive.value = true; @@ -360,7 +362,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { return coerceDataGridCellValue({ value, oldValue, - databaseType: databaseType.value, + databaseType: resolvedDatabaseType.value, columnInfo: tableColumnForGridColumn(columnIndex), }) as CellValue; } @@ -396,7 +398,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { const val = item?.data[colIdx] ?? null; editValue.value = dataGridCellEditorText({ value: val, - databaseType: databaseType.value, + databaseType: resolvedDatabaseType.value, columnInfo: tableColumnForGridColumn(colIdx), }); focusEditInput(); @@ -544,8 +546,8 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { } function shouldClearClonedColumn(columnName: string, columnInfo: ColumnInfo | undefined): boolean { - if (databaseType.value === "oracle" && columnName.toUpperCase() === DBX_ROWID_COLUMN) return true; - if (databaseType.value === "neo4j" && columnName === DBX_NEO4J_ELEMENT_ID_COLUMN) return true; + if (resolvedDatabaseType.value === "oracle" && columnName.toUpperCase() === DBX_ROWID_COLUMN) return true; + if (resolvedDatabaseType.value === "neo4j" && columnName === DBX_NEO4J_ELEMENT_ID_COLUMN) return true; const extra = columnInfo?.extra ?? ""; const columnDefault = columnInfo?.column_default ?? ""; return /\b(auto_increment|autoincrement|identity|generated)\b/i.test(extra) || /\bnextval\s*\(/i.test(columnDefault); @@ -656,7 +658,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { function saveStatementOptions() { if (!tableMeta.value) return null; return { - databaseType: databaseType.value, + databaseType: resolvedDatabaseType.value, tableMeta: tableMeta.value, columns: result.value.columns, sourceColumns: sourceColumns.value, @@ -709,7 +711,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { } async function recordFailedDataGridHistory(statements: string[], rollbackStatements: string[], start: number, error: unknown) { - const message = normalizeDataGridSaveError(databaseType.value, error); + const message = normalizeDataGridSaveError(resolvedDatabaseType.value, error); try { await recordDataGridHistory(statements, rollbackStatements, Date.now() - start, { success: false, @@ -740,7 +742,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { rows: result.value.rows, }); } catch (e: any) { - saveError.value = normalizeDataGridSaveError(databaseType.value, e); + saveError.value = normalizeDataGridSaveError(resolvedDatabaseType.value, e); isSaving.value = false; return; } @@ -762,7 +764,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { try { preparedSave = await api.prepareDataGridSave(stmtOptions); } catch (e: any) { - saveError.value = normalizeDataGridSaveError(databaseType.value, e); + saveError.value = normalizeDataGridSaveError(resolvedDatabaseType.value, e); isSaving.value = false; return; } @@ -783,6 +785,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { let apiResult: { affected_rows?: number } | undefined; console.info("[DBX][dataGrid:save-statements]", { databaseType: databaseType.value, + resolvedDatabaseType: resolvedDatabaseType.value, table: tableMeta.value ? [tableMeta.value.schema, tableMeta.value.tableName].filter(Boolean).join(".") : undefined, statements: stmts, rollbackStatements: rollbackStmts, @@ -950,7 +953,7 @@ export function useDataGridEditor(options: UseDataGridEditorOptions) { previewStatements.value = stmts; return stmts; } catch (e: any) { - saveError.value = normalizeDataGridSaveError(databaseType.value, e); + saveError.value = normalizeDataGridSaveError(resolvedDatabaseType.value, e); return []; } finally { isPreviewLoading.value = false; diff --git a/apps/desktop/src/lib/__tests__/tableEditing.spec.ts b/apps/desktop/src/lib/__tests__/tableEditing.spec.ts index d478e1ff14..00cfa9fbef 100644 --- a/apps/desktop/src/lib/__tests__/tableEditing.spec.ts +++ b/apps/desktop/src/lib/__tests__/tableEditing.spec.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from "vitest"; -import { DBX_ROWID_COLUMN, canUseKeylessRowPredicate, editablePrimaryKeys, editableRowIdentifierColumns, isTableDataEditable } from "@/lib/tableEditing"; +import { DBX_ROWID_COLUMN, canEditExistingTableRows, canUseKeylessRowPredicate, editablePrimaryKeys, editableRowIdentifierColumns, isClickHouseExistingRowReadonlyColumn, isTableDataEditable, supportsDataGridTransaction } from "@/lib/tableEditing"; import type { ColumnInfo, IndexInfo } from "@/types/database"; function column(name: string, isPrimaryKey = false): ColumnInfo { @@ -45,4 +45,19 @@ describe("tableEditing", () => { expect(editableRowIdentifierColumns("postgres", [column("email"), column("name")], [index(["email"], true, "email IS NOT NULL")])).toEqual([]); expect(editableRowIdentifierColumns("postgres", [column("id", true), column("email")], [index(["email"])])).toEqual(["id"]); }); + + it("allows ClickHouse table editing when row identifiers are available", () => { + expect(isTableDataEditable("clickhouse", ["id"], "BASE TABLE")).toBe(true); + expect(canEditExistingTableRows("clickhouse", undefined, ["id"])).toBe(true); + expect(supportsDataGridTransaction("clickhouse")).toBe(false); + expect(isTableDataEditable("clickhouse", [], "BASE TABLE")).toBe(true); + expect(canEditExistingTableRows("clickhouse", undefined, [])).toBe(false); + }); + + it("treats ClickHouse row identifier cells as readonly on existing rows", () => { + expect(isClickHouseExistingRowReadonlyColumn("clickhouse", "ID", ["id"])).toBe(true); + expect(isClickHouseExistingRowReadonlyColumn("clickhouse", "name", ["id"])).toBe(false); + expect(isClickHouseExistingRowReadonlyColumn("clickhouse", "event_date", ["id"], [{ ...column("event_date"), extra: "partition_key" }])).toBe(true); + expect(isClickHouseExistingRowReadonlyColumn("postgres", "id", ["id"])).toBe(false); + }); }); diff --git a/apps/desktop/src/lib/databaseTableDataCapabilities.ts b/apps/desktop/src/lib/databaseTableDataCapabilities.ts index 3e8f5739b9..6998d02af9 100644 --- a/apps/desktop/src/lib/databaseTableDataCapabilities.ts +++ b/apps/desktop/src/lib/databaseTableDataCapabilities.ts @@ -142,12 +142,11 @@ const DATABASE_CAPABILITY_OVERRIDES: Partial info.name.toLowerCase() === column.toLowerCase()); return !!columnInfo?.is_primary_key || /\btag\b/i.test(columnInfo?.extra ?? ""); } + +export function isClickHouseExistingRowReadonlyColumn(databaseType: DatabaseType | undefined, column: string, primaryKeys: readonly string[], columns: ColumnInfo[] = []): boolean { + if (databaseType !== "clickhouse") return false; + if (primaryKeys.some((key) => key.toLowerCase() === column.toLowerCase())) return true; + const columnInfo = columns.find((info) => info.name.toLowerCase() === column.toLowerCase()); + return /\bpartition_key\b/i.test(columnInfo?.extra ?? ""); +} diff --git a/crates/dbx-core/src/data_grid_sql.rs b/crates/dbx-core/src/data_grid_sql.rs index 6764d750a4..3a65005834 100644 --- a/crates/dbx-core/src/data_grid_sql.rs +++ b/crates/dbx-core/src/data_grid_sql.rs @@ -254,7 +254,7 @@ pub fn build_data_grid_copy_update_statements(options: DataGridCopyUpdateStateme .join(" AND "); statements.push(data_grid_statement( options.database_type, - format!("UPDATE {table} SET {sets} WHERE {where_clause}"), + data_grid_update_sql(options.database_type, &table, &sets, &where_clause), )); } statements @@ -418,6 +418,10 @@ fn validate_data_grid_save(options: &DataGridSaveStatementOptions) -> Option Option Option { + if options.database_type != Some(DatabaseType::ClickHouse) || options.dirty_rows.is_empty() { + return None; + } + let save_columns = effective_columns(options); + let column_info = options.table_meta.columns.as_deref().unwrap_or(&[]); + let primary_key_set: Vec = + options.table_meta.primary_keys.iter().map(|primary_key| normalize_column_name(primary_key)).collect(); + let has_clickhouse_key_metadata = !primary_key_set.is_empty() + || column_info.iter().any(|column| is_clickhouse_partition_key_column(options.database_type, Some(column))); + if !has_clickhouse_key_metadata { + return None; + } + + for (_, changes) in &options.dirty_rows { + if changes.is_empty() { + continue; + } + let has_mutable_column = changes.iter().any(|(column_index, _)| { + let Some(column) = save_columns.get(*column_index).and_then(|column| column.as_deref()) else { + return false; + }; + !is_grid_update_omitted_column( + options.database_type, + column_info_for(column_info, column), + Some(column), + &primary_key_set, + ) + }); + if !has_mutable_column { + return Some(clickhouse_no_mutable_columns_error()); + } + } + None +} + fn validate_inserted_primary_keys(options: &DataGridSaveStatementOptions) -> Option { let primary_keys = &options.table_meta.primary_keys; if primary_keys.is_empty() || options.new_rows.is_empty() { @@ -504,6 +544,8 @@ fn build_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Ve &options.table_meta.table_name, ); let mut statements = Vec::new(); + let primary_key_set: Vec = + options.table_meta.primary_keys.iter().map(|primary_key| normalize_column_name(primary_key)).collect(); for (row_index, changes) in &options.dirty_rows { let Some(row) = options.rows.get(*row_index) else { @@ -517,6 +559,7 @@ fn build_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Ve options.database_type, column_info_for(column_info, column), Some(column), + &primary_key_set, ) { return None; } @@ -540,7 +583,7 @@ fn build_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Ve ); statements.push(data_grid_statement( options.database_type, - format!("UPDATE {table} SET {sets} WHERE {where_clause}"), + data_grid_update_sql(options.database_type, &table, &sets, &where_clause), )); } @@ -555,8 +598,10 @@ fn build_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Ve row, column_info, ); - statements - .push(data_grid_statement(options.database_type, format!("DELETE FROM {table} WHERE {where_clause}"))); + statements.push(data_grid_statement( + options.database_type, + data_grid_delete_sql(options.database_type, &table, &where_clause), + )); } for row in &options.new_rows { @@ -601,6 +646,9 @@ fn build_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) - if options.database_type == Some(DatabaseType::Neo4j) { return build_neo4j_data_grid_rollback_statements(options); } + if options.database_type == Some(DatabaseType::ClickHouse) { + return Vec::new(); + } let save_columns = effective_columns(options); let column_info = options.table_meta.columns.as_deref().unwrap_or(&[]); @@ -671,6 +719,7 @@ fn build_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) - options.database_type, column_info_for(column_info, column), Some(column), + &[], ) { return None; } @@ -1143,6 +1192,22 @@ fn data_grid_statement(database_type: Option, sql: String) -> Stri } } +fn data_grid_update_sql(database_type: Option, table: &str, sets: &str, where_clause: &str) -> String { + if database_type == Some(DatabaseType::ClickHouse) { + format!("ALTER TABLE {table} UPDATE {sets} WHERE {where_clause}") + } else { + format!("UPDATE {table} SET {sets} WHERE {where_clause}") + } +} + +fn data_grid_delete_sql(database_type: Option, table: &str, where_clause: &str) -> String { + if database_type == Some(DatabaseType::ClickHouse) { + format!("ALTER TABLE {table} DELETE WHERE {where_clause}") + } else { + format!("DELETE FROM {table} WHERE {where_clause}") + } +} + fn uses_mysql_binary_text_predicate( database_type: Option, value: &Value, @@ -1192,8 +1257,35 @@ fn is_grid_update_omitted_column( database_type: Option, column_info: Option<&DataGridColumnInfo>, name: Option<&str>, + primary_key_set: &[String], ) -> bool { - is_oracle_row_id(database_type, name) || is_non_identity_generated_column(column_info) + is_oracle_row_id(database_type, name) + || is_clickhouse_key_column(database_type, column_info, name, primary_key_set) + || is_non_identity_generated_column(column_info) +} + +fn is_clickhouse_key_column( + database_type: Option, + column_info: Option<&DataGridColumnInfo>, + name: Option<&str>, + primary_key_set: &[String], +) -> bool { + if database_type != Some(DatabaseType::ClickHouse) { + return false; + } + column_info.is_some_and(|column| column.is_primary_key) + || is_clickhouse_partition_key_column(database_type, column_info) + || name.is_some_and(|name| primary_key_set.contains(&normalize_column_name(name))) +} + +fn is_clickhouse_partition_key_column( + database_type: Option, + column_info: Option<&DataGridColumnInfo>, +) -> bool { + database_type == Some(DatabaseType::ClickHouse) + && column_info.and_then(|column| column.extra.as_deref()).is_some_and(|extra| { + extra.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_').any(|part| part == "partition_key") + }) } fn is_postgres_tsvector_column(database_type: Option, column_info: Option<&DataGridColumnInfo>) -> bool { @@ -1282,6 +1374,10 @@ fn null_write_error(column: &str) -> String { format!("Column \"{column}\" does not allow NULL.") } +fn clickhouse_no_mutable_columns_error() -> String { + "ClickHouse primary or partition key columns cannot be updated. Change a non-key column before saving.".to_string() +} + fn predicate_ident(database_type: Option, name: &str) -> String { if is_oracle_row_id(database_type, Some(name)) { "ROWIDTOCHAR(ROWID)".to_string() @@ -1659,6 +1755,146 @@ mod tests { ); } + #[test] + fn prepares_clickhouse_mutation_save_statements() { + let mut id_column = column("id", "UInt64", false, None); + id_column.is_primary_key = true; + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::ClickHouse), + table_meta: DataGridTableMeta { + schema: Some("default".to_string()), + table_name: "people".to_string(), + primary_keys: vec!["id".to_string()], + columns: Some(vec![id_column, column("name", "String", true, None)]), + }, + columns: vec!["id".to_string(), "name".to_string()], + source_columns: None, + rows: vec![vec![json!(1), json!("Ada")]], + dirty_rows: vec![(0, vec![(1, json!("Linus"))])], + deleted_rows: vec![0], + new_rows: vec![vec![json!(2), json!("Grace")]], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec![ + "ALTER TABLE \"people\" UPDATE \"name\" = 'Linus' WHERE \"id\" = 1;", + "ALTER TABLE \"people\" DELETE WHERE \"id\" = 1;", + "INSERT INTO \"people\" (\"id\", \"name\") VALUES (2, 'Grace');", + ] + ); + assert!(result.rollback_statements.is_empty()); + } + + #[test] + fn rejects_clickhouse_key_only_update() { + let mut id_column = column("id", "UInt64", false, None); + id_column.is_primary_key = true; + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::ClickHouse), + table_meta: DataGridTableMeta { + schema: Some("default".to_string()), + table_name: "people".to_string(), + primary_keys: vec!["id".to_string()], + columns: Some(vec![id_column, column("name", "String", true, None)]), + }, + columns: vec!["id".to_string(), "name".to_string()], + source_columns: None, + rows: vec![vec![json!(1), json!("Ada")]], + dirty_rows: vec![(0, vec![(0, json!(2))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!( + result.validation_error, + Some( + "ClickHouse primary or partition key columns cannot be updated. Change a non-key column before saving." + .to_string() + ) + ); + assert!(result.statements.is_empty()); + } + + #[test] + fn omits_clickhouse_partition_key_update_assignments() { + let mut event_date_column = column("event_date", "Date", false, Some("partition_key")); + event_date_column.is_primary_key = false; + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::ClickHouse), + table_meta: DataGridTableMeta { + schema: Some("default".to_string()), + table_name: "events".to_string(), + primary_keys: vec!["id".to_string()], + columns: Some(vec![ + column("id", "UInt64", false, None), + event_date_column, + column("name", "String", true, None), + ]), + }, + columns: vec!["id".to_string(), "event_date".to_string(), "name".to_string()], + source_columns: None, + rows: vec![vec![json!(1), json!("2026-06-24"), json!("Ada")]], + dirty_rows: vec![(0, vec![(1, json!("2026-06-25")), (2, json!("Linus"))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, None); + assert_eq!(result.statements, vec!["ALTER TABLE \"events\" UPDATE \"name\" = 'Linus' WHERE \"id\" = 1;"]); + } + + #[test] + fn rejects_clickhouse_partition_key_only_update() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::ClickHouse), + table_meta: DataGridTableMeta { + schema: Some("default".to_string()), + table_name: "events".to_string(), + primary_keys: vec!["id".to_string()], + columns: Some(vec![ + column("id", "UInt64", false, None), + column("event_date", "Date", false, Some("partition_key")), + column("name", "String", true, None), + ]), + }, + columns: vec!["id".to_string(), "event_date".to_string(), "name".to_string()], + source_columns: None, + rows: vec![vec![json!(1), json!("2026-06-24"), json!("Ada")]], + dirty_rows: vec![(0, vec![(1, json!("2026-06-25"))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!( + result.validation_error, + Some( + "ClickHouse primary or partition key columns cannot be updated. Change a non-key column before saving." + .to_string() + ) + ); + assert!(result.statements.is_empty()); + } + + #[test] + fn builds_clickhouse_copy_update_statements() { + let statements = build_data_grid_copy_update_statements(DataGridCopyUpdateStatementOptions { + database_type: Some(DatabaseType::ClickHouse), + table_meta: DataGridTableMeta { + schema: Some("default".to_string()), + table_name: "people".to_string(), + primary_keys: vec!["id".to_string()], + columns: Some(vec![column("id", "UInt64", false, None), column("name", "String", true, None)]), + }, + columns: vec!["id".to_string(), "name".to_string()], + source_columns: None, + rows: vec![vec![json!(1), json!("Ada")]], + }); + + assert_eq!(statements, vec!["ALTER TABLE \"people\" UPDATE \"name\" = 'Ada' WHERE \"id\" = 1;"]); + } + #[test] fn prepares_databend_keyless_save_statements_with_row_predicate() { let result = prepare_data_grid_save(DataGridSaveStatementOptions { diff --git a/crates/dbx-core/src/db/clickhouse_driver.rs b/crates/dbx-core/src/db/clickhouse_driver.rs index f28adea877..ab669d44b4 100644 --- a/crates/dbx-core/src/db/clickhouse_driver.rs +++ b/crates/dbx-core/src/db/clickhouse_driver.rs @@ -285,7 +285,7 @@ pub async fn list_tables(client: &ChClient, database: &str) -> Result Result, String> { let sql = format!( - "SELECT name, type, default_kind, default_expression, is_in_primary_key, comment \ + "SELECT name, type, default_kind, default_expression, is_in_primary_key, is_in_partition_key, comment \ FROM system.columns WHERE database = '{}' AND table = '{}' ORDER BY position", database.replace('\'', "\\'"), table.replace('\'', "\\'") @@ -298,6 +298,7 @@ pub async fn get_columns(client: &ChClient, database: &str, table: &str) -> Resu let data_type = row.get(1).and_then(|v| v.as_str()).unwrap_or("").to_string(); let is_nullable = data_type.starts_with("Nullable"); let is_pk = row.get(4).and_then(|v| v.as_u64()).unwrap_or(0) == 1; + let is_partition_key = row.get(5).and_then(|v| v.as_u64()).unwrap_or(0) == 1; let default_kind = row.get(2).and_then(|v| v.as_str()).unwrap_or(""); let default_expr = row.get(3).and_then(|v| v.as_str()).unwrap_or(""); let column_default = if default_kind.is_empty() { None } else { Some(default_expr.to_string()) }; @@ -307,8 +308,8 @@ pub async fn get_columns(client: &ChClient, database: &str, table: &str) -> Resu is_nullable, column_default, is_primary_key: is_pk, - extra: None, - comment: row.get(5).and_then(|v| v.as_str()).filter(|value| !value.is_empty()).map(str::to_string), + extra: is_partition_key.then(|| "partition_key".to_string()), + comment: row.get(6).and_then(|v| v.as_str()).filter(|value| !value.is_empty()).map(str::to_string), numeric_precision: None, numeric_scale: None, character_maximum_length: None, diff --git a/packages/app-tests/sqlAnalysis.test.ts b/packages/app-tests/sqlAnalysis.test.ts index dff010ff3d..471675a5c9 100644 --- a/packages/app-tests/sqlAnalysis.test.ts +++ b/packages/app-tests/sqlAnalysis.test.ts @@ -1,6 +1,6 @@ import { strict as assert } from "node:assert"; import { test } from "vitest"; -import { allEditableColumnsWriteable, allPrimaryKeysPresent, analyzeEditableQuery, analyzeEditableQueryEditability, isBinaryType, queryEditabilityMessageKey } from "../../apps/desktop/src/lib/sqlAnalysis.ts"; +import { allEditableColumnsWriteable, allPrimaryKeysPresent, analyzeEditableQuery, analyzeEditableQueryEditability, isBinaryType, queryEditabilityMessageKey, sourceColumnsForResult } from "../../apps/desktop/src/lib/sqlAnalysis.ts"; test("recognizes a simple single-table SELECT as editable", () => { const result = analyzeEditableQueryEditability("select id, name from public.users where active = true order by id"); @@ -102,6 +102,23 @@ test("accepts aliased primary key source columns for row identity", () => { assert.equal(allPrimaryKeysPresent(["id"], ["id", "name"], analyzeEditableQuery("select id, name from users")!), true); }); +test("maps ClickHouse simple query results when identifier columns are returned", () => { + const analysis = analyzeEditableQuery("SELECT id, name, score + 1 AS next_score FROM default.people"); + + assert.ok(analysis); + assert.equal(allPrimaryKeysPresent(["id"], ["id", "name", "next_score"], analysis), true); + assert.equal(allEditableColumnsWriteable(analysis, ["id", "name", "next_score"]), true); + assert.deepEqual(sourceColumnsForResult(analysis, ["id", "name", "next_score"]), ["id", "name", undefined]); +}); + +test("rejects ClickHouse query result editing when identifier source columns are omitted", () => { + const analysis = analyzeEditableQuery("SELECT name FROM default.people"); + + assert.ok(analysis); + assert.equal(allPrimaryKeysPresent(["id"], ["name"], analysis), false); + assert.deepEqual(sourceColumnsForResult(analysis, ["name"]), ["name"]); +}); + test("recognizes binary type declarations with lengths", () => { assert.equal(isBinaryType("binary(16)"), true); assert.equal(isBinaryType("VARBINARY(255)"), true);