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
feat(xugu): transfer selected schema objects between Xugu databases
Elias2c73a404fe9a
diff --git a/apps/desktop/src/components/transfer/DataTransferDialog.vue b/apps/desktop/src/components/transfer/DataTransferDialog.vueindex faf2a2453c..bbadd579fe 100644--- a/apps/desktop/src/components/transfer/DataTransferDialog.vue+++ b/apps/desktop/src/components/transfer/DataTransferDialog.vue@@ -31,7 +31,7 @@ import { ensureReadOnlyWriteAccess } from "@/lib/database/readOnlyWriteAccess";import { useProductionSafetyStore } from "@/stores/productionSafetyStore";import * as api from "@/lib/backend/api";import type { TransferColumnNameCase, TransferContent, TransferObjectKind, TransferTableNameCase } from "@/lib/backend/api";-import { crossFamilyTransferableKinds, isSameTransferFamily, isTransferPairSupported, transferObjectFamily, transferObjectKindsForDatabase } from "@/lib/database/transferObjectKinds";+import { crossFamilyTransferableKinds, isSameTransferFamily, isTransferPairSupported, transferObjectFamily, transferObjectKindsForDatabase, transferSchemasForDatabase } from "@/lib/database/transferObjectKinds";import ObjectSelectionTree from "@/components/transfer/ObjectSelectionTree.vue";import TransferTaskTree from "@/components/transfer/TransferTaskTree.vue";import DataTransferProgressDialog from "@/components/transfer/DataTransferProgressDialog.vue";@@ -116,14 +116,16 @@ const selectedTables = computed(() => new Set(selectedObjects.value.TABLE ?? [])const selectedTableList = computed(() => [...selectedTables.value]);const OBJECT_KIND_LABEL_KEY: Record<TransferObjectKind, string> = {- TABLE: "objectTypeTable",- VIEW: "objectTypeView",- MATERIALIZED_VIEW: "objectTypeMaterializedView",- PROCEDURE: "objectTypeProcedure",- FUNCTION: "objectTypeFunction",- TRIGGER: "objectTypeTrigger",- SEQUENCE: "objectTypeSequence",- EVENT: "objectTypeEvent",+ TABLE: "transfer.objectTypeTable",+ VIEW: "transfer.objectTypeView",+ MATERIALIZED_VIEW: "transfer.objectTypeMaterializedView",+ PROCEDURE: "transfer.objectTypeProcedure",+ FUNCTION: "transfer.objectTypeFunction",+ TRIGGER: "transfer.objectTypeTrigger",+ SEQUENCE: "transfer.objectTypeSequence",+ EVENT: "transfer.objectTypeEvent",+ PACKAGE: "tree.packages",+ SYNONYM: "tree.synonyms",};const treeSelection = computed<Record<string, string[]>>({@@ -140,7 +142,7 @@ const treeSelection = computed<Record<string, string[]>>({const treeGroups = computed(() =>(Object.keys(objectGroups.value) as TransferObjectKind[]).map((kind) => ({kind,- label: t(`transfer.${OBJECT_KIND_LABEL_KEY[kind]}`),+ label: t(OBJECT_KIND_LABEL_KEY[kind]),items: objectGroups.value[kind] ?? [],})),);@@ -156,6 +158,17 @@ const treeDisabledGroups = computed<TransferObjectKind[]>(() => {return presentKinds.filter((k) => k !== "TABLE" && !allowed.includes(k));});+const objectSelectionSummary = computed(() => {+ if (transferDatabaseTypeForConnection(store.getConfig(sourceConnectionId.value)) !== "xugu") {+ return { selected: selectedTables.value.size, total: objectGroups.value.TABLE?.length ?? 0 };+ }+ const enabled = treeGroups.value.filter((group) => !treeDisabledGroups.value.includes(group.kind));+ return {+ selected: enabled.reduce((count, group) => count + group.items.filter((name) => selectedObjects.value[group.kind]?.has(name)).length, 0),+ total: enabled.reduce((count, group) => count + group.items.length, 0),+ };+});+const treeDisabledHints = computed<Record<string, string>>(() => {const hints: Record<string, string> = {};const dataOnly = transferContent.value === "dataOnly";@@ -505,7 +518,7 @@ async function loadSchemas(connectionId: string, database: string, side: "sourcereturn;}try {- const schemas = await api.listSchemas(connectionId, database);+ const schemas = transferSchemasForDatabase(transferDatabaseTypeForConnection(store.getConfig(connectionId)), await api.listSchemas(connectionId, database));if (isStale()) return;const selected = preferredSchema && schemas.includes(preferredSchema) ? preferredSchema : schemas.includes("public") ? "public" : (schemas[0] ?? "");if (side === "source") {@@ -593,6 +606,7 @@ async function loadObjects(isCancelled: () => boolean = () => false) {const schema = needsSchema && schemaValue ? schemaValue : database;const kinds = transferObjectKindsForDatabase(transferDatabaseTypeForConnection(config));const groups: Partial<Record<TransferObjectKind, string[]>> = {};+ const xuguLoadFailures: string[] = [];for (const kind of kinds) {try {if (kind === "TABLE") {@@ -602,11 +616,13 @@ async function loadObjects(isCancelled: () => boolean = () => false) {const objects = await api.listObjects(connectionId, database, schema, [kind], undefined, undefined, undefined, catalog);groups[kind] = objects.map((o) => o.name);}- } catch {+ } catch (error) {groups[kind] = [];+ if (transferDatabaseTypeForConnection(config) === "xugu") xuguLoadFailures.push(`${kind}: ${String(error)}`);}}if (isStale()) return;+ if (xuguLoadFailures.length) toast(xuguLoadFailures.join("\n"), 8000);objectGroups.value = groups;applyPendingTableSelection();applyPendingObjectSelection();@@ -1553,7 +1569,7 @@ async function saveConfigTask() {<div class="flex items-center justify-between"><div class="text-xs font-medium text-muted-foreground uppercase tracking-wider">{{ t("transfer.objects") }}- <span v-if="objectGroups.TABLE?.length" class="text-muted-foreground/60">({{ selectedTables.size }}/{{ objectGroups.TABLE.length }})</span>+ <span v-if="objectSelectionSummary.total" class="text-muted-foreground/60">({{ objectSelectionSummary.selected }}/{{ objectSelectionSummary.total }})</span></div></div>diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.tsindex a64264fa4c..b1a9a1fa9c 100644--- a/apps/desktop/src/lib/backend/tauri.ts+++ b/apps/desktop/src/lib/backend/tauri.ts@@ -5927,7 +5927,7 @@ export type TransferTableNameCase = "preserve" | "lower" | "upper";export type TransferColumnNameCase = "preserve" | "lower" | "upper";export type TransferOwnershipPolicy = "preserve" | "skip" | "reassignMissing";export type TransferContent = "structureAndData" | "structureOnly" | "dataOnly";-export type TransferObjectKind = "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "TRIGGER" | "SEQUENCE" | "EVENT";+export type TransferObjectKind = "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "TRIGGER" | "SEQUENCE" | "EVENT" | "PACKAGE" | "SYNONYM";export interface TransferObjectSelection {objectType: TransferObjectKind;diff --git a/apps/desktop/src/lib/database/__tests__/transferObjectKinds.spec.ts b/apps/desktop/src/lib/database/__tests__/transferObjectKinds.spec.tsindex 1efd3575d8..bc6dbc4d1a 100644--- a/apps/desktop/src/lib/database/__tests__/transferObjectKinds.spec.ts+++ b/apps/desktop/src/lib/database/__tests__/transferObjectKinds.spec.ts@@ -1,12 +1,19 @@import { describe, expect, it } from "vitest";-import { transferObjectFamily, transferObjectKindsForDatabase, isSameTransferFamily, crossFamilyTransferableKinds, isTransferPairSupported, TransferObjectFamily } from "@/lib/database/transferObjectKinds";+import { transferObjectFamily, transferObjectKindsForDatabase, isSameTransferFamily, crossFamilyTransferableKinds, isTransferPairSupported, TransferObjectFamily, transferSchemasForDatabase } from "@/lib/database/transferObjectKinds";+import { XUGU_PUBLIC_SYNONYM_SCOPE, XUGU_SCHEDULER_JOB_SCOPE } from "@/lib/sidebar/xuguPublicSynonyms";import { manifestDatabaseTypes } from "@/lib/database/databaseDriverManifest";import { supportsTransfer } from "@/lib/database/databaseFeatureSupport";import type { DatabaseType } from "@/types/database";-const TABLE_ONLY_TRANSFER_DATABASES: DatabaseType[] = ["sqlite", "rqlite", "turso", "cloudflare-d1", "duckdb", "clickhouse", "mongodb", "highgo", "vastbase", "goldendb", "yashandb", "questdb", "h2", "hive", "argo", "transwarp", "kyuubi", "impala", "db2", "iris", "spark", "xugu"];+const TABLE_ONLY_TRANSFER_DATABASES: DatabaseType[] = ["sqlite", "rqlite", "turso", "cloudflare-d1", "duckdb", "clickhouse", "mongodb", "highgo", "vastbase", "goldendb", "yashandb", "questdb", "h2", "hive", "argo", "transwarp", "kyuubi", "impala", "db2", "iris", "spark"];describe("transferObjectKinds", () => {+ it("keeps Xugu synthetic scopes out of both transfer schema selectors without filtering other engines", () => {+ const schemas = ["APP", "SYSDBA", XUGU_PUBLIC_SYNONYM_SCOPE, XUGU_SCHEDULER_JOB_SCOPE];+ expect(transferSchemasForDatabase("xugu", schemas)).toEqual(["APP", "SYSDBA"]);+ expect(transferSchemasForDatabase("postgres", schemas)).toBe(schemas);+ expect(transferSchemasForDatabase("mysql", schemas)).toBe(schemas);+ });it("groups databases into transfer families", () => {expect(transferObjectFamily("mysql")).toBe(TransferObjectFamily.Mysql);expect(transferObjectFamily("kingbase")).toBe(TransferObjectFamily.Postgres);@@ -27,7 +34,7 @@ describe("transferObjectKinds", () => {});it("covers every transfer-capable database outside the richer object families", () => {- const manifestTypes = manifestDatabaseTypes().filter((dbType) => supportsTransfer(dbType) && !transferObjectFamily(dbType));+ const manifestTypes = manifestDatabaseTypes().filter((dbType) => dbType !== "xugu" && supportsTransfer(dbType) && !transferObjectFamily(dbType));expect([...manifestTypes].sort()).toEqual([...TABLE_ONLY_TRANSFER_DATABASES].sort());});@@ -53,6 +60,18 @@ describe("transferObjectKinds", () => {expect(isTransferPairSupported(undefined, "xugu")).toBe(true);});+ it("exposes native Xugu schema objects without enabling them for other engines", () => {+ const kinds = ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "SEQUENCE", "PACKAGE", "SYNONYM"];+ expect(transferObjectKindsForDatabase("xugu")).toEqual(kinds);+ expect(crossFamilyTransferableKinds("xugu", "xugu")).toEqual(kinds);+ for (const engine of ["postgres", "mysql", "oracle", "dameng", "sqlserver"] as const) {+ expect(crossFamilyTransferableKinds("xugu", engine)).toEqual([]);+ expect(crossFamilyTransferableKinds(engine, "xugu")).toEqual([]);+ expect(transferObjectKindsForDatabase(engine)).not.toContain("PACKAGE");+ expect(transferObjectKindsForDatabase(engine)).not.toContain("SYNONYM");+ }+ });+it("limits cross-family transferable kinds to sequences only", () => {// mysql participates: VIEW is disabled (query body not translated) and// mysql has no sequences on either sidediff --git a/apps/desktop/src/lib/database/transferObjectKinds.ts b/apps/desktop/src/lib/database/transferObjectKinds.tsindex cd7d3cddd7..f9c5bdd170 100644--- a/apps/desktop/src/lib/database/transferObjectKinds.ts+++ b/apps/desktop/src/lib/database/transferObjectKinds.ts@@ -1,6 +1,11 @@import type { DatabaseType } from "@/types/database";import { supportsTransfer } from "@/lib/database/databaseFeatureSupport";import { databaseTransferObjectFamily } from "@/lib/database/databaseDriverManifest";+import { isXuguSyntheticScope } from "@/lib/sidebar/xuguPublicSynonyms";++export function transferSchemasForDatabase(dbType: DatabaseType | undefined, schemas: string[]): string[] {+ return dbType === "xugu" ? schemas.filter((schema) => !isXuguSyntheticScope(schema)) : schemas;+}export enum TransferObjectFamily {Mysql = "mysql",@@ -9,7 +14,7 @@ export enum TransferObjectFamily {SqlServer = "sqlserver",}-export type TransferObjectKind = "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "TRIGGER" | "SEQUENCE" | "EVENT";+export type TransferObjectKind = "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "TRIGGER" | "SEQUENCE" | "EVENT" | "PACKAGE" | "SYNONYM";const MYSQL_KINDS: TransferObjectKind[] = ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "EVENT"];const POSTGRES_KINDS: TransferObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "SEQUENCE"];@@ -34,6 +39,7 @@ export function isTransferPairSupported(source?: DatabaseType, target?: Database}export function transferObjectKindsForDatabase(dbType?: DatabaseType): TransferObjectKind[] {+ if (dbType === "xugu") return ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "SEQUENCE", "PACKAGE", "SYNONYM"];switch (transferObjectFamily(dbType)) {case TransferObjectFamily.Mysql:return [...MYSQL_KINDS];@@ -58,6 +64,7 @@ export function transferObjectKindsForDatabase(dbType?: DatabaseType): TransferO* incompatible target.*/export function crossFamilyTransferableKinds(a?: DatabaseType, b?: DatabaseType): TransferObjectKind[] {+ if (a === "xugu" || b === "xugu") return a === "xugu" && b === "xugu" ? transferObjectKindsForDatabase("xugu") : [];if (isSameTransferFamily(a, b)) {return transferObjectKindsForDatabase(a);}diff --git a/crates/dbx-core/src/data/transfer.rs b/crates/dbx-core/src/data/transfer.rsindex 485c86ab33..7493a72a92 100644--- a/crates/dbx-core/src/data/transfer.rs+++ b/crates/dbx-core/src/data/transfer.rs@@ -26,6 +26,7 @@ mod db2;mod ddl_plan;mod overwrite_clear;mod structure_plan;+pub(crate) mod xugu_objects;pub use overwrite_clear::clear_foreign_key_linked_overwrite_targets;@@ -268,6 +269,8 @@ pub enum TransferObjectKind {Trigger,Sequence,Event,+ Package,+ Synonym,}#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]@@ -306,6 +309,9 @@ pub fn transfer_object_kinds_for_family(family: &TransferObjectFamily) -> Vec<Tr}pub fn transfer_object_kinds(db_type: &DatabaseType) -> Vec<TransferObjectKind> {+ if *db_type == DatabaseType::Xugu {+ return xugu_objects::supported_kinds();+ }match transfer_object_family(db_type) {Some(family) => transfer_object_kinds_for_family(&family),None => Vec::new(),@@ -718,6 +724,13 @@ pub fn validate_transfer_target_table_names(request: &TransferRequest) -> Result/// target for the cross-family DDL pipeline (the executor rejects it).pub fn cross_family_transferable_object_kinds(source: &DatabaseType, target: &DatabaseType) -> Vec<TransferObjectKind> {use TransferObjectKind::*;+ if *source == DatabaseType::Xugu || *target == DatabaseType::Xugu {+ return if *source == DatabaseType::Xugu && *target == DatabaseType::Xugu {+ xugu_objects::supported_kinds()+ } else {+ vec![]+ };+ }if is_same_transfer_family(source, target) {return transfer_object_kinds(source);}@@ -1144,8 +1157,10 @@ pub fn validate_transfer_database_pair(if !matches!((source_db_type, target_db_type), (DatabaseType::Xugu, DatabaseType::Xugu)) {return Err("虚谷数据传输当前仅支持虚谷到虚谷".to_string());}- if request.objects.as_ref().is_some_and(|objects| !objects.is_empty()) {- return Err("虚谷数据传输当前仅支持表对象".to_string());+ if request.objects.as_ref().is_some_and(|objects| {+ objects.iter().any(|selection| !xugu_objects::supported_kinds().contains(&selection.object_type))+ }) {+ return Err("虚谷数据传输不支持所选对象类型".to_string());}if request.mode == TransferMode::Upsert || request.drop_target_before_create {return Err("虚谷数据传输当前仅支持追加或覆盖,暂不支持更新插入或重建".to_string());@@ -9534,6 +9549,8 @@ pub fn ordered_transfer_object_kinds(kinds: Vec<TransferObjectKind>) -> Vec<TranTransferObjectKind::Procedure => 4,TransferObjectKind::Trigger => 5,TransferObjectKind::Event => 6,+ TransferObjectKind::Package => 3,+ TransferObjectKind::Synonym => 4,};let mut kinds = kinds;kinds.sort_by_key(rank);@@ -9713,6 +9730,9 @@ whereif !should_transfer_schema_objects(&source_db_type, &target_db_type, request) {return Ok(TransferObjectOutcome::default());}+ if source_db_type == DatabaseType::Xugu && target_db_type == DatabaseType::Xugu {+ return Err("Xugu schema objects must run through the prepared transfer plan".into());+ }if !is_same_transfer_family(&source_db_type, &target_db_type) {return transfer_cross_family_schema_objects(state,@@ -15575,7 +15595,7 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;}#[test]- fn xugu_transfer_is_same_engine_table_only_and_append_or_overwrite() {+ fn xugu_transfer_is_same_engine_only_and_append_or_overwrite() {let request = base_request();assert!(validate_transfer_database_pair(&request, &DatabaseType::Xugu, &DatabaseType::Xugu).is_ok());// Existing non-Xugu transfer combinations retain their prior policy.@@ -15632,7 +15652,7 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;}#[test]- fn xugu_structure_transfer_rejects_renamed_tables_and_non_table_objects() {+ fn xugu_structure_transfer_preserves_names_and_accepts_native_objects() {let request = TransferRequest { target_table_name_case: TransferTableNameCase::Upper, ..base_request() };assert!(validate_transfer_database_pair(&request, &DatabaseType::Xugu, &DatabaseType::Xugu).unwrap_err()@@ -15645,9 +15665,29 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;}]),..base_request()};- assert!(validate_transfer_database_pair(&request, &DatabaseType::Xugu, &DatabaseType::Xugu)- .unwrap_err()- .contains("仅支持表对象"));+ assert!(validate_transfer_database_pair(&request, &DatabaseType::Xugu, &DatabaseType::Xugu).is_ok());+ for kind in [+ TransferObjectKind::Package,+ TransferObjectKind::Synonym,+ TransferObjectKind::Sequence,+ TransferObjectKind::Procedure,+ TransferObjectKind::Function,+ TransferObjectKind::Trigger,+ ] {+ let request = TransferRequest {+ objects: Some(vec![TransferObjectSelection { object_type: kind, names: vec!["O".into()] }]),+ ..base_request()+ };+ assert!(validate_transfer_database_pair(&request, &DatabaseType::Xugu, &DatabaseType::Xugu).is_ok());+ }+ let unsupported = TransferRequest {+ objects: Some(vec![TransferObjectSelection {+ object_type: TransferObjectKind::Event,+ names: vec!["E".into()],+ }]),+ ..base_request()+ };+ assert!(validate_transfer_database_pair(&unsupported, &DatabaseType::Xugu, &DatabaseType::Xugu).is_err());}#[test]diff --git a/crates/dbx-core/src/data/transfer/structure_plan.rs b/crates/dbx-core/src/data/transfer/structure_plan.rsindex e6338d9f83..8e367ffbdf 100644--- a/crates/dbx-core/src/data/transfer/structure_plan.rs+++ b/crates/dbx-core/src/data/transfer/structure_plan.rs@@ -49,17 +49,32 @@ pub(super) async fn build_structure_preview(source_pool_key: &str,target_pool_key: &str,) -> Result<TransferStructurePreview, String> {- let schema_object_preview = mysql_schema_object_preview_sql(- state,- request,- source_db_type,- target_db_type,- source_pool_key,- target_pool_key,- )- .await?;+ let xugu_plan = if *source_db_type == DatabaseType::Xugu+ && *target_db_type == DatabaseType::Xugu+ && should_transfer_schema_objects(source_db_type, target_db_type, request)+ {+ Some(xugu_objects::prepare(state, request, source_pool_key).await?)+ } else {+ None+ };+ let schema_object_preview = if let Some(plan) = &xugu_plan {+ Some(plan.preview_after_tables())+ } else {+ mysql_schema_object_preview_sql(+ state,+ request,+ source_db_type,+ target_db_type,+ source_pool_key,+ target_pool_key,+ )+ .await?+ };if !request.create_table {let mut sections = vec![CREATE_TABLE_DISABLED_NOTE.to_string()];+ if let Some(plan) = &xugu_plan {+ sections.push(plan.preview_before_tables());+ }if let Some(sql) = &schema_object_preview {sections.push(sql.clone());}@@ -90,6 +105,9 @@ pub(super) async fn build_structure_preview(let (tables, known_foreign_keys) = sorted_source_tables_with_foreign_keys(state, request).await;let mut sections: Vec<String> = Vec::new();+ if let Some(plan) = &xugu_plan {+ sections.push(plan.preview_before_tables());+ }let mut operations = Vec::new();let mut deferred_fk_operations = Vec::new();if let Some(create_schema_sql) = &create_schema_sql {@@ -189,14 +207,16 @@ pub(super) async fn build_structure_preview(sql: sections.join("\n\n"),tables: planned_tables,operations,- schema_objects_expanded: request.mode == TransferMode::Overwrite- && transfer_object_family(source_db_type) == Some(TransferObjectFamily::Mysql)- && transfer_object_family(target_db_type) == Some(TransferObjectFamily::Mysql)- && request.object_selection_mode().selections().iter().any(|selection| {- selection.object_type != TransferObjectKind::Table- && transfer_object_kinds_for_family(&TransferObjectFamily::Mysql).contains(&selection.object_type)- && !selection.names.is_empty()- }),+ schema_objects_expanded: xugu_plan.is_some()+ || request.mode == TransferMode::Overwrite+ && transfer_object_family(source_db_type) == Some(TransferObjectFamily::Mysql)+ && transfer_object_family(target_db_type) == Some(TransferObjectFamily::Mysql)+ && request.object_selection_mode().selections().iter().any(|selection| {+ selection.object_type != TransferObjectKind::Table+ && transfer_object_kinds_for_family(&TransferObjectFamily::Mysql)+ .contains(&selection.object_type)+ && !selection.names.is_empty()+ }),})}@@ -638,6 +658,8 @@ fn preview_object_kind_label(kind: &TransferObjectKind) -> &'static str {TransferObjectKind::Trigger => "Triggers",TransferObjectKind::Sequence => "Sequences",TransferObjectKind::Event => "Events",+ TransferObjectKind::Package => "Packages",+ TransferObjectKind::Synonym => "Synonyms",}}diff --git a/crates/dbx-core/src/data/transfer/xugu_objects.rs b/crates/dbx-core/src/data/transfer/xugu_objects.rsnew file mode 100644index 0000000000..b25f56b010--- /dev/null+++ b/crates/dbx-core/src/data/transfer/xugu_objects.rs@@ -0,0 +1,1135 @@+//! Selected Xugu schema objects. No Oracle-family routing or cross-engine DDL conversion.+//! Read all definitions and dependencies before the first write. Never replay uncertain DDL.++use super::*;+use sqlparser::{+ dialect::GenericDialect,+ tokenizer::{Token, Tokenizer},+};++pub(crate) fn supported_kinds() -> Vec<TransferObjectKind> {+ use TransferObjectKind::*;+ vec![Table, View, Procedure, Function, Trigger, Sequence, Package, Synonym]+}++fn source_kind(kind: TransferObjectKind) -> Result<db::ObjectSourceKind, String> {+ use db::ObjectSourceKind as S;+ Ok(match kind {+ TransferObjectKind::View => S::View,+ TransferObjectKind::Procedure => S::Procedure,+ TransferObjectKind::Function => S::Function,+ TransferObjectKind::Trigger => S::Trigger,+ TransferObjectKind::Sequence => S::Sequence,+ TransferObjectKind::Package => S::Package,+ TransferObjectKind::Synonym => S::Synonym,+ _ => return Err(format!("Unsupported Xugu schema object: {kind:?}")),+ })+}++fn keyword(kind: &db::ObjectSourceKind) -> &'static str {+ use db::ObjectSourceKind::*;+ match kind {+ View => "VIEW",+ Procedure => "PROCEDURE",+ Function => "FUNCTION",+ Trigger => "TRIGGER",+ Sequence => "SEQUENCE",+ Package => "PACKAGE",+ PackageBody => "PACKAGE BODY",+ Synonym => "SYNONYM",+ _ => "",+ }+}++fn word(token: &Token, expected: &str) -> bool {+ matches!(token, Token::Word(w) if w.quote_style.is_none() && w.value.eq_ignore_ascii_case(expected))+}++fn identifier_matches(token: &Token, expected: &str) -> bool {+ matches!(token, Token::Word(w) if if w.quote_style.is_some() { w.value == expected } else { w.value.to_uppercase() == expected })+}++/// Rewrite identifiers, not string literals/comments/dynamic SQL. Always qualify the+/// declaration, including catalog definitions whose object name was unqualified.+#[cfg(test)]+fn render_definition(+ source: &str,+ kind: &db::ObjectSourceKind,+ name: &str,+ source_schema: &str,+ target_schema: &str,+) -> Result<String, String> {+ render_definition_in_scope(source, kind, name, source_schema, target_schema, false)+}++fn render_definition_in_scope(+ source: &str,+ kind: &db::ObjectSourceKind,+ name: &str,+ source_schema: &str,+ target_schema: &str,+ schema_is_package: bool,+) -> Result<String, String> {+ let source = source.trim();+ let source = source.strip_suffix("\n/").unwrap_or(source).trim_end();+ let mut tokens = Tokenizer::new(&GenericDialect {}, source).tokenize().map_err(|e| e.to_string())?;+ let indices: Vec<usize> =+ tokens.iter().enumerate().filter_map(|(i, t)| (!matches!(t, Token::Whitespace(_))).then_some(i)).collect();+ let at = |p: usize| indices.get(p).and_then(|i| tokens.get(*i));+ let q = |s: &str| quote_identifier(s, &DatabaseType::Xugu);+ let qualified = format!("{}.{}", q(target_schema), q(name));+ if *kind == db::ObjectSourceKind::View && at(0).is_some_and(|t| word(t, "SELECT") || word(t, "WITH")) {+ let ddl = format!("CREATE VIEW {}.{} AS\n{source}", q(source_schema), q(name));+ return render_definition_in_scope(&ddl, kind, name, source_schema, target_schema, schema_is_package);+ }+ let mut p = 0;+ if at(p).is_some_and(|t| word(t, "CREATE")) {+ p += 1;+ if at(p).is_some_and(|t| word(t, "OR")) {+ if !at(p + 1).is_some_and(|t| word(t, "REPLACE")) {+ return Err("Invalid CREATE prefix".into());+ }+ p += 2;+ }+ if at(p).is_some_and(|t| word(t, "FORCE") || word(t, "NOFORCE")) {+ p += 1;+ }+ }+ for part in keyword(kind).split_whitespace() {+ if !at(p).is_some_and(|t| word(t, part)) {+ return Err(format!("Missing complete {} definition for {name}", keyword(kind)));+ }+ p += 1;+ }+ if at(p).is_some_and(|t| word(t, "IF")) {+ if !at(p + 1).is_some_and(|t| word(t, "NOT")) || !at(p + 2).is_some_and(|t| word(t, "EXISTS")) {+ return Err("Invalid IF NOT EXISTS prefix".into());+ }+ // Existence was checked separately. A concurrent create must fail,+ // never masquerade as this transfer successfully creating the object.+ p += 3;+ }+ let first = at(p).ok_or("Missing object declaration name")?;+ if at(p + 1) == Some(&Token::Period) {+ if !identifier_matches(first, source_schema) || !at(p + 2).is_some_and(|t| identifier_matches(t, name)) {+ return Err(format!("Source declaration does not match {source_schema}.{name}"));+ }+ p += 3;+ } else {+ if !identifier_matches(first, name) {+ return Err(format!("Source declaration does not match {name}"));+ }+ p += 1;+ }+ let body_start = *indices.get(p).ok_or("Incomplete object definition")?;+ let package_shadows_schema = schema_is_package+ || (matches!(kind, db::ObjectSourceKind::Package | db::ObjectSourceKind::PackageBody) && name == source_schema);+ // A qualifier can also be an alias or a PL/SQL variable. Fail closed when+ // the source schema name is declared/used as an unqualified identifier;+ // rewriting its later dotted references would silently change semantics.+ if source_schema != target_schema {+ for (position, index) in indices.iter().enumerate().filter(|(_, index)| **index >= body_start) {+ if identifier_matches(&tokens[*index], source_schema)+ && indices.get(position + 1).map(|i| &tokens[*i]) != Some(&Token::Period)+ {+ return Err(format!(+ "Ambiguous schema/alias identifier {source_schema} in {name}; cross-schema transfer refused"+ ));+ }+ }+ }+ // Only the schema token preceding a period is rewritten. Quoted identifiers+ // retain exact-case semantics; unquoted identifiers follow Xugu case folding.+ for (position, index) in indices.iter().enumerate() {+ if *index >= body_start+ && indices.get(position + 1).map(|i| &tokens[*i]) == Some(&Token::Period)+ && position.checked_sub(1).map(|p| &tokens[indices[p]]) != Some(&Token::Period)+ && identifier_matches(&tokens[*index], source_schema)+ {+ // In a package named like its schema, SRC.F can mean a package+ // member rather than a schema-qualified standalone function. No+ // token-only rewrite can prove which meaning the compiler chose.+ let relation_position = position.checked_sub(1).is_some_and(|p| {+ ["FROM", "JOIN", "UPDATE", "INTO", "REFERENCES"].iter().any(|k| word(&tokens[indices[p]], k))+ });+ if source_schema != target_schema && package_shadows_schema && !relation_position {+ return Err(format!(+ "Ambiguous package/schema qualifier {source_schema} in {name}; cross-schema transfer refused"+ ));+ }+ tokens[*index] = Token::Word(sqlparser::tokenizer::Word {+ value: target_schema.into(),+ quote_style: Some('"'),+ keyword: sqlparser::keywords::Keyword::NoKeyword,+ });+ }+ }+ let tail: String = tokens[body_start..].iter().map(ToString::to_string).collect();+ validate_single_definition(format!("CREATE {} {qualified} {tail}", keyword(kind)))+}++fn validate_single_definition(ddl: String) -> Result<String, String> {+ let statements = split_sql_statements_for_database(&ddl, DatabaseType::Xugu);+ if statements.len() != 1 {+ return Err("Xugu object source must contain exactly one complete definition".into());+ }+ Ok(statements.into_iter().next().unwrap())+}++#[derive(Debug)]+struct PlannedObject {+ kind: TransferObjectKind,+ name: String,+ definition: String,+ package_body: Option<String>,+ trigger_state_sql: Option<String>,+ exists: bool,+ dependencies: HashSet<String>,+}++#[derive(Debug, Default)]+pub(crate) struct Plan {+ objects: Vec<PlannedObject>,+}++fn metadata_bool(value: &serde_json::Value) -> Option<bool> {+ if let Some(value) = value.as_bool() {+ return Some(value);+ }+ if let Some(value) = value.as_i64() {+ return match value {+ 0 => Some(false),+ 1 => Some(true),+ _ => None,+ };+ }+ match value.as_str()?.trim().to_ascii_lowercase().as_str() {+ "false" | "f" | "0" => Some(false),+ "true" | "t" | "1" => Some(true),+ _ => None,+ }+}++/// The dictionary is the same permission-scoped dependency source used by the+/// dependency inspector. Some servers omit dependency rows, so selected SQL+/// references are also collected below; unselected objects are never copied.+fn dependencies_sql(schema: &str) -> String {+ format!("SELECT o.OBJ_NAME, r.OBJ_NAME FROM ALL_DEPENDS d \+ JOIN ALL_OBJECTS o ON o.DB_ID=d.DB_ID AND o.SCHEMA_ID=d.OWNER_ID2 AND o.OBJ_ID=d.OBJ_ID2 AND o.OBJ_TYPE=d.OBJ_TYPE2 \+ JOIN ALL_OBJECTS r ON r.DB_ID=d.DB_ID AND r.SCHEMA_ID=d.OWNER_ID1 AND r.OBJ_ID=d.OBJ_ID1 AND r.OBJ_TYPE=d.OBJ_TYPE1 \+ JOIN ALL_SCHEMAS s ON s.DB_ID=o.DB_ID AND s.SCHEMA_ID=o.SCHEMA_ID \+ WHERE o.DB_ID=CURRENT_DB_ID AND s.SCHEMA_NAME={} AND r.SCHEMA_ID=o.SCHEMA_ID",quote_string_literal(schema))+}++struct CteBinding {+ name: Token,+ declaration: usize,+ visible: std::ops::Range<usize>,+}++fn closing_parenthesis(code: &[&Token], start: usize) -> Option<usize> {+ if code.get(start).copied() != Some(&Token::LParen) {+ return None;+ }+ let mut depth = 0;+ for (i, token) in code.iter().enumerate().skip(start) {+ match token {+ Token::LParen => depth += 1,+ Token::RParen => {+ depth -= 1;+ if depth == 0 {+ return Some(i);+ }+ }+ _ => {}+ }+ }+ None+}++/// CTE names are query-local relations, not catalog objects. Preserve lexical+/// scope, sequential visibility and quoted case; an explicit schema qualifier+/// still denotes a real object even when a CTE has the same name.+fn cte_bindings(code: &[&Token]) -> Result<Vec<CteBinding>, String> {+ let mut bindings = Vec::new();+ for start in 0..code.len() {+ if !word(code[start], "WITH") {+ continue;+ }+ let mut p = start + 1;+ let recursive = code.get(p).is_some_and(|t| word(t, "RECURSIVE"));+ p += usize::from(recursive);+ let mut depth = 0;+ let end = (p..code.len())+ .find(|&i| match code[i] {+ Token::LParen => {+ depth += 1;+ false+ }+ Token::RParen if depth == 0 => true,+ Token::RParen => {+ depth -= 1;+ false+ }+ Token::SemiColon => depth == 0,+ _ => false,+ })+ .unwrap_or(code.len());+ let first_body = p;+ while p < end && matches!(code[p], Token::Word(_)) {+ let declaration = p;+ let name = code[p].clone();+ p += 1;+ if code.get(p).copied() == Some(&Token::LParen) {+ p = closing_parenthesis(code, p).ok_or("Incomplete CTE column list")? + 1;+ }+ if !code.get(p).is_some_and(|t| word(t, "AS")) {+ break; // WITH CHECK OPTION, WITH READ ONLY, etc.+ }+ p += 1;+ if code.get(p).is_some_and(|t| word(t, "NOT")) {+ p += 1;+ }+ if code.get(p).is_some_and(|t| word(t, "MATERIALIZED")) {+ p += 1;+ }+ let Some(close) = closing_parenthesis(code, p) else {+ return Err("Incomplete or unsupported CTE definition".into());+ };+ bindings.push(CteBinding {+ name,+ declaration,+ visible: (if recursive { first_body } else { close + 1 })..end,+ });+ p = close + 1;+ if code.get(p).copied() != Some(&Token::Comma) {+ break;+ }+ p += 1;+ }+ }+ Ok(bindings)+}++/// Supplement incomplete dependency dictionaries using identifier tokens in the+/// definitions we already read. This is ordering only, not SQL rewriting or an+/// automatic dependency-copy closure. Literals/comments and explicitly external+/// schemas cannot create local dependencies.+fn add_definition_dependencies(+ objects: &mut [PlannedObject],+ tables: &[String],+ source_schema: &str,+ target_schema: &str,+) -> Result<(), String> {+ let names: Vec<String> = objects.iter().map(|o| o.name.clone()).chain(tables.iter().cloned()).collect();+ for object in objects.iter_mut().filter(|o| !o.exists) {+ for ddl in std::iter::once(object.definition.as_str()).chain(object.package_body.as_deref()) {+ let tokens = Tokenizer::new(&GenericDialect {}, ddl).tokenize().map_err(|e| e.to_string())?;+ let code: Vec<&Token> = tokens.iter().filter(|t| !matches!(t, Token::Whitespace(_))).collect();+ let ctes = cte_bindings(&code)?;+ let local_routines: Vec<&Token> = code+ .windows(2)+ .filter(|pair| word(pair[0], "FUNCTION") || word(pair[0], "PROCEDURE"))+ .map(|pair| pair[1])+ .collect();+ for (i, token) in code.iter().enumerate() {+ let Some(name) = names.iter().find(|name| **name != object.name && identifier_matches(token, name))+ else {+ continue;+ };+ let previous = i.checked_sub(1).and_then(|p| code.get(p)).copied();+ let next = code.get(i + 1).copied();+ let cte_name = ctes.iter().any(|cte| {+ cte.declaration == i+ || (cte.visible.contains(&i)+ && identifier_matches(&cte.name, name)+ && previous != Some(&Token::Period)+ && next != Some(&Token::LParen)+ && (next == Some(&Token::Period)+ || previous.is_some_and(|t| word(t, "FROM") || word(t, "JOIN"))))+ });+ if cte_name {+ continue;+ }+ let is_reference = if previous == Some(&Token::Period) {+ i.checked_sub(2).and_then(|p| code.get(p)).is_some_and(|qualifier| {+ identifier_matches(qualifier, source_schema) || identifier_matches(qualifier, target_schema)+ })+ } else {+ let is_local = local_routines.iter().any(|local| identifier_matches(local, name));+ let is_declaration = previous.is_some_and(|t| {+ ["FUNCTION", "PROCEDURE", "TRIGGER", "PACKAGE", "VIEW", "SEQUENCE", "SYNONYM"]+ .iter()+ .any(|k| word(t, k))+ });+ !is_local+ && !is_declaration+ && (matches!(next, Some(Token::LParen | Token::Period))+ || previous.is_some_and(|t| {+ ["FROM", "JOIN", "INTO", "UPDATE", "REFERENCES", "FOR", "CALL", "EXEC", "EXECUTE"]+ .iter()+ .any(|k| word(t, k))+ }))+ };+ if is_reference {+ object.dependencies.insert(name.clone());+ }+ }+ }+ }+ Ok(())+}++fn order_objects(mut objects: Vec<PlannedObject>) -> Result<Vec<PlannedObject>, String> {+ let mut ordered = Vec::with_capacity(objects.len());+ while !objects.is_empty() {+ let remaining: HashSet<String> = objects.iter().filter(|o| !o.exists).map(|o| o.name.clone()).collect();+ let next = objects.iter().position(|o| {+ o.exists+ || (o.dependencies.is_disjoint(&remaining)+ && (o.kind != TransferObjectKind::Trigger+ || objects.iter().all(|other| other.kind == TransferObjectKind::Trigger || other.exists)))+ });+ let Some(i) = next else {+ let phase_note = if objects.iter().any(|o| o.package_body.is_some()) {+ "; separate package specification/body compilation phases are not supported"+ } else {+ ""+ };+ return Err(format!(+ "Cyclic Xugu object dependencies: {}{phase_note}",+ objects.iter().map(|o| o.name.as_str()).collect::<Vec<_>>().join(", "),+ ));+ };+ ordered.push(objects.remove(i));+ }+ Ok(ordered)+}++pub(crate) async fn prepare(state: &AppState, request: &TransferRequest, source_pool: &str) -> Result<Plan, String> {+ if request.content == TransferContent::DataOnly {+ return Ok(Plan::default());+ }+ if request.source_schema.is_empty()+ || request.target_schema.is_empty()+ || request.source_schema.contains('\0')+ || request.target_schema.contains('\0')+ {+ return Err("Xugu schema-object transfer requires real source and target schemas".into());+ }+ let mut objects = Vec::new();+ let mut seen = HashSet::new();+ // The qualifier can occur outside the package too. Include unselected,+ // visible packages before treating the prefix as a schema name.+ let schema_is_package = if request.source_schema != request.target_schema {+ crate::schema::list_objects_core(+ state,+ &request.source_connection_id,+ &request.source_database,+ &request.source_schema,+ None,+ None,+ None,+ Some(&["PACKAGE".to_string()]),+ None,+ )+ .await?+ .iter()+ .any(|package| package.name == request.source_schema)+ } else {+ false+ };+ for selection in request.objects.as_deref().unwrap_or_default() {+ if selection.object_type == TransferObjectKind::Table {+ continue;+ }+ let kind = source_kind(selection.object_type)?;+ let kinds = [keyword(&kind).to_string()];+ let source_objects = crate::schema::list_objects_core(+ state,+ &request.source_connection_id,+ &request.source_database,+ &request.source_schema,+ None,+ None,+ None,+ Some(&kinds),+ None,+ )+ .await?;+ let target_objects = crate::schema::list_objects_core(+ state,+ &request.target_connection_id,+ &request.target_database,+ &request.target_schema,+ None,+ None,+ None,+ Some(&kinds),+ None,+ )+ .await?;+ for name in &selection.names {+ if !seen.insert(name.clone()) {+ return Err(format!("Duplicate or ambiguous Xugu object selection: {name}"));+ }+ if source_objects.iter().filter(|o| o.name == *name).count() != 1 {+ return Err(format!("Xugu source object not found, not visible or ambiguous: {name}"));+ }+ if selection.object_type == TransferObjectKind::Sequence {+ let sql = format!("SELECT q.IS_SYS FROM ALL_SEQUENCES q JOIN ALL_SCHEMAS s ON q.DB_ID=s.DB_ID AND q.SCHEMA_ID=s.SCHEMA_ID WHERE q.DB_ID=CURRENT_DB_ID AND s.SCHEMA_NAME={} AND q.SEQ_NAME={}",quote_string_literal(&request.source_schema),quote_string_literal(name));+ let result = execute_read_on_pool(state, source_pool, &sql).await?;+ let value = result.rows.first().and_then(|r| r.first()).ok_or("Sequence metadata is unavailable")?;+ if metadata_bool(value) != Some(false) {+ return Err(format!("Identity/system sequence {name} must not be transferred independently"));+ }+ }+ let target_count = target_objects.iter().filter(|o| o.name == *name).count();+ if target_count > 1 {+ return Err(format!("Ambiguous Xugu target object: {name}"));+ }+ let exists = target_count == 1;+ let mut object = PlannedObject {+ kind: selection.object_type,+ name: name.clone(),+ definition: String::new(),+ package_body: None,+ trigger_state_sql: None,+ exists,+ dependencies: HashSet::new(),+ };+ if !exists {+ if source_objects.iter().any(|o| o.name == *name && o.valid == Some(false)) {+ return Err(format!("Xugu source object is invalid: {name}; compile or repair it before transfer"));+ }+ if selection.object_type == TransferObjectKind::Trigger {+ let sql = format!("SELECT t.ENABLE FROM ALL_TRIGGERS t JOIN ALL_SCHEMAS s ON t.DB_ID=s.DB_ID AND t.SCHEMA_ID=s.SCHEMA_ID WHERE t.DB_ID=CURRENT_DB_ID AND s.SCHEMA_NAME={} AND t.TRIG_NAME={}", quote_string_literal(&request.source_schema), quote_string_literal(name));+ let result = execute_read_on_pool(state, source_pool, &sql).await?;+ let enabled = result+ .rows+ .first()+ .and_then(|r| r.first())+ .and_then(metadata_bool)+ .filter(|_| result.rows.len() == 1)+ .ok_or_else(|| format!("Trigger state unavailable or ambiguous: {name}"))?;+ object.trigger_state_sql = Some(format!(+ "ALTER TRIGGER {}.{} {}",+ quote_identifier(&request.target_schema, &DatabaseType::Xugu),+ quote_identifier(name, &DatabaseType::Xugu),+ if enabled { "ENABLE" } else { "DISABLE" }+ ));+ }+ let source = crate::schema::get_object_source_core(+ state,+ &request.source_connection_id,+ &request.source_database,+ &request.source_schema,+ name,+ kind.clone(),+ None,+ None,+ )+ .await?;+ object.definition = render_definition_in_scope(+ &source.source,+ &kind,+ name,+ &request.source_schema,+ &request.target_schema,+ schema_is_package,+ )?;+ if selection.object_type == TransferObjectKind::Package {+ let body = crate::schema::get_object_source_core(+ state,+ &request.source_connection_id,+ &request.source_database,+ &request.source_schema,+ name,+ db::ObjectSourceKind::PackageBody,+ None,+ None,+ )+ .await?;+ if !body.source.trim().is_empty() {+ object.package_body = Some(render_definition_in_scope(+ &body.source,+ &db::ObjectSourceKind::PackageBody,+ name,+ &request.source_schema,+ &request.target_schema,+ schema_is_package,+ )?);+ }+ }+ }+ objects.push(object);+ }+ }+ if objects.iter().all(|o| o.exists) {+ return Ok(Plan { objects });+ }+ let dependencies = execute_read_on_pool(state, source_pool, &dependencies_sql(&request.source_schema)).await?;+ for row in dependencies.rows {+ if let (Some(name), Some(dependency)) =+ (row.first().and_then(|v| v.as_str()), row.get(1).and_then(|v| v.as_str()))+ {+ if name != dependency {+ for object in objects.iter_mut().filter(|o| o.name == name) {+ object.dependencies.insert(dependency.into());+ }+ }+ }+ }+ add_definition_dependencies(&mut objects, &request.tables, &request.source_schema, &request.target_schema)?;+ // Independent sequences are prerequisites for table defaults. Packages run+ // after tables because their specifications can declare table%ROWTYPE.+ objects.sort_by_key(|o| match o.kind {+ TransferObjectKind::Sequence => 0,+ TransferObjectKind::Package => 1,+ TransferObjectKind::Trigger => 3,+ _ => 2,+ });+ Ok(Plan { objects: order_objects(objects)? })+}++impl Plan {+ pub(crate) fn preview_before_tables(&self) -> String {+ self.objects+ .iter()+ .filter(|o| !o.exists && o.kind == TransferObjectKind::Sequence)+ .map(|o| format!("{};", o.definition.trim_end_matches(';')))+ .collect::<Vec<_>>()+ .join("\n\n")+ }+ pub(crate) fn preview_after_tables(&self) -> String {+ self.objects+ .iter()+ .filter(|o| o.kind != TransferObjectKind::Sequence || o.exists)+ .map(|o| {+ if o.exists {+ return format!("-- Skip existing {:?}: {}", o.kind, o.name);+ }+ let sql = if o.kind == TransferObjectKind::Package {+ return match &o.package_body {+ Some(body) => {+ format!("{};\n\n{};", o.definition.trim_end_matches(';'), body.trim_end_matches(';'))+ }+ None => format!("{};", o.definition.trim_end_matches(';')),+ };+ } else {+ &o.definition+ };+ if sql.is_empty() {+ format!("-- Package {} has no body", o.name)+ } else {+ let mut sql = format!("{};", sql.trim_end_matches(';'));+ if let Some(state) = &o.trigger_state_sql {+ sql.push_str(&format!("\n{state};"));+ }+ sql+ }+ })+ .collect::<Vec<_>>()+ .join("\n\n")+ }+ pub(crate) async fn before_tables(+ &self,+ state: &AppState,+ request: &TransferRequest,+ target_pool: &str,+ ) -> Result<(), String> {+ for object in &self.objects {+ if is_cancelled(&request.transfer_id).await {+ return Err("Cancelled".into());+ }+ if !object.exists && object.kind == TransferObjectKind::Sequence {+ execute_on_pool(state, target_pool, &object.definition)+ .await+ .map_err(|e| format!("Xugu prerequisite {:?} {} failed: {e}", object.kind, object.name))?;+ }+ }+ Ok(())+ }+ pub(crate) async fn after_tables<F: FnMut(TransferProgress)>(+ &self,+ state: &AppState,+ request: &TransferRequest,+ target_pool: &str,+ failed_tables: &[String],+ mut progress: F,+ ) -> Result<TransferObjectOutcome, String> {+ let mut outcome = TransferObjectOutcome::default();+ let mut failed: HashSet<String> = failed_tables.iter().cloned().collect();+ for object in &self.objects {+ if is_cancelled(&request.transfer_id).await {+ return Err("Cancelled".into());+ }+ let label = format!("{:?}:{}", object.kind, object.name);+ let result = if object.exists {+ outcome.skipped.push(label.clone());+ Ok(())+ } else if !object.dependencies.is_disjoint(&failed) {+ Err("A selected prerequisite failed; dependent object was not created".to_string())+ } else {+ let sql = match object.kind {+ TransferObjectKind::Sequence => None,+ _ => Some(object.definition.as_str()),+ };+ match sql {+ Some(sql) => {+ let result = execute_on_pool(state, target_pool, sql).await.map(|_| ());+ if result.is_ok() {+ if let Some(sql) = object.package_body.as_ref().or(object.trigger_state_sql.as_ref()) {+ execute_on_pool(state, target_pool, sql).await.map(|_| ())+ } else {+ result+ }+ } else {+ result+ }+ }+ None => Ok(()),+ }+ };+ let result = if result.is_ok() && !object.exists {+ // Some database DDL can succeed while leaving a programmable+ // object invalid. Do not report such a transfer as successful.+ let kinds = [keyword(&source_kind(object.kind)?).to_string()];+ match crate::schema::list_objects_core(+ state,+ &request.target_connection_id,+ &request.target_database,+ &request.target_schema,+ None,+ None,+ None,+ Some(&kinds),+ None,+ )+ .await+ {+ Ok(objects) => {+ let verified = verify_created_object(&objects, &object.name);+ if verified.is_ok() && object.package_body.is_some() {+ let sql = package_body_state_sql(&request.target_schema, &object.name);+ match execute_read_on_pool(state, target_pool, &sql).await {+ Ok(result) => verify_package_body_state(&result.rows, &object.name),+ Err(error) => Err(format!("Unable to verify package body {}: {error}", object.name)),+ }+ } else {+ verified+ }+ }+ Err(error) => Err(format!("Unable to verify created object {}: {error}", object.name)),+ }+ } else {+ result+ };+ let error = result.err();+ if error.is_some() {+ failed.insert(object.name.clone());+ outcome.failed.push(label.clone());+ } else if !object.exists {+ outcome.transferred.push(label.clone());+ }+ progress(TransferProgress {+ transfer_id: request.transfer_id.clone(),+ table: format!("schema object: {label}"),+ table_index: request.tables.len(),+ total_tables: request.tables.len(),+ rows_transferred: (outcome.transferred.len() + outcome.skipped.len()) as u64,+ total_rows: None,+ status: if error.is_some() { TransferStatus::Error } else { TransferStatus::Running },+ error,+ terminal: false,+ });+ }+ Ok(outcome)+ }+}++fn package_body_state_sql(schema: &str, name: &str) -> String {+ format!("SELECT p.ALL_OK FROM ALL_PACKAGES p JOIN ALL_SCHEMAS s ON s.DB_ID=p.DB_ID AND s.SCHEMA_ID=p.SCHEMA_ID WHERE p.DB_ID=CURRENT_DB_ID AND s.SCHEMA_NAME={} AND p.PACK_NAME={} AND p.BODY IS NOT NULL", quote_string_literal(schema), quote_string_literal(name))+}++fn verify_package_body_state(rows: &[Vec<serde_json::Value>], name: &str) -> Result<(), String> {+ if rows.len() == 1 && rows[0].first().and_then(metadata_bool) == Some(true) {+ Ok(())+ } else {+ Err(format!("Created Xugu package body is missing, invalid or its state is unavailable: {name}"))+ }+}++fn verify_created_object(objects: &[db::ObjectInfo], name: &str) -> Result<(), String> {+ let matching: Vec<_> = objects.iter().filter(|o| o.name == name).collect();+ match matching.as_slice() {+ [object] if object.valid != Some(false) => Ok(()),+ [_] => Err(format!("Created Xugu object is invalid: {name}")),+ _ => Err(format!("Created Xugu object not found or ambiguous: {name}")),+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn package_body_verification_uses_all_ok_and_refuses_unknown_state() {+ use serde_json::json;+ let sql = package_body_state_sql("Dst'Q", "Pkg");+ assert!(sql.contains("SELECT p.ALL_OK"));+ assert!(!sql.contains("VALID"));+ assert!(sql.contains("'Dst''Q'"));+ assert!(sql.contains("p.BODY IS NOT NULL"));+ assert!(verify_package_body_state(&[vec![json!(true)]], "Pkg").is_ok());+ for rows in+ [vec![], vec![vec![json!(false)]], vec![vec![json!(null)]], vec![vec![json!(true)], vec![json!(true)]]]+ {+ assert!(verify_package_body_state(&rows, "Pkg").is_err());+ }+ }++ fn planned(kind: TransferObjectKind, name: &str, dependencies: &[&str]) -> PlannedObject {+ PlannedObject {+ kind,+ name: name.into(),+ definition: format!("CREATE {kind:?} \"DST\".\"{name}\""),+ package_body: None,+ trigger_state_sql: None,+ exists: false,+ dependencies: dependencies.iter().map(|s| (*s).into()).collect(),+ }+ }++ #[test]+ fn orders_selected_dependencies_and_places_triggers_last() {+ use TransferObjectKind::*;+ let objects = order_objects(vec![+ planned(Trigger, "TR", &["P"]),+ planned(Procedure, "P", &["V2", "PKG"]),+ planned(View, "V2", &["V1"]),+ planned(Package, "PKG", &["F"]),+ planned(Function, "F", &[]),+ planned(View, "V1", &["UNSELECTED_TABLE"]),+ ])+ .unwrap();+ let names: Vec<_> = objects.iter().map(|o| o.name.as_str()).collect();+ let pos = |name| names.iter().position(|n| *n == name).unwrap();+ assert!(pos("F") < pos("PKG"));+ assert!(pos("PKG") < pos("P"));+ assert!(pos("V1") < pos("V2"));+ assert!(pos("V2") < pos("P"));+ assert_eq!(names.last(), Some(&"TR"));+ }++ #[test]+ fn missing_dictionary_rows_still_order_real_view_and_routine_references() {+ use TransferObjectKind::*;+ let mut objects = vec![+ planned(Package, "PKG_TEST", &[]),+ planned(Procedure, "P_ADD", &[]),+ planned(View, "V_CHAIN", &[]),+ planned(View, "V_ITEMS", &[]),+ planned(Function, "F_ADD", &[]),+ ];+ objects[0].package_body = Some("CREATE PACKAGE BODY DST.PKG_TEST AS FUNCTION GET_BASE RETURN INT AS BEGIN RETURN DST.F_ADD(40, 2); END; END;".into());+ objects[1].definition =+ "CREATE PROCEDURE DST.P_ADD AS BEGIN INSERT INTO DST.AUDIT_LOG VALUES (DST.F_ADD(1, 2)); END;".into();+ objects[2].definition = "CREATE VIEW DST.V_CHAIN AS SELECT * FROM DST.V_ITEMS".into();+ objects[3].definition = "CREATE VIEW DST.V_ITEMS AS SELECT * FROM DST.ITEMS".into();+ add_definition_dependencies(&mut objects, &["AUDIT_LOG".into(), "ITEMS".into()], "SRC", "DST").unwrap();+ assert!(objects[1].dependencies.contains("AUDIT_LOG"));+ assert!(objects[3].dependencies.contains("ITEMS"));+ let objects = order_objects(objects).unwrap();+ let pos = |name| objects.iter().position(|o| o.name == name).unwrap();+ assert!(pos("F_ADD") < pos("PKG_TEST"));+ assert!(pos("F_ADD") < pos("P_ADD"));+ assert!(pos("V_ITEMS") < pos("V_CHAIN"));+ }++ #[test]+ fn selected_reference_scan_ignores_literals_external_schemas_and_local_routines() {+ use TransferObjectKind::*;+ let mut objects = vec![planned(Package, "P", &[]), planned(Function, "F", &[]), planned(View, "V", &[])];+ objects[0].package_body = Some("CREATE PACKAGE BODY DST.P AS FUNCTION F RETURN INT AS BEGIN RETURN 1; END; PROCEDURE LOCAL_P AS BEGIN OTHER.F(); F(); -- DST.V\n DBMS_OUTPUT.PUT_LINE('DST.V'); END; END;".into());+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ assert!(objects[0].dependencies.is_empty());+ objects[0].package_body = Some("CREATE PACKAGE BODY DST.P AS PROCEDURE LOCAL_P AS BEGIN F(); END; END;".into());+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ assert!(objects[0].dependencies.contains("F"));+ }++ #[test]+ fn refuses_cycles_but_accepts_existing_dependencies() {+ use TransferObjectKind::*;+ assert!(order_objects(vec![planned(View, "A", &["B"]), planned(View, "B", &["A"])]).is_err());+ let mut existing = planned(View, "B", &["A"]);+ existing.exists = true;+ let ordered = order_objects(vec![planned(View, "A", &["B"]), existing]).unwrap();+ // B is already present on the destination, so A need not wait for its+ // skip record. Existing B's source dependencies are not replayed.+ assert_eq!(ordered.len(), 2);+ assert!(ordered.iter().any(|o| o.name == "B" && o.exists));+ assert!(ordered.iter().any(|o| o.name == "A" && !o.exists));+ }++ #[test]+ fn cte_names_do_not_create_false_catalog_dependencies_or_cycles() {+ use TransferObjectKind::*;+ for query in [+ "WITH V_B AS (SELECT 1 AS N) SELECT N FROM V_B",+ "WITH V_B(N) AS (SELECT 1) SELECT V_B.N FROM V_B",+ "WITH FIRST_CTE AS (SELECT 1 AS N), V_B AS (SELECT N FROM FIRST_CTE) SELECT N FROM V_B",+ "WITH RECURSIVE V_B(N) AS (SELECT 1 UNION ALL SELECT N + 1 FROM V_B WHERE N < 3) SELECT N FROM V_B",+ "SELECT N FROM (WITH V_B AS (SELECT 1 AS N) SELECT N FROM V_B) Q",+ ] {+ let mut objects = vec![planned(View, "V_A", &[]), planned(View, "V_B", &[])];+ objects[0].definition = format!("CREATE VIEW DST.V_A AS {query}");+ objects[1].definition = "CREATE VIEW DST.V_B AS SELECT N FROM DST.V_A".into();+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ assert!(objects[0].dependencies.is_empty(), "{query}");+ let ordered = order_objects(objects).unwrap();+ assert_eq!(ordered[0].name, "V_A");+ assert_eq!(ordered[1].name, "V_B");+ }+ }++ #[test]+ fn cte_scopes_preserve_real_qualified_outer_and_function_dependencies() {+ use TransferObjectKind::*;+ for query in [+ // A non-recursive CTE cannot shadow the relation in its own body.+ "WITH V_B AS (SELECT * FROM V_B) SELECT * FROM V_B",+ "WITH V_B AS (SELECT 1 AS N) SELECT * FROM DST.V_B",+ "SELECT * FROM (WITH V_B AS (SELECT 1 AS N) SELECT N FROM V_B) Q JOIN V_B ON 1=1",+ // Quoted CTE names retain exact case.+ "WITH \"v_b\" AS (SELECT 1 AS N) SELECT * FROM V_B",+ // Relation aliases do not shadow the function namespace.+ "WITH V_B AS (SELECT 1 AS N) SELECT V_B() FROM V_B",+ // CTE declarations in a later statement cannot affect earlier ones.+ "SELECT * FROM V_B; WITH V_B AS (SELECT 1 AS N) SELECT N FROM V_B",+ ] {+ let mut objects = vec![planned(View, "V_A", &[]), planned(View, "V_B", &[])];+ objects[0].definition = format!("CREATE VIEW DST.V_A AS {query}");+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ assert!(objects[0].dependencies.contains("V_B"), "{query}");+ }+ }++ #[test]+ fn ctes_in_programmable_objects_have_statement_local_scope() {+ use TransferObjectKind::*;+ let mut objects = vec![planned(Procedure, "P", &[]), planned(View, "V", &[])];+ objects[0].definition =+ "CREATE PROCEDURE DST.P AS BEGIN WITH V AS (SELECT 1 AS N) SELECT N FROM V; SELECT * FROM DST.V; END;"+ .into();+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ assert!(objects[0].dependencies.contains("V"));+ objects[0].dependencies.clear();+ objects[0].definition =+ "CREATE PROCEDURE DST.P AS BEGIN WITH V AS (SELECT 1 AS N) SELECT N FROM V; END;".into();+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ assert!(objects[0].dependencies.is_empty());+ }++ #[test]+ fn package_phase_cycles_are_explicitly_rejected_before_execution() {+ use TransferObjectKind::*;+ let mut package = planned(Package, "PKG", &[]);+ package.package_body = Some(+ "CREATE PACKAGE BODY DST.PKG AS FUNCTION F(N INT) RETURN INT AS BEGIN RETURN DST.G(N); END; END;".into(),+ );+ let mut function = planned(Function, "G", &[]);+ function.definition = "CREATE FUNCTION DST.G(N INT) RETURN INT AS BEGIN RETURN DST.PKG.BASE(N); END;".into();+ let mut objects = vec![package, function];+ add_definition_dependencies(&mut objects, &[], "SRC", "DST").unwrap();+ let error = order_objects(objects).unwrap_err();+ assert!(error.contains("Cyclic Xugu object dependencies"));+ assert!(error.contains("separate package specification/body compilation phases are not supported"));+ }++ #[test]+ fn same_named_package_and_schema_never_rewrite_ambiguous_member_calls() {+ for kind in [db::ObjectSourceKind::Package, db::ObjectSourceKind::PackageBody] {+ let source = format!(+ "CREATE {} SRC.SRC AS FUNCTION F RETURN INT AS BEGIN RETURN SRC.G(); END; END;",+ keyword(&kind)+ );+ let error = render_definition(&source, &kind, "SRC", "SRC", "DST").unwrap_err();+ assert!(error.contains("Ambiguous package/schema qualifier"));+ let unchanged = render_definition(&source, &kind, "SRC", "SRC", "SRC").unwrap();+ assert!(unchanged.contains("RETURN \"SRC\".G()"));+ }+ let literal = render_definition(+ "PACKAGE SRC.SRC AS V VARCHAR := 'SRC.G()'; END;",+ &db::ObjectSourceKind::Package,+ "SRC",+ "SRC",+ "DST",+ )+ .unwrap();+ assert!(literal.contains("'SRC.G()'"));+ }++ #[test]+ fn only_the_first_schema_qualifier_is_rewritten() {+ let ddl = render_definition(+ "SELECT OTHER.SRC.ID, SRC.T.ID FROM OTHER.SRC JOIN SRC.T ON 1=1",+ &db::ObjectSourceKind::View,+ "V",+ "SRC",+ "DST",+ );+ // An unqualified schema-name occurrence remains conservatively rejected.+ assert!(ddl.is_err());+ let ddl = render_definition("SELECT OTHER.SRC.ID FROM OTHER.T", &db::ObjectSourceKind::View, "V", "SRC", "DST")+ .unwrap();+ assert!(ddl.contains("OTHER.SRC.ID"));+ assert!(!ddl.contains("OTHER.\"DST\""));+ }++ #[test]+ fn unselected_same_named_packages_also_guard_view_and_routine_rewrites() {+ for (kind, source) in [+ (db::ObjectSourceKind::View, "SELECT SRC.G(1) AS N FROM DUAL"),+ (db::ObjectSourceKind::Function, "FUNCTION F RETURN INT AS BEGIN RETURN SRC.G(1); END;"),+ ] {+ assert!(render_definition_in_scope(source, &kind, "F", "SRC", "DST", true)+ .unwrap_err()+ .contains("Ambiguous package/schema qualifier"));+ let sql = render_definition_in_scope(source, &kind, "F", "SRC", "DST", false).unwrap();+ assert!(sql.contains("\"DST\".G(1)"));+ }+ let sql =+ render_definition_in_scope("SELECT N FROM SRC.V", &db::ObjectSourceKind::View, "F", "SRC", "DST", true)+ .unwrap();+ assert!(sql.contains("FROM \"DST\".V"));+ }++ #[test]+ fn preview_matches_sequence_package_trigger_phases_and_existing_skips() {+ use TransferObjectKind::*;+ let sequence = planned(Sequence, "SEQ", &[]);+ let mut existing = planned(Sequence, "EXISTING", &[]);+ existing.exists = true;+ let mut package = planned(Package, "PKG", &[]);+ package.package_body = Some("CREATE PACKAGE BODY \"DST\".\"PKG\" AS END;".into());+ let mut trigger = planned(Trigger, "TR", &[]);+ trigger.trigger_state_sql = Some("ALTER TRIGGER \"DST\".\"TR\" DISABLE".into());+ let plan = Plan { objects: vec![sequence, existing, package, trigger] };+ let before = plan.preview_before_tables();+ assert!(before.contains("\"SEQ\""));+ assert!(!before.contains("PKG"));+ let after = plan.preview_after_tables();+ assert!(after.contains("-- Skip existing Sequence: EXISTING"));+ assert!(after.contains("CREATE Package \"DST\".\"PKG\";"));+ assert!(after.contains("CREATE PACKAGE BODY"));+ assert!(after.ends_with("ALTER TRIGGER \"DST\".\"TR\" DISABLE;"));+ assert!(!after.contains("\"SEQ\""));+ }++ #[test]+ fn metadata_booleans_never_default_unknown_values_to_false() {+ use serde_json::json;+ for value in [json!(false), json!(0), json!("FALSE"), json!("f"), json!("0")] {+ assert_eq!(metadata_bool(&value), Some(false));+ }+ for value in [json!(true), json!(1), json!("TRUE"), json!("t"), json!("1")] {+ assert_eq!(metadata_bool(&value), Some(true));+ }+ for value in [json!(null), json!(2), json!("unknown"), json!({})] {+ assert_eq!(metadata_bool(&value), None);+ }+ }++ #[test]+ fn verifies_existence_and_validity_instead_of_trusting_create_success() {+ let object = |valid| {+ serde_json::from_value::<db::ObjectInfo>(serde_json::json!({+ "name": "V", "object_type": "VIEW", "valid": valid,+ }))+ .unwrap()+ };+ assert!(verify_created_object(&[object(Some(true))], "V").is_ok());+ assert!(verify_created_object(&[object(None)], "V").is_ok());+ assert!(verify_created_object(&[object(Some(false))], "V").is_err());+ assert!(verify_created_object(&[], "V").is_err());+ assert!(verify_created_object(&[object(Some(true)), object(Some(true))], "V").is_err());+ }++ #[test]+ fn rejects_schema_name_used_as_an_alias_or_variable_across_schemas() {+ assert!(render_definition("SELECT SRC.ID FROM OTHER.T SRC", &db::ObjectSourceKind::View, "V", "SRC", "DST")+ .is_err());+ assert!(render_definition(+ "PROCEDURE P AS SRC INTEGER; BEGIN SRC := 1; END;",+ &db::ObjectSourceKind::Procedure,+ "P",+ "SRC",+ "DST"+ )+ .is_err());+ assert!(+ render_definition("SELECT SRC.ID FROM OTHER.T SRC", &db::ObjectSourceKind::View, "V", "SRC", "SRC").is_ok()+ );+ }+ #[test]+ fn definition_qualifies_and_rewrites_identifiers_only() {+ let ddl = render_definition(+ "CREATE OR REPLACE PROCEDURE SRC.P AS BEGIN INSERT INTO SRC.T VALUES ('SRC.T'); -- SRC.T\nEND;",+ &db::ObjectSourceKind::Procedure,+ "P",+ "SRC",+ "Dst",+ )+ .unwrap();+ assert!(ddl.starts_with("CREATE PROCEDURE \"Dst\".\"P\""));+ assert!(ddl.contains("INSERT INTO \"Dst\".T"));+ assert!(ddl.contains("'SRC.T'"));+ assert!(ddl.contains("-- SRC.T"));+ assert!(!ddl.contains("OR REPLACE"));+ }+ #[test]+ fn refuses_wrong_objects_and_empty_sources() {+ for source in [+ "",+ "-- metadata unavailable",+ "CREATE VIEW OTHER.V AS SELECT 1",+ "CREATE VIEW SRC.WRONG AS SELECT 1",+ "CREATE PUBLIC SYNONYM S FOR SRC.T",+ ] {+ assert!(render_definition(source, &db::ObjectSourceKind::View, "V", "SRC", "DST").is_err(), "{source}");+ }+ assert!(render_definition("SELECT 1; DROP TABLE T;", &db::ObjectSourceKind::View, "V", "SRC", "DST").is_err());+ }+ #[test]+ fn preserves_quoted_case_and_package_body() {+ let ddl = render_definition(+ "PACKAGE BODY \"Src\".\"Pkg\" AS FUNCTION F RETURN INT AS BEGIN RETURN 1; END; END;\n/",+ &db::ObjectSourceKind::PackageBody,+ "Pkg",+ "Src",+ "Dst",+ )+ .unwrap();+ assert!(ddl.starts_with("CREATE PACKAGE BODY \"Dst\".\"Pkg\""));+ assert!(ddl.contains("RETURN 1; END; END"));+ assert!(render_definition("CREATE VIEW SRC.\"v\" AS SELECT 1", &db::ObjectSourceKind::View, "V", "SRC", "DST")+ .is_err());+ }+ #[test]+ fn wraps_bare_view_and_preserves_external_schema() {+ let ddl = render_definition(+ "SELECT 'SRC.X' FROM SRC.T JOIN OTHER.T U ON 1=1",+ &db::ObjectSourceKind::View,+ "V",+ "SRC",+ "DST",+ )+ .unwrap();+ // Bare view sources must pass through the same identifier rewrite.+ assert!(ddl.starts_with("CREATE VIEW \"DST\".\"V\" AS"));+ assert!(ddl.contains("FROM \"DST\".T"));+ assert!(ddl.contains("OTHER.T"));+ }+}diff --git a/crates/dbx-core/src/data/transfer_runner.rs b/crates/dbx-core/src/data/transfer_runner.rsindex e9a5600858..b538acd808 100644--- a/crates/dbx-core/src/data/transfer_runner.rs+++ b/crates/dbx-core/src/data/transfer_runner.rs@@ -155,6 +155,50 @@ wherelet mut last_rows_transferred = 0_u64;let mut last_total_rows = None;+ // Xugu-only preflight: read every selected definition before writing,+ // then establish independent sequences before tables. Packages and+ // programmable objects follow tables; triggers run last. Other engines+ // retain their existing execution order.+ let xugu_object_plan = if source_db_type == DatabaseType::Xugu+ && target_db_type == DatabaseType::Xugu+ && super::transfer::should_transfer_schema_objects(&source_db_type, &target_db_type, &request)+ {+ let prepared = super::transfer::xugu_objects::prepare(&state, &request, &source_pool_key).await;+ let result = match prepared {+ Ok(plan) => plan.before_tables(&state, &request, &target_pool_key).await.map(|()| plan),+ Err(error) => Err(error),+ };+ match result {+ Ok(plan) => Some(plan),+ Err(error) => {+ emit_terminal_progress(+ &app,+ history.as_ref(),+ TransferProgress {+ transfer_id: transfer_id.clone(),+ table: "schema objects".into(),+ table_index: 0,+ total_tables,+ rows_transferred: 0,+ total_rows: None,+ status: if error == "Cancelled" {+ TransferStatus::Cancelled+ } else {+ TransferStatus::Error+ },+ error: Some(error),+ terminal: true,+ },+ )+ .await;+ super::transfer::clear_cancelled(&transfer_id).await;+ return;+ }+ }+ } else {+ None+ };+// When drop_target_before_create is true, perform a rename pre-pass in// parents_first=false order (children first) so that foreign keys on the// backup tables remain intact. The main create/insert pass then runs in@@ -502,16 +546,27 @@ where// transfers schema objects; PG→PG keeps the legacy empty-selection// default only when structure participates in the transfer.let mut object_outcome = super::transfer::TransferObjectOutcome::default();- match super::transfer::transfer_schema_objects_with_routine_context(- &state,- &request,- &source_pool_key,- &target_pool_key,- routine_context.as_ref(),- |progress| emit_progress(&app, progress),- )- .await- {+ let object_result = if let Some(plan) = xugu_object_plan.as_ref() {+ plan.after_tables(&state, &request, &target_pool_key, &failed_tables, |mut progress| {+ // Object completion is not a copied row. Preserve the table-data+ // counters while reporting the current Xugu schema object.+ progress.rows_transferred = last_rows_transferred;+ progress.total_rows = last_total_rows;+ emit_progress(&app, progress)+ })+ .await+ } else {+ super::transfer::transfer_schema_objects_with_routine_context(+ &state,+ &request,+ &source_pool_key,+ &target_pool_key,+ routine_context.as_ref(),+ |progress| emit_progress(&app, progress),+ )+ .await+ };+ match object_result {Ok(outcome) => {if let Some(journal) = history.as_ref() {journal.record_object_outcome(&outcome).await;