From 609f6805a3d472f27816e9a78dd0109c55c0c477 Mon Sep 17 00:00:00 2001 From: jearhe <0verme7753@gmail.com> Date: Thu, 8 Oct 2026 11:25:45 +0800 Subject: [PATCH] fix(transfer): distinguish explicit empty object selection from default --- .../transfer/DataTransferDialog.vue | 4 +- .../__tests__/transferSelections.spec.ts | 19 +- .../components/transfer/transferSelections.ts | 4 + .../__tests__/transferTaskStore.spec.ts | 33 + crates/dbx-core/src/data/transfer.rs | 767 +++++++++++++----- .../src/data/transfer/structure_plan.rs | 41 +- crates/dbx-core/tests/live_mysql_transfer.rs | 32 +- .../dbx-core/tests/live_postgres_transfer.rs | 28 +- .../live_sqlite_to_sqlserver_transfer.rs | 2 +- .../tests/live_sqlserver_completion.rs | 2 +- .../dbx-core/tests/live_sqlserver_transfer.rs | 12 +- crates/dbx-web/src/routes/transfer.rs | 2 +- 12 files changed, 705 insertions(+), 241 deletions(-) diff --git a/apps/desktop/src/components/transfer/DataTransferDialog.vue b/apps/desktop/src/components/transfer/DataTransferDialog.vue index 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.ts index 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 { 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.ts index 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>>, disabledGroups: TransferObjectKind[]): { objects: TransferObjectSelectionPayload[] } { + return { objects: buildTransferObjectSelections(selectedObjects, disabledGroups) }; +} + export function buildTransferObjectSelections(selectedObjects: Partial>>, 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.ts index 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; + 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; delete legacyConfig.quoteTargetColumnNames; diff --git a/crates/dbx-core/src/data/transfer.rs b/crates/dbx-core/src/data/transfer.rs index 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, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub objects: Option>, #[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> { + 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<(), String Data-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, } +#[derive(Debug, Clone, Default)] +struct PostgresTableDependencySelection { + extension_names: Vec, + enum_type_names: Vec, + domain_names: Vec, +} + +impl PostgresTableDependencySelection { + fn type_names(&self) -> Vec { + let mut names = self.enum_type_names.iter().chain(&self.domain_names).cloned().collect::>(); + 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 { - 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 { 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, - selections: &[TransferObjectSelection], + selection_mode: TransferObjectSelectionMode<'_>, ) -> Vec { - // 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()); + 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) + } } - 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; - } - 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 @@ where let 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 @@ where let 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 @@ where let 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 @@ where if 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 @@ where let 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 = 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 { + if tables.is_empty() { + return None; + } + let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::>().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 { + 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, 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::>().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::>().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::>().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::>().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::>().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::>().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::>().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::>().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, 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::>(); @@ -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::>().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, 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 @@ where ensure_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::>(); + 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::>(); + 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::>(); + 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 @@ where let 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::>(); 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::>(); let policy_statements = get_postgres_policy_statements_for_transfer( @@ -11487,19 +11772,10 @@ where catalog_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>, + ) -> 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()]), )); - // 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, - &[] + TransferContent::StructureOnly, + Some(Vec::new()), )); - assert!(!should_transfer_schema_objects( - &DatabaseType::Kingbase, + assert!(!should_transfer_with_objects( &DatabaseType::Postgres, - &TransferContent::StructureAndData, - &[] + &DatabaseType::Postgres, + TransferContent::StructureOnly, + Some(vec![table()]), )); - assert!(!should_transfer_schema_objects( - &DatabaseType::Kingbase, - &DatabaseType::Kingbase, - &TransferContent::StructureAndData, - &[TransferObjectSelection { object_type: TransferObjectKind::Table, names: vec!["orders".into()] }] + + // 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_schema_objects( - &DatabaseType::Kingbase, - &DatabaseType::Kingbase, - &TransferContent::StructureOnly, - &[TransferObjectSelection { object_type: TransferObjectKind::View, names: vec!["v_orders".into()] }] - )); - assert!(should_transfer_schema_objects( + assert!(should_transfer_with_objects( &DatabaseType::Postgres, &DatabaseType::OpenGauss, - &TransferContent::StructureOnly, - &[] + TransferContent::StructureOnly, + None, )); - // empty selection: every other combination transfers nothing - assert!(!should_transfer_schema_objects( + assert!(!should_transfer_with_objects( + &DatabaseType::Kingbase, + &DatabaseType::Postgres, + TransferContent::StructureAndData, + None, + )); + assert!(!should_transfer_with_objects( + &DatabaseType::Kingbase, + &DatabaseType::Kingbase, + TransferContent::StructureAndData, + Some(vec![table()]), + )); + assert!(should_transfer_with_objects( + &DatabaseType::Kingbase, + &DatabaseType::Kingbase, + TransferContent::StructureOnly, + Some(vec![view()]), + )); + 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.rs index 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 { - 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, 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.rs index 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_col 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, @@ -935,7 +935,7 @@ async fn live_mysql_transfer_structure_overwrite_rejects_incompatible_target_col 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, @@ -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_us 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, diff --git a/crates/dbx-core/tests/live_postgres_transfer.rs b/crates/dbx-core/tests/live_postgres_transfer.rs index 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_tab drop_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_t drop_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_t let 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.rs index 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.rs index 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.rs index 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_val 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-web/src/routes/transfer.rs b/crates/dbx-web/src/routes/transfer.rs index 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,