diff --git a/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java b/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java index 0c0891dd3b..f9cb2e27b2 100644 --- a/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java +++ b/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java @@ -51,6 +51,8 @@ public final class TDengineAgent extends BaseDatabaseAgent { Pattern.compile("(?i)^(decimal|numeric)\\(\\d+,\\s*(\\d+)\\)"); private static final Pattern CHARACTER_LENGTH_PATTERN = Pattern.compile("(?i)^(binary|nchar|varchar|varbinary)\\((\\d+)\\)"); + private static final Pattern COMPOSITE_KEY_PATTERN = + Pattern.compile("(?i)\\bCOMPOSITE\\s+KEY\\b"); private Connection connection; @@ -355,7 +357,7 @@ public final class TDengineAgent extends BaseDatabaseAgent { return groupName.toLowerCase(Locale.ROOT); } - private static List readDescribeColumns(ResultSet rs) throws Exception { + static List readDescribeColumns(ResultSet rs) throws Exception { List result = new ArrayList<>(); int ordinal = 0; while (rs.next()) { @@ -364,12 +366,13 @@ public final class TDengineAgent extends BaseDatabaseAgent { String dataType = coalesce(rs.getString(2)); String note = optionalString(rs, 4); boolean isTag = note != null && note.toUpperCase(Locale.ROOT).contains("TAG"); + boolean isPrimaryKey = !isTag && (ordinal == 1 || (note != null && COMPOSITE_KEY_PATTERN.matcher(note).find())); result.add(new ColumnInfo( name, dataType, - ordinal != 1, + !isPrimaryKey, null, - ordinal == 1 && !isTag, + isPrimaryKey, note, isTag ? "TAG" : null, parseNumericPrecision(dataType), diff --git a/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java b/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java index bfde41f1db..b606577f1a 100644 --- a/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java +++ b/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java @@ -1,6 +1,6 @@ package com.dbx.agent.tdengine; -import com.dbx.agent.test.TestSupport; +import com.dbx.agent.ColumnInfo; import com.dbx.agent.ConnectParams; import com.dbx.agent.DatabaseAgent; import com.dbx.agent.ExecuteQueryOptions; @@ -9,6 +9,7 @@ import com.dbx.agent.TableInfo; import com.dbx.agent.test.JdbcAgentFake; import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest; import com.dbx.agent.test.JdbcMetadataSqlFake; +import com.dbx.agent.test.TestSupport; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.nio.charset.StandardCharsets; @@ -165,6 +166,26 @@ class TDengineAgentMetadataTest { Assertions.assertEquals("meters", tables.get(1).getParent_name()); } + @Test + void marksTimestampAndCompositeKeyDescribeColumnsAsPrimaryKeys() throws Exception { + ResultSet resultSet = describeResultSet(new String[][] { + {"ts", "TIMESTAMP", "8", ""}, + {"seq", "INT", "4", "COMPOSITE KEY"}, + {"voltage", "FLOAT", "4", ""}, + {"site", "VARCHAR(32)", "32", "TAG"} + }); + + List columns = TDengineAgent.readDescribeColumns(resultSet); + + Assertions.assertTrue(columns.get(0).getIs_primary_key()); + Assertions.assertFalse(columns.get(0).getIs_nullable()); + Assertions.assertTrue(columns.get(1).getIs_primary_key()); + Assertions.assertFalse(columns.get(1).getIs_nullable()); + Assertions.assertFalse(columns.get(2).getIs_primary_key()); + Assertions.assertFalse(columns.get(3).getIs_primary_key()); + Assertions.assertEquals("TAG", columns.get(3).getExtra()); + } + @Test void doesNotExposeDatabasesAsSchemas() { TDengineAgent agent = new TDengineAgent(); @@ -302,4 +323,25 @@ class TDengineAgentMetadataTest { Assertions.assertEquals("jdbc:TAOS-RS://127.0.0.1:6041/db?timezone=UTC#anchor", sanitized); } + + private static ResultSet describeResultSet(String[][] rows) { + int[] rowIndex = {-1}; + return (ResultSet) Proxy.newProxyInstance( + ResultSet.class.getClassLoader(), + new Class[] {ResultSet.class}, + (proxy, method, args) -> { + if ("next".equals(method.getName())) { + rowIndex[0] += 1; + return rowIndex[0] < rows.length; + } + if ("getString".equals(method.getName())) { + return rows[rowIndex[0]][((Integer) args[0]) - 1]; + } + if ("close".equals(method.getName())) { + return null; + } + throw new UnsupportedOperationException(method.getName()); + } + ); + } } diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue index 6f550373a8..e1dbbaa4ee 100644 --- a/apps/desktop/src/components/grid/DataGrid.vue +++ b/apps/desktop/src/components/grid/DataGrid.vue @@ -91,7 +91,18 @@ import type { BuildSingleColumnAlterSqlOptions } from "@/lib/table/tableStructur import { buildTableSelectSql, quoteTableIdentifier } from "@/lib/table/tableSelectSql"; import { uuid } from "@/lib/common/utils"; import { compactHeaderColumnType, resolveHeaderColumnType } from "@/lib/dataGrid/dataGridColumnType"; -import { canEditExistingTableRows, canInsertTableRows, canUseKeylessRowPredicate, hiveTablePropertiesIndicateTransactional, isClickHouseExistingRowReadonlyColumn, isHiddenGridColumn, isTdengineExistingRowReadonlyColumn, usesSyntheticRowIdKey } from "@/lib/table/tableEditing"; +import { + canDeleteExistingTdengineRows, + canEditExistingTableRows, + canInsertTableRows, + canUseKeylessRowPredicate, + hasCompleteTdengineRowIdentity, + hiveTablePropertiesIndicateTransactional, + isClickHouseExistingRowReadonlyColumn, + isHiddenGridColumn, + isTdengineExistingRowReadonlyColumn, + usesSyntheticRowIdKey, +} from "@/lib/table/tableEditing"; import { buildDataGridColumnDistinctValuesSql, buildDataGridContextFilterCondition, buildDataGridCountSql, buildHiveTablePropertiesSql, type DataGridContextFilterMode } from "@/lib/dataGrid/dataGridSql"; import { buildVisibleTransposeRows, @@ -3636,7 +3647,10 @@ const canUseWhereSearch = computed(() => !!props.tableMeta && !!props.onExecuteS const canUseServerColumnFilter = computed(() => canUseWhereSearch.value && !!props.connectionId && !!props.tableMeta); type DataGridTableMeta = NonNullable; const hiveTableTransactional = ref(undefined); -const canEditExistingRows = computed(() => !!props.customSaveHandler || canEditExistingTableRows(props.databaseType, hiveTableTransactional.value, props.tableMeta?.primaryKeys ?? [])); +const resultSourceColumns = computed(() => props.result.columns.map((column, index) => props.sourceColumns?.[index] ?? column)); +const canEditExistingRows = computed( + () => !!props.customSaveHandler || (canEditExistingTableRows(props.databaseType, hiveTableTransactional.value, props.tableMeta?.primaryKeys ?? []) && hasCompleteTdengineRowIdentity(props.databaseType, props.tableMeta?.primaryKeys ?? [], resultSourceColumns.value)), +); const customReadonlyColumns = computed(() => new Set((props.customSaveHandler?.readonlyColumns ?? []).map((column) => column.toLowerCase()))); const hasDataGridSaveTarget = computed(() => !!props.tableMeta || !!props.customSaveHandler); const hasDataGridInsertTarget = computed(() => { @@ -3647,6 +3661,7 @@ const hasDataGridInsertTarget = computed(() => { }); const canInsertRows = computed(() => !!props.editable && hasDataGridInsertTarget.value); const canDeleteRows = computed(() => props.allowDeleteRows !== false && (!props.customSaveHandler || props.customSaveHandler.canDelete !== false)); +const canDeleteExistingRows = computed(() => !!props.customSaveHandler || canDeleteExistingTdengineRows(props.databaseType, props.tableMeta?.primaryKeys ?? [])); watch( () => [props.databaseType, props.connectionId, props.database, props.tableMeta?.schema, props.tableMeta?.tableName], async () => { @@ -4196,7 +4211,7 @@ function canDeleteRowItem(item: RowItem | undefined): boolean { isDraft: !!item.isDraft, isDeleted: item.isDeleted, isNew: item.isNew, - canEditExistingRows: canEditExistingRows.value, + canEditExistingRows: canEditExistingRows.value && canDeleteExistingRows.value, isSavingNewRow: isSavingNewRow(item), }); } @@ -6104,7 +6119,7 @@ const canvasDetailButtonCell = computed(() => { const target = hoveredDetailCell.value ?? quickDownloadMenuCell.value ?? (showCellDetail.value ? detailCell.value : null); if (!target || !cellDetailButtonVisible(target.rowIndex, target.col)) return null; const editing = editingCell.value; - if (editing?.rowId === displayItems.value[target.rowIndex]?.id && editing.col === target.col) return null; + if (editing && editing.rowId === displayItems.value[target.rowIndex]?.id && editing.col === target.col) return null; const visibleColIdx = visibleColumnIndexes.value.indexOf(target.col); if (visibleColIdx < 0) return null; const rect = canvasCellViewportRect(target.rowIndex, visibleColIdx); diff --git a/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts b/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts index f6842ab797..4ef92077d9 100644 --- a/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts +++ b/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts @@ -1,5 +1,19 @@ import { describe, expect, it } from "vitest"; -import { DBX_ROWID_COLUMN, canEditExistingTableRows, canUseKeylessRowPredicate, editablePrimaryKeys, editableRowIdentifierColumns, isClickHouseExistingRowReadonlyColumn, isTableDataEditable, supportsDataGridTransaction, usesSyntheticRowIdKey } from "@/lib/table/tableEditing"; +import { + DBX_ROWID_COLUMN, + DBX_TDENGINE_TBNAME_COLUMN, + canDeleteExistingTdengineRows, + canEditExistingTableRows, + canUseKeylessRowPredicate, + editablePrimaryKeys, + editableRowIdentifierColumns, + hasCompleteTdengineRowIdentity, + isClickHouseExistingRowReadonlyColumn, + isTdengineExistingRowReadonlyColumn, + isTableDataEditable, + supportsDataGridTransaction, + usesSyntheticRowIdKey, +} from "@/lib/table/tableEditing"; import type { ColumnInfo, IndexInfo } from "@/types/database"; function column(name: string, isPrimaryKey = false): ColumnInfo { @@ -59,6 +73,31 @@ describe("tableEditing", () => { expect(canEditExistingTableRows("clickhouse", undefined, [])).toBe(false); }); + it("uses tbname only when editing TDengine stable rows", () => { + const columns = [column("ts", true), column("seq", true), column("voltage")]; + expect(editablePrimaryKeys("tdengine", columns, "STABLE")).toEqual([DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"]); + expect(editablePrimaryKeys("tdengine", columns, "TABLE")).toEqual(["ts", "seq"]); + expect(canEditExistingTableRows("tdengine", undefined, ["ts", "seq"])).toBe(true); + expect(canEditExistingTableRows("tdengine", undefined, [])).toBe(false); + expect(isTdengineExistingRowReadonlyColumn("tdengine", "seq", columns)).toBe(true); + }); + + it("requires every TDengine row identifier in editable results", () => { + const stableKeys = [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"]; + expect(hasCompleteTdengineRowIdentity("tdengine", stableKeys, ["tbname", "ts", "seq", "voltage"])).toBe(true); + expect(hasCompleteTdengineRowIdentity("tdengine", stableKeys, ["tbname", "ts", "voltage"])).toBe(false); + expect(hasCompleteTdengineRowIdentity("tdengine", ["ts", "seq"], ["ts", "seq", "voltage"])).toBe(true); + expect(hasCompleteTdengineRowIdentity("postgres", ["id"], [])).toBe(true); + }); + + it("disables existing-row deletion for TDengine composite keys", () => { + expect(canDeleteExistingTdengineRows("tdengine", ["ts"])).toBe(true); + expect(canDeleteExistingTdengineRows("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts"])).toBe(true); + expect(canDeleteExistingTdengineRows("tdengine", ["ts", "seq"])).toBe(false); + expect(canDeleteExistingTdengineRows("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"])).toBe(false); + expect(canDeleteExistingTdengineRows("postgres", ["id", "tenant_id"])).toBe(true); + }); + 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); diff --git a/apps/desktop/src/lib/table/tableEditing.ts b/apps/desktop/src/lib/table/tableEditing.ts index a8c22adce8..46529b7fba 100644 --- a/apps/desktop/src/lib/table/tableEditing.ts +++ b/apps/desktop/src/lib/table/tableEditing.ts @@ -9,10 +9,15 @@ function isViewTableType(tableType?: string): boolean { return tableType?.toUpperCase().includes("VIEW") === true; } +function isTdengineStableTableType(tableType?: string): boolean { + const normalized = tableType?.trim().toUpperCase(); + return normalized === "STABLE" || normalized === "SUPER TABLE" || normalized === "SUPERTABLE"; +} + export function editablePrimaryKeys(databaseType: DatabaseType | undefined, columns: ColumnInfo[], tableType?: string): string[] { const primaryKeys = columns.filter((column) => column.is_primary_key).map((column) => column.name); if (isViewTableType(tableType)) return primaryKeys; - if (databaseType === "tdengine" && primaryKeys.length > 0) return [DBX_TDENGINE_TBNAME_COLUMN, ...primaryKeys]; + if (databaseType === "tdengine" && primaryKeys.length > 0 && isTdengineStableTableType(tableType)) return [DBX_TDENGINE_TBNAME_COLUMN, ...primaryKeys]; const syntheticKey = getDatabaseCapability(databaseType).syntheticKey; if (syntheticKey === "oracle-rowid" && primaryKeys.length === 0) return [DBX_ROWID_COLUMN]; if (syntheticKey === "neo4j-element-id" && primaryKeys.length === 0) return [DBX_NEO4J_ELEMENT_ID_COLUMN]; @@ -55,11 +60,23 @@ export function canEditExistingTableRows(databaseType: DatabaseType | undefined, if (tableData.readonly) return false; if (tableData.existingRowsReadonly) return false; if (tableData.requiresTransactionalTableForExistingRows && hiveTableTransactional !== true) return false; - if (databaseType === "tdengine" && !primaryKeys?.some((key) => key.toLowerCase() === DBX_TDENGINE_TBNAME_COLUMN)) return false; if (tableData.updateRequiresPrimaryKey && primaryKeys && primaryKeys.length === 0) return false; return true; } +export function hasCompleteTdengineRowIdentity(databaseType: DatabaseType | undefined, primaryKeys: readonly string[], resultColumns: readonly (string | undefined)[]): boolean { + if (databaseType !== "tdengine") return true; + if (primaryKeys.length === 0) return false; + const availableColumns = new Set(resultColumns.filter((column): column is string => !!column).map((column) => column.toLowerCase())); + return primaryKeys.every((primaryKey) => availableColumns.has(primaryKey.toLowerCase())); +} + +export function canDeleteExistingTdengineRows(databaseType: DatabaseType | undefined, primaryKeys: readonly string[]): boolean { + if (databaseType !== "tdengine") return true; + const rowPrimaryKeys = primaryKeys.filter((primaryKey) => primaryKey.toLowerCase() !== DBX_TDENGINE_TBNAME_COLUMN); + return rowPrimaryKeys.length <= 1; +} + export function hiveTablePropertiesIndicateTransactional(result: { rows: readonly (readonly unknown[])[] }): boolean { return result.rows.some((row) => { const name = String(row[0] ?? "") diff --git a/crates/dbx-core/src/data_grid_sql.rs b/crates/dbx-core/src/data_grid_sql.rs index ae62eb82f0..143939f2d9 100644 --- a/crates/dbx-core/src/data_grid_sql.rs +++ b/crates/dbx-core/src/data_grid_sql.rs @@ -8,7 +8,10 @@ use data_grid_neo4j_sql::{build_neo4j_data_grid_rollback_statements, build_neo4j #[path = "data_grid_tdengine_sql.rs"] mod data_grid_tdengine_sql; -use data_grid_tdengine_sql::build_tdengine_data_grid_save_statements; +use data_grid_tdengine_sql::{ + build_tdengine_data_grid_rollback_statements, build_tdengine_data_grid_save_statements, + validate_tdengine_existing_rows, validate_tdengine_inserted_rows, +}; use crate::models::connection::DatabaseType; use crate::sql_dialect::{ @@ -643,9 +646,15 @@ fn build_neo4j_data_grid_column_distinct_values_sql(options: &DataGridColumnDist } fn validate_data_grid_save(options: &DataGridSaveStatementOptions) -> Option { + if let Some(error) = validate_tdengine_inserted_rows(options) { + return Some(error); + } if let Some(error) = validate_inserted_primary_keys(options) { return Some(error); } + if let Some(error) = validate_tdengine_existing_rows(options) { + return Some(error); + } let not_null_columns: Vec = options .table_meta @@ -896,6 +905,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::Tdengine) { + return build_tdengine_data_grid_rollback_statements(options); + } if options.database_type == Some(DatabaseType::ClickHouse) { return Vec::new(); } @@ -2951,6 +2963,374 @@ mod tests { ); } + #[test] + fn prepares_tdengine_child_table_delete_from_stable_row() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "meters".to_string(), + primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()], + columns: Some(vec![column("ts", "TIMESTAMP", false, None), column("voltage", "FLOAT", true, None)]), + }, + columns: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "voltage".to_string()], + source_columns: None, + rows: vec![vec![json!("codex_delete_verify"), json!("2026-07-10T13:59:00.456+08:00"), json!(221.5)]], + dirty_rows: vec![], + deleted_rows: vec![0], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec!["DELETE FROM `dbx_tdengine_demo`.`codex_delete_verify` WHERE `ts` = '2026-07-10T13:59:00.456+08:00';"] + ); + assert_eq!( + result.rollback_statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`meters` (`tbname`, `ts`, `voltage`) VALUES ('codex_delete_verify', '2026-07-10T13:59:00.456+08:00', 221.5);"] + ); + } + + #[test] + fn rejects_tdengine_composite_key_delete_from_same_timestamp_stable_rows() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "meters".to_string(), + primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "seq".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("seq", "INT", false, Some("COMPOSITE KEY")), + column("voltage", "FLOAT", true, None), + ]), + }, + columns: vec![ + DBX_TDENGINE_TBNAME_COLUMN.to_string(), + "ts".to_string(), + "seq".to_string(), + "voltage".to_string(), + ], + source_columns: None, + rows: vec![ + vec![json!("device_a"), json!("2026-07-10T13:59:00.456+08:00"), json!(1), json!(221.5)], + vec![json!("device_a"), json!("2026-07-10T13:59:00.456+08:00"), json!(2), json!(222.5)], + ], + dirty_rows: vec![], + deleted_rows: vec![1], + new_rows: vec![], + }); + + assert_eq!( + result.validation_error, + Some("TDengine tables with composite keys do not support row deletion.".to_string()) + ); + assert!(result.statements.is_empty()); + assert!(result.rollback_statements.is_empty()); + } + + #[test] + fn prepares_tdengine_delete_from_direct_child_table_row() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "codex_grid_accept_20260710".to_string(), + primary_keys: vec!["ts".to_string()], + columns: Some(vec![column("ts", "TIMESTAMP", false, None), column("voltage", "FLOAT", true, None)]), + }, + columns: vec!["ts".to_string(), "voltage".to_string()], + source_columns: None, + rows: vec![vec![json!("2026-07-10T16:00:00.111+08:00"), json!(220.1)]], + dirty_rows: vec![], + deleted_rows: vec![0], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec!["DELETE FROM `dbx_tdengine_demo`.`codex_grid_accept_20260710` WHERE `ts` = '2026-07-10T16:00:00.111+08:00';"] + ); + assert_eq!( + result.rollback_statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`codex_grid_accept_20260710` (`ts`, `voltage`) VALUES ('2026-07-10T16:00:00.111+08:00', 220.1);"] + ); + } + + #[test] + fn prepares_tdengine_overwrite_for_direct_child_table_row() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "codex_grid_update_verify_20260710".to_string(), + primary_keys: vec!["ts".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("voltage", "FLOAT", true, None), + column("current", "FLOAT", true, None), + ]), + }, + columns: vec!["ts".to_string(), "voltage".to_string(), "current".to_string()], + source_columns: None, + rows: vec![vec![json!("2026-07-10T16:30:00.444+08:00"), json!(220.0), json!(1.0)]], + dirty_rows: vec![(0, vec![(1, json!(229.9))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`codex_grid_update_verify_20260710` (`ts`, `voltage`, `current`) VALUES ('2026-07-10T16:30:00.444+08:00', 229.9, 1.0);"] + ); + assert_eq!( + result.rollback_statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`codex_grid_update_verify_20260710` (`ts`, `voltage`, `current`) VALUES ('2026-07-10T16:30:00.444+08:00', 220.0, 1.0);"] + ); + } + + #[test] + fn prepares_tdengine_composite_key_overwrite_and_rollback_for_same_timestamp_child_rows() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "device_a".to_string(), + primary_keys: vec!["ts".to_string(), "seq".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("seq", "INT", false, Some("COMPOSITE KEY")), + column("voltage", "FLOAT", true, None), + ]), + }, + columns: vec!["ts".to_string(), "seq".to_string(), "voltage".to_string()], + source_columns: None, + rows: vec![ + vec![json!("2026-07-10T16:30:00.444+08:00"), json!(1), json!(220.0)], + vec![json!("2026-07-10T16:30:00.444+08:00"), json!(2), json!(221.0)], + ], + dirty_rows: vec![(1, vec![(2, json!(229.9))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`device_a` (`ts`, `seq`, `voltage`) VALUES ('2026-07-10T16:30:00.444+08:00', 2, 229.9);"] + ); + assert_eq!( + result.rollback_statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`device_a` (`ts`, `seq`, `voltage`) VALUES ('2026-07-10T16:30:00.444+08:00', 2, 221.0);"] + ); + } + + #[test] + fn prepares_tdengine_stable_insert_with_child_table_identity() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "issue_3121_devices".to_string(), + primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("reading", "FLOAT", true, None), + column("site", "VARCHAR", true, Some("TAG")), + ]), + }, + columns: vec![ + DBX_TDENGINE_TBNAME_COLUMN.to_string(), + "ts".to_string(), + "reading".to_string(), + "site".to_string(), + ], + source_columns: None, + rows: vec![], + dirty_rows: vec![], + deleted_rows: vec![], + new_rows: vec![vec![ + json!("codex_issue3121_insert_verify"), + json!("2026-07-10T17:48:51.000+08:00"), + json!(1.0), + json!("codex-lab"), + ]], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec!["INSERT INTO `dbx_tdengine_demo`.`issue_3121_devices` (`tbname`, `ts`, `reading`, `site`) VALUES ('codex_issue3121_insert_verify', '2026-07-10T17:48:51.000+08:00', 1.0, 'codex-lab');"] + ); + assert_eq!( + result.rollback_statements, + vec!["DELETE FROM `dbx_tdengine_demo`.`codex_issue3121_insert_verify` WHERE `ts` = '2026-07-10T17:48:51.000+08:00';"] + ); + } + + #[test] + fn skips_tdengine_composite_key_insert_rollback_for_same_timestamp_rows() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "meters".to_string(), + primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "seq".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("seq", "INT", false, Some("COMPOSITE KEY")), + column("voltage", "FLOAT", true, None), + ]), + }, + columns: vec![ + DBX_TDENGINE_TBNAME_COLUMN.to_string(), + "ts".to_string(), + "seq".to_string(), + "voltage".to_string(), + ], + source_columns: None, + rows: vec![], + dirty_rows: vec![], + deleted_rows: vec![], + new_rows: vec![ + vec![json!("device_a"), json!("2026-07-10T17:48:51.000+08:00"), json!(1), json!(221.0)], + vec![json!("device_a"), json!("2026-07-10T17:48:51.000+08:00"), json!(2), json!(222.0)], + ], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + vec![ + "INSERT INTO `dbx_tdengine_demo`.`meters` (`tbname`, `ts`, `seq`, `voltage`) VALUES ('device_a', '2026-07-10T17:48:51.000+08:00', 1, 221.0);", + "INSERT INTO `dbx_tdengine_demo`.`meters` (`tbname`, `ts`, `seq`, `voltage`) VALUES ('device_a', '2026-07-10T17:48:51.000+08:00', 2, 222.0);", + ] + ); + assert!(result.rollback_statements.is_empty()); + } + + #[test] + fn rejects_tdengine_stable_insert_without_child_table_identity() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "issue_3121_devices".to_string(), + primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()], + columns: Some(vec![column("ts", "TIMESTAMP", false, None), column("reading", "FLOAT", true, None)]), + }, + columns: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "reading".to_string()], + source_columns: None, + rows: vec![], + dirty_rows: vec![], + deleted_rows: vec![], + new_rows: vec![vec![Value::Null, json!("2026-07-10T17:48:51.000+08:00"), json!(1.0)]], + }); + + assert_eq!( + result.validation_error, + Some("TDengine STABLE inserts require a child table name (tbname).".to_string()) + ); + assert!(result.statements.is_empty()); + assert!(result.rollback_statements.is_empty()); + } + + #[test] + fn rejects_tdengine_delete_without_child_table_identity() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "meters".to_string(), + primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()], + columns: Some(vec![column("ts", "TIMESTAMP", false, None)]), + }, + columns: vec!["ts".to_string()], + source_columns: None, + rows: vec![vec![json!("2026-07-10T13:59:00.456+08:00")]], + dirty_rows: vec![], + deleted_rows: vec![0], + new_rows: vec![], + }); + + assert_eq!( + result.validation_error, + Some("TDengine row editing requires all row identifier columns in the result.".to_string()) + ); + assert!(result.statements.is_empty()); + } + + #[test] + fn rejects_tdengine_existing_row_edit_when_composite_key_is_missing() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "device_a".to_string(), + primary_keys: vec!["ts".to_string(), "seq".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("seq", "INT", false, Some("COMPOSITE KEY")), + column("voltage", "FLOAT", true, None), + ]), + }, + columns: vec!["ts".to_string(), "voltage".to_string()], + source_columns: None, + rows: vec![vec![json!("2026-07-10T16:30:00.444+08:00"), json!(220.0)]], + dirty_rows: vec![(0, vec![(1, json!(229.9))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!( + result.validation_error, + Some("TDengine row editing requires all row identifier columns in the result.".to_string()) + ); + assert!(result.statements.is_empty()); + assert!(result.rollback_statements.is_empty()); + } + + #[test] + fn rejects_tdengine_existing_row_identity_changes() { + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Tdengine), + table_meta: DataGridTableMeta { + catalog: None, + schema: Some("dbx_tdengine_demo".to_string()), + table_name: "device_a".to_string(), + primary_keys: vec!["ts".to_string(), "seq".to_string()], + columns: Some(vec![ + column("ts", "TIMESTAMP", false, None), + column("seq", "INT", false, Some("COMPOSITE KEY")), + column("voltage", "FLOAT", true, None), + ]), + }, + columns: vec!["ts".to_string(), "seq".to_string(), "voltage".to_string()], + source_columns: None, + rows: vec![vec![json!("2026-07-10T16:30:00.444+08:00"), json!(2), json!(220.0)]], + dirty_rows: vec![(0, vec![(1, json!(3))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, Some("TDengine row identifier columns cannot be edited.".to_string())); + assert!(result.statements.is_empty()); + assert!(result.rollback_statements.is_empty()); + } + #[test] fn prepares_databend_save_statements() { let result = prepare_data_grid_save(DataGridSaveStatementOptions { diff --git a/crates/dbx-core/src/data_grid_tdengine_sql.rs b/crates/dbx-core/src/data_grid_tdengine_sql.rs index 9e1b0d672e..966273e19e 100644 --- a/crates/dbx-core/src/data_grid_tdengine_sql.rs +++ b/crates/dbx-core/src/data_grid_tdengine_sql.rs @@ -6,11 +6,16 @@ use crate::models::connection::DatabaseType; pub(super) fn build_tdengine_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Vec { let save_columns = effective_columns(options); let mut statements = Vec::new(); - let can_overwrite_existing_rows = save_columns + let has_tbname = save_columns .iter() .any(|column| column.as_deref().is_some_and(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))); + let requires_tbname = options + .table_meta + .primary_keys + .iter() + .any(|primary_key| primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)); - if can_overwrite_existing_rows { + if has_tbname || !requires_tbname { for (row_index, changes) in &options.dirty_rows { let Some(row) = options.rows.get(*row_index) else { continue; @@ -27,6 +32,15 @@ pub(super) fn build_tdengine_data_grid_save_statements(options: &DataGridSaveSta } } + for row_index in &options.deleted_rows { + let Some(row) = options.rows.get(*row_index) else { + continue; + }; + if let Some(statement) = build_tdengine_delete_statement(options, &save_columns, row) { + statements.push(statement); + } + } + for row in &options.new_rows { if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, row) { statements.push(statement); @@ -36,6 +50,183 @@ pub(super) fn build_tdengine_data_grid_save_statements(options: &DataGridSaveSta statements } +pub(super) fn build_tdengine_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) -> Vec { + if has_tdengine_composite_primary_key(options) && !options.new_rows.is_empty() { + return Vec::new(); + } + + let save_columns = effective_columns(options); + let mut statements = Vec::new(); + + for row in &options.new_rows { + if let Some(statement) = build_tdengine_delete_statement(options, &save_columns, row) { + statements.push(statement); + } + } + + for row_index in &options.deleted_rows { + let Some(row) = options.rows.get(*row_index) else { + continue; + }; + if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, row) { + statements.push(statement); + } + } + + for (row_index, _) in &options.dirty_rows { + let Some(row) = options.rows.get(*row_index) else { + continue; + }; + if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, row) { + statements.push(statement); + } + } + + statements +} + +pub(super) fn validate_tdengine_inserted_rows(options: &DataGridSaveStatementOptions) -> Option { + if options.database_type != Some(DatabaseType::Tdengine) || options.new_rows.is_empty() { + return None; + } + + let requires_tbname = options + .table_meta + .primary_keys + .iter() + .any(|primary_key| primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)); + if !requires_tbname { + return None; + } + + let save_columns = effective_columns(options); + if options + .new_rows + .iter() + .any(|row| tdengine_tbname_value(&save_columns, row).is_none_or(|tbname| tbname.trim().is_empty())) + { + return Some(tdengine_insert_identity_error()); + } + + None +} + +pub(super) fn validate_tdengine_existing_rows(options: &DataGridSaveStatementOptions) -> Option { + if options.database_type != Some(DatabaseType::Tdengine) + || (options.deleted_rows.is_empty() && options.dirty_rows.is_empty()) + { + return None; + } + + if has_tdengine_composite_primary_key(options) && !options.deleted_rows.is_empty() { + return Some(tdengine_composite_key_delete_error()); + } + + let save_columns = effective_columns(options); + let primary_keys = tdengine_row_primary_keys(options); + let requires_tbname = options + .table_meta + .primary_keys + .iter() + .any(|primary_key| primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)); + if (requires_tbname + && !save_columns.iter().any(|column| { + column.as_deref().is_some_and(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)) + })) + || primary_keys.is_empty() + || primary_keys.iter().any(|primary_key| find_column_index(&save_columns, primary_key).is_none()) + { + return Some(tdengine_row_identity_error()); + } + + if options.dirty_rows.iter().any(|(_, changes)| { + changes.iter().any(|(column_index, _)| { + save_columns.get(*column_index).and_then(Option::as_deref).is_some_and(|column| { + options.table_meta.primary_keys.iter().any(|primary_key| primary_key.eq_ignore_ascii_case(column)) + }) + }) + }) { + return Some(tdengine_row_identity_readonly_error()); + } + + for row_index in + options.deleted_rows.iter().copied().chain(options.dirty_rows.iter().map(|(row_index, _)| *row_index)) + { + let Some(row) = options.rows.get(row_index) else { + return Some(tdengine_row_identity_error()); + }; + if (requires_tbname && tdengine_tbname_value(&save_columns, row).is_none_or(|tbname| tbname.trim().is_empty())) + || primary_keys.iter().any(|primary_key| { + find_column_index(&save_columns, primary_key) + .and_then(|index| row.get(index)) + .is_none_or(Value::is_null) + }) + { + return Some(tdengine_row_identity_error()); + } + } + + None +} + +fn build_tdengine_delete_statement( + options: &DataGridSaveStatementOptions, + save_columns: &[Option], + row: &[Value], +) -> Option { + if has_tdengine_composite_primary_key(options) { + return None; + } + + let table_name = tdengine_tbname_value(save_columns, row).unwrap_or_else(|| options.table_meta.table_name.clone()); + let primary_keys = tdengine_row_primary_keys(options); + let where_clause = build_primary_key_where( + Some(DatabaseType::Tdengine), + &primary_keys, + save_columns, + row, + options.table_meta.columns.as_deref().unwrap_or(&[]), + ); + if where_clause.is_empty() { + return None; + } + let table = qualified_table_name(Some(DatabaseType::Tdengine), options.table_meta.schema.as_deref(), &table_name); + Some(data_grid_statement( + Some(DatabaseType::Tdengine), + data_grid_delete_sql(Some(DatabaseType::Tdengine), &table, &where_clause), + )) +} + +fn tdengine_row_primary_keys(options: &DataGridSaveStatementOptions) -> Vec { + options + .table_meta + .primary_keys + .iter() + .filter(|primary_key| !primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)) + .cloned() + .collect() +} + +fn has_tdengine_composite_primary_key(options: &DataGridSaveStatementOptions) -> bool { + tdengine_row_primary_keys(options).len() > 1 +} + +fn tdengine_row_identity_error() -> String { + "TDengine row editing requires all row identifier columns in the result.".to_string() +} + +fn tdengine_row_identity_readonly_error() -> String { + "TDengine row identifier columns cannot be edited.".to_string() +} + +fn tdengine_composite_key_delete_error() -> String { + "TDengine tables with composite keys do not support row deletion.".to_string() +} + +fn tdengine_insert_identity_error() -> String { + "TDengine STABLE inserts require a child table name (tbname).".to_string() +} + fn build_tdengine_insert_statement( options: &DataGridSaveStatementOptions, save_columns: &[Option], diff --git a/crates/dbx-core/src/sql_dialect/table_select.rs b/crates/dbx-core/src/sql_dialect/table_select.rs index 09c3e362c5..b749edbdfd 100644 --- a/crates/dbx-core/src/sql_dialect/table_select.rs +++ b/crates/dbx-core/src/sql_dialect/table_select.rs @@ -248,6 +248,9 @@ pub(super) fn build_select_columns( include_tdengine_tbname: bool, ) -> String { if columns.is_empty() { + if database_type == Some(DatabaseType::Tdengine) && include_tdengine_tbname { + return format!("{DBX_TDENGINE_TBNAME_COLUMN}, *"); + } return "*".to_string(); } if database_type == Some(DatabaseType::Tdengine) { diff --git a/crates/dbx-core/src/sql_dialect/tests.rs b/crates/dbx-core/src/sql_dialect/tests.rs index a8a04b656a..c25cc95df4 100644 --- a/crates/dbx-core/src/sql_dialect/tests.rs +++ b/crates/dbx-core/src/sql_dialect/tests.rs @@ -565,6 +565,24 @@ fn builds_iris_table_data_sql_with_literal_top_and_quoted_object() { #[test] fn builds_table_data_special_column_queries() { + assert_eq!( + build_table_data_select_sql(TableDataSelectSqlOptions { + database_type: Some(DatabaseType::Tdengine), + schema: Some("test_db".to_string()), + table_name: "meters".to_string(), + table_type: Some("STABLE".to_string()), + primary_keys: Vec::new(), + columns: Vec::new(), + fallback_order_columns: Vec::new(), + order_by: None, + limit: Some(100), + offset: None, + where_input: None, + include_row_id: false, + ..Default::default() + }), + "SELECT tbname, * FROM `test_db`.`meters` LIMIT 100;" + ); assert_eq!( build_table_data_select_sql(TableDataSelectSqlOptions { database_type: Some(DatabaseType::Tdengine), diff --git a/packages/app-tests/tableEditing.test.ts b/packages/app-tests/tableEditing.test.ts index eb34ceccf4..94262e02c0 100644 --- a/packages/app-tests/tableEditing.test.ts +++ b/packages/app-tests/tableEditing.test.ts @@ -7,6 +7,7 @@ import { canEditExistingTableRows, canInsertTableRows, editablePrimaryKeys, + hasCompleteTdengineRowIdentity, hiveTablePropertiesIndicateTransactional, isHiddenGridColumn, isTdengineExistingRowReadonlyColumn, @@ -39,8 +40,12 @@ test("does not synthesize ROWID for non-Oracle keyless tables", () => { assert.deepEqual(editablePrimaryKeys("mysql", [column("ID"), column("CITY")]), []); }); -test("uses tbname and timestamp as TDengine editable keys", () => { - assert.deepEqual(editablePrimaryKeys("tdengine", [column("ts", true), column("current")]), [DBX_TDENGINE_TBNAME_COLUMN, "ts"]); +test("uses table-specific TDengine editable keys", () => { + const columns = [column("ts", true), column("seq", true), column("current")]; + assert.deepEqual(editablePrimaryKeys("tdengine", columns, "STABLE"), [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"]); + assert.deepEqual(editablePrimaryKeys("tdengine", columns, "TABLE"), ["ts", "seq"]); + assert.equal(hasCompleteTdengineRowIdentity("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"], ["tbname", "ts", "seq", "current"]), true); + assert.equal(hasCompleteTdengineRowIdentity("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"], ["tbname", "ts", "current"]), false); }); test("allows updateable SQL table data editing even without declared primary keys", () => { @@ -97,7 +102,8 @@ test("allows existing row edits according to database-specific key requirements" assert.equal(canEditExistingTableRows("duckdb", undefined, ["id"]), true); assert.equal(canEditExistingTableRows("informix", undefined, []), true); assert.equal(canEditExistingTableRows("informix", undefined, ["id"]), true); - assert.equal(canEditExistingTableRows("tdengine", undefined, ["ts"]), false); + assert.equal(canEditExistingTableRows("tdengine", undefined, []), false); + assert.equal(canEditExistingTableRows("tdengine", undefined, ["ts"]), true); assert.equal(canEditExistingTableRows("tdengine", undefined, [DBX_TDENGINE_TBNAME_COLUMN, "ts"]), true); assert.equal(canEditExistingTableRows("postgres", undefined), true); }); @@ -126,6 +132,7 @@ test("uses elementId as Neo4j editable key when labels have no primary key", () test("keeps TDengine existing row identity and tag columns read-only", () => { assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", DBX_TDENGINE_TBNAME_COLUMN, [column("ts", true)]), true); assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "ts", [column("ts", true)]), true); + assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "seq", [column("ts", true), column("seq", true)]), true); assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "location", [column("location")]), false); assert.equal(isTdengineExistingRowReadonlyColumn("mysql", "ts", [column("ts", true)]), false); assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "location", [{ ...column("location"), extra: "TAG", comment: "TAG" }]), true);