Skip to content

armgit / dbx

Public Imported from GitHub
0

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

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.vue
index 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: "source
return;
}
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.ts
index 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.ts
index 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 side
diff --git a/apps/desktop/src/lib/database/transferObjectKinds.ts b/apps/desktop/src/lib/database/transferObjectKinds.ts
index 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.rs
index 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<Tran
TransferObjectKind::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 @@ where
if !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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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 @@ where
let 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;