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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(sqlserver): omit non-insertable timestamp/rowversion and computed columns in INSERT scripts
YingNing5b2772c4442a
diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.spec.tsindex 7d597daede..8cd808e8e6 100644--- a/apps/desktop/src/composables/__tests__/useDataGridExport.spec.ts+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.spec.ts@@ -1032,6 +1032,53 @@ describe("useDataGridExport prepared row statements", () => {expect(state.canCopyWithExtractor("sql-inserts")).toBe(false);});+ it("omits SQL Server rowversion columns from INSERT copies", () => {+ const table: DataGridTableMeta = {+ tableName: "sync_state",+ primaryKeys: ["id"],+ columns: [+ { name: "id", data_type: "int", is_nullable: false, is_primary_key: true },+ { name: "row_version", data_type: "timestamp", is_nullable: false },+ ],+ };+ const rowVersion = "0x00000000000007D1";+ const onlyRowVersion: CellSelectionMatrix = { rowIndexes: [0], columnIndexes: [1], columns: ["row_version"], rows: [[rowVersion]] };+ const withPrimaryKey: CellSelectionMatrix = { rowIndexes: [0], columnIndexes: [0, 1], columns: ["id", "row_version"], rows: [[1, rowVersion]] };++ expect(createExportState(table, ["id", "row_version"], onlyRowVersion, [1, rowVersion], undefined, undefined, [], DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS, false, undefined, false, undefined, undefined, "sqlserver").canCopyWithExtractor("sql-inserts")).toBe(false);+ expect(createExportState(table, ["id", "row_version"], withPrimaryKey, [1, rowVersion], undefined, undefined, [], DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS, false, undefined, false, undefined, undefined, "sqlserver").canCopyWithExtractor("sql-inserts")).toBe(true);+ });++ it("omits SQL Server computed columns from INSERT copies unless skipping is disabled", () => {+ const table: DataGridTableMeta = {+ tableName: "orders",+ primaryKeys: [],+ columns: [+ { name: "note", data_type: "nvarchar(50)", is_nullable: true },+ { name: "total", data_type: "int", is_nullable: true, extra: "computed" },+ ],+ };+ const matrix: CellSelectionMatrix = { rowIndexes: [0], columnIndexes: [1], columns: ["total"], rows: [[42]] };+ const includeComputed = {+ ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS,+ sql: { ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS.sql, skipComputedColumns: false },+ };++ expect(createExportState(table, ["note", "total"], matrix, ["ok", 42], undefined, undefined, [], DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS, false, undefined, false, undefined, undefined, "sqlserver").canCopyWithExtractor("sql-inserts")).toBe(false);+ expect(createExportState(table, ["note", "total"], matrix, ["ok", 42], undefined, undefined, [], includeComputed, false, undefined, false, undefined, undefined, "sqlserver").canCopyWithExtractor("sql-inserts")).toBe(true);+ });++ it("keeps MySQL timestamp columns insertable in INSERT copies", () => {+ const table: DataGridTableMeta = {+ tableName: "events",+ primaryKeys: [],+ columns: [{ name: "created_at", data_type: "timestamp", is_nullable: false }],+ };+ const matrix: CellSelectionMatrix = { rowIndexes: [0], columnIndexes: [0], columns: ["created_at"], rows: [["2026-09-30 10:00:00"]] };++ expect(createExportState(table, ["created_at"], matrix, ["2026-09-30 10:00:00"]).canCopyWithExtractor("sql-inserts")).toBe(true);+ });+it("keeps a manually-assigned primary key insertable under primary-key exclusion", () => {const compositeKeyTable: DataGridTableMeta = {tableName: "daily_stats",diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.tsindex b43f451f4f..5e017f702c 100644--- a/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts@@ -154,6 +154,40 @@ describe("SQL export column selection across entrypoints", () => {expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: true, columns: sqlExportColumnChoices(names).filter((column) => column.name !== "generated") });});+ it("prefers SQL Server table metadata types so non-insertable columns get filtered", async () => {+ vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch" });+ const names = ["id", "row_version", "total"];+ const items = [{ id: 7, sourceIndex: 0, data: [7, "0x00000000000007D1", 42], isNew: false, isDeleted: false, isDirtyCol: [false, false, false], status: "" }];+ await useDataGridExport(+ createOptions({+ displayItems: computed(() => items),+ getRowItem: (id) => items.find((item) => item.id === id),+ context: computed(() => "table-data"),+ databaseType: computed(() => "sqlserver"),+ columns: computed(() => names),+ sourceColumns: computed(() => names),+ columnTypes: computed(() => ["int4", "varbinary", "int4"]),+ tableMeta: computed(() => ({+ tableName: "sync_state",+ primaryKeys: ["id"],+ columns: [+ { name: "id", data_type: "int" },+ { name: "row_version", data_type: "timestamp" },+ { name: "total", data_type: "int", extra: "computed" },+ ],+ })),+ }),+ ).exportCurrentPageSql();+ expect(formatSqlInsert).toHaveBeenCalledWith(+ expect.objectContaining({+ columns: ["id", "row_version", "total"],+ columnTypes: ["int", "timestamp", "int"],+ columnExtras: [null, null, "computed"],+ rows: [[7, "0x00000000000007D1", 42]],+ }),+ );+ });+it("omits PostgreSQL tsvector fields using query metadata", async () => {vi.mocked(showSqlInsertModeDialog).mockResolvedValue(null);await useDataGridExport(createOptions({ allColumns: computed(() => ["id", "search"]), allColumnTypes: computed(() => ["int", "pg_catalog.tsvector"]) })).exportSql();diff --git a/apps/desktop/src/composables/useDataGridExport.ts b/apps/desktop/src/composables/useDataGridExport.tsindex b40e66af89..a55302071a 100644--- a/apps/desktop/src/composables/useDataGridExport.ts+++ b/apps/desktop/src/composables/useDataGridExport.ts@@ -1850,7 +1850,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {selectedColumns?: SqlExportColumnSelection[],): {columns: string[];- columnTypes?: Array<string | undefined>;+ columnTypes?: Array<string | null | undefined>;columnExtras?: Array<string | null>;spatialColumns?: QueryResult["spatial_columns"];spatialValues?: QueryResult["spatial_values"];@@ -1864,6 +1864,10 @@ export function useDataGridExport(options: UseDataGridExportOptions) {const exportColumnTypes = matchesVisibleColumns && columnTypes.value?.length === result.columns.length ? columnTypes.value : result.columnTypes?.length === result.columns.length ? result.columnTypes : undefined;const metaColumns = tableMeta.value?.columns;const exportColumnExtras = metaColumns?.length ? exportColumns.map((column) => (column ? (metaColumns.find((meta) => normalizeColumnName(meta.name) === normalizeColumnName(column))?.extra ?? null) : null)) : undefined;+ // SQL Server 的结果集列类型来自 TDS:rowversion 会报成 varbinary/binary,据此无法识别不可插入列;+ // 表元数据(sys.columns)里才是 "timestamp"。与数据库级导出链同口径,SQL Server 的 INSERT 载荷+ // 优先用表元数据类型、缺元数据时回退结果集类型(其它引擎维持结果集类型优先)。+ const metadataTypeByColumn = databaseType.value === "sqlserver" && metaColumns?.length ? new Map(metaColumns.map((meta) => [normalizeColumnName(meta.name), meta.data_type])) : undefined;const indexBySource = new Map(columnIndexes.map((item, index) => [item.index, index]));const spatialColumns = result.spatialColumns?.flatMap((column) => {const columnIndex = indexBySource.get(column.column_index);@@ -1871,7 +1875,13 @@ export function useDataGridExport(options: UseDataGridExportOptions) {});return {columns: columnIndexes.map((item) => item.column),- columnTypes: exportColumnTypes ? columnIndexes.map((item) => exportColumnTypes[item.index]) : undefined,+ columnTypes:+ exportColumnTypes || metadataTypeByColumn+ ? columnIndexes.map((item) => {+ const metadataType = metadataTypeByColumn?.get(normalizeColumnName(item.column))?.trim();+ return metadataType || exportColumnTypes?.[item.index] || null;+ })+ : undefined,columnExtras: exportColumnExtras?.some((extra) => !!extra) ? columnIndexes.map((item) => exportColumnExtras[item.index] ?? null) : undefined,...(spatialColumns?.length ? { spatialColumns } : {}),...(result.spatialValues?.length ? { spatialValues: result.spatialValues.map((row) => columnIndexes.map((item) => row[item.index] ?? null)) } : {}),@@ -1977,9 +1987,14 @@ function isCopyInsertOmittedColumn(databaseType: DatabaseType | undefined, columconst columnInfo = tableMeta?.columns?.find((item) => normalizeColumnName(item.name) === normalizeColumnName(column));const normalizedType = columnInfo?.data_type.trim().replace(/^"|"$/g, "").toLowerCase();if (databaseType === "postgres" && (normalizedType === "tsvector" || normalizedType?.endsWith(".tsvector"))) return true;+ // SQL Server 的 timestamp/rowversion 是服务端计数器(TDS 上即 binary(8)),永远不能显式插入;+ // 与 tsvector 同款无条件剔除(镜像 data_grid_sql 的 is_grid_insert_omitted_column)。+ const baseType = normalizedType?.split("(")[0]?.trim();+ if (databaseType === "sqlserver" && (baseType === "timestamp" || baseType === "rowversion")) return true;const extra = columnInfo?.extra?.toLowerCase() ?? "";const isAutoGenerated = isAutoGeneratedColumn(column, tableMeta);- const isComputed = extra.includes("generated always as") && !extra.includes("identity");+ // SQL Server 计算列的 extra 是裸字符串 "computed"(sys.columns),与其它方言的 generated 关键字同样受「跳过计算列」开关控制。+ const isComputed = (extra.includes("generated always as") || (databaseType === "sqlserver" && extra.trim() === "computed")) && !extra.includes("identity");const isPrimaryKey = (tableMeta?.primaryKeys ?? []).some((key) => normalizeColumnName(key) === normalizeColumnName(column));return ((extractorOptions?.sql.skipGeneratedColumns ?? true) && isAutoGenerated && !isPrimaryKey) || ((extractorOptions?.sql.skipComputedColumns ?? true) && isComputed);}diff --git a/crates/dbx-core/src/data/database_export.rs b/crates/dbx-core/src/data/database_export.rsindex 14b174fd29..5f3579c4a3 100644--- a/crates/dbx-core/src/data/database_export.rs+++ b/crates/dbx-core/src/data/database_export.rs@@ -815,6 +815,30 @@ fn is_sqlserver_binary_export_column(database_type: Option<DatabaseType>, column})}+/// SQL Server columns that can never take an explicit `INSERT` value:+/// `timestamp`/`rowversion` counters and computed columns both reject supplied+/// values ("Cannot insert an explicit value into a timestamp column" / "Cannot+/// insert a value into the computed column"), so INSERT scripts (grid copy, SQL+/// export) must omit them, the same way tsvector columns are omitted for+/// PostgreSQL (issue #10764).+fn is_sqlserver_non_insertable_export_column(+ database_type: Option<DatabaseType>,+ column_type: Option<&str>,+ column_extra: Option<&str>,+) -> bool {+ if database_type != Some(DatabaseType::SqlServer) {+ return false;+ }+ if column_extra.is_some_and(|extra| extra.trim().eq_ignore_ascii_case("computed")) {+ return true;+ }+ column_type.is_some_and(|column_type| {+ let normalized = column_type.trim().to_ascii_lowercase();+ let base = normalized.split(['(', ' ', '\t', '\n']).next().unwrap_or("").trim();+ matches!(base, "timestamp" | "rowversion")+ })+}+/// Renders a SQL Server binary value as a T-SQL binary literal (`0x..`). Values/// that are not `0x`-prefixed hex text keep the previous string quoting, so an/// unexpected driver encoding is not silently reinterpreted.@@ -1822,6 +1846,7 @@ fn is_export_insert_column() -> bool {!is_internal_export_column(database_type, column)&& !is_postgres_tsvector_export_column(database_type, column_type)+ && !is_sqlserver_non_insertable_export_column(database_type, column_type, column_extra)&& (database_type != Some(DatabaseType::Mysql) || !is_mysql_generated_column_extra(column_extra))}@@ -7037,7 +7062,80 @@ mod tests {}#[test]- fn sqlserver_rowversion_timestamp_type_is_not_treated_as_datetime() {+ fn sqlserver_insert_scripts_omit_non_insertable_timestamp_and_computed_columns() {+ // `timestamp`/`rowversion` counters and computed columns can never take+ // an explicit INSERT value ("Cannot insert an explicit value into a+ // timestamp column" / "Cannot insert a value into the computed column"),+ // so generated INSERT scripts (grid copy, SQL export) must omit them+ // (issue #10764).+ let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {+ database_type: Some(DatabaseType::SqlServer),+ identifier_quote: None,+ schema: Some("dbo".to_string()),+ table_name: Some("sync_state".to_string()),+ qualified_table_name: None,+ columns: vec![+ "id".to_string(),+ "note".to_string(),+ "row_version".to_string(),+ "stamp_alias".to_string(),+ "total".to_string(),+ ],+ column_types: vec![+ Some("int".to_string()),+ Some("nvarchar(50)".to_string()),+ Some("timestamp".to_string()),+ Some("rowversion".to_string()),+ Some("int".to_string()),+ ],+ column_extras: vec![None, None, None, None, Some("computed".to_string())],+ spatial_columns: Vec::new(),+ spatial_values: Vec::new(),+ rows: vec![vec![+ json!(7),+ json!("ok"),+ json!("0x00000000000007D1"),+ json!("0x00000000000007D2"),+ json!(42),+ ]],+ batch_size: Some(10),+ preserve_original_language: false,+ })+ .unwrap();++ assert_eq!(statements, vec!["INSERT INTO [dbo].[sync_state] ([id], [note]) VALUES (7, N'ok');"]);+ }++ #[test]+ fn mysql_insert_scripts_keep_timestamp_columns() {+ // MySQL `timestamp` is an ordinary datetime column and must stay insertable.+ let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {+ database_type: Some(DatabaseType::Mysql),+ identifier_quote: None,+ schema: None,+ table_name: Some("events".to_string()),+ qualified_table_name: None,+ columns: vec!["id".to_string(), "created_at".to_string()],+ column_types: vec![Some("int".to_string()), Some("timestamp".to_string())],+ column_extras: Vec::new(),+ spatial_columns: Vec::new(),+ spatial_values: Vec::new(),+ rows: vec![vec![json!(1), json!("2026-09-30 10:00:00")]],+ batch_size: Some(10),+ preserve_original_language: false,+ })+ .unwrap();++ assert_eq!(statements.len(), 1);+ assert!(statements[0].contains("`created_at`"), "statements: {statements:?}");+ }++ #[test]+ fn sqlserver_rowversion_timestamp_columns_are_omitted_from_insert_export() {+ // `timestamp`/`rowversion` is a server-generated counter on SQL Server,+ // not a datetime: a replayed INSERT with an explicit value is rejected+ // ("Cannot insert an explicit value into a timestamp column"), so the+ // column is omitted while `datetime2` keeps its literal (issue #10764).let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {database_type: Some(DatabaseType::SqlServer),identifier_quote: None,@@ -7055,12 +7153,7 @@ mod tests {}).unwrap();- assert_eq!(- statements,- vec![- "INSERT INTO [dbo].[events] ([row_version], [created_at]) VALUES ('2026-06-12T10:11:12Z', '2026-06-12 10:11:12.123');"- ]- );+ assert_eq!(statements, vec!["INSERT INTO [dbo].[events] ([created_at]) VALUES ('2026-06-12 10:11:12.123');"]);}#[test]@@ -7386,6 +7479,32 @@ mod tests {);}+ #[test]+ fn database_row_writer_omits_sqlserver_timestamp_columns_from_export_files() {+ let directory = tempfile::tempdir().unwrap();+ let path = directory.path().join("sync_state.sql");+ let mut file = std::fs::File::create(&path).unwrap();++ write_database_export_rows(+ &mut file,+ &[vec![json!(7), json!("0x00000000000007D1")]],+ &["id".to_string(), "row_version".to_string()],+ &[Some("int".to_string()), Some("timestamp".to_string())],+ &[None, None],+ "sync_state",+ "dbo",+ &DatabaseType::SqlServer,+ SqlInsertDialect::Standard,+ )+ .unwrap();+ drop(file);++ assert_eq!(+ std::fs::read_to_string(path).unwrap(),+ "INSERT INTO \"dbo\".\"sync_state\" (\"id\") VALUES (7);\n\n"+ );+ }+#[test]fn split_zip_export_writer_splits_across_insert_batches_into_valid_sql() {let directory = tempfile::tempdir().unwrap();diff --git a/crates/dbx-core/src/data/table_export.rs b/crates/dbx-core/src/data/table_export.rsindex 7ffbba6a58..ae4af06cb6 100644--- a/crates/dbx-core/src/data/table_export.rs+++ b/crates/dbx-core/src/data/table_export.rs@@ -246,8 +246,12 @@ fn resolve_requested_export_columns((resolved_columns, resolved_column_types, resolved_primary_keys)}-fn requested_mysql_sql_export_needs_column_metadata(database_type: DatabaseType, format: &str) -> bool {- database_type == DatabaseType::Mysql && format.eq_ignore_ascii_case("sql")+/// A data-grid SQL export must resolve column metadata from the table when the+/// result-set types cannot drive the INSERT-omission rules: MySQL (generated+/// column extras) and SQL Server (TDS reports `rowversion` as `varbinary`,+/// never as `timestamp`).+fn requested_sql_export_needs_column_metadata(database_type: DatabaseType, format: &str) -> bool {+ matches!(database_type, DatabaseType::Mysql | DatabaseType::SqlServer) && format.eq_ignore_ascii_case("sql")}fn ensure_sql_insert_export_types_supported(format: &str, column_types: &[Option<String>]) -> Result<(), String> {@@ -280,7 +284,14 @@ fn resolve_requested_column_extras_by_position(.collect()}+/// Resolve the column types used by a SQL export. The data grid supplies the+/// types it read from the result set; SQL Server reports `timestamp`/+/// `rowversion` there as `varbinary`/`binary` (TDS), so the INSERT-omission+/// rules would never see it. SQL Server therefore prefers the table metadata+/// (sys.columns) types; other engines keep the result-set types for literal+/// formatting and only fall back to metadata for missing entries.fn resolve_requested_export_column_types(+ database_type: DatabaseType,requested_columns: &[String],requested_column_types: &[Option<String>],table_columns: &[crate::db::ColumnInfo],@@ -290,14 +301,18 @@ fn resolve_requested_export_column_types(.iter().enumerate().map(|(index, requested)| {- requested_column_types+ let requested_type = requested_column_types.get(index).cloned().flatten()- .filter(|column_type| !column_type.trim().is_empty())- .or_else(|| {- table_columns_by_name.get(&requested.to_ascii_lowercase()).map(|column| column.data_type.clone())- })+ .filter(|column_type| !column_type.trim().is_empty());+ let metadata_type =+ table_columns_by_name.get(&requested.to_ascii_lowercase()).map(|column| column.data_type.clone());+ if database_type == DatabaseType::SqlServer {+ metadata_type.filter(|column_type| !column_type.trim().is_empty()).or(requested_type)+ } else {+ requested_type.or(metadata_type)+ }}).collect()}@@ -1633,30 +1648,29 @@ async fn export_table_data_core_inner(request.column_types.as_deref(),request.primary_keys.as_deref(),);- let (column_types, column_extras) =- if requested_mysql_sql_export_needs_column_metadata(db_type, &request.format) {- let table_columns = crate::schema::get_columns_core(- state,- &request.connection_id,- &request.database,- request.schema.as_deref().unwrap_or(""),- &request.table_name,- )- .await?;- (- resolve_requested_export_column_types(&col_names, &requested_column_types, &table_columns),- resolve_requested_export_column_extras(&col_names, &table_columns),- )- } else {- (- requested_column_types,- resolve_requested_column_extras_by_position(- db_type,- requested_columns,- request.column_extras.as_deref(),- ),- )- };+ let (column_types, column_extras) = if requested_sql_export_needs_column_metadata(db_type, &request.format) {+ let table_columns = crate::schema::get_columns_core(+ state,+ &request.connection_id,+ &request.database,+ request.schema.as_deref().unwrap_or(""),+ &request.table_name,+ )+ .await?;+ (+ resolve_requested_export_column_types(db_type, &col_names, &requested_column_types, &table_columns),+ resolve_requested_export_column_extras(&col_names, &table_columns),+ )+ } else {+ (+ requested_column_types,+ resolve_requested_column_extras_by_position(+ db_type,+ requested_columns,+ request.column_extras.as_deref(),+ ),+ )+ };(col_names, column_types, column_extras, primary_keys)} else {let columns = crate::schema::get_columns_core(@@ -3572,7 +3586,7 @@ mod tests {}#[test]- fn requested_mysql_sql_export_resolves_column_metadata_only_for_sql() {+ fn requested_sql_exports_resolve_column_metadata_for_mysql_and_sqlserver() {let table_columns = vec![crate::db::ColumnInfo {name: "ID".to_string(),@@ -3589,13 +3603,16 @@ mod tests {];let requested_columns = vec!["virtual_total".to_string(), "id".to_string(), "missing".to_string()];- assert!(requested_mysql_sql_export_needs_column_metadata(DatabaseType::Mysql, "SQL"));+ assert!(requested_sql_export_needs_column_metadata(DatabaseType::Mysql, "SQL"));+ assert!(requested_sql_export_needs_column_metadata(DatabaseType::SqlServer, "sql"));for format in ["csv", "json", "xlsx"] {- assert!(!requested_mysql_sql_export_needs_column_metadata(DatabaseType::Mysql, format));+ assert!(!requested_sql_export_needs_column_metadata(DatabaseType::Mysql, format));}- assert!(!requested_mysql_sql_export_needs_column_metadata(DatabaseType::Postgres, "sql"));+ assert!(!requested_sql_export_needs_column_metadata(DatabaseType::Postgres, "sql"));+ assert!(!requested_sql_export_needs_column_metadata(DatabaseType::SqlServer, "csv"));assert_eq!(resolve_requested_export_column_types(+ DatabaseType::Mysql,&requested_columns,&[Some("".to_string()), Some("bigint".to_string())],&table_columns,@@ -3606,6 +3623,38 @@ mod tests {resolve_requested_export_column_extras(&requested_columns, &table_columns),vec![Some("VIRTUAL GENERATED".to_string()), Some("auto_increment".to_string()), None]);++ // SQL Server: result-set types report `rowversion` as `varbinary`, so the+ // table metadata types must win — this is what makes the `timestamp` /+ // `computed` omission rules hit on grid SQL exports.+ let sqlserver_columns = vec![+ crate::db::ColumnInfo { name: "id".to_string(), data_type: "int".to_string(), ..Default::default() },+ crate::db::ColumnInfo {+ name: "row_version".to_string(),+ data_type: "timestamp".to_string(),+ ..Default::default()+ },+ crate::db::ColumnInfo {+ name: "total".to_string(),+ data_type: "int".to_string(),+ extra: Some("computed".to_string()),+ ..Default::default()+ },+ ];+ let sqlserver_requested = vec!["id".to_string(), "row_version".to_string(), "total".to_string()];+ assert_eq!(+ resolve_requested_export_column_types(+ DatabaseType::SqlServer,+ &sqlserver_requested,+ &[Some("int4".to_string()), Some("varbinary".to_string()), Some("int4".to_string())],+ &sqlserver_columns,+ ),+ vec![Some("int".to_string()), Some("timestamp".to_string()), Some("int".to_string())]+ );+ assert_eq!(+ resolve_requested_export_column_extras(&sqlserver_requested, &sqlserver_columns),+ vec![None, None, Some("computed".to_string())]+ );}#[test]diff --git a/crates/dbx-sql-data/src/data_grid_sql.rs b/crates/dbx-sql-data/src/data_grid_sql.rsindex 978475cd93..5b328f6c07 100644--- a/crates/dbx-sql-data/src/data_grid_sql.rs+++ b/crates/dbx-sql-data/src/data_grid_sql.rs@@ -3549,7 +3549,10 @@ pub fn is_grid_insert_omitted_column() -> bool {is_synthetic_row_id(database_type, name)|| is_postgres_tsvector_column(database_type, column_info)- || (!include_computed_columns && is_non_identity_generated_column(column_info))+ || is_sqlserver_rowversion_column(database_type, column_info)+ || (!include_computed_columns+ && (is_non_identity_generated_column(column_info)+ || is_sqlserver_computed_column(database_type, column_info)))}fn is_grid_update_omitted_column(@@ -3597,6 +3600,38 @@ fn is_postgres_tsvector_type(data_type: &str) -> bool {normalized == "tsvector" || normalized.ends_with(".tsvector")}+/// SQL Server `timestamp`/`rowversion` columns are server-generated counters:+/// like PostgreSQL `tsvector` they can never take an explicit INSERT value+/// ("Cannot insert an explicit value into a timestamp column"), so they are+/// omitted unconditionally. The grid copy path carries table metadata+/// (sys.columns) types here, where the column surfaces as `timestamp`;+/// result-set types (`varbinary` on TDS) would not identify it.+fn is_sqlserver_rowversion_column(+ database_type: Option<DatabaseType>,+ column_info: Option<&DataGridColumnInfo>,+) -> bool {+ database_type == Some(DatabaseType::SqlServer)+ && column_info.map(|column| is_sqlserver_rowversion_type(&column.data_type)).unwrap_or(false)+}++fn is_sqlserver_rowversion_type(data_type: &str) -> bool {+ let normalized = data_type.trim().trim_matches('"').to_ascii_lowercase();+ let base = normalized.split(['(', ' ', '\t', '\n']).next().unwrap_or("").trim();+ matches!(base, "timestamp" | "rowversion")+}++/// SQL Server computed columns mark themselves with the bare `computed` string+/// in their metadata EXTRA (sys.columns), which the dialect-neutral generated+/// keywords ("generated always as"/"virtual generated"/"stored generated") do+/// not match; without this branch a copy INSERT would still write a value into+/// a computed column ("Cannot insert a value into the computed column").+fn is_sqlserver_computed_column(database_type: Option<DatabaseType>, column_info: Option<&DataGridColumnInfo>) -> bool {+ database_type == Some(DatabaseType::SqlServer)+ && column_info+ .and_then(|column| column.extra.as_deref())+ .is_some_and(|extra| extra.trim().eq_ignore_ascii_case("computed"))+}+pub fn is_non_identity_generated_column(column_info: Option<&DataGridColumnInfo>) -> bool {let extra = column_info.and_then(|column| column.extra.as_deref()).unwrap_or("").to_ascii_lowercase();(extra.contains("generated always as") || extra.contains("virtual generated") || extra.contains("stored generated"))@@ -5546,6 +5581,84 @@ mod tests {);}+ #[test]+ fn builds_copy_insert_statement_omits_sqlserver_rowversion_and_computed_columns() {+ // The copy path carries table metadata (sys.columns): `rowversion` shows+ // up as data_type "timestamp" and computed columns as extra "computed".+ // Both reject explicit INSERT values, so the copy INSERT must omit them+ // (issue #10764); computed returns only under the explicit option.+ let options = |include_computed_columns: bool| DataGridCopyInsertStatementOptions {+ database_type: Some(DatabaseType::SqlServer),+ identifier_quote: None,+ table_meta: Some(DataGridTableMeta {+ catalog: None,+ database: Some("dbx_test".to_string()),+ schema: Some("dbo".to_string()),+ table_name: "sync_state".to_string(),+ primary_keys: vec!["id".to_string()],+ columns: Some(vec![+ column("id", "int", false, None),+ column("note", "nvarchar(50)", true, None),+ column("row_version", "timestamp", false, None),+ column("total", "int", true, Some("computed")),+ ]),+ }),+ columns: vec!["id".to_string(), "note".to_string(), "row_version".to_string(), "total".to_string()],+ column_types: None,+ source_columns: None,+ rows: vec![vec![json!(7), json!("ok"), json!("0x00000000000007D1"), json!(42)]],+ exclude_primary_keys: false,+ include_computed_columns,+ include_database_name: true,+ insert_mode: DataGridCopyInsertMode::Merged,+ };++ assert_eq!(+ build_data_grid_copy_insert_statement(options(false)).as_deref(),+ Some("INSERT INTO [dbx_test].[dbo].[sync_state] ([id], [note]) VALUES (7, N'ok');")+ );+ assert_eq!(+ build_data_grid_copy_insert_statement(options(true)).as_deref(),+ Some("INSERT INTO [dbx_test].[dbo].[sync_state] ([id], [note], [total]) VALUES (7, N'ok', 42);")+ );+ }++ #[test]+ fn sqlserver_rowversion_and_computed_rules_do_not_leak_into_other_dialects() {+ let rowversion = column("row_version", "timestamp", false, None);+ let computed = column("total", "int", true, Some("computed"));+ assert!(is_grid_insert_omitted_column(+ Some(DatabaseType::SqlServer),+ Some(&rowversion),+ Some("row_version"),+ false+ ));+ assert!(is_grid_insert_omitted_column(Some(DatabaseType::SqlServer), Some(&computed), Some("total"), false));+ // The computed-column option only governs the computed family; the SQL+ // Server rowversion rule stays unconditional.+ assert!(is_grid_insert_omitted_column(+ Some(DatabaseType::SqlServer),+ Some(&rowversion),+ Some("row_version"),+ true+ ));+ assert!(!is_grid_insert_omitted_column(Some(DatabaseType::SqlServer), Some(&computed), Some("total"), true));+ // MySQL `timestamp` is an ordinary datetime column and must stay insertable.+ let mysql_timestamp = column("created_at", "timestamp", false, None);+ assert!(!is_grid_insert_omitted_column(+ Some(DatabaseType::Mysql),+ Some(&mysql_timestamp),+ Some("created_at"),+ false+ ));+ assert!(!is_grid_insert_omitted_column(+ Some(DatabaseType::Postgres),+ Some(&mysql_timestamp),+ Some("created_at"),+ false+ ));+ }+#[test]fn oracle_copy_insert_uses_result_column_types_for_date_literals() {let statement = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {