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(transfer): distinguish explicit empty object selection from default
jearhe609f6805a3d4
diff --git a/apps/desktop/src/components/transfer/DataTransferDialog.vue b/apps/desktop/src/components/transfer/DataTransferDialog.vueindex 684c2db0c4..2072d0cfb7 100644--- a/apps/desktop/src/components/transfer/DataTransferDialog.vue+++ b/apps/desktop/src/components/transfer/DataTransferDialog.vue@@ -4,7 +4,7 @@ import { uuid } from "@/lib/common/utils";import { useI18n } from "vue-i18n";import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";import { Button } from "@/components/ui/button";-import { buildTransferObjectSelections, countTransferObjects } from "./transferSelections";+import { buildTransferObjectSelectionField, countTransferObjects } from "./transferSelections";import { createTaskLoadTracker } from "./taskLoadTracker";import { describeTransferStructureOperation, summarizeTransferStructureOperations } from "./structurePlanSummary";import {@@ -812,7 +812,7 @@ async function requestStartTransfer() {tables: [...selectedTables.value],createTable: transferContent.value !== "dataOnly",content: transferContent.value,- objects: buildTransferObjectSelections(selectedObjects.value, treeDisabledGroups.value),+ ...buildTransferObjectSelectionField(selectedObjects.value, treeDisabledGroups.value),...transferStrategyOptions(targetTableStrategy.value),targetTableNameCase: targetTableNameCase.value,quoteTargetColumnNames: quoteTargetColumnNames.value,diff --git a/apps/desktop/src/components/transfer/__tests__/transferSelections.spec.ts b/apps/desktop/src/components/transfer/__tests__/transferSelections.spec.tsindex 7d8ac5451d..5c4260ec9d 100644--- a/apps/desktop/src/components/transfer/__tests__/transferSelections.spec.ts+++ b/apps/desktop/src/components/transfer/__tests__/transferSelections.spec.ts@@ -1,5 +1,5 @@import { describe, expect, it } from "vitest";-import { buildTransferObjectSelections, countTransferObjects, matchBulkObjectNames, parseBulkObjectNames } from "../transferSelections";+import { buildTransferObjectSelectionField, buildTransferObjectSelections, countTransferObjects, matchBulkObjectNames, parseBulkObjectNames } from "../transferSelections";function setOf(names: string[]): Set<string> {return new Set(names);@@ -44,6 +44,23 @@ describe("buildTransferObjectSelections", () => {expect(result).toEqual([]);});+ it("keeps an explicit empty objects field for a saved TABLE-only request", () => {+ const request = {+ tables: ["orders"],+ ...buildTransferObjectSelectionField({ TABLE: setOf(["orders"]) }, []),+ };+ expect(Object.hasOwn(request, "objects")).toBe(true);+ expect(request.objects).toEqual([]);+ });++ it("keeps only the non-table selection for a saved TABLE + VIEW request", () => {+ const request = {+ tables: ["orders"],+ ...buildTransferObjectSelectionField({ TABLE: setOf(["orders"]), VIEW: setOf(["v_orders"]) }, []),+ };+ expect(request.objects).toEqual([{ objectType: "VIEW", names: ["v_orders"] }]);+ });+it("filters disabled object types even when stale selections remain", () => {const result = buildTransferObjectSelections({diff --git a/apps/desktop/src/components/transfer/transferSelections.ts b/apps/desktop/src/components/transfer/transferSelections.tsindex 17f43ba4ea..9fecbde258 100644--- a/apps/desktop/src/components/transfer/transferSelections.ts+++ b/apps/desktop/src/components/transfer/transferSelections.ts@@ -17,6 +17,10 @@ export function countTransferObjects(request: Pick<TransferRequest, "tables" | "* cross-family matrix does not allow) are dropped at the request boundary* even if stale selections are still present in the tree.*/+export function buildTransferObjectSelectionField(selectedObjects: Partial<Record<TransferObjectKind, Set<string>>>, disabledGroups: TransferObjectKind[]): { objects: TransferObjectSelectionPayload[] } {+ return { objects: buildTransferObjectSelections(selectedObjects, disabledGroups) };+}+export function buildTransferObjectSelections(selectedObjects: Partial<Record<TransferObjectKind, Set<string>>>, disabledGroups: TransferObjectKind[]): TransferObjectSelectionPayload[] {return (Object.keys(selectedObjects) as TransferObjectKind[]).filter((kind) => kind !== "TABLE" && !disabledGroups.includes(kind))diff --git a/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts b/apps/desktop/src/stores/__tests__/transferTaskStore.spec.tsindex ef8d55956c..755e561363 100644--- a/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts+++ b/apps/desktop/src/stores/__tests__/transferTaskStore.spec.ts@@ -67,6 +67,39 @@ describe("transferTaskStore", () => {expect(store.listTasks("folder-1").map((task) => task.id)).toEqual(["task-1"]);});+ it("normalizes a legacy task with no object selection to an empty modern selection map", async () => {+ const legacyConfig = makeConfig() as Partial<TransferTaskConfig>;+ delete legacyConfig.objects;+ vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({+ version: 1,+ folders: [],+ tasks: [{ id: "legacy-selection", name: "legacy selection", config: legacyConfig }],+ } as unknown as TransferTaskLibrary);++ const store = useTransferTaskStore();+ await store.initFromStorage();++ expect(store.getTask("legacy-selection")?.config.objects).toEqual({});+ });++ it("round-trips TABLE-only and TABLE + VIEW task selections", async () => {+ const store = useTransferTaskStore();+ const tableOnly = await store.saveTask({ name: "table-only", config: makeConfig({ objects: { TABLE: ["orders"] } }) });+ const tableAndView = await store.saveTask({+ name: "table-and-view",+ config: makeConfig({ objects: { TABLE: ["orders"], VIEW: ["v_orders"] } }),+ });+ const persisted = vi.mocked(api.saveTransferTaskLibrary).mock.calls.at(-1)?.[0] as TransferTaskLibrary;++ vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue(persisted);+ setActivePinia(createPinia());+ const reloadedStore = useTransferTaskStore();+ await reloadedStore.initFromStorage();++ expect(reloadedStore.getTask(tableOnly.id)?.config.objects).toEqual({ TABLE: ["orders"] });+ expect(reloadedStore.getTask(tableAndView.id)?.config.objects).toEqual({ TABLE: ["orders"], VIEW: ["v_orders"] });+ });+it("keeps target column quoting enabled for saved tasks created before the option existed", async () => {const legacyConfig = makeConfig() as Partial<TransferTaskConfig>;delete legacyConfig.quoteTargetColumnNames;diff --git a/crates/dbx-core/src/data/transfer.rs b/crates/dbx-core/src/data/transfer.rsindex 1a3bcdef49..d4edeac8a7 100644--- a/crates/dbx-core/src/data/transfer.rs+++ b/crates/dbx-core/src/data/transfer.rs@@ -268,8 +268,8 @@ pub struct TransferRequest {pub create_table: bool,#[serde(default)]pub content: TransferContent,- #[serde(default)]- pub objects: Vec<TransferObjectSelection>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub objects: Option<Vec<TransferObjectSelection>>,#[serde(default)]pub mode: TransferMode,#[serde(default)]@@ -422,7 +422,42 @@ pub struct TransferStructurePreviewTable {pub sql: String,}+#[derive(Debug, Clone, Copy)]+enum TransferObjectSelectionMode<'a> {+ LegacyUnspecified,+ Explicit(&'a [TransferObjectSelection]),+}++impl<'a> TransferObjectSelectionMode<'a> {+ fn selections(self) -> &'a [TransferObjectSelection] {+ match self {+ Self::LegacyUnspecified => &[],+ Self::Explicit(selections) => selections,+ }+ }++ fn is_legacy_unspecified(self) -> bool {+ matches!(self, Self::LegacyUnspecified)+ }++ fn filter_supported(self, supported: &[TransferObjectKind]) -> Option<Vec<TransferObjectSelection>> {+ match self {+ Self::LegacyUnspecified => None,+ Self::Explicit(selections) => Some(+ selections.iter().filter(|selection| supported.contains(&selection.object_type)).cloned().collect(),+ ),+ }+ }+}+impl TransferRequest {+ fn object_selection_mode(&self) -> TransferObjectSelectionMode<'_> {+ match self.objects.as_deref() {+ Some(selections) => TransferObjectSelectionMode::Explicit(selections),+ None => TransferObjectSelectionMode::LegacyUnspecified,+ }+ }+pub fn target_table_name(&self, source_table: &str) -> String {match self.target_table_name_case {TransferTableNameCase::Preserve => source_table.to_string(),@@ -935,7 +970,8 @@ fn rewrite_cross_family_schema_qualifier(pub fn validate_transfer_request(request: &TransferRequest) -> Result<(), String> {validate_transfer_target_table_names(request)?;- if matches!(request.content, TransferContent::DataOnly) && !request.objects.is_empty() {+ let selection_mode = request.object_selection_mode();+ if matches!(request.content, TransferContent::DataOnly) && !selection_mode.selections().is_empty() {return Err("仅数据模式不传输非表对象".to_string());}if request.drop_target_before_create@@ -945,7 +981,7 @@ pub fn validate_transfer_request(request: &TransferRequest) -> Result<(), StringData-only mode does not create tables, so a dropped target would not be rebuilt.".to_string());}- for selection in &request.objects {+ for selection in selection_mode.selections() {if selection.names.is_empty() {return Err(format!("Object selection for {:?} is empty", selection.object_type));}@@ -2845,6 +2881,22 @@ struct PostgresDomainSource {checks: Vec<String>,}+#[derive(Debug, Clone, Default)]+struct PostgresTableDependencySelection {+ extension_names: Vec<String>,+ enum_type_names: Vec<String>,+ domain_names: Vec<String>,+}++impl PostgresTableDependencySelection {+ fn type_names(&self) -> Vec<String> {+ let mut names = self.enum_type_names.iter().chain(&self.domain_names).cloned().collect::<Vec<_>>();+ names.sort();+ names.dedup();+ names+ }+}+#[derive(Debug, Clone)]struct PostgresMaterializedViewSource {view_name: String,@@ -7680,7 +7732,7 @@ pub fn selected_object_names(selections: &[TransferObjectSelection], kind: &Tran}fn selected_postgres_sequence_names(request: &TransferRequest) -> Vec<String> {- let mut names = selected_object_names(&request.objects, &TransferObjectKind::Sequence);+ let mut names = selected_object_names(request.object_selection_mode().selections(), &TransferObjectKind::Sequence);names.sort();names.dedup();names@@ -7694,12 +7746,27 @@ fn postgres_transfer_relation_names(request: &TransferRequest) -> Vec<String> {names}-/// Whether a kind participates in a transfer. An empty selection is the legacy-/// PG→PG default: every kind participates (views, functions, triggers,-/// materialized views are all transferred). Once the caller explicitly selects-/// objects, only kinds with a non-empty selection participate.-pub fn object_kind_selected_or_defaulted(selections: &[TransferObjectSelection], kind: &TransferObjectKind) -> bool {- selections.is_empty() || !selected_object_names(selections, kind).is_empty()+/// Whether a kind participates in a transfer. `None` is the legacy PG→PG fallback;+/// `Some([])` is an explicit empty selection and selects no kinds.+pub fn object_kind_selected_or_defaulted(+ selections: Option<&[TransferObjectSelection]>,+ kind: &TransferObjectKind,+) -> bool {+ selections.is_none_or(|selections| !selected_object_names(selections, kind).is_empty())+}++fn object_name_selected_or_defaulted(+ selection_mode: TransferObjectSelectionMode<'_>,+ kind: &TransferObjectKind,+ name: &str,+) -> bool {+ match selection_mode {+ TransferObjectSelectionMode::LegacyUnspecified => true,+ TransferObjectSelectionMode::Explicit(selections) => {+ object_kind_selected_or_defaulted(Some(selections), kind)+ && selected_object_names(selections, kind).iter().any(|selected| selected == name)+ }+ }}pub fn should_copy_data(content: &TransferContent) -> bool {@@ -7721,12 +7788,11 @@ fn transfer_kind_from_object_source_kind(kind: &db::ObjectSourceKind) -> Option<fn filter_object_sources_by_selection(sources: Vec<db::ObjectSource>,- selections: &[TransferObjectSelection],+ selection_mode: TransferObjectSelectionMode<'_>,) -> Vec<db::ObjectSource> {- // Empty selection is the legacy PG→PG default: transfer everything.- if selections.is_empty() {+ let TransferObjectSelectionMode::Explicit(selections) = selection_mode else {return sources;- }+ };sources.into_iter().filter(|source| {@@ -7747,29 +7813,29 @@ fn filter_object_sources_by_selection(pub fn should_transfer_schema_objects(source_db_type: &DatabaseType,target_db_type: &DatabaseType,- content: &TransferContent,- objects: &[TransferObjectSelection],+ request: &TransferRequest,) -> bool {- if matches!(content, TransferContent::DataOnly) {+ if matches!(request.content, TransferContent::DataOnly) {return false;}- if !objects.is_empty() {- // A table-only selection is already handled by the table transfer pass.- // Do not enter the PostgreSQL-family schema-object path just because the- // request also carries the selected table kind. This matters for- // Kingbase, whose catalog is not a drop-in PostgreSQL catalog.- return objects- .iter()- .any(|selection| selection.object_type != TransferObjectKind::Table && !selection.names.is_empty());- }- if matches!(source_db_type, DatabaseType::Kingbase) || matches!(target_db_type, DatabaseType::Kingbase) {- // Kingbase V8 does not expose every PostgreSQL pg_catalog relation used- // by the optional object scanner. Empty selection means the legacy- // table-transfer request here, so avoid probing unsupported catalogs.- return false;+ match request.object_selection_mode() {+ TransferObjectSelectionMode::Explicit(selections) => {+ // A table-only selection is already handled by the table transfer pass.+ // Explicit empty selections must never enter a legacy all-objects path.+ selections+ .iter()+ .any(|selection| selection.object_type != TransferObjectKind::Table && !selection.names.is_empty())+ }+ TransferObjectSelectionMode::LegacyUnspecified => {+ if matches!(source_db_type, DatabaseType::Kingbase) || matches!(target_db_type, DatabaseType::Kingbase) {+ // Kingbase V8 does not expose every PostgreSQL pg_catalog relation used+ // by the optional object scanner, so keep its confirmed no-fallback behavior.+ return false;+ }+ transfer_object_family(source_db_type) == Some(TransferObjectFamily::Postgres)+ && transfer_object_family(target_db_type) == Some(TransferObjectFamily::Postgres)+ }}- transfer_object_family(source_db_type) == Some(TransferObjectFamily::Postgres)- && transfer_object_family(target_db_type) == Some(TransferObjectFamily::Postgres)}/// Transfers selected non-table objects from source to target.@@ -7792,7 +7858,7 @@ where}let source_db_type = get_db_type(state, &request.source_connection_id).await?;let target_db_type = get_db_type(state, &request.target_connection_id).await?;- if !should_transfer_schema_objects(&source_db_type, &target_db_type, &request.content, &request.objects) {+ if !should_transfer_schema_objects(&source_db_type, &target_db_type, request) {return Ok(TransferObjectOutcome::default());}if !is_same_transfer_family(&source_db_type, &target_db_type) {@@ -7812,8 +7878,7 @@ wherelet mut filtered_request = request.clone();if let Some(family) = transfer_object_family(&source_db_type) {let supported = transfer_object_kinds_for_family(&family);- filtered_request.objects =- request.objects.iter().filter(|sel| supported.contains(&sel.object_type)).cloned().collect();+ filtered_request.objects = request.object_selection_mode().filter_supported(&supported);}match transfer_object_family(&source_db_type) {Some(TransferObjectFamily::Postgres) => {@@ -7868,9 +7933,11 @@ wherelet source_db = &request.source_database;let target_db =if request.target_database.trim().is_empty() { source_db.as_str() } else { request.target_database.as_str() };- let order = ordered_transfer_object_kinds(request.objects.iter().map(|s| s.object_type).collect());+ let order = ordered_transfer_object_kinds(+ request.object_selection_mode().selections().iter().map(|s| s.object_type).collect(),+ );for kind in order {- for name in selected_object_names(&request.objects, &kind) {+ for name in selected_object_names(request.object_selection_mode().selections(), &kind) {if is_cancelled(&request.transfer_id).await {return Err("Cancelled".to_string());}@@ -7937,9 +8004,11 @@ wherelet mut outcome = TransferObjectOutcome::default();let source_schema = resolve_oracle_schema(&request.source_schema, &request.source_database);let target_schema = resolve_oracle_schema(&request.target_schema, &request.target_database);- let order = ordered_transfer_object_kinds(request.objects.iter().map(|s| s.object_type).collect());+ let order = ordered_transfer_object_kinds(+ request.object_selection_mode().selections().iter().map(|s| s.object_type).collect(),+ );for kind in order {- for name in selected_object_names(&request.objects, &kind) {+ for name in selected_object_names(request.object_selection_mode().selections(), &kind) {if is_cancelled(&request.transfer_id).await {return Err("Cancelled".to_string());}@@ -8008,9 +8077,11 @@ whereif request.source_schema.trim().is_empty() { "dbo".to_string() } else { request.source_schema.clone() };let target_schema =if request.target_schema.trim().is_empty() { "dbo".to_string() } else { request.target_schema.clone() };- let order = ordered_transfer_object_kinds(request.objects.iter().map(|s| s.object_type).collect());+ let order = ordered_transfer_object_kinds(+ request.object_selection_mode().selections().iter().map(|s| s.object_type).collect(),+ );for kind in order {- for name in selected_object_names(&request.objects, &kind) {+ for name in selected_object_names(request.object_selection_mode().selections(), &kind) {if is_cancelled(&request.transfer_id).await {return Err("Cancelled".to_string());}@@ -8078,7 +8149,8 @@ wherelet target_db_type = get_db_type(state, &request.target_connection_id).await?;let allowed = cross_family_transferable_object_kinds(&source_db_type, &target_db_type);let unsupported: Vec<String> = request- .objects+ .object_selection_mode()+ .selections().iter().filter(|selection| !allowed.contains(&selection.object_type)).map(|selection| format!("{:?}", selection.object_type))@@ -8099,9 +8171,11 @@ where};let source_schema = resolve_schema(&request.source_schema, &request.source_database, &source_db_type);let target_schema = resolve_schema(&request.target_schema, &request.target_database, &target_db_type);- let order = ordered_transfer_object_kinds(request.objects.iter().map(|s| s.object_type).collect());+ let order = ordered_transfer_object_kinds(+ request.object_selection_mode().selections().iter().map(|s| s.object_type).collect(),+ );for kind in order {- for name in selected_object_names(&request.objects, &kind) {+ for name in selected_object_names(request.object_selection_mode().selections(), &kind) {if is_cancelled(&request.transfer_id).await {return Err("Cancelled".to_string());}@@ -8381,19 +8455,102 @@ async fn get_postgres_trigger_sources_for_transfer(.collect())}+fn postgres_table_dependency_selection_sql(schema: &str, tables: &[String]) -> Option<String> {+ if tables.is_empty() {+ return None;+ }+ let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");+ let source_schema = quote_string_literal(schema);+ Some(format!(+ "WITH RECURSIVE selected_tables AS ( \+ SELECT c.oid FROM pg_catalog.pg_class c \+ JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \+ WHERE n.nspname = {source_schema} AND c.relkind IN ('r','p','f') AND c.relname IN ({table_list}) \+ ), selected_dependencies(classid, objid) AS ( \+ SELECT 'pg_catalog.pg_class'::regclass, oid FROM selected_tables \+ UNION SELECT 'pg_catalog.pg_attrdef'::regclass, a.oid \+ FROM pg_catalog.pg_attrdef a JOIN selected_tables t ON t.oid = a.adrelid \+ UNION SELECT 'pg_catalog.pg_constraint'::regclass, c.oid \+ FROM pg_catalog.pg_constraint c JOIN selected_tables t ON t.oid = c.conrelid \+ UNION SELECT 'pg_catalog.pg_class'::regclass, i.indexrelid \+ FROM pg_catalog.pg_index i JOIN selected_tables t ON t.oid = i.indrelid \+ UNION \+ SELECT d.refclassid, d.refobjid \+ FROM pg_catalog.pg_depend d \+ JOIN selected_dependencies parent ON d.classid = parent.classid AND d.objid = parent.objid \+ WHERE d.deptype <> 'p' AND d.refclassid IN ( \+ 'pg_catalog.pg_type'::regclass, 'pg_catalog.pg_proc'::regclass, \+ 'pg_catalog.pg_extension'::regclass, 'pg_catalog.pg_opclass'::regclass, \+ 'pg_catalog.pg_operator'::regclass, 'pg_catalog.pg_collation'::regclass \+ ) \+ ) \+ SELECT 'ENUM'::text, t.typname \+ FROM selected_dependencies d JOIN pg_catalog.pg_type t ON d.classid = 'pg_catalog.pg_type'::regclass AND d.objid = t.oid \+ JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \+ WHERE t.typtype = 'e' AND n.nspname = {source_schema} \+ UNION \+ SELECT 'DOMAIN'::text, t.typname \+ FROM selected_dependencies d JOIN pg_catalog.pg_type t ON d.classid = 'pg_catalog.pg_type'::regclass AND d.objid = t.oid \+ JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \+ WHERE t.typtype = 'd' AND n.nspname = {source_schema} \+ UNION \+ SELECT 'EXTENSION'::text, e.extname \+ FROM selected_dependencies d JOIN pg_catalog.pg_extension e ON d.classid = 'pg_catalog.pg_extension'::regclass AND d.objid = e.oid \+ ORDER BY 1, 2"+ ))+}++async fn get_postgres_table_dependency_selection(+ state: &AppState,+ pool_key: &str,+ schema: &str,+ tables: &[String],+) -> Result<PostgresTableDependencySelection, String> {+ let Some(sql) = postgres_table_dependency_selection_sql(schema, tables) else {+ return Ok(PostgresTableDependencySelection::default());+ };+ let rows = execute_on_pool(state, pool_key, &sql).await?.rows;+ let mut selection = PostgresTableDependencySelection::default();+ for row in rows {+ let (Some(kind), Some(name)) = (json_string_cell(&row, 0), json_string_cell(&row, 1)) else {+ continue;+ };+ match kind.as_str() {+ "ENUM" => selection.enum_type_names.push(name),+ "DOMAIN" => selection.domain_names.push(name),+ "EXTENSION" => selection.extension_names.push(name),+ _ => {}+ }+ }+ for names in [&mut selection.extension_names, &mut selection.enum_type_names, &mut selection.domain_names] {+ names.sort();+ names.dedup();+ }+ Ok(selection)+}+async fn get_postgres_extension_sources_for_transfer(state: &AppState,pool_key: &str,schema: &str,+ selected_names: Option<&[String]>,) -> Result<Vec<PostgresExtensionSource>, String> {- let sql = format!(- "SELECT e.extname \- FROM pg_extension e \- JOIN pg_namespace n ON n.oid = e.extnamespace \- WHERE n.nspname = {} \- ORDER BY e.extname",- quote_string_literal(schema)- );+ let sql = if let Some(names) = selected_names {+ if names.is_empty() {+ return Ok(Vec::new());+ }+ let name_list = names.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ format!("SELECT extname FROM pg_catalog.pg_extension WHERE extname IN ({name_list}) ORDER BY extname")+ } else {+ format!(+ "SELECT e.extname \+ FROM pg_extension e \+ JOIN pg_namespace n ON n.oid = e.extnamespace \+ WHERE n.nspname = {} \+ ORDER BY e.extname",+ quote_string_literal(schema)+ )+ };let rows = execute_on_pool(state, pool_key, &sql).await?.rows;Ok(rows.into_iter()@@ -8530,15 +8687,94 @@ async fn get_postgres_policy_statements_for_transfer(Ok(result_rows_to_string_statements(execute_on_pool(state, pool_key, &sql).await?.rows))}+fn postgres_transfer_relation_scope_filter(request: &TransferRequest) -> String {+ match request.object_selection_mode() {+ TransferObjectSelectionMode::LegacyUnspecified => {+ let names = postgres_transfer_relation_names(request);+ let name_list = names.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ let table_filter =+ if names.is_empty() { "FALSE".to_string() } else { format!("c.relname IN ({name_list})") };+ format!("(c.relkind IN ('v','m') OR ({table_filter} AND c.relkind IN ('r','p','f','S'))) ")+ }+ TransferObjectSelectionMode::Explicit(selections) => {+ let mut filters = Vec::new();+ if !request.tables.is_empty() {+ let names = request.tables.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ filters.push(format!("(c.relkind IN ('r','p','f') AND c.relname IN ({names}))"));+ }+ for (kind, relkind) in [+ (TransferObjectKind::View, "v"),+ (TransferObjectKind::MaterializedView, "m"),+ (TransferObjectKind::Sequence, "S"),+ ] {+ let names = selected_object_names(selections, &kind);+ if !names.is_empty() {+ let name_list = names.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ filters.push(format!("(c.relkind = '{relkind}' AND c.relname IN ({name_list}))"));+ }+ }+ if filters.is_empty() {+ "FALSE".to_string()+ } else {+ filters.join(" OR ")+ }+ }+ }+}++fn postgres_transfer_routine_scope_filter(request: &TransferRequest, has_prokind: bool) -> String {+ match request.object_selection_mode() {+ TransferObjectSelectionMode::LegacyUnspecified => {+ postgres_transfer_routine_catalog_sql(has_prokind).1.to_string()+ }+ TransferObjectSelectionMode::Explicit(selections) => {+ let mut filters = Vec::new();+ let functions = selected_object_names(selections, &TransferObjectKind::Function);+ if !functions.is_empty() {+ let names = functions.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ filters.push(if has_prokind {+ format!("(p.prokind = 'f' AND p.proname IN ({names}))")+ } else {+ format!("(p.proname IN ({names}) AND NOT p.proisagg AND NOT p.proiswindow)")+ });+ }+ if has_prokind {+ let procedures = selected_object_names(selections, &TransferObjectKind::Procedure);+ if !procedures.is_empty() {+ let names = procedures.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ filters.push(format!("(p.prokind = 'p' AND p.proname IN ({names}))"));+ }+ }+ if filters.is_empty() {+ "FALSE".to_string()+ } else {+ filters.join(" OR ")+ }+ }+ }+}+fn postgres_transfer_ownership_statements_sql(source_schema: &str,target_schema: &str,- tables: &[String],+ request: &TransferRequest,has_prokind: bool,+ dependency_type_names: &[String],) -> String {- let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");- let table_filter = if tables.is_empty() { "FALSE".to_string() } else { format!("c.relname IN ({table_list})") };- let (routine_kind, routine_filter) = postgres_transfer_routine_catalog_sql(has_prokind);+ let (routine_kind, _) = postgres_transfer_routine_catalog_sql(has_prokind);+ let relation_filter = postgres_transfer_relation_scope_filter(request);+ let routine_filter = postgres_transfer_routine_scope_filter(request, has_prokind);+ let is_legacy = request.object_selection_mode().is_legacy_unspecified();+ let schema_scope_filter = if is_legacy { "TRUE" } else { "FALSE" };+ let type_filter = if is_legacy {+ "t.typtype IN ('e','d')".to_string()+ } else if dependency_type_names.is_empty() {+ "FALSE".to_string()+ } else {+ let names = dependency_type_names.iter().map(|name| quote_string_literal(name)).collect::<Vec<_>>().join(", ");+ format!("t.typtype IN ('e','d') AND t.typname IN ({names})")+ };+format!("WITH relation_owners AS ( \SELECT CASE c.relkind \@@ -8551,7 +8787,7 @@ fn postgres_transfer_ownership_statements_sql(pg_get_userbyid(c.relowner) AS owner_name \FROM pg_catalog.pg_class c \JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \- WHERE n.nspname = {source_schema} AND (c.relkind IN ('v','m') OR ({table_filter} AND c.relkind IN ('r','p','f','S'))) \+ WHERE n.nspname = {source_schema} AND {relation_filter} \), \routine_owners AS ( \SELECT format('ALTER %s %I.%I(%s) OWNER TO ', \@@ -8568,12 +8804,12 @@ fn postgres_transfer_ownership_statements_sql(pg_get_userbyid(t.typowner) AS owner_name \FROM pg_catalog.pg_type t \JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \- WHERE n.nspname = {source_schema} AND t.typtype IN ('e','d') \+ WHERE n.nspname = {source_schema} AND {type_filter} \) \SELECT stmt_prefix, owner_name FROM ( \SELECT format('ALTER SCHEMA %I OWNER TO ', {target_schema}) AS stmt_prefix, \pg_get_userbyid(n.nspowner) AS owner_name \- FROM pg_catalog.pg_namespace n WHERE n.nspname = {source_schema} \+ FROM pg_catalog.pg_namespace n WHERE n.nspname = {source_schema} AND {schema_scope_filter} \UNION ALL SELECT stmt_prefix, owner_name FROM relation_owners \UNION ALL SELECT stmt_prefix, owner_name FROM routine_owners \UNION ALL SELECT stmt_prefix, owner_name FROM type_owners \@@ -8581,19 +8817,33 @@ fn postgres_transfer_ownership_statements_sql(WHERE stmt_prefix IS NOT NULL AND owner_name IS NOT NULL",source_schema = quote_string_literal(source_schema),target_schema = quote_string_literal(target_schema),- table_filter = table_filter,+ relation_filter = relation_filter,+ routine_filter = routine_filter,+ type_filter = type_filter,+ schema_scope_filter = schema_scope_filter,)}async fn get_postgres_ownership_statements_for_transfer(state: &AppState,pool_key: &str,- source_schema: &str,- target_schema: &str,- tables: &[String],+ request: &TransferRequest,has_prokind: bool,) -> Result<Vec<PostgresOwnershipStatement>, String> {- let sql = postgres_transfer_ownership_statements_sql(source_schema, target_schema, tables, has_prokind);+ let dependency_type_names = if request.object_selection_mode().is_legacy_unspecified() {+ Vec::new()+ } else {+ get_postgres_table_dependency_selection(state, pool_key, &request.source_schema, &request.tables)+ .await?+ .type_names()+ };+ let sql = postgres_transfer_ownership_statements_sql(+ &request.source_schema,+ &request.target_schema,+ request,+ has_prokind,+ &dependency_type_names,+ );Ok(result_rows_to_postgres_ownership_statements(execute_on_pool(state, pool_key, &sql).await?.rows))}@@ -8750,16 +9000,8 @@ pub async fn preview_transfer_ownership(let (missing_owners, target_owner) =if request.create_table && is_postgres_compat_transfer(source_db_type, target_db_type) {let has_prokind = postgres_transfer_catalog_capabilities(state, source_pool_key).await?.has_prokind;- let relation_names = postgres_transfer_relation_names(request);- let statements = get_postgres_ownership_statements_for_transfer(- state,- source_pool_key,- &request.source_schema,- &request.target_schema,- &relation_names,- has_prokind,- )- .await?;+ let statements =+ get_postgres_ownership_statements_for_transfer(state, source_pool_key, request, has_prokind).await?;let roles = distinct_postgres_ownership_roles(&statements);let existing_roles = get_existing_postgres_roles(state, target_pool_key, &roles).await?;let missing_owners = roles.into_iter().filter(|role| !existing_roles.contains(role)).collect::<Vec<_>>();@@ -8806,12 +9048,13 @@ pub async fn preview_transfer_ownership(fn postgres_transfer_grant_statements_sql(source_schema: &str,target_schema: &str,- tables: &[String],+ request: &TransferRequest,has_prokind: bool,) -> String {- let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");- let table_filter = if tables.is_empty() { "FALSE".to_string() } else { format!("c.relname IN ({table_list})") };- let (routine_kind, routine_filter) = postgres_transfer_routine_catalog_sql(has_prokind);+ let (routine_kind, _) = postgres_transfer_routine_catalog_sql(has_prokind);+ let relation_filter = postgres_transfer_relation_scope_filter(request);+ let routine_filter = postgres_transfer_routine_scope_filter(request, has_prokind);+ let schema_scope_filter = if request.object_selection_mode().is_legacy_unspecified() { "TRUE" } else { "FALSE" };format!("WITH schema_grants AS ( \SELECT format( \@@ -8824,7 +9067,7 @@ fn postgres_transfer_grant_statements_sql(FROM ( \SELECT n.nspname, (aclexplode(n.nspacl)).* \FROM pg_catalog.pg_namespace n \- WHERE n.nspname = {source_schema} \+ WHERE n.nspname = {source_schema} AND {schema_scope_filter} \) a \LEFT JOIN pg_roles grantee ON grantee.oid = a.grantee \GROUP BY a.grantee, grantee.rolname \@@ -8844,7 +9087,7 @@ fn postgres_transfer_grant_statements_sql(SELECT c.relname, c.relkind, (aclexplode(c.relacl)).* \FROM pg_catalog.pg_class c \JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \- WHERE n.nspname = {source_schema} AND (c.relkind IN ('v','m') OR ({table_filter} AND c.relkind IN ('r','p','f','S'))) \+ WHERE n.nspname = {source_schema} AND {relation_filter} \) a \LEFT JOIN pg_roles grantee ON grantee.oid = a.grantee \) rels \@@ -8881,19 +9124,20 @@ fn postgres_transfer_grant_statements_sql(WHERE stmt IS NOT NULL",source_schema = quote_string_literal(source_schema),target_schema = quote_string_literal(target_schema),- table_filter = table_filter,+ schema_scope_filter = schema_scope_filter,+ relation_filter = relation_filter,+ routine_filter = routine_filter,)}async fn get_postgres_grant_statements_for_transfer(state: &AppState,pool_key: &str,- source_schema: &str,- target_schema: &str,- tables: &[String],+ request: &TransferRequest,has_prokind: bool,) -> Result<Vec<String>, String> {- let sql = postgres_transfer_grant_statements_sql(source_schema, target_schema, tables, has_prokind);+ let sql =+ postgres_transfer_grant_statements_sql(&request.source_schema, &request.target_schema, request, has_prokind);Ok(result_rows_to_string_statements(execute_on_pool(state, pool_key, &sql).await?.rows))}@@ -11301,11 +11545,48 @@ whereensure_postgres_transfer_schema_exists(state, target_pool_key, &request.target_schema, &target_db_type).await?;- let extensions =- get_postgres_extension_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;- let enum_types = get_postgres_enum_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;- let domains = get_postgres_domain_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;- let selected_sequence_names = if request.objects.is_empty() {+ let selection_mode = request.object_selection_mode();+ let table_dependencies = if selection_mode.is_legacy_unspecified() {+ None+ } else {+ Some(+ get_postgres_table_dependency_selection(state, source_pool_key, &request.source_schema, &request.tables)+ .await?,+ )+ };+ let extensions = get_postgres_extension_sources_for_transfer(+ state,+ source_pool_key,+ &request.source_schema,+ table_dependencies.as_ref().map(|dependencies| dependencies.extension_names.as_slice()),+ )+ .await?+ .into_iter()+ .filter(|extension| {+ table_dependencies+ .as_ref()+ .is_none_or(|dependencies| dependencies.extension_names.contains(&extension.extension_name))+ })+ .collect::<Vec<_>>();+ let enum_types = get_postgres_enum_sources_for_transfer(state, source_pool_key, &request.source_schema)+ .await?+ .into_iter()+ .filter(|enum_type| {+ table_dependencies+ .as_ref()+ .is_none_or(|dependencies| dependencies.enum_type_names.contains(&enum_type.type_name))+ })+ .collect::<Vec<_>>();+ let domains = get_postgres_domain_sources_for_transfer(state, source_pool_key, &request.source_schema)+ .await?+ .into_iter()+ .filter(|domain| {+ table_dependencies+ .as_ref()+ .is_none_or(|dependencies| dependencies.domain_names.contains(&domain.domain_name))+ })+ .collect::<Vec<_>>();+ let selected_sequence_names = if selection_mode.is_legacy_unspecified() {get_postgres_sequence_names_for_transfer(state, source_pool_key, &request.source_schema).await?} else {selected_postgres_sequence_names(request)@@ -11455,16 +11736,18 @@ wherelet object_sources = filter_object_sources_by_selection(get_postgres_schema_object_sources_for_transfer(state, source_pool_key, &request.source_schema, has_prokind).await?,- &request.objects,+ request.object_selection_mode(),);let materialized_views =get_postgres_materialized_view_sources_for_transfer(state, source_pool_key, &request.source_schema).await?.into_iter().filter(|view| {- object_kind_selected_or_defaulted(&request.objects, &TransferObjectKind::MaterializedView)- && selected_object_names(&request.objects, &TransferObjectKind::MaterializedView)- .contains(&view.view_name)+ object_name_selected_or_defaulted(+ request.object_selection_mode(),+ &TransferObjectKind::MaterializedView,+ &view.view_name,+ )}).collect::<Vec<_>>();let trigger_sources =@@ -11472,9 +11755,11 @@ where.await?.into_iter().filter(|trigger| {- object_kind_selected_or_defaulted(&request.objects, &TransferObjectKind::Trigger)- && selected_object_names(&request.objects, &TransferObjectKind::Trigger)- .contains(&trigger.trigger_name)+ object_name_selected_or_defaulted(+ request.object_selection_mode(),+ &TransferObjectKind::Trigger,+ &trigger.trigger_name,+ )}).collect::<Vec<_>>();let policy_statements = get_postgres_policy_statements_for_transfer(@@ -11487,19 +11772,10 @@ wherecatalog_capabilities.supports_policy_permissiveness,).await?;- let relation_names = postgres_transfer_relation_names(request);let ownership_statements = if matches!(request.ownership_policy, TransferOwnershipPolicy::Skip) {Vec::new()} else {- get_postgres_ownership_statements_for_transfer(- state,- source_pool_key,- &request.source_schema,- &request.target_schema,- &relation_names,- has_prokind,- )- .await?+ get_postgres_ownership_statements_for_transfer(state, source_pool_key, request, has_prokind).await?};let ownership_existing_roles = if matches!(request.ownership_policy, TransferOwnershipPolicy::ReassignMissing) {let roles = distinct_postgres_ownership_roles(&ownership_statements);@@ -11514,15 +11790,8 @@ where} else {None};- let grant_statements = get_postgres_grant_statements_for_transfer(- state,- source_pool_key,- &request.source_schema,- &request.target_schema,- &relation_names,- has_prokind,- )- .await?;+ let grant_statements =+ get_postgres_grant_statements_for_transfer(state, source_pool_key, request, has_prokind).await?;let materialized_view_step_count = materialized_views.iter().map(|view| generate_postgres_materialized_view_ddls(view, &request.target_schema).len())@@ -12673,10 +12942,38 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;})).unwrap();assert_eq!(request.content, TransferContent::StructureAndData);- assert!(request.objects.is_empty());+ assert_eq!(request.objects, None);assert!(request.quote_target_column_names);}+ #[test]+ fn transfer_request_distinguishes_missing_empty_and_selected_objects() {+ let mut base = serde_json::json!({+ "transferId": "t1", "sourceConnectionId": "s", "sourceDatabase": "db",+ "sourceSchema": "public", "targetConnectionId": "t", "targetDatabase": "db",+ "targetSchema": "public", "tables": ["a"], "createTable": true,+ "mode": "append", "targetTableNameCase": "preserve", "batchSize": 1000+ });+ let legacy: TransferRequest = serde_json::from_value(base.clone()).unwrap();+ assert_eq!(legacy.objects, None);+ assert!(serde_json::to_value(&legacy).unwrap().get("objects").is_none());++ base["objects"] = serde_json::json!([]);+ let explicit_empty: TransferRequest = serde_json::from_value(base.clone()).unwrap();+ assert_eq!(explicit_empty.objects, Some(Vec::new()));+ assert_eq!(serde_json::to_value(&explicit_empty).unwrap()["objects"], serde_json::json!([]));++ base["objects"] = serde_json::json!([{"objectType": "VIEW", "names": ["v1"]}]);+ let explicit_selection: TransferRequest = serde_json::from_value(base).unwrap();+ assert_eq!(+ explicit_selection.objects,+ Some(vec![TransferObjectSelection {+ object_type: TransferObjectKind::View,+ names: vec!["v1".to_string()],+ }]),+ );+ }+#[test]fn transfer_request_serializes_new_fields_camel_case() {let request = TransferRequest {@@ -12692,10 +12989,10 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;tables: vec!["a".to_string()],create_table: true,content: TransferContent::StructureOnly,- objects: vec![TransferObjectSelection {+ objects: Some(vec![TransferObjectSelection {object_type: TransferObjectKind::View,names: vec!["v1".to_string()],- }],+ }]),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -12752,6 +13049,17 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;assert!(!sqlserver.contains(&TransferObjectKind::MaterializedView));assert!(transfer_object_kinds(&DatabaseType::Sqlite).is_empty());}++ #[test]+ fn object_kind_fallback_distinguishes_unspecified_from_explicit_empty() {+ let view = TransferObjectKind::View;+ assert!(object_kind_selected_or_defaulted(None, &view));+ assert!(!object_kind_selected_or_defaulted(Some(&[]), &view));+ assert!(object_kind_selected_or_defaulted(+ Some(&[TransferObjectSelection { object_type: view, names: vec!["v1".into()] }]),+ &view,+ ));+ }}mod transfer_validation_tests {@@ -12777,17 +13085,17 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;ownership_policy: TransferOwnershipPolicy::Preserve,batch_size: 1000,content: TransferContent::DataOnly,- objects: Vec::new(),+ objects: Some(Vec::new()),drop_target_before_create: false,drop_target_confirmed: false,};assert!(validate_transfer_request(&base).is_ok());let with_objects = TransferRequest {- objects: vec![TransferObjectSelection {+ objects: Some(vec![TransferObjectSelection {object_type: TransferObjectKind::View,names: vec!["v".into()],- }],+ }]),..base.clone()};// DataOnly + objects → error@@ -12817,7 +13125,7 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;ownership_policy: TransferOwnershipPolicy::Preserve,batch_size: 1000,content: TransferContent::StructureAndData,- objects: Vec::new(),+ objects: Some(Vec::new()),drop_target_before_create: false,drop_target_confirmed: false,};@@ -12923,96 +13231,124 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;.contains(&View));}+ fn should_transfer_with_objects(+ source: &DatabaseType,+ target: &DatabaseType,+ content: TransferContent,+ objects: Option<Vec<TransferObjectSelection>>,+ ) -> bool {+ let mut request = super::test_transfer_request(vec!["orders"]);+ request.content = content;+ request.objects = objects;+ should_transfer_schema_objects(source, target, &request)+ }+#[test]fn should_transfer_schema_objects_matrix() {- // DataOnly never transfers schema objects, even for PG-family pairs.- assert!(!should_transfer_schema_objects(+ let view = || TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v1".into()] };+ let table =+ || TransferObjectSelection { object_type: TransferObjectKind::Table, names: vec!["orders".into()] };++ // DataOnly never transfers schema objects, regardless of selection state.+ assert!(!should_transfer_with_objects(&DatabaseType::Postgres,&DatabaseType::Postgres,- &TransferContent::DataOnly,- &[]+ TransferContent::DataOnly,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Postgres,&DatabaseType::Postgres,- &TransferContent::DataOnly,- &[TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v1".into()] }]+ TransferContent::DataOnly,+ Some(vec![view()]),));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Mysql,&DatabaseType::Dameng,- &TransferContent::DataOnly,- &[TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v1".into()] }]+ TransferContent::DataOnly,+ Some(vec![view()]),));- // Non-empty selections participate in structure modes.- assert!(should_transfer_schema_objects(++ // Explicit selections run only when a non-table object is selected.+ assert!(should_transfer_with_objects(&DatabaseType::Postgres,&DatabaseType::Mysql,- &TransferContent::StructureOnly,- &[TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v1".into()] }]+ TransferContent::StructureOnly,+ Some(vec![view()]),+ ));+ assert!(!should_transfer_with_objects(+ &DatabaseType::Postgres,+ &DatabaseType::Postgres,+ TransferContent::StructureOnly,+ Some(Vec::new()),));- // Empty selection: PG→PG keeps the legacy transfer-everything default- // only when structure participates in the transfer.- assert!(should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(+ &DatabaseType::Postgres,&DatabaseType::Postgres,+ TransferContent::StructureOnly,+ Some(vec![table()]),+ ));++ // Only legacy-unspecified PostgreSQL pairs keep the all-objects fallback.+ assert!(should_transfer_with_objects(+ &DatabaseType::Postgres,+ &DatabaseType::Postgres,+ TransferContent::StructureOnly,+ None,+ ));+ assert!(should_transfer_with_objects(&DatabaseType::Postgres,- &TransferContent::StructureOnly,- &[]+ &DatabaseType::OpenGauss,+ TransferContent::StructureOnly,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Kingbase,&DatabaseType::Postgres,- &TransferContent::StructureAndData,- &[]+ TransferContent::StructureAndData,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Kingbase,&DatabaseType::Kingbase,- &TransferContent::StructureAndData,- &[TransferObjectSelection { object_type: TransferObjectKind::Table, names: vec!["orders".into()] }]+ TransferContent::StructureAndData,+ Some(vec![table()]),));- assert!(should_transfer_schema_objects(+ assert!(should_transfer_with_objects(&DatabaseType::Kingbase,&DatabaseType::Kingbase,- &TransferContent::StructureOnly,- &[TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v_orders".into()] }]+ TransferContent::StructureOnly,+ Some(vec![view()]),));- assert!(should_transfer_schema_objects(- &DatabaseType::Postgres,- &DatabaseType::OpenGauss,- &TransferContent::StructureOnly,- &[]- ));- // empty selection: every other combination transfers nothing- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Postgres,&DatabaseType::Mysql,- &TransferContent::StructureOnly,- &[]+ TransferContent::StructureOnly,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Mysql,&DatabaseType::Mysql,- &TransferContent::StructureAndData,- &[]+ TransferContent::StructureAndData,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Mysql,&DatabaseType::Dameng,- &TransferContent::StructureOnly,- &[]+ TransferContent::StructureOnly,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Dameng,&DatabaseType::SqlServer,- &TransferContent::StructureAndData,- &[]+ TransferContent::StructureAndData,+ None,));- assert!(!should_transfer_schema_objects(+ assert!(!should_transfer_with_objects(&DatabaseType::Sqlite,&DatabaseType::Sqlite,- &TransferContent::StructureOnly,- &[]+ TransferContent::StructureOnly,+ None,));}@@ -13733,6 +14069,19 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;}}+ #[test]+ fn postgres_table_dependency_closure_is_scoped_to_selected_tables() {+ assert!(postgres_table_dependency_selection_sql("public", &[]).is_none());+ let sql = postgres_table_dependency_selection_sql("public", &["orders".into()]).unwrap();+ assert!(sql.contains("c.relkind IN ('r','p','f') AND c.relname IN ('orders')"));+ assert!(sql.contains("selected_dependencies(classid, objid)"));+ assert!(sql.contains("'pg_catalog.pg_type'::regclass"));+ assert!(sql.contains("'pg_catalog.pg_extension'::regclass"));+ assert!(sql.contains("'ENUM'::text"));+ assert!(sql.contains("'DOMAIN'::text"));+ assert!(sql.contains("'EXTENSION'::text"));+ }+#[test]fn postgres_transfer_relation_sources_exclude_extension_members() {for relkind in ['v', 'm'] {@@ -13749,25 +14098,38 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;}#[test]- fn postgres_transfer_ownership_supports_legacy_catalogs() {- let modern = postgres_transfer_ownership_statements_sql("public", "archive", &["items".into()], true);- assert!(modern.contains("CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END"));- assert!(modern.contains("p.prokind IN ('p','f')"));-- let legacy = postgres_transfer_ownership_statements_sql("public", "archive", &["items".into()], false);+ fn postgres_transfer_ownership_scopes_explicit_objects_and_supports_legacy_catalogs() {+ let mut request = super::test_transfer_request(vec!["items"]);+ request.objects = None;+ let legacy = postgres_transfer_ownership_statements_sql("public", "archive", &request, false, &[]);assert!(!legacy.contains("prokind"));assert!(legacy.contains("'FUNCTION'"));assert!(legacy.contains("NOT p.proisagg"));assert!(legacy.contains("NOT p.proiswindow"));+ assert!(legacy.contains("n.nspname = 'public' AND TRUE"));++ request.objects = Some(vec![+ TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v_orders".into()] },+ TransferObjectSelection { object_type: TransferObjectKind::Function, names: vec!["f_orders".into()] },+ ]);+ let explicit = postgres_transfer_ownership_statements_sql(+ "public",+ "archive",+ &request,+ true,+ &["order_status".into()],+ );+ assert!(explicit.contains("c.relkind = 'v' AND c.relname IN ('v_orders')"));+ assert!(explicit.contains("p.prokind = 'f' AND p.proname IN ('f_orders')"));+ assert!(explicit.contains("t.typname IN ('order_status')"));+ assert!(explicit.contains("n.nspname = 'public' AND FALSE"));}#[test]- fn postgres_transfer_grants_support_legacy_catalogs() {- let modern = postgres_transfer_grant_statements_sql("public", "archive", &["items".into()], true);- assert!(modern.contains("CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END"));- assert!(modern.contains("p.prokind IN ('p','f')"));-- let legacy = postgres_transfer_grant_statements_sql("public", "archive", &["items".into()], false);+ fn postgres_transfer_grants_scope_explicit_objects_and_support_legacy_catalogs() {+ let mut request = super::test_transfer_request(vec!["items"]);+ request.objects = None;+ let legacy = postgres_transfer_grant_statements_sql("public", "archive", &request, false);assert!(!legacy.contains("prokind"));assert!(legacy.contains("'FUNCTION'::text AS routine_kind"));assert!(legacy.contains("NOT p.proisagg"));@@ -13776,6 +14138,15 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;assert!(legacy.contains("(aclexplode(n.nspacl)).*"));assert!(legacy.contains("(aclexplode(c.relacl)).*"));assert!(legacy.contains("(aclexplode(p.proacl)).*"));++ request.objects = Some(vec![+ TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v_orders".into()] },+ TransferObjectSelection { object_type: TransferObjectKind::Function, names: vec!["f_orders".into()] },+ ]);+ let explicit = postgres_transfer_grant_statements_sql("public", "archive", &request, true);+ assert!(explicit.contains("c.relkind = 'v' AND c.relname IN ('v_orders')"));+ assert!(explicit.contains("p.prokind = 'f' AND p.proname IN ('f_orders')"));+ assert!(explicit.contains("n.nspname = 'public' AND FALSE"));}#[test]@@ -13800,23 +14171,31 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;];let selection =vec![TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v1".into()] }];- let filtered = filter_object_sources_by_selection(sources, &selection);+ let filtered =+ filter_object_sources_by_selection(sources.clone(), TransferObjectSelectionMode::Explicit(&selection));assert_eq!(filtered.len(), 1);assert_eq!(filtered[0].name, "v1");+ assert!(filter_object_sources_by_selection(sources.clone(), TransferObjectSelectionMode::Explicit(&[]),)+ .is_empty());+ assert_eq!(+ filter_object_sources_by_selection(sources, TransferObjectSelectionMode::LegacyUnspecified).len(),+ 2,+ );}#[test]fn selected_postgres_sequences_are_prepared_without_changing_default_requests() {let mut request = test_transfer_request(vec!["biz_banner"]);+ request.objects = None;assert!(selected_postgres_sequence_names(&request).is_empty());- request.objects = vec![+ request.objects = Some(vec![TransferObjectSelection { object_type: TransferObjectKind::Table, names: vec!["biz_banner".into()] },TransferObjectSelection {object_type: TransferObjectKind::Sequence,names: vec!["biz_banner_id_seq".into(), "biz_banner_id_seq".into()],},- ];+ ]);assert_eq!(selected_postgres_sequence_names(&request), vec!["biz_banner_id_seq"]);assert_eq!(postgres_transfer_relation_names(&request), vec!["biz_banner", "biz_banner_id_seq"]);@@ -13901,7 +14280,7 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;tables: tables.into_iter().map(str::to_string).collect(),create_table: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,diff --git a/crates/dbx-core/src/data/transfer/structure_plan.rs b/crates/dbx-core/src/data/transfer/structure_plan.rsindex 1f64205dec..64d6f749f9 100644--- a/crates/dbx-core/src/data/transfer/structure_plan.rs+++ b/crates/dbx-core/src/data/transfer/structure_plan.rs@@ -28,9 +28,15 @@ const CREATE_TABLE_DISABLED_NOTE: &str =/// Emitted when the transfer also moves non-table schema objects whose DDL this preview/// deliberately does not expand (views, routines, triggers, standalone sequences, ...).const UNEXPANDED_OBJECTS_NOTE: &str = "\--- Additional selected schema objects are transferred during execution.+-- Additional schema objects selected by this request (or the legacy PostgreSQL default) are transferred.-- Their generated DDL is not expanded in this preview.";+/// Emitted for PostgreSQL-compatible table transfers whose dependency closure is applied by+/// the execution pass but is intentionally not expanded in the table DDL preview.+const POSTGRES_TABLE_DEPENDENCIES_NOTE: &str = "\+-- PostgreSQL table dependencies (types, extensions, policies and sequence bindings) are transferred+-- for the selected tables during execution; their generated SQL is not expanded in this preview.";+/// Plan the structure DDL a structure-only transfer is about to run.////// Everything inside is read-only: metadata reads plus SQL rendering. The only statements@@ -147,6 +153,9 @@ pub(super) async fn build_structure_preview(}sections.extend(table_sections);+ if pg_compat_transfer && !request.tables.is_empty() {+ sections.push(POSTGRES_TABLE_DEPENDENCIES_NOTE.to_string());+ }if !deferred_fk_alters.is_empty() {// MySQL-family targets defer foreign keys so creation order never has to satisfy// them; the create pass flushes these after every table exists.@@ -496,13 +505,15 @@ fn unexpanded_schema_object_notes(target_db_type: &DatabaseType,request: &TransferRequest,) -> Vec<String> {- if !should_transfer_schema_objects(source_db_type, target_db_type, &request.content, &request.objects) {+ if !should_transfer_schema_objects(source_db_type, target_db_type, request) {return Vec::new();}+ let selections = match request.object_selection_mode() {+ TransferObjectSelectionMode::LegacyUnspecified => return vec![UNEXPANDED_OBJECTS_NOTE.to_string()],+ TransferObjectSelectionMode::Explicit(selections) => selections,+ };let mut notes = vec![UNEXPANDED_OBJECTS_NOTE.to_string()];- // An empty selection is the legacy PostgreSQL default (everything is transferred), so- // there is no concrete list to print — and the note above already says so.- for selection in &request.objects {+ for selection in selections {if selection.object_type == TransferObjectKind::Table || selection.names.is_empty() {continue;}@@ -660,6 +671,26 @@ mod tests {assert!(schema.get("sourceTable").is_none());}+ #[test]+ fn unexpanded_object_notes_distinguish_legacy_and_explicit_empty_selections() {+ let legacy = structure_request(json!({}));+ let explicit_empty = structure_request(json!({ "objects": [] }));+ let explicit_view = structure_request(json!({+ "objects": [{ "objectType": "VIEW", "names": ["v_orders"] }]+ }));++ assert_eq!(+ unexpanded_schema_object_notes(&DatabaseType::Postgres, &DatabaseType::Postgres, &legacy),+ vec![UNEXPANDED_OBJECTS_NOTE.to_string()],+ );+ assert!(unexpanded_schema_object_notes(&DatabaseType::Postgres, &DatabaseType::Postgres, &explicit_empty)+ .is_empty());+ assert_eq!(+ unexpanded_schema_object_notes(&DatabaseType::Postgres, &DatabaseType::Postgres, &explicit_view),+ vec![UNEXPANDED_OBJECTS_NOTE.to_string(), "-- Views: v_orders".to_string()],+ );+ }+async fn sqlite_fixture() -> (tempfile::TempDir, Arc<AppState>, String, String) {let directory = tempfile::tempdir().unwrap();let storage = crate::persistence::test_storage::open(&directory.path().join("storage.db")).await.unwrap();diff --git a/crates/dbx-core/tests/live_mysql_transfer.rs b/crates/dbx-core/tests/live_mysql_transfer.rsindex 9e39798985..b8d7e23d17 100644--- a/crates/dbx-core/tests/live_mysql_transfer.rs+++ b/crates/dbx-core/tests/live_mysql_transfer.rs@@ -88,7 +88,7 @@ fn transfer_request(drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -194,7 +194,7 @@ async fn run_live_mysql_cross_version_transfer_completes_on_small_stack() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -349,7 +349,7 @@ async fn live_mysql_transfer_keeps_columns_whose_comment_mentions_foreign_key()drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -508,7 +508,7 @@ async fn live_mysql_transfer_downgrades_unsupported_source_collations() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -572,7 +572,7 @@ async fn live_mysql_transfer_downgrades_unsupported_source_collations() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -879,7 +879,7 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_coldrop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Overwrite,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -935,7 +935,7 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_coldrop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Overwrite,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1032,7 +1032,7 @@ async fn live_mysql_transfer_structure_only_rejects_incompatible_target_columns(drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::StructureOnly,- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1131,7 +1131,7 @@ async fn live_mysql_transfer_drop_target_parent_child_foreign_key() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1324,7 +1324,7 @@ async fn live_mysql_transfer_drop_target_rebuilds_incompatible_structure() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1512,7 +1512,7 @@ async fn live_mysql_transfer_drop_target_rejects_external_incoming_fk() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1603,7 +1603,7 @@ async fn live_mysql_transfer_drop_target_circular_foreign_keys() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1832,7 +1832,7 @@ async fn live_mysql_transfer_drop_target_retains_backup_on_failure() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -2010,7 +2010,7 @@ async fn live_mysql_keyset_pagination_copies_every_row() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -2134,7 +2134,7 @@ async fn live_mysql_progress_read_survives_total_duration_beyond_timeout() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -2234,7 +2234,7 @@ async fn live_mysql_transfer_drop_target_inspects_dependent_views_without_the_usdrop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,diff --git a/crates/dbx-core/tests/live_postgres_transfer.rs b/crates/dbx-core/tests/live_postgres_transfer.rsindex 81c58e7481..36ae366440 100644--- a/crates/dbx-core/tests/live_postgres_transfer.rs+++ b/crates/dbx-core/tests/live_postgres_transfer.rs@@ -258,7 +258,7 @@ async fn live_postgres_transfer_upserts_generated_always_identity_values() {drop_target_before_create: false,drop_target_confirmed: false,content: dbx_core::transfer::TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Upsert,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -435,7 +435,7 @@ async fn live_postgres_structure_only_preserves_table_indexes() {drop_target_before_create: false,drop_target_confirmed: false,content: dbx_core::transfer::TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -719,7 +719,7 @@ async fn live_postgres_transfer_preserves_data_and_schema_objects() {drop_target_before_create: false,drop_target_confirmed: false,content: dbx_core::transfer::TransferContent::default(),- objects: Vec::new(),+ objects: None,mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1021,7 +1021,7 @@ async fn live_postgres_transfer_skips_create_ddl_for_existing_target_table() {drop_target_before_create: false,drop_target_confirmed: false,content: dbx_core::transfer::TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1145,13 +1145,13 @@ async fn live_postgres_transfer_creates_selected_sequence_before_referencing_tabdrop_target_before_create: false,drop_target_confirmed: false,content: dbx_core::transfer::TransferContent::default(),- objects: vec![+ objects: Some(vec![TransferObjectSelection { object_type: TransferObjectKind::Table, names: vec!["biz_banner".to_string()] },TransferObjectSelection {object_type: TransferObjectKind::Sequence,names: vec!["biz_banner_id_seq".to_string()],},- ],+ ]),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1336,7 +1336,7 @@ async fn live_postgres_transfer_drop_target_rebuilds_structure_and_indexes() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1537,7 +1537,7 @@ impl PostgresRebuildFixture {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1860,7 +1860,7 @@ async fn live_postgres_keyset_pagination_copies_every_row() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -1972,7 +1972,7 @@ async fn live_postgres_progress_read_survives_total_duration_beyond_timeout() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -2078,7 +2078,7 @@ async fn live_postgres_keyset_large_batch_copies_every_row() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -2191,10 +2191,10 @@ async fn live_postgres_structure_only_preview_renders_ddl_without_touching_the_tdrop_target_confirmed: false,content: TransferContent::StructureOnly,// A selected non-table object must be disclosed as not expanded, never silently dropped.- objects: vec![TransferObjectSelection {+ objects: Some(vec![TransferObjectSelection {object_type: TransferObjectKind::Function,names: vec!["preview_probe_function".to_string()],- }],+ }]),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -2260,7 +2260,7 @@ async fn live_postgres_structure_only_preview_renders_ddl_without_touching_the_tlet mut missing_schema_request = request.clone();missing_schema_request.transfer_id = format!("live-pg-preview-missing-{suffix}");missing_schema_request.target_schema = missing_target_schema.clone();- missing_schema_request.objects = Vec::new();+ missing_schema_request.objects = Some(Vec::new());let missing_preview = preview_transfer_ownership(&state,&missing_schema_request,diff --git a/crates/dbx-core/tests/live_sqlite_to_sqlserver_transfer.rs b/crates/dbx-core/tests/live_sqlite_to_sqlserver_transfer.rsindex 6ae75608dd..866cc75c45 100644--- a/crates/dbx-core/tests/live_sqlite_to_sqlserver_transfer.rs+++ b/crates/dbx-core/tests/live_sqlite_to_sqlserver_transfer.rs@@ -169,7 +169,7 @@ async fn live_sqlite_to_sqlserver_keeps_sixty_four_bit_integer_values() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,diff --git a/crates/dbx-core/tests/live_sqlserver_completion.rs b/crates/dbx-core/tests/live_sqlserver_completion.rsindex 7d684b6933..5ca0e1178f 100644--- a/crates/dbx-core/tests/live_sqlserver_completion.rs+++ b/crates/dbx-core/tests/live_sqlserver_completion.rs@@ -1405,7 +1405,7 @@ async fn live_sqlserver_transfer_table_skips_rowversion_insert_column() {drop_target_before_create: false,drop_target_confirmed: false,content: dbx_core::transfer::TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: dbx_core::transfer::TransferMode::Append,target_table_name_case: dbx_core::transfer::TransferTableNameCase::Upper,quote_target_column_names: true,diff --git a/crates/dbx-core/tests/live_sqlserver_transfer.rs b/crates/dbx-core/tests/live_sqlserver_transfer.rsindex f221096012..eacb6fc3fe 100644--- a/crates/dbx-core/tests/live_sqlserver_transfer.rs+++ b/crates/dbx-core/tests/live_sqlserver_transfer.rs@@ -181,7 +181,7 @@ async fn live_sqlserver_transfer_rebuild_releases_constraint_and_index_names() {drop_target_before_create: true,drop_target_confirmed: true,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -342,7 +342,7 @@ async fn live_sqlserver_transfer_overwrite_handles_existing_identity_target() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Overwrite,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -459,7 +459,7 @@ async fn live_sqlserver_keyset_pagination_copies_every_row() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -580,7 +580,7 @@ async fn live_sqlserver_progress_read_survives_total_duration_beyond_timeout() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -699,7 +699,7 @@ async fn live_sqlserver_keyset_uniqueidentifier_datetime2_composite_key() {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,@@ -811,7 +811,7 @@ async fn live_sqlserver_transfer_new_identity_target_keeps_explicit_identity_valdrop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::default(),- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,diff --git a/crates/dbx-web/src/routes/transfer.rs b/crates/dbx-web/src/routes/transfer.rsindex a9a5584150..4a0974e2f3 100644--- a/crates/dbx-web/src/routes/transfer.rs+++ b/crates/dbx-web/src/routes/transfer.rs@@ -774,7 +774,7 @@ mod tests {drop_target_before_create: false,drop_target_confirmed: false,content: TransferContent::DataOnly,- objects: Vec::new(),+ objects: Some(Vec::new()),mode: TransferMode::Append,target_table_name_case: TransferTableNameCase::Preserve,quote_target_column_names: true,