Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

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.ts
index 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.ts
index 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.ts
index 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, colum
const 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.rs
index 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.rs
index 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.rs
index 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 {