+
+
+
+
+
@@ -837,12 +1080,23 @@ const targetConnectionInfo = computed(() => {
- {{ deployResult?.success ? t("diff.deploySuccess") : t("diff.deployFailed") }}
+ {{ t("diff.deployMixedTitle") }}
+ {{ t("diff.deployRolledBackTitle") }}
+ {{ deployResult?.success ? t("diff.deploySuccess") : t("diff.deployFailed") }}
-
+
+
{{ deployResult.message }}
+
+ {{ t("diff.deployMixedWarning") }}
+
+
+
+
{{ deployResult.message }}
+
+
{{ t("diff.deploySuccessMessage") }}
{{ t("diff.affectedRows") }}: {{ deployResult.affectedRows ?? 0 }}
@@ -875,11 +1129,25 @@ const targetConnectionInfo = computed(() => {
{{ t("schemaDiff.optionsTitle") }}
-
+
+
+
+
diff --git a/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue b/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue
index 8c82e10c7..ca2f83094 100644
--- a/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue
+++ b/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue
@@ -147,6 +147,36 @@ function getItemClasses(state: "checked" | "unchecked" | "indeterminate"): strin
+
+
+
{{ t("schemaDiff.options.advancedSection") }}
+
+
+
+
+ {{ localOptions.renameThreshold.toFixed(2) }}
+
+
+ {{ t("schemaDiff.options.detectRenames") }}
+
+
+
+
+
+ {{ localOptions.compatibilityThreshold.toFixed(2) }}
+
+
+
+
+
+
+
+
+
{{ t("schemaDiff.options.batchSection") }}
+
+
+
+
diff --git a/apps/desktop/src/components/diff/StrictTagAlertPanel.vue b/apps/desktop/src/components/diff/StrictTagAlertPanel.vue
new file mode 100644
index 000000000..a66eef464
--- /dev/null
+++ b/apps/desktop/src/components/diff/StrictTagAlertPanel.vue
@@ -0,0 +1,87 @@
+
+
+
+
+
+
+
{{ t("strictTag.title") }}
+
+
+
+
+
{{ t("strictTag.blockingExecution") }}
+
+
+
+ {{ t("strictTag.noViolations") }}
+
+
+
+
+ {{ t("strictTag.violationsFound", { count: violations.length }) }}
+
+
+
+
+
+
+
+ | {{ t("strictTag.fileName") }} |
+ {{ t("strictTag.lineNumber") }} |
+ {{ t("strictTag.tagName") }} |
+ {{ t("strictTag.suggestion") }} |
+ {{ t("common.actions") }} |
+
+
+
+
+ | {{ v.fileName }} |
+ {{ v.lineNumber }} |
+ {{ v.tagName }} |
+ {{ v.suggestion }} |
+
+
+
+
+
+
+ |
+
+
+
+
+
+
+
+
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index ad49b62df..b583d6168 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -4000,10 +4000,54 @@ export default {
port: "Port",
copied: "Copied to clipboard",
saveConfigPrompt: "Please enter config name:",
+ defaultConfigName: "Default",
+ dependsOn: "depends on",
+ dependedBy: "depended by",
close: "Close",
searchConnection: "Search connections...",
searchDatabase: "Search databases...",
searchSchema: "Search schemas...",
+ openFieldMapping: "Field Mapping",
+ fieldMapping: {
+ title: "Field Type Mapping",
+ sameTypeHint: "Source and target are the same database type. Field mapping is only needed when comparing across different database types.",
+ preset: "Built-in Preset",
+ selectPreset: "Select a preset...",
+ noMappings: "No field mappings defined",
+ sourceType: "Source Type",
+ targetType: "Target Type",
+ paramStrategy: "Param Strategy",
+ strategyPreserve: "Preserve",
+ strategyStrip: "Strip",
+ strategyCustom: "Custom",
+ customParamsPlaceholder: "e.g. (100)",
+ addMapping: "Add Mapping",
+ autoGenerate: "Auto-Generate",
+ import: "Import",
+ export: "Export",
+ done: "Done",
+ importTypeMismatch: "The imported mappings were exported for {src} → {tgt}, but the current comparison is {curSrc} → {curTgt}. The type mappings may not be accurate. Continue anyway?",
+ importSuccess: "Field mappings imported successfully",
+ importError: "Failed to import field mappings. Please check the JSON format.",
+ clearMappings: "Clear",
+ staleMappingWarning: "The database type has changed from {prevSrc} → {prevTgt} to {curSrc} → {curTgt}. Existing field mappings may no longer be valid. Clear them?",
+ },
+ deployMode: "Deploy",
+ forwardSql: "Forward SQL",
+ rollbackSql: "Rollback SQL",
+ rollbackMode: "Rollback",
+ deployMixed: "Deployment partially completed. Some statements may already be applied ({executedCount}/{statementCount}). DDL may not be transactional.",
+ deployRolledBack: "All changes have been rolled back.",
+ rollbackIncompleteBlocked: "Rollback SQL is incomplete (missing objects). Execution is blocked.",
+ rollbackIncompleteBanner: "Rollback is incomplete — missing trigger/table DDL. Fix missing objects before executing.",
+ deployMixedTitle: "Partially Deployed",
+ deployRolledBackTitle: "Rolled Back",
+ deployMixedWarning: "Some statements may already be applied while others failed. The database may be in an inconsistent state. Review the transaction log and take manual corrective action before retrying.",
+ },
+ rollbackComparison: {
+ title: "Rollback Comparison",
+ forwardSql: "Forward SQL",
+ rollbackSql: "Rollback SQL",
},
schemaDiff: {
optionsTitle: "Compare Options",
@@ -4052,6 +4096,17 @@ export default {
cascadeDelete: "Use CASCADE delete",
sequenceLastValues: "Compare sequence last values",
compareColumnOrder: "Compare column order",
+ detectRenames: "Detect renames",
+ detectTableRenames: "Detect table renames",
+ enableRollback: "Enable rollback",
+ advancedSection: "Advanced",
+ renameThreshold: "Rename threshold",
+ compatibilityThreshold: "Compatibility threshold",
+ sourceDialect: "Source dialect",
+ targetDialect: "Target dialect",
+ batchSection: "Batch",
+ batchPatterns: "Table patterns (comma-separated)",
+ dialectAuto: "auto",
},
},
dataCompare: {
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index b6422561c..26e1cbb2b 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -3785,6 +3785,50 @@ export default withEnglishFallback({
searchConnection: "Buscar conexiones...",
searchDatabase: "Buscar bases de datos...",
searchSchema: "Buscar esquemas...",
+ defaultConfigName: "Predeterminado",
+ dependsOn: "depende de",
+ dependedBy: "dependido por",
+ openFieldMapping: "Mapeo de Campos",
+ fieldMapping: {
+ title: "Mapeo de Tipos de Campo",
+ sameTypeHint: "Origen y destino son del mismo tipo de base de datos. El mapeo de campos solo es necesario al comparar entre diferentes tipos de bases de datos.",
+ preset: "Preajuste Integrado",
+ selectPreset: "Seleccionar un preajuste...",
+ noMappings: "No hay mapeos de campos definidos",
+ sourceType: "Tipo de Origen",
+ targetType: "Tipo de Destino",
+ paramStrategy: "Estrategia de Parámetros",
+ strategyPreserve: "Preservar",
+ strategyStrip: "Eliminar",
+ strategyCustom: "Personalizado",
+ customParamsPlaceholder: "ej. (100)",
+ addMapping: "Agregar Mapeo",
+ autoGenerate: "Auto-Generar",
+ import: "Importar",
+ export: "Exportar",
+ done: "Listo",
+ importTypeMismatch: "Los mapeos importados se exportaron para {src} → {tgt}, pero la comparación actual es {curSrc} → {curTgt}. Los mapeos de tipos pueden no ser precisos. ¿Continuar de todos modos?",
+ importSuccess: "Mapeos de campos importados correctamente",
+ importError: "Error al importar mapeos de campos. Verifique el formato JSON.",
+ clearMappings: "Limpiar",
+ staleMappingWarning: "El tipo de base de datos ha cambiado de {prevSrc} → {prevTgt} a {curSrc} → {curTgt}. Los mapeos de campos existentes pueden no ser válidos. ¿Limpiarlos?",
+ },
+ deployMode: "Desplegar",
+ forwardSql: "SQL Directo",
+ rollbackSql: "SQL de Reversión",
+ rollbackMode: "Reversión",
+ deployMixed: "Despliegue parcialmente completado. Algunas declaraciones pueden haberse aplicado ya ({executedCount}/{statementCount}). El DDL puede no ser transaccional.",
+ deployRolledBack: "Todos los cambios han sido revertidos.",
+ rollbackIncompleteBlocked: "Rollback incomplete (missing objects). Execution blocked.",
+ rollbackIncompleteBanner: "Rollback incomplete — missing trigger/table DDL.",
+ deployMixedTitle: "Parcialmente Desplegado",
+ deployRolledBackTitle: "Revertido",
+ deployMixedWarning: "Algunas declaraciones pueden haberse aplicado mientras que otras fallaron. La base de datos puede estar en un estado inconsistente. Revise el registro de transacciones y tome medidas correctivas manuales antes de reintentar.",
+ },
+ rollbackComparison: {
+ title: "Comparación de Reversión",
+ forwardSql: "SQL Directo",
+ rollbackSql: "SQL de Reversión",
},
schemaDiff: {
optionsTitle: "Opciones de comparación",
@@ -3833,6 +3877,17 @@ export default withEnglishFallback({
cascadeDelete: "Use CASCADE delete",
sequenceLastValues: "Compare sequence last values",
compareColumnOrder: "Compare column order",
+ detectRenames: "Detectar renombrados",
+ detectTableRenames: "Detectar renombrados de tabla",
+ enableRollback: "Habilitar reversión",
+ advancedSection: "Avanzado",
+ renameThreshold: "Umbral de renombrado",
+ compatibilityThreshold: "Umbral de compatibilidad",
+ sourceDialect: "Dialecto de origen",
+ targetDialect: "Dialecto de destino",
+ batchSection: "Lote",
+ batchPatterns: "Patrones de tabla (separados por comas)",
+ dialectAuto: "automático",
},
},
dataCompare: {
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 4d46d441e..b7e34dd5c 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -3783,6 +3783,50 @@ export default withEnglishFallback({
searchConnection: "Cerca connessioni...",
searchDatabase: "Cerca database...",
searchSchema: "Cerca schemi...",
+ defaultConfigName: "Predefinito",
+ dependsOn: "dipende da",
+ dependedBy: "dipendente da",
+ openFieldMapping: "Mappatura Campi",
+ fieldMapping: {
+ title: "Mappatura Tipi di Campo",
+ sameTypeHint: "Origine e destinazione sono lo stesso tipo di database. La mappatura dei campi è necessaria solo quando si confrontano tipi di database diversi.",
+ preset: "Preimpostazione Integrata",
+ selectPreset: "Seleziona una preimpostazione...",
+ noMappings: "Nessuna mappatura di campi definita",
+ sourceType: "Tipo Origine",
+ targetType: "Tipo Destinazione",
+ paramStrategy: "Strategia Parametri",
+ strategyPreserve: "Preserva",
+ strategyStrip: "Rimuovi",
+ strategyCustom: "Personalizzato",
+ customParamsPlaceholder: "es. (100)",
+ addMapping: "Aggiungi Mappatura",
+ autoGenerate: "Genera Automaticamente",
+ import: "Importa",
+ export: "Esporta",
+ done: "Fatto",
+ importTypeMismatch: "Le mappature importate sono state esportate per {src} → {tgt}, ma il confronto corrente è {curSrc} → {curTgt}. Le mappature dei tipi potrebbero non essere accurate. Continuare comunque?",
+ importSuccess: "Mappature dei campi importate con successo",
+ importError: "Importazione mappature campi non riuscita. Verificare il formato JSON.",
+ clearMappings: "Cancella",
+ staleMappingWarning: "Il tipo di database è cambiato da {prevSrc} → {prevTgt} a {curSrc} → {curTgt}. Le mappature dei campi esistenti potrebbero non essere più valide. Cancellarle?",
+ },
+ deployMode: "Distribuisci",
+ forwardSql: "SQL Diretto",
+ rollbackSql: "SQL di Rollback",
+ rollbackMode: "Rollback",
+ deployMixed: "Distribuzione parzialmente completata. Alcune istruzioni potrebbero essere già applicate ({executedCount}/{statementCount}). Il DDL potrebbe non essere transazionale.",
+ deployRolledBack: "Tutte le modifiche sono state annullate.",
+ rollbackIncompleteBlocked: "Rollback incomplete (missing objects). Execution blocked.",
+ rollbackIncompleteBanner: "Rollback incomplete — missing trigger/table DDL.",
+ deployMixedTitle: "Parzialmente Distribuito",
+ deployRolledBackTitle: "Annullato",
+ deployMixedWarning: "Alcune istruzioni potrebbero essere già applicate mentre altre sono fallite. Il database potrebbe trovarsi in uno stato inconsistente. Controllare il log delle transazioni e intervenire manualmente prima di riprovare.",
+ },
+ rollbackComparison: {
+ title: "Confronto Rollback",
+ forwardSql: "SQL Diretto",
+ rollbackSql: "SQL di Rollback",
},
schemaDiff: {
optionsTitle: "Opzioni di Confronto",
@@ -3831,6 +3875,17 @@ export default withEnglishFallback({
cascadeDelete: "Usa CASCADE delete",
sequenceLastValues: "Confronta ultimi valori sequenza",
compareColumnOrder: "Confronta ordine colonne",
+ detectRenames: "Rileva ridenominazioni",
+ detectTableRenames: "Rileva ridenominazioni tabelle",
+ enableRollback: "Abilita rollback",
+ advancedSection: "Avanzate",
+ renameThreshold: "Soglia ridenominazione",
+ compatibilityThreshold: "Soglia compatibilità",
+ sourceDialect: "Dialetto origine",
+ targetDialect: "Dialetto destinazione",
+ batchSection: "Batch",
+ batchPatterns: "Pattern tabella (separati da virgola)",
+ dialectAuto: "auto",
},
},
dataCompare: {
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index dee28013b..4ce56b0fb 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -3784,6 +3784,50 @@ export default withEnglishFallback({
searchConnection: "接続を検索...",
searchDatabase: "データベースを検索...",
searchSchema: "スキーマを検索...",
+ defaultConfigName: "デフォルト",
+ dependsOn: "に依存",
+ dependedBy: "から依存される",
+ openFieldMapping: "フィールドマッピング",
+ fieldMapping: {
+ title: "フィールド型マッピング",
+ sameTypeHint: "ソースとターゲットが同じデータベースタイプです。フィールドマッピングは異なるデータベースタイプ間での比較時のみ必要です。",
+ preset: "組み込みプリセット",
+ selectPreset: "プリセットを選択...",
+ noMappings: "フィールドマッピングが定義されていません",
+ sourceType: "ソース型",
+ targetType: "ターゲット型",
+ paramStrategy: "パラメータ戦略",
+ strategyPreserve: "保持",
+ strategyStrip: "除去",
+ strategyCustom: "カスタム",
+ customParamsPlaceholder: "例: (100)",
+ addMapping: "マッピングを追加",
+ autoGenerate: "自動生成",
+ import: "インポート",
+ export: "エクスポート",
+ done: "完了",
+ importTypeMismatch: "インポートされたマッピングは {src} → {tgt} 用にエクスポートされましたが、現在の比較は {curSrc} → {curTgt} です。型マッピングが正確でない可能性があります。続行しますか？",
+ importSuccess: "フィールドマッピングが正常にインポートされました",
+ importError: "フィールドマッピングのインポートに失敗しました。JSON形式を確認してください。",
+ clearMappings: "クリア",
+ staleMappingWarning: "データベースタイプが {prevSrc} → {prevTgt} から {curSrc} → {curTgt} に変更されました。既存のフィールドマッピングは有効でない可能性があります。クリアしますか？",
+ },
+ deployMode: "デプロイ",
+ forwardSql: "フォワードSQL",
+ rollbackSql: "ロールバックSQL",
+ rollbackMode: "ロールバック",
+ deployMixed: "デプロイが部分的に完了しました。一部のステートメントは既に適用済みの可能性があります（{executedCount}/{statementCount}）。DDL はトランザクション対象外の場合があります。",
+ deployRolledBack: "すべての変更がロールバックされました。",
+ rollbackIncompleteBlocked: "Rollback incomplete (missing objects). Execution blocked.",
+ rollbackIncompleteBanner: "Rollback incomplete — missing trigger/table DDL.",
+ deployMixedTitle: "部分的にデプロイ",
+ deployRolledBackTitle: "ロールバック済み",
+ deployMixedWarning: "一部のステートメントは既に適用済みで、他のステートメントは失敗した可能性があります。データベースが不整合な状態にある可能性があります。再試行前にトランザクションログを確認し、手動で修正してください。",
+ },
+ rollbackComparison: {
+ title: "ロールバック比較",
+ forwardSql: "フォワードSQL",
+ rollbackSql: "ロールバックSQL",
},
schemaDiff: {
optionsTitle: "比較オプション",
@@ -3832,6 +3876,17 @@ export default withEnglishFallback({
cascadeDelete: "CASCADE削除を使用",
sequenceLastValues: "シーケンス最終値を比較",
compareColumnOrder: "列順序を比較",
+ detectRenames: "名前変更を検出",
+ detectTableRenames: "テーブル名変更を検出",
+ enableRollback: "ロールバックを有効化",
+ advancedSection: "詳細設定",
+ renameThreshold: "名前変更しきい値",
+ compatibilityThreshold: "互換性しきい値",
+ sourceDialect: "ソース方言",
+ targetDialect: "ターゲット方言",
+ batchSection: "バッチ",
+ batchPatterns: "テーブルパターン（カンマ区切り）",
+ dialectAuto: "自動",
},
},
dataCompare: {
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 1a2411e9a..7874025c3 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -3785,6 +3785,50 @@ export default withEnglishFallback({
searchConnection: "Pesquisar conexões...",
searchDatabase: "Pesquisar bancos de dados...",
searchSchema: "Pesquisar schemas...",
+ defaultConfigName: "Padrão",
+ dependsOn: "depende de",
+ dependedBy: "dependido por",
+ openFieldMapping: "Mapeamento de Campos",
+ fieldMapping: {
+ title: "Mapeamento de Tipos de Campo",
+ sameTypeHint: "Origem e destino são do mesmo tipo de banco de dados. O mapeamento de campos só é necessário ao comparar entre tipos de banco de dados diferentes.",
+ preset: "Predefinição Integrada",
+ selectPreset: "Selecionar uma predefinição...",
+ noMappings: "Nenhum mapeamento de campos definido",
+ sourceType: "Tipo de Origem",
+ targetType: "Tipo de Destino",
+ paramStrategy: "Estratégia de Parâmetros",
+ strategyPreserve: "Preservar",
+ strategyStrip: "Remover",
+ strategyCustom: "Personalizado",
+ customParamsPlaceholder: "ex.: (100)",
+ addMapping: "Adicionar Mapeamento",
+ autoGenerate: "Auto-Gerar",
+ import: "Importar",
+ export: "Exportar",
+ done: "Concluído",
+ importTypeMismatch: "Os mapeamentos importados foram exportados para {src} → {tgt}, mas a comparação atual é {curSrc} → {curTgt}. Os mapeamentos de tipo podem não ser precisos. Continuar mesmo assim?",
+ importSuccess: "Mapeamentos de campos importados com sucesso",
+ importError: "Falha ao importar mapeamentos de campos. Verifique o formato JSON.",
+ clearMappings: "Limpar",
+ staleMappingWarning: "O tipo de banco de dados mudou de {prevSrc} → {prevTgt} para {curSrc} → {curTgt}. Os mapeamentos de campos existentes podem não ser mais válidos. Limpá-los?",
+ },
+ deployMode: "Implantar",
+ forwardSql: "SQL Direto",
+ rollbackSql: "SQL de Reversão",
+ rollbackMode: "Reversão",
+ deployMixed: "Implantação parcialmente concluída. Algumas instruções podem já ter sido aplicadas ({executedCount}/{statementCount}). DDL pode não ser transacional.",
+ deployRolledBack: "Todas as alterações foram revertidas.",
+ rollbackIncompleteBlocked: "Rollback incomplete (missing objects). Execution blocked.",
+ rollbackIncompleteBanner: "Rollback incomplete — missing trigger/table DDL.",
+ deployMixedTitle: "Parcialmente Implantado",
+ deployRolledBackTitle: "Revertido",
+ deployMixedWarning: "Algumas instruções podem já ter sido aplicadas enquanto outras falharam. O banco de dados pode estar em um estado inconsistente. Revise o log de transações e tome ação corretiva manual antes de tentar novamente.",
+ },
+ rollbackComparison: {
+ title: "Comparação de Reversão",
+ forwardSql: "SQL Direto",
+ rollbackSql: "SQL de Reversão",
},
schemaDiff: {
optionsTitle: "Opções de Comparação",
@@ -3833,6 +3877,17 @@ export default withEnglishFallback({
cascadeDelete: "Usar CASCADE delete",
sequenceLastValues: "Comparar últimos valores de sequência",
compareColumnOrder: "Comparar ordem das colunas",
+ detectRenames: "Detectar renomeações",
+ detectTableRenames: "Detectar renomeações de tabela",
+ enableRollback: "Habilitar rollback",
+ advancedSection: "Avançado",
+ renameThreshold: "Limiar de renomeação",
+ compatibilityThreshold: "Limiar de compatibilidade",
+ sourceDialect: "Dialeto de origem",
+ targetDialect: "Dialeto de destino",
+ batchSection: "Lote",
+ batchPatterns: "Padrões de tabela (separados por vírgula)",
+ dialectAuto: "automático",
},
},
dataCompare: {
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 4c097b595..2be5a72fc 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -4001,9 +4001,53 @@ export default withEnglishFallback({
configDeleted: "配置已删除",
noDeployScriptAll: "暂无所选对象的部署脚本",
saveConfigPrompt: "请输入配置名称:",
+ defaultConfigName: "默认",
+ dependsOn: "依赖于",
+ dependedBy: "被依赖",
searchConnection: "搜索连接...",
searchDatabase: "搜索数据库...",
searchSchema: "搜索模式...",
+ openFieldMapping: "字段映射",
+ fieldMapping: {
+ title: "字段类型映射",
+ sameTypeHint: "源和目标数据库类型相同，仅在不同类型数据库之间比较时才需要字段映射。",
+ preset: "内置预设",
+ selectPreset: "选择预设...",
+ noMappings: "暂无字段映射",
+ sourceType: "源类型",
+ targetType: "目标类型",
+ paramStrategy: "参数策略",
+ strategyPreserve: "保留",
+ strategyStrip: "去除",
+ strategyCustom: "自定义",
+ customParamsPlaceholder: "如 (100)",
+ addMapping: "添加映射",
+ autoGenerate: "自动生成",
+ import: "导入",
+ export: "导出",
+ done: "完成",
+ importTypeMismatch: "导入的映射文件是 {src} → {tgt} 的，但当前比较是 {curSrc} → {curTgt}。类型映射可能不准确。是否继续？",
+ importSuccess: "字段映射导入成功",
+ importError: "字段映射导入失败，请检查 JSON 格式。",
+ clearMappings: "清空",
+ staleMappingWarning: "数据库类型已从 {prevSrc} → {prevTgt} 变更为 {curSrc} → {curTgt}，现有字段映射可能不再有效。是否清除？",
+ },
+ deployMode: "部署",
+ forwardSql: "正向 SQL",
+ rollbackSql: "回滚 SQL",
+ rollbackMode: "回滚",
+ deployMixed: "部署部分完成，部分语句可能已生效（{executedCount}/{statementCount}）。DDL 可能不支持事务。",
+ deployRolledBack: "所有变更已回滚。",
+ rollbackIncompleteBlocked: "回滚 SQL 不完整（存在缺失对象），已禁止执行。",
+ rollbackIncompleteBanner: "回滚不完整 — 缺少触发器/表 DDL。请先补全缺失对象再执行。",
+ deployMixedTitle: "部分已部署",
+ deployRolledBackTitle: "已回滚",
+ deployMixedWarning: "部分语句可能已生效，其余语句失败。数据库可能处于不一致状态，请在重试前检查事务日志并手动处理。",
+ },
+ rollbackComparison: {
+ title: "回滚对比",
+ forwardSql: "正向 SQL",
+ rollbackSql: "回滚 SQL",
},
schemaDiff: {
optionsTitle: "比较选项",
@@ -4052,6 +4096,17 @@ export default withEnglishFallback({
cascadeDelete: "使用级联删除",
sequenceLastValues: "比较序列最后值",
compareColumnOrder: "比较字段顺序",
+ detectRenames: "检测重命名",
+ detectTableRenames: "检测表重命名",
+ enableRollback: "启用回滚",
+ advancedSection: "高级选项",
+ renameThreshold: "重命名阈值",
+ compatibilityThreshold: "兼容性阈值",
+ sourceDialect: "源数据库方言",
+ targetDialect: "目标数据库方言",
+ batchSection: "批次模式",
+ batchPatterns: "表名模式（逗号分隔）",
+ dialectAuto: "自动",
},
},
dataCompare: {
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 934078c17..bcecba777 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -3456,6 +3456,50 @@ export default withEnglishFallback({
searchConnection: "搜尋連線...",
searchDatabase: "搜尋資料庫...",
searchSchema: "搜尋結構描述...",
+ defaultConfigName: "預設",
+ dependsOn: "依賴於",
+ dependedBy: "被依賴",
+ openFieldMapping: "欄位映射",
+ fieldMapping: {
+ title: "欄位類型映射",
+ sameTypeHint: "來源與目標資料庫類型相同，僅在不同類型資料庫之間比較時才需要欄位映射。",
+ preset: "內建預設",
+ selectPreset: "選擇預設...",
+ noMappings: "暫無欄位映射",
+ sourceType: "來源類型",
+ targetType: "目標類型",
+ paramStrategy: "參數策略",
+ strategyPreserve: "保留",
+ strategyStrip: "去除",
+ strategyCustom: "自訂",
+ customParamsPlaceholder: "如 (100)",
+ addMapping: "新增映射",
+ autoGenerate: "自動生成",
+ import: "匯入",
+ export: "匯出",
+ done: "完成",
+ importTypeMismatch: "匯入的映射檔案是 {src} → {tgt} 的，但目前比較是 {curSrc} → {curTgt}。類型映射可能不準確。是否繼續？",
+ importSuccess: "欄位映射匯入成功",
+ importError: "欄位映射匯入失敗，請檢查 JSON 格式。",
+ clearMappings: "清空",
+ staleMappingWarning: "資料庫類型已從 {prevSrc} → {prevTgt} 變更為 {curSrc} → {curTgt}，現有欄位映射可能不再有效。是否清除？",
+ },
+ deployMode: "部署",
+ forwardSql: "正向 SQL",
+ rollbackSql: "回溯 SQL",
+ rollbackMode: "回溯",
+ deployMixed: "部署部分完成，部分語句可能已生效（{executedCount}/{statementCount}）。DDL 可能不支援交易。",
+ deployRolledBack: "所有變更已回溯。",
+ rollbackIncompleteBlocked: "Rollback SQL is incomplete (missing objects). Execution is blocked.",
+ rollbackIncompleteBanner: "Rollback is incomplete — missing trigger/table DDL. Fix missing objects before executing.",
+ deployMixedTitle: "部分已部署",
+ deployRolledBackTitle: "已回溯",
+ deployMixedWarning: "部分語句可能已生效，其餘語句失敗。資料庫可能處於不一致狀態，請在重試前檢查交易日誌並手動處理。",
+ },
+ rollbackComparison: {
+ title: "回溯對比",
+ forwardSql: "正向 SQL",
+ rollbackSql: "回溯 SQL",
},
schemaDiff: {
optionsTitle: "比較選項",
@@ -3504,6 +3548,17 @@ export default withEnglishFallback({
cascadeDelete: "使用級聯刪除",
sequenceLastValues: "比較序列最後值",
compareColumnOrder: "比較欄位順序",
+ detectRenames: "檢測重新命名",
+ detectTableRenames: "檢測表重新命名",
+ enableRollback: "啟用回溯",
+ advancedSection: "進階選項",
+ renameThreshold: "重新命名閾值",
+ compatibilityThreshold: "相容性閾值",
+ sourceDialect: "來源資料庫方言",
+ targetDialect: "目標資料庫方言",
+ batchSection: "批次模式",
+ batchPatterns: "資料表模式（逗號分隔）",
+ dialectAuto: "自動",
},
},
dataCompare: {
diff --git a/apps/desktop/src/lib/backend/__tests__/listDialectDataTypes.spec.ts b/apps/desktop/src/lib/backend/__tests__/listDialectDataTypes.spec.ts
new file mode 100644
index 000000000..bca2ee17a
--- /dev/null
+++ b/apps/desktop/src/lib/backend/__tests__/listDialectDataTypes.spec.ts
@@ -0,0 +1,40 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ invoke: vi.fn(),
+}));
+
+vi.mock("@tauri-apps/api/core", () => ({
+ invoke: mocks.invoke,
+}));
+
+vi.mock("@tauri-apps/api/event", () => ({
+ listen: vi.fn(),
+}));
+
+describe("listDialectDataTypes backend adapters", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.unstubAllGlobals();
+ });
+
+ it("uses the Tauri dialect command", async () => {
+ mocks.invoke.mockResolvedValue(["INTEGER", "TEXT"]);
+ const { listDialectDataTypes } = await import("@/lib/backend/tauri");
+
+ await expect(listDialectDataTypes("PostgreSQL")).resolves.toEqual(["INTEGER", "TEXT"]);
+ expect(mocks.invoke).toHaveBeenCalledWith("list_dialect_data_types", { dialectName: "PostgreSQL" });
+ });
+
+ it("uses the matching Web dialect route", async () => {
+ const fetchMock = vi.fn().mockResolvedValue({
+ ok: true,
+ json: vi.fn().mockResolvedValue(["INTEGER", "TEXT"]),
+ });
+ vi.stubGlobal("fetch", fetchMock);
+ const { listDialectDataTypes } = await import("@/lib/backend/http");
+
+ await expect(listDialectDataTypes("PostgreSQL")).resolves.toEqual(["INTEGER", "TEXT"]);
+ expect(fetchMock).toHaveBeenCalledWith("/api/dialect/data-types?dialect_name=PostgreSQL");
+ });
+});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index e088ee18a..5342f16df 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -175,6 +175,7 @@ export const listExtensions = forward("listExtensions");
export const listAvailableExtensions = forward("listAvailableExtensions");
export const prepareSchemaDiff = forward("prepareSchemaDiff");
export const generateSchemaSyncSql = forward("generateSchemaSyncSql");
+export const listDialectDataTypes = forward("listDialectDataTypes");
// Query
export const executeQuery = forward("executeQuery");
@@ -182,6 +183,7 @@ export const executeMulti = forward("executeMulti");
export const executeMultiWithProgress = forward("executeMultiWithProgress");
export const executeBatch = forward("executeBatch");
export const executeScript = forward("executeScript");
+export const executeScriptWith2pc = forward("executeScriptWith2pc");
export const executeInTransaction = forward("executeInTransaction");
export const beginManualTransaction = forward("beginManualTransaction");
export const executeInManualTransaction = forward("executeInManualTransaction");
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index 9cdb4322a..eb880bb0f 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -776,6 +776,10 @@ export async function listAvailableExtensions(connectionId: string, database: st
return get(`/api/schema/available-extensions?${qs({ connection_id: connectionId, database })}`);
}
+export async function listDialectDataTypes(dialectName: string): Promise
{
+ return get(`/api/dialect/data-types?${qs({ dialect_name: dialectName })}`);
+}
+
// ---------------------------------------------------------------------------
// Query
// ---------------------------------------------------------------------------
@@ -867,6 +871,10 @@ export async function executeScript(connectionId: string, database: string, sql:
return post("/api/query/execute-script", { connectionId, database, sql, schema });
}
+export async function executeScriptWith2pc(connectionId: string, database: string, statements: string[], schema?: string): Promise {
+ return post("/api/query/execute-script-2pc", { connectionId, database, statements, schema });
+}
+
export async function executeInTransaction(connectionId: string, database: string, statements: string[], schema?: string): Promise {
return post("/api/query/execute-in-transaction", { connectionId, database, statements, schema });
}
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 945bdbab3..4da46fa26 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -44,6 +44,7 @@ import type {
SavedSqlLibrary,
SshConfigHostEntry,
TunnelProfile,
+ TransactionLog,
} from "@/types/database";
import { isTauriCommandUnavailable, normalizeConnectionTestResult } from "@/lib/connection/connectionDatabaseInfo";
import type { CollectionInfo } from "@/types/database";
@@ -999,6 +1000,10 @@ export async function executeScript(connectionId: string, database: string, sql:
return invoke("execute_script", { connectionId, database, sql, schema });
}
+export async function executeScriptWith2pc(connectionId: string, database: string, statements: string[], schema?: string): Promise {
+ return invoke("execute_script_with_2pc", { connectionId, database, statements, schema });
+}
+
export async function executeInTransaction(connectionId: string, database: string, statements: string[], schema?: string): Promise {
return invoke("execute_in_transaction", { connectionId, database, statements, schema });
}
@@ -1284,6 +1289,10 @@ export async function prepareSchemaDiff(options: SchemaDiffPreparationOptions):
return invoke("prepare_schema_diff", { options });
}
+export async function listDialectDataTypes(dialectName: string): Promise {
+ return invoke("list_dialect_data_types", { dialectName });
+}
+
export async function generateSchemaSyncSql(diffs: TableDiff[], databaseType: DatabaseType, targetSchema?: string, functionDiffs?: FunctionDiff[], sequenceDiffs?: SequenceDiff[], ruleDiffs?: RuleDiff[], ownerDiffs?: OwnerDiff[], cascadeDelete?: boolean): Promise {
return invoke("generate_schema_sync_sql", {
diffs,
diff --git a/apps/desktop/src/lib/dataGrid/dataCompare.ts b/apps/desktop/src/lib/dataGrid/dataCompare.ts
index 4cfdb6ac1..24d66b940 100644
--- a/apps/desktop/src/lib/dataGrid/dataCompare.ts
+++ b/apps/desktop/src/lib/dataGrid/dataCompare.ts
@@ -2,6 +2,15 @@ import type { ColumnInfo, DatabaseType, QueryResult } from "@/types/database";
export type DataCompareCellValue = QueryResult["rows"][number][number];
+export type SamplingStrategy = "Random" | "ExtremeValues" | "Hybrid";
+
+export interface DegradationThreshold {
+ fullCompareMaxRows: number;
+ sampleMaxRows: number;
+ sampleSize: number;
+ extremeSampleCount: number;
+}
+
export interface DataCompareChangedCell {
column: string;
source: DataCompareCellValue;
@@ -57,6 +66,9 @@ export interface DataCompareFromTablesOptions {
columns: string[];
keyColumns: string[];
fetchBatchSize?: number;
+ degradationThreshold?: DegradationThreshold;
+ samplingStrategy?: SamplingStrategy;
+ enableChecksum?: boolean;
}
export interface DataCompareMissingTargetOptions {
@@ -70,6 +82,9 @@ export interface DataCompareMissingTargetOptions {
targetTable: string;
keyColumns: string[];
fetchBatchSize?: number;
+ degradationThreshold?: DegradationThreshold;
+ samplingStrategy?: SamplingStrategy;
+ enableChecksum?: boolean;
}
export interface DataCompareFromTablesPreparation extends DataComparePreparation {
diff --git a/apps/desktop/src/lib/fieldMappingPresets.ts b/apps/desktop/src/lib/fieldMappingPresets.ts
new file mode 100644
index 000000000..9199c2690
--- /dev/null
+++ b/apps/desktop/src/lib/fieldMappingPresets.ts
@@ -0,0 +1,112 @@
+import type { FieldMappingEntry } from "@/types/schemaDiff";
+
+export interface FieldMappingPreset {
+ id: string;
+ label: string;
+ sourceDialect: string;
+ targetDialect: string;
+ mappings: FieldMappingEntry[];
+}
+
+export const FIELD_MAPPING_PRESETS: FieldMappingPreset[] = [
+ {
+ id: "mysql-to-dameng",
+ label: "MySQL → 达梦 (DM)",
+ sourceDialect: "mysql",
+ targetDialect: "dameng",
+ mappings: [
+ { sourceType: "VARCHAR", targetType: "VARCHAR", paramStrategy: "preserve" },
+ { sourceType: "CHAR", targetType: "CHAR", paramStrategy: "preserve" },
+ { sourceType: "TEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "TINYTEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "MEDIUMTEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "LONGTEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "INT", targetType: "INT", paramStrategy: "preserve" },
+ { sourceType: "BIGINT", targetType: "BIGINT", paramStrategy: "preserve" },
+ { sourceType: "DECIMAL", targetType: "NUMERIC", paramStrategy: "preserve" },
+ { sourceType: "FLOAT", targetType: "FLOAT", paramStrategy: "preserve" },
+ { sourceType: "DOUBLE", targetType: "DOUBLE", paramStrategy: "preserve" },
+ { sourceType: "DATE", targetType: "DATE", paramStrategy: "preserve" },
+ { sourceType: "DATETIME", targetType: "TIMESTAMP", paramStrategy: "preserve" },
+ { sourceType: "TIMESTAMP", targetType: "TIMESTAMP", paramStrategy: "preserve" },
+ { sourceType: "BLOB", targetType: "BLOB", paramStrategy: "strip" },
+ { sourceType: "JSON", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "TINYINT", targetType: "TINYINT", paramStrategy: "preserve" },
+ { sourceType: "SMALLINT", targetType: "SMALLINT", paramStrategy: "preserve" },
+ { sourceType: "BOOLEAN", targetType: "BOOLEAN", paramStrategy: "preserve" },
+ ],
+ },
+ {
+ id: "mysql-to-postgresql",
+ label: "MySQL → PostgreSQL",
+ sourceDialect: "mysql",
+ targetDialect: "postgresql",
+ mappings: [
+ { sourceType: "VARCHAR", targetType: "VARCHAR", paramStrategy: "preserve" },
+ { sourceType: "CHAR", targetType: "CHAR", paramStrategy: "preserve" },
+ { sourceType: "TEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "TINYTEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "MEDIUMTEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "LONGTEXT", targetType: "TEXT", paramStrategy: "strip" },
+ { sourceType: "INT", targetType: "INTEGER", paramStrategy: "preserve" },
+ { sourceType: "BIGINT", targetType: "BIGINT", paramStrategy: "preserve" },
+ { sourceType: "DECIMAL", targetType: "NUMERIC", paramStrategy: "preserve" },
+ { sourceType: "FLOAT", targetType: "REAL", paramStrategy: "preserve" },
+ { sourceType: "DOUBLE", targetType: "DOUBLE PRECISION", paramStrategy: "preserve" },
+ { sourceType: "DATETIME", targetType: "TIMESTAMP", paramStrategy: "preserve" },
+ { sourceType: "TIMESTAMP", targetType: "TIMESTAMP", paramStrategy: "preserve" },
+ { sourceType: "BLOB", targetType: "BYTEA", paramStrategy: "strip" },
+ { sourceType: "JSON", targetType: "JSONB", paramStrategy: "preserve" },
+ { sourceType: "TINYINT", targetType: "SMALLINT", paramStrategy: "preserve" },
+ { sourceType: "BOOLEAN", targetType: "BOOLEAN", paramStrategy: "preserve" },
+ ],
+ },
+ {
+ id: "mysql-to-oracle",
+ label: "MySQL → Oracle",
+ sourceDialect: "mysql",
+ targetDialect: "oracle",
+ mappings: [
+ { sourceType: "VARCHAR", targetType: "VARCHAR2", paramStrategy: "preserve" },
+ { sourceType: "CHAR", targetType: "CHAR", paramStrategy: "preserve" },
+ { sourceType: "TEXT", targetType: "CLOB", paramStrategy: "strip" },
+ { sourceType: "TINYTEXT", targetType: "CLOB", paramStrategy: "strip" },
+ { sourceType: "MEDIUMTEXT", targetType: "CLOB", paramStrategy: "strip" },
+ { sourceType: "LONGTEXT", targetType: "CLOB", paramStrategy: "strip" },
+ { sourceType: "INT", targetType: "NUMBER", paramStrategy: "preserve" },
+ { sourceType: "BIGINT", targetType: "NUMBER", paramStrategy: "preserve" },
+ { sourceType: "DECIMAL", targetType: "NUMBER", paramStrategy: "preserve" },
+ { sourceType: "FLOAT", targetType: "BINARY_FLOAT", paramStrategy: "preserve" },
+ { sourceType: "DOUBLE", targetType: "BINARY_DOUBLE", paramStrategy: "preserve" },
+ { sourceType: "DATETIME", targetType: "TIMESTAMP", paramStrategy: "preserve" },
+ { sourceType: "TIMESTAMP", targetType: "TIMESTAMP", paramStrategy: "preserve" },
+ { sourceType: "BLOB", targetType: "BLOB", paramStrategy: "strip" },
+ { sourceType: "JSON", targetType: "CLOB", paramStrategy: "strip" },
+ { sourceType: "BOOLEAN", targetType: "NUMBER(1)", paramStrategy: "custom", customParams: "(1)" },
+ ],
+ },
+];
+
+export function findPreset(sourceDialect: string, targetDialect: string): FieldMappingPreset | undefined {
+ // Look for exact forward match
+ const forward = FIELD_MAPPING_PRESETS.find((p) => p.sourceDialect === sourceDialect && p.targetDialect === targetDialect);
+ if (forward) return forward;
+
+ // Look for reverse match and auto-generate bidirectional preset
+ const reverse = FIELD_MAPPING_PRESETS.find((p) => p.sourceDialect === targetDialect && p.targetDialect === sourceDialect);
+ if (reverse) {
+ return {
+ id: `${reverse.id}-reverse`,
+ label: `${reverse.label.split(" → ").reverse().join(" → ")}`,
+ sourceDialect,
+ targetDialect,
+ mappings: reverse.mappings.map((m) => ({
+ sourceType: m.targetType,
+ targetType: m.sourceType,
+ paramStrategy: m.paramStrategy === "custom" ? "strip" : m.paramStrategy,
+ })),
+ };
+ }
+
+ return undefined;
+}
diff --git a/apps/desktop/src/lib/schema/__tests__/deployTxResult.spec.ts b/apps/desktop/src/lib/schema/__tests__/deployTxResult.spec.ts
new file mode 100644
index 000000000..8c9bd410a
--- /dev/null
+++ b/apps/desktop/src/lib/schema/__tests__/deployTxResult.spec.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { buildDeployTxResult } from "@/lib/schema/deployTxResult";
+
+const t = (key: string, params?: Record) => {
+ const fallback: Record = {
+ "diff.executeSuccess": "Executed successfully",
+ "diff.deployMixed": "Deployment partially completed. Some statements may already be applied ({executedCount}/{statementCount}). DDL may not be transactional.",
+ "diff.deployRolledBack": "All changes have been rolled back.",
+ "diff.deployFailed": "Deployment failed: {status}",
+ };
+ let msg = fallback[key] || key;
+ if (params) {
+ for (const [k, v] of Object.entries(params)) {
+ msg = msg.replace(`{${k}}`, String(v));
+ }
+ }
+ return msg;
+};
+
+describe("buildDeployTxResult", () => {
+ it("returns success for committed transaction", () => {
+ const result = buildDeployTxResult({ status: "committed", transaction_id: "tx1", executedCount: 2 }, t);
+ expect(result.success).toBe(true);
+ expect(result.status).toBe("committed");
+ expect(result.message).toBe("Executed successfully");
+ expect(result.executedCount).toBe(2);
+ });
+
+ it("returns failure with mixed status for partially committed", () => {
+ const result = buildDeployTxResult(
+ {
+ status: "mixed",
+ participants: [{ id: "1" }, { id: "2" }],
+ executedCount: 1,
+ statementCount: 2,
+ },
+ t,
+ );
+ expect(result.success).toBe(false);
+ expect(result.status).toBe("mixed");
+ expect(result.message).toContain("partially completed");
+ expect(result.message).toContain("1/2");
+ expect(result.message).toContain("may not be transactional");
+ expect(result.executedCount).toBe(1);
+ expect(result.statementCount).toBe(2);
+ });
+
+ it("returns failure with rolled_back status and error detail", () => {
+ const result = buildDeployTxResult({ status: "rolled_back", error: "syntax error near SELECT", executedCount: 0, statementCount: 2 }, t);
+ expect(result.success).toBe(false);
+ expect(result.status).toBe("rolled_back");
+ expect(result.message).toContain("rolled back");
+ expect(result.message).toContain("syntax error");
+ expect(result.executedCount).toBe(0);
+ expect(result.statementCount).toBe(2);
+ });
+
+ it("returns failure for unknown status", () => {
+ const result = buildDeployTxResult({ status: "unknown" }, t);
+ expect(result.success).toBe(false);
+ expect(result.status).toBe("unknown");
+ expect(result.message).toContain("unknown");
+ });
+
+ it("returns failure for null/undefined txLog", () => {
+ const result = buildDeployTxResult(null, t);
+ expect(result.success).toBe(false);
+ expect(result.status).toBe("unknown");
+ });
+
+ it("maps MySQL-style partial DDL failure (1 of 2 applied) for UI", () => {
+ const result = buildDeployTxResult(
+ {
+ status: "mixed",
+ executedCount: 1,
+ statementCount: 2,
+ error: "Statement 2 failed: table already exists",
+ metadata: { atomicity: "partial_effects_possible", ddl_atomic: false },
+ },
+ t,
+ );
+ expect(result.success).toBe(false);
+ expect(result.status).toBe("mixed");
+ expect(result.executedCount).toBe(1);
+ expect(result.statementCount).toBe(2);
+ expect(result.message).toContain("1/2");
+ expect(result.message).toMatch(/may already be applied|may not be transactional/i);
+ });
+});
diff --git a/apps/desktop/src/lib/schema/deployTxResult.ts b/apps/desktop/src/lib/schema/deployTxResult.ts
new file mode 100644
index 000000000..b17cbed53
--- /dev/null
+++ b/apps/desktop/src/lib/schema/deployTxResult.ts
@@ -0,0 +1,61 @@
+export interface DeployTxResult {
+ success: boolean;
+ status?: string;
+ message: string;
+ affectedRows?: number;
+ error?: string;
+ executedCount?: number;
+ statementCount?: number;
+}
+
+export function buildDeployTxResult(txLog: any, t: (key: string, params?: Record) => string): DeployTxResult {
+ const status = txLog?.status;
+ const error = txLog?.error ?? txLog?.metadata?.error;
+ const executedCount = txLog?.executedCount ?? txLog?.executed_count;
+ const statementCount = txLog?.statementCount ?? txLog?.statement_count;
+ const affectedRows = txLog?.metadata?.affected_rows ?? txLog?.affectedRows;
+
+ if (status === "committed") {
+ return {
+ success: true,
+ status,
+ message: t("diff.executeSuccess"),
+ affectedRows,
+ executedCount,
+ statementCount,
+ };
+ }
+ if (status === "mixed") {
+ return {
+ success: false,
+ status,
+ message: t("diff.deployMixed", {
+ participants: txLog?.participants?.length ?? 0,
+ executedCount: executedCount ?? 0,
+ statementCount: statementCount ?? 0,
+ }),
+ error,
+ executedCount,
+ statementCount,
+ };
+ }
+ if (status === "rolled_back") {
+ const detail = error ? `: ${error}` : "";
+ return {
+ success: false,
+ status,
+ message: `${t("diff.deployRolledBack")}${detail}`,
+ error,
+ executedCount: executedCount ?? 0,
+ statementCount,
+ };
+ }
+ return {
+ success: false,
+ status: status || "unknown",
+ message: t("diff.deployFailed", { status: status || "unknown" }),
+ error,
+ executedCount,
+ statementCount,
+ };
+}
diff --git a/apps/desktop/src/lib/schema/schemaDiff.ts b/apps/desktop/src/lib/schema/schemaDiff.ts
index 2bd7f7b07..50db44870 100644
--- a/apps/desktop/src/lib/schema/schemaDiff.ts
+++ b/apps/desktop/src/lib/schema/schemaDiff.ts
@@ -1,5 +1,111 @@
import type { ColumnInfo, IndexInfo, ForeignKeyInfo, TriggerInfo, FunctionInfo, SequenceInfo, RuleInfo, OwnerInfo, DatabaseType, TableInfo } from "@/types/database";
+const DIALECT_KIND_MAP: Record = {
+ mysql: "mysql",
+ doris: "mysql",
+ starrocks: "mysql",
+ goldendb: "mysql",
+ sundb: "mysql",
+ databend: "mysql",
+ gbase: "mysql",
+ postgres: "postgres",
+ gaussdb: "postgres",
+ kwdb: "postgres",
+ opengauss: "postgres",
+ highgo: "postgres",
+ vastbase: "postgres",
+ kingbase: "postgres",
+ firebird: "postgres",
+ redshift: "postgres",
+ vertica: "postgres",
+ exasol: "postgres",
+ sqlite: "sqlite",
+ rqlite: "sqlite",
+ turso: "sqlite",
+ duckdb: "duckdb",
+ sqlserver: "sql_server",
+ access: "sql_server",
+ oracle: "oracle",
+ dameng: "oracle",
+ "oceanbase-oracle": "oracle",
+ iris: "oracle",
+ yashandb: "oracle",
+ xugu: "oracle",
+ h2: "h2",
+ clickhouse: "click_house",
+ manticoresearch: "manticore_search",
+ informix: "informix",
+ questdb: "questdb",
+};
+
+export function databaseTypeToDialectKind(dbType: DatabaseType): string {
+ return DIALECT_KIND_MAP[dbType] ?? "unsupported";
+}
+
+const DIALECT_ALIAS_MAP: Record = {
+ access: "sql_server",
+ mssql: "sql_server",
+ "sql server": "sql_server",
+ postgresql: "postgres",
+ sqlite3: "sqlite",
+ "oceanbase-oracle": "oracle",
+ oceanbase: "oracle",
+ dameng: "oracle",
+ iris: "oracle",
+ yashandb: "oracle",
+ xugu: "oracle",
+ gaussdb: "postgres",
+ kwdb: "postgres",
+ opengauss: "postgres",
+ highgo: "postgres",
+ vastbase: "postgres",
+ kingbase: "postgres",
+ firebird: "postgres",
+ redshift: "postgres",
+ vertica: "postgres",
+ exasol: "postgres",
+ doris: "mysql",
+ starrocks: "mysql",
+ goldendb: "mysql",
+ sundb: "mysql",
+ databend: "mysql",
+ gbase: "mysql",
+ rqlite: "sqlite",
+ turso: "sqlite",
+ manticore: "manticore_search",
+ questdb: "questdb",
+ clickhouse: "click_house",
+};
+
+export function normalizeDialectKind(input: string): string {
+ const lower = input.trim().toLowerCase();
+ if (DIALECT_KIND_MAP[lower]) return DIALECT_KIND_MAP[lower];
+ if (DIALECT_ALIAS_MAP[lower]) return DIALECT_ALIAS_MAP[lower];
+ return lower;
+}
+
+function levenshteinDistance(a: string, b: string): number {
+ const m = a.length;
+ const n = b.length;
+ if (m === 0) return n;
+ if (n === 0) return m;
+ let prev = Array.from({ length: n + 1 }, (_, i) => i);
+ for (let i = 1; i <= m; i++) {
+ const curr = [i];
+ for (let j = 1; j <= n; j++) {
+ curr[j] = a[i - 1] === b[j - 1] ? prev[j - 1] : Math.min(prev[j], curr[j - 1], prev[j - 1]) + 1;
+ }
+ prev = curr;
+ }
+ return prev[n];
+}
+
+function nameSimilarity(a: string, b: string): number {
+ const maxLen = Math.max(a.length, b.length);
+ if (maxLen === 0) return 1;
+ return 1 - levenshteinDistance(a, b) / maxLen;
+}
+
export interface ColumnDiff {
type: "added" | "removed" | "modified";
name: string;
@@ -65,7 +171,7 @@ export interface OwnerDiff {
}
export interface TableDiff {
- type: "added" | "removed" | "modified";
+ type: "added" | "removed" | "modified" | "renamed";
objectType?: "table" | "view";
name: string;
columns?: ColumnDiff[];
@@ -88,6 +194,11 @@ export interface TableSchemaDetail {
ddl?: string;
}
+export interface FieldMappingEntry {
+ sourceType: string;
+ targetType: string;
+}
+
export interface SchemaDiffPreparationOptions {
sourceTables: TableInfo[];
targetTables: TableInfo[];
@@ -106,8 +217,58 @@ export interface SchemaDiffPreparationOptions {
ignoreComments?: boolean;
cascadeDelete?: boolean;
compareColumnOrder?: boolean;
+ detectRenames?: boolean;
+ detectTableRenames?: boolean;
+ renameThreshold?: number;
+ enableRollback?: boolean;
+ batchPatterns?: string[];
+ sourceDialect?: string;
+ targetDialect?: string;
+ compatibilityThreshold?: number;
+ fieldMappings?: FieldMappingEntry[];
}
+export interface RenameCandidate {
+ sourceName: string;
+ targetName: string;
+ score: number;
+}
+
+export interface CompatibilityWarning {
+ table: string;
+ column: string;
+ sourceType: string;
+ targetType: string;
+ risk: string;
+ message: string;
+}
+
+export interface PermissionDiff {
+ objectName: string;
+ permissionType: string;
+ sourcePermission: string | null;
+ targetPermission: string | null;
+}
+
+export interface DependencyNode {
+ tableName: string;
+ dependsOn: string[];
+ dependedBy: string[];
+}
+
+export interface DependencyGraph {
+ nodes: DependencyNode[];
+}
+
+export interface MissingRollbackObject {
+ kind: string;
+ name: string;
+ table?: string;
+ reason: string;
+}
+
+export type RollbackCompleteness = "complete" | "incomplete";
+
export interface SchemaDiffPreparation {
diffs: TableDiff[];
functionDiffs?: FunctionDiff[];
@@ -115,6 +276,15 @@ export interface SchemaDiffPreparation {
ruleDiffs?: RuleDiff[];
ownerDiffs?: OwnerDiff[];
syncSql: string;
+ rollbackSyncSql?: string;
+ rollbackCompleteness?: RollbackCompleteness;
+ missingRollbackObjects?: MissingRollbackObject[];
+ renameCandidates?: RenameCandidate[];
+ rollbackGraph?: unknown;
+ compatibilityWarnings?: CompatibilityWarning[];
+ permissionDiffs?: PermissionDiff[];
+ permissionSyncSql?: string;
+ dependencyGraph?: DependencyGraph;
}
const MYSQL_LIKE_SCHEMA_DIFF_TARGET_TYPES = new Set(["mysql", "doris", "starrocks", "goldendb", "sundb", "databend", "gbase"]);
@@ -146,10 +316,17 @@ export interface SchemaDiffObject {
sourceDdl?: string;
targetDdl?: string;
deploySql?: string;
+ rollbackDdl?: string;
changes?: string[];
children?: SchemaDiffObject[];
/** Function arguments signature (for PostgreSQL overloaded functions) */
arguments?: string;
+ renameMetadata?: {
+ confirmed: boolean;
+ sourceName?: string;
+ targetName?: string;
+ score?: number;
+ };
}
export interface SchemaDiffGroup {
@@ -164,6 +341,7 @@ export interface SchemaDiffGroup {
export function getOperationType(diffType: string): DiffOperationType {
switch (diffType) {
case "modified":
+ case "renamed":
return "modify";
case "added":
return "create";
@@ -203,23 +381,27 @@ function buildSequenceDdl(seq: SequenceInfo): string {
return parts.join("\n");
}
-export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiffs: FunctionDiff[] = [], sequenceDiffs: SequenceDiff[] = [], ruleDiffs: RuleDiff[] = [], ownerDiffs: OwnerDiff[] = []): SchemaDiffObject[] {
+export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiffs: FunctionDiff[] = [], sequenceDiffs: SequenceDiff[] = [], ruleDiffs: RuleDiff[] = [], ownerDiffs: OwnerDiff[] = [], renameCandidates?: RenameCandidate[]): SchemaDiffObject[] {
const objects: SchemaDiffObject[] = [];
for (const diff of tableDiffs) {
const opType = getOperationType(diff.type);
+ const isRenamed = diff.type === "renamed";
+ const newName = isRenamed && renameCandidates ? (renameCandidates.find((rc) => rc.sourceName === diff.name)?.targetName ?? diff.name) : undefined;
+
const obj: SchemaDiffObject = {
id: `table-${diff.name}`,
operationType: opType,
objectKind: diff.objectType === "view" ? "view" : "table",
name: diff.name,
sourceName: diff.type === "added" ? undefined : diff.name,
- targetName: diff.type === "removed" ? undefined : diff.name,
+ targetName: diff.type === "removed" ? undefined : isRenamed ? newName : diff.name,
selected: opType !== "none",
sourceDdl: diff.ddl,
targetDdl: diff.targetDdl,
- deploySql: diff.syncSql,
+ deploySql: isRenamed && newName ? (diff.objectType === "view" ? `ALTER VIEW ${diff.name} RENAME TO ${newName};` : `RENAME TABLE ${diff.name} TO ${newName};`) : diff.syncSql,
changes: diff.columns?.flatMap((c) => c.changes || []),
+ renameMetadata: isRenamed && newName ? { confirmed: true, sourceName: diff.name, targetName: newName, score: renameCandidates?.find((rc) => rc.sourceName === diff.name)?.score } : undefined,
children: [
...(diff.columns?.map((c) => ({
id: `col-${diff.name}-${c.name}`,
@@ -324,6 +506,24 @@ export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiff
});
}
+ // Pre-mark rename candidates on diff objects (for UI display before user confirms)
+ if (renameCandidates && renameCandidates.length > 0) {
+ for (const rc of renameCandidates) {
+ for (const obj of objects) {
+ // Backend-detected renames: diff_type = "renamed", already has metadata set above
+ if (obj.renameMetadata) continue;
+ // Legacy: mark rename candidates on delete+create pairs (fallback for older backends)
+ if (obj.operationType === "delete" && obj.name === rc.sourceName) {
+ obj.renameMetadata = { confirmed: false, targetName: rc.targetName, score: rc.score };
+ }
+ if (obj.operationType === "create" && obj.name === rc.targetName) {
+ obj.renameMetadata = { confirmed: false, sourceName: rc.sourceName, score: rc.score };
+ obj.sourceName = rc.sourceName;
+ }
+ }
+ }
+ }
+
return objects;
}
@@ -382,6 +582,133 @@ function generateDropSql(obj: SchemaDiffObject): string {
return `DROP ${sqlType} IF EXISTS ${obj.name};`;
}
+/** Detect column renames in raw SQL and replace DROP+ADD with RENAME COLUMN. */
+export function injectColumnRenameSql(sql: string, diffs: TableDiff[], threshold: number, reverse = false): string {
+ if (!sql || !threshold) return sql;
+
+ // Build rename pairs: for each table, match removed columns with added columns by similarity
+ const replacements: { table: string; oldName: string; newName: string }[] = [];
+ for (const diff of diffs) {
+ if (!diff.columns || diff.type !== "modified") continue;
+ const removedCols = diff.columns.filter((c) => c.type === "removed");
+ const addedCols = diff.columns.filter((c) => c.type === "added");
+ if (removedCols.length === 0 || addedCols.length === 0) continue;
+
+ const used = new Set();
+ for (const rc of removedCols) {
+ let best: (typeof addedCols)[0] | null = null;
+ let bestSim = 0;
+ for (const ac of addedCols) {
+ if (used.has(ac.name)) continue;
+ const sim = nameSimilarity(rc.name, ac.name);
+ if (sim > bestSim) {
+ bestSim = sim;
+ best = ac;
+ }
+ }
+ if (best && bestSim >= threshold) {
+ // rc = removed column (exists in source, NOT in target → needs to be ADDED to target)
+ // best = added column (exists in target, NOT in source → needs to be DROPPED from target)
+ // To sync target → source: rename target's "best.name" to source's "rc.name"
+ replacements.push({ table: diff.name, oldName: best.name, newName: rc.name });
+ used.add(best.name);
+ }
+ }
+ }
+
+ if (replacements.length === 0) return sql;
+
+ // Process each ALTER TABLE block
+ const lines = sql.split("\n");
+ const out: string[] = [];
+ let currentTable = "";
+ let inAlter = false;
+ let alterStart = -1;
+ const tableRenames = new Map();
+
+ for (const r of replacements) {
+ const list = tableRenames.get(r.table) || [];
+ list.push(r);
+ tableRenames.set(r.table, list);
+ }
+
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i];
+ const trimmed = line.trim();
+
+ // Detect ALTER TABLE
+ const alterMatch = trimmed.match(/^ALTER\s+TABLE\s+(?:`[^`]+`\.)?`?(\w+)`?/i);
+ if (alterMatch && !inAlter) {
+ currentTable = alterMatch[1];
+ const renames = tableRenames.get(currentTable);
+ if (renames) {
+ inAlter = true;
+ alterStart = i;
+ continue; // skip current ALTER TABLE line, we'll rebuild it
+ }
+ }
+
+ if (!inAlter) {
+ out.push(line);
+ continue;
+ }
+
+ // Inside an ALTER TABLE block being rewritten
+ const endOfAlter = trimmed === ";" || trimmed.endsWith(";") || (i + 1 < lines.length && lines[i + 1].trim().toUpperCase().startsWith("ALTER")) || i === lines.length - 1;
+
+ if (endOfAlter) {
+ const renames = tableRenames.get(currentTable)!;
+ // Emit RENAME COLUMN statements
+ out.push(`-- Alter table: ${currentTable} (column renames detected)`);
+ for (const r of renames) {
+ const fromName = reverse ? r.newName : r.oldName;
+ const toName = reverse ? r.oldName : r.newName;
+ out.push(`ALTER TABLE ${currentTable} RENAME COLUMN ${fromName} TO ${toName};`);
+ }
+ // Collect remaining ALTER clauses (non-renamed columns)
+ const remaining: string[] = [];
+ for (let j = alterStart + 1; j <= i; j++) {
+ const l = lines[j].trim();
+ if (!l || l === ";") continue;
+ // Forward: ADD for newName, DROP for oldName. Reverse: ADD for oldName, DROP for newName.
+ const isAddRename = l.toUpperCase().startsWith("ADD COLUMN") && renames.some((r) => l.includes(reverse ? r.oldName : r.newName));
+ const isDropRename = l.toUpperCase().startsWith("DROP COLUMN") && renames.some((r) => l.includes(reverse ? r.newName : r.oldName));
+ if (isAddRename || isDropRename) continue;
+ // Clean trailing comma if next line is removed
+ let cleaned = l;
+ let nextIdx = j + 1;
+ while (nextIdx <= i) {
+ const nextLine = lines[nextIdx].trim();
+ if (!nextLine) {
+ nextIdx++;
+ continue;
+ }
+ const nextIsAddRename = nextLine.toUpperCase().startsWith("ADD COLUMN") && renames.some((r) => nextLine.includes(reverse ? r.oldName : r.newName));
+ const nextIsDropRename = nextLine.toUpperCase().startsWith("DROP COLUMN") && renames.some((r) => nextLine.includes(reverse ? r.newName : r.oldName));
+ if (nextIsAddRename || nextIsDropRename) {
+ cleaned = cleaned.replace(/,\s*$/, "");
+ }
+ break;
+ }
+ remaining.push(cleaned);
+ }
+ if (remaining.length > 0) {
+ const last = remaining[remaining.length - 1].replace(/,\s*$/, "").replace(/;\s*$/, "");
+ remaining[remaining.length - 1] = last;
+ out.push(`ALTER TABLE ${currentTable}`);
+ for (const r of remaining) {
+ out.push(` ${r}`);
+ }
+ out.push(";");
+ }
+ inAlter = false;
+ currentTable = "";
+ }
+ }
+
+ return out.join("\n").trim();
+}
+
export interface ObjectTypeGroup {
kind: DiffObjectKind;
label: string;
diff --git a/apps/desktop/src/lib/schema/schemaDiffOptions.ts b/apps/desktop/src/lib/schema/schemaDiffOptions.ts
index 45cd1156e..07847bafa 100644
--- a/apps/desktop/src/lib/schema/schemaDiffOptions.ts
+++ b/apps/desktop/src/lib/schema/schemaDiffOptions.ts
@@ -23,6 +23,9 @@ export const POSTGRES_SCHEMA_DIFF_OPTIONS: SchemaDiffOptionItem[] = [
{ id: "cascadeDelete", labelKey: "schemaDiff.options.cascadeDelete", defaultChecked: false },
{ id: "sequenceLastValues", labelKey: "schemaDiff.options.sequenceLastValues", defaultChecked: true },
{ id: "compareColumnOrder", labelKey: "schemaDiff.options.compareColumnOrder", defaultChecked: false },
+ { id: "detectRenames", labelKey: "schemaDiff.options.detectRenames", defaultChecked: false },
+ { id: "detectTableRenames", labelKey: "schemaDiff.options.detectTableRenames", defaultChecked: false },
+ { id: "enableRollback", labelKey: "schemaDiff.options.enableRollback", defaultChecked: false },
];
export const SCHEMA_DIFF_OPTIONS_BY_DB_TYPE: Record = {
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index aca7f33e0..6dc9910d8 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -640,6 +640,26 @@ export interface QueryResultRun {
tableMeta?: QueryTab["tableMeta"];
}
+export interface ParticipantInfo {
+ id: string;
+ name: string;
+ role: string;
+}
+
+export interface TransactionLog {
+ transaction_id: string;
+ status: string;
+ participants: ParticipantInfo[];
+ created_at: string;
+ updated_at: string;
+ metadata: unknown;
+ /** camelCase fields from SchemaDiffDeployResult */
+ transactionId?: string;
+ executedCount?: number;
+ statementCount?: number;
+ error?: string;
+}
+
export interface SqlTextSpan {
start_line: number;
start_column: number;
diff --git a/apps/desktop/src/types/governance.ts b/apps/desktop/src/types/governance.ts
new file mode 100644
index 000000000..9a6e8e955
--- /dev/null
+++ b/apps/desktop/src/types/governance.ts
@@ -0,0 +1,135 @@
+export interface ConfigAuditEntry {
+ id: string;
+ timestamp: string;
+ operator: string;
+ reason: string;
+ keyPath: string;
+ changeDiff: unknown;
+ configSnapshot: unknown;
+}
+
+export interface ConfigVersionSnapshot {
+ id: string;
+ keyPath: string;
+ version: number;
+ snapshotJson: unknown;
+ checksum: string;
+ createdAt: string;
+}
+
+export interface AuditQuery {
+ keyPath?: string;
+ operator?: string;
+ limit?: number;
+ offset?: number;
+}
+
+export interface AuditSummary {
+ totalEntries: number;
+ entries: ConfigAuditEntry[];
+}
+
+export type ApprovalStatus = "draft" | "pending_approval" | "approved" | "rejected";
+
+export interface ApprovalRecord {
+ id: string;
+ configDomain: string;
+ changeDescription: string;
+ status: ApprovalStatus;
+ requester: string;
+ reviewer?: string;
+ reviewedAt?: string;
+ webhookUrl?: string;
+ draftConfigJson: unknown;
+ createdAt: string;
+ updatedAt: string;
+}
+
+export interface DriftAlert {
+ id: string;
+ sourceEnv: string;
+ targetEnv: string;
+ configKey: string;
+ expectedChecksum: string;
+ actualChecksum: string;
+ detailsJson: unknown;
+ detectedAt: string;
+ acknowledged: boolean;
+}
+
+export interface DriftReport {
+ sourceEnv: string;
+ targetEnv: string;
+ keyPath: string;
+ sourceChecksum: string;
+ targetChecksum: string;
+ mismatchedFields: string[];
+ sourceChangedAt?: string;
+ detectedAt: string;
+}
+
+export type DdlRiskLevel = "safe" | "caution" | "dangerous" | "blocked";
+
+export type ExecStrategy = "online" | "lazy" | "offline" | "batch";
+
+export interface LockInfo {
+ lockType: string;
+ objects: string[];
+ duration: string;
+}
+
+export interface ImpactReport {
+ overallRisk: DdlRiskLevel;
+ ddlRiskLevel: DdlRiskLevel;
+ estimatedLocks: LockInfo[];
+ estimatedTotalDuration: string;
+ recommendedStrategy: ExecStrategy;
+ warnings: string[];
+ requiresMaintenanceWindow: boolean;
+ isReversible: boolean;
+}
+
+export type OscExecutionStatus = "preparing" | "copying" | "cut_over" | "completed" | "failed" | "postponed";
+
+export interface OscStatus {
+ toolType: "gh-ost" | "pt-osc";
+ tableName: string;
+ status: OscExecutionStatus;
+ progressPercent: number;
+ estimatedRemainingSecs?: number;
+ error?: string;
+}
+
+export type DegradationLevel = "full" | "sample" | "skip_with_risk";
+
+export interface BusinessTag {
+ key: string;
+ value: string;
+ description: string;
+ immutable: boolean;
+}
+
+export interface ConflictItem {
+ objectName: string;
+ conflictType: string;
+ sourceValue: string;
+ targetValue: string;
+ autoResolvable: boolean;
+}
+
+export interface RebasePlan {
+ id: string;
+ baselineId: string;
+ conflicts: ConflictItem[];
+ totalObjects: number;
+ autoResolvedCount: number;
+ createdAt: string;
+}
+
+export interface ConfigDriftSummary {
+ sourceEnv: string;
+ targetEnv: string;
+ driftCount: number;
+ lastDetectedAt: string;
+ hasUnacknowledged: boolean;
+}
diff --git a/apps/desktop/src/types/schemaDiff.ts b/apps/desktop/src/types/schemaDiff.ts
index 4a3444ab9..4de47387d 100644
--- a/apps/desktop/src/types/schemaDiff.ts
+++ b/apps/desktop/src/types/schemaDiff.ts
@@ -20,6 +20,24 @@ export interface SchemaDiffCompareOptions {
tableIncludePattern: string;
tableExcludePattern: string;
tableFilterPriority: SchemaDiffTableFilterPriority;
+ detectRenames: boolean;
+ renameThreshold: number;
+ detectTableRenames: boolean;
+ enableRollback: boolean;
+ batchPatterns: string;
+ sourceDialect: string;
+ targetDialect: string;
+ compatibilityThreshold: number;
+ fieldMappings: FieldMappingEntry[];
+}
+
+export type FieldMappingParamStrategy = "preserve" | "strip" | "custom";
+
+export interface FieldMappingEntry {
+ sourceType: string;
+ targetType: string;
+ paramStrategy: FieldMappingParamStrategy;
+ customParams?: string;
}
export interface SchemaDiffConfig {
@@ -69,6 +87,15 @@ export const DEFAULT_POSTGRES_OPTIONS: SchemaDiffCompareOptions = {
tableIncludePattern: "",
tableExcludePattern: "",
tableFilterPriority: "exclude",
+ detectRenames: false,
+ renameThreshold: 0.5,
+ detectTableRenames: false,
+ enableRollback: false,
+ batchPatterns: "",
+ sourceDialect: "",
+ targetDialect: "",
+ compatibilityThreshold: 0.5,
+ fieldMappings: [],
};
export const DEFAULT_MYSQL_OPTIONS: SchemaDiffCompareOptions = {
@@ -91,6 +118,15 @@ export const DEFAULT_MYSQL_OPTIONS: SchemaDiffCompareOptions = {
tableIncludePattern: "",
tableExcludePattern: "",
tableFilterPriority: "exclude",
+ detectRenames: false,
+ renameThreshold: 0.5,
+ detectTableRenames: false,
+ enableRollback: false,
+ batchPatterns: "",
+ sourceDialect: "",
+ targetDialect: "",
+ compatibilityThreshold: 0.5,
+ fieldMappings: [],
};
export function getDefaultOptionsForDbType(dbType: string): SchemaDiffCompareOptions {
diff --git a/crates/dbx-core/Cargo.toml b/crates/dbx-core/Cargo.toml
index 2f2320d46..cbd616e6a 100644
--- a/crates/dbx-core/Cargo.toml
+++ b/crates/dbx-core/Cargo.toml
@@ -98,4 +98,9 @@ zip = { version = "4", default-features = false, features = ["deflate"] }
flate2 = "1"
tar = "0.4"
sysinfo = { version = "0.32", features = ["system"] }
+serde_yaml = "0.9"
+minijinja = "2"
+notify = { version = "7", default-features = false, features = ["macos_kqueue"] }
+arc-swap = "1"
+insta = { version = "1", features = ["json", "glob"] }
tempfile = "3"
diff --git a/crates/dbx-core/build.rs b/crates/dbx-core/build.rs
new file mode 100644
index 000000000..3f8e5da0a
--- /dev/null
+++ b/crates/dbx-core/build.rs
@@ -0,0 +1,51 @@
+use std::env;
+use std::path::Path;
+
+fn main() {
+ let cargo_manifest_dir_str = env::var("CARGO_MANIFEST_DIR").unwrap();
+ let cargo_manifest_dir = Path::new(&cargo_manifest_dir_str);
+ let dialects_dir = cargo_manifest_dir.join("..").join("..").join("plugins").join("dialects");
+ let dialects_dir = std::fs::canonicalize(&dialects_dir).unwrap_or(dialects_dir);
+
+ let out_dir_str = env::var("OUT_DIR").unwrap();
+ let dest_path = Path::new(&out_dir_str).join("core_dialects.rs");
+
+ let mut entries: Vec<_> = std::fs::read_dir(&dialects_dir)
+ .expect("Cannot read plugins/dialects directory")
+ .filter_map(|e| e.ok())
+ .filter(|e| e.path().extension().is_some_and(|ext| ext == "yaml" || ext == "yml"))
+ .collect();
+ entries.sort_by_key(|e| e.file_name());
+
+ // Watch the directory itself so additions/removals of dialect files trigger a rebuild.
+ println!("cargo::rerun-if-changed={}", dialects_dir.to_str().unwrap());
+
+ let mut code = String::from("{\n");
+
+ for entry in &entries {
+ let path = entry.path();
+ let canonical = std::fs::canonicalize(&path).unwrap_or_else(|_| path.clone());
+ let file_name = path.file_stem().unwrap().to_str().unwrap();
+ let path_str = canonical.to_str().unwrap();
+
+ // Watch each dialect file individually. Editing a single YAML must invalidate
+ // the embedded `core_dialects.rs`, otherwise the compiled binary keeps a stale
+ // type catalog (e.g. old type names) and silently misbehaves (see field mapping).
+ println!("cargo::rerun-if-changed={}", path_str);
+
+ code.push_str("match crate::sql_dialect::dialect_loader::DialectPluginLoader::load_from_string(\n");
+ code.push_str(&format!(" include_str!(\"{}\"),\n", path_str.replace('\\', "\\\\")));
+ code.push_str(" None,\n");
+ code.push_str(") {\n");
+ code.push_str(" Ok((_kind, yaml, descriptor)) => {\n");
+ code.push_str(" let name = yaml.dialect.name.clone();\n");
+ code.push_str(" registry.register_descriptor(&name, descriptor, yaml);\n");
+ code.push_str(" }\n");
+ code.push_str(&format!(" Err(e) => log::warn!(\"Failed to load core dialect '{}': {{e}}\"),\n", file_name));
+ code.push_str("};\n");
+ }
+
+ code.push_str("}\n");
+
+ std::fs::write(&dest_path, code).expect("Failed to write core_dialects.rs");
+}
diff --git a/crates/dbx-core/src/config/expression.rs b/crates/dbx-core/src/config/expression.rs
new file mode 100644
index 000000000..ed2011e64
--- /dev/null
+++ b/crates/dbx-core/src/config/expression.rs
@@ -0,0 +1,307 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Expression {
+ EnvVar(String),
+ Ref(String),
+ Eval(String),
+ Literal(String),
+}
+
+pub fn parse_expression(input: &str) -> Expression {
+ let trimmed = input.trim();
+ if trimmed.starts_with("${env:") && trimmed.ends_with('}') {
+ let inner = &trimmed[6..trimmed.len() - 1];
+ Expression::EnvVar(inner.to_string())
+ } else if trimmed.starts_with("${ref:") && trimmed.ends_with('}') {
+ let inner = &trimmed[6..trimmed.len() - 1];
+ Expression::Ref(inner.to_string())
+ } else if trimmed.starts_with("${eval:") && trimmed.ends_with('}') {
+ let inner = &trimmed[7..trimmed.len() - 1];
+ Expression::Eval(inner.to_string())
+ } else {
+ Expression::Literal(input.to_string())
+ }
+}
+
+pub fn resolve_env_var(name: &str) -> Result {
+ std::env::var(name).map_err(|_| format!("Environment variable '${name}' not set"))
+}
+
+pub fn resolve_ref(path: &str, merged: &HashMap) -> Result {
+ let parts: Vec<&str> = path.split('.').collect();
+ let key = parts[0];
+ let value = merged.get(key).ok_or_else(|| format!("Config reference '${path}' not found in merged config"))?;
+
+ if parts.len() == 1 {
+ return Ok(value.clone());
+ }
+
+ let mut current = value;
+ for part in &parts[1..] {
+ match current {
+ serde_json::Value::Object(map) => {
+ current =
+ map.get(*part).ok_or_else(|| format!("Config reference '${path}': key '{part}' not found"))?;
+ }
+ _ => {
+ return Err(format!("Config reference '${path}': intermediate value is not an object"));
+ }
+ }
+ }
+ Ok(current.clone())
+}
+
+/// Parses JSON literals only (numbers, booleans, null, quoted strings).
+/// Does NOT support arithmetic, operators, or function calls.
+fn eval_simple(expr: &str) -> Result {
+ let expr = expr.trim();
+
+ if let Ok(v) = expr.parse::() {
+ return Ok(serde_json::Value::Number(v.into()));
+ }
+
+ if let Ok(v) = expr.parse::() {
+ if let Some(n) = serde_json::Number::from_f64(v) {
+ return Ok(serde_json::Value::Number(n));
+ }
+ }
+
+ if expr == "true" {
+ return Ok(serde_json::Value::Bool(true));
+ }
+ if expr == "false" {
+ return Ok(serde_json::Value::Bool(false));
+ }
+ if expr == "null" {
+ return Ok(serde_json::Value::Null);
+ }
+
+ if expr.starts_with('"') && expr.ends_with('"') && expr.len() >= 2 {
+ return Ok(serde_json::Value::String(expr[1..expr.len() - 1].to_string()));
+ }
+
+ Err(format!("Cannot evaluate expression: '{expr}'"))
+}
+
+pub fn resolve_expression(
+ expression: &Expression,
+ merged: &HashMap,
+) -> Result {
+ match expression {
+ Expression::EnvVar(name) => {
+ let val = resolve_env_var(name)?;
+ Ok(serde_json::Value::String(val))
+ }
+ Expression::Ref(path) => resolve_ref(path, merged),
+ Expression::Eval(expr) => eval_simple(expr),
+ Expression::Literal(val) => Ok(serde_json::Value::String(val.clone())),
+ }
+}
+
+pub fn resolve_all_expressions_in_value(
+ value: &serde_json::Value,
+ merged: &HashMap,
+) -> Result {
+ match value {
+ serde_json::Value::String(s) => {
+ let expr = parse_expression(s);
+ resolve_expression(&expr, merged)
+ }
+ serde_json::Value::Object(map) => {
+ let mut resolved = serde_json::Map::new();
+ for (k, v) in map {
+ resolved.insert(k.clone(), resolve_all_expressions_in_value(v, merged)?);
+ }
+ Ok(serde_json::Value::Object(resolved))
+ }
+ serde_json::Value::Array(arr) => {
+ let mut resolved = Vec::new();
+ for v in arr {
+ resolved.push(resolve_all_expressions_in_value(v, merged)?);
+ }
+ Ok(serde_json::Value::Array(resolved))
+ }
+ other => Ok(other.clone()),
+ }
+}
+
+pub fn apply_expression_resolution(
+ config: &mut HashMap,
+ merged: &HashMap,
+) -> Result<(), String> {
+ let mut resolved = HashMap::new();
+ for (k, v) in config.iter() {
+ resolved.insert(k.clone(), resolve_all_expressions_in_value(v, merged)?);
+ }
+ config.extend(resolved);
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_parse_env_var_expression() {
+ assert_eq!(parse_expression("${env:HOME}"), Expression::EnvVar("HOME".to_string()));
+ }
+
+ #[test]
+ fn test_parse_ref_expression() {
+ assert_eq!(parse_expression("${ref:database.host}"), Expression::Ref("database.host".to_string()));
+ }
+
+ #[test]
+ fn test_parse_eval_expression() {
+ assert_eq!(parse_expression("${eval:42}"), Expression::Eval("42".to_string()));
+ }
+
+ #[test]
+ fn test_parse_literal() {
+ assert_eq!(parse_expression("hello"), Expression::Literal("hello".to_string()));
+ assert_eq!(parse_expression("${not-an-expr}"), Expression::Literal("${not-an-expr}".to_string()));
+ }
+
+ #[test]
+ fn test_resolve_env_var() {
+ std::env::set_var("DBX_TEST_VAR", "test_value");
+ let result = resolve_env_var("DBX_TEST_VAR");
+ assert_eq!(result.unwrap(), "test_value");
+ std::env::remove_var("DBX_TEST_VAR");
+ }
+
+ #[test]
+ fn test_resolve_env_var_missing() {
+ let result = resolve_env_var("DBX_NONEXISTENT_VAR_12345");
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_resolve_ref_simple() {
+ let mut merged = HashMap::new();
+ merged.insert("host".to_string(), serde_json::Value::String("localhost".to_string()));
+
+ let result = resolve_ref("host", &merged).unwrap();
+ assert_eq!(result, serde_json::Value::String("localhost".to_string()));
+ }
+
+ #[test]
+ fn test_resolve_ref_nested() {
+ let mut merged = HashMap::new();
+ let mut db = serde_json::Map::new();
+ db.insert("host".to_string(), serde_json::Value::String("pg.example.com".to_string()));
+ db.insert("port".to_string(), serde_json::Value::Number(serde_json::Number::from(5432)));
+ merged.insert("database".to_string(), serde_json::Value::Object(db));
+
+ let host = resolve_ref("database.host", &merged).unwrap();
+ assert_eq!(host, serde_json::Value::String("pg.example.com".to_string()));
+
+ let port = resolve_ref("database.port", &merged).unwrap();
+ assert_eq!(port, serde_json::Value::Number(serde_json::Number::from(5432)));
+ }
+
+ #[test]
+ fn test_resolve_ref_missing() {
+ let merged = HashMap::new();
+ let result = resolve_ref("nonexistent", &merged);
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_eval_simple_integer() {
+ let result = eval_simple("42").unwrap();
+ assert_eq!(result, serde_json::Value::Number(serde_json::Number::from(42)));
+ }
+
+ #[test]
+ fn test_eval_simple_bool() {
+ assert_eq!(eval_simple("true").unwrap(), serde_json::Value::Bool(true));
+ assert_eq!(eval_simple("false").unwrap(), serde_json::Value::Bool(false));
+ }
+
+ #[test]
+ fn test_eval_simple_null() {
+ assert_eq!(eval_simple("null").unwrap(), serde_json::Value::Null);
+ }
+
+ #[test]
+ fn test_eval_simple_string() {
+ let result = eval_simple(r#""hello world""#).unwrap();
+ assert_eq!(result, serde_json::Value::String("hello world".to_string()));
+ }
+
+ #[test]
+ fn test_eval_simple_invalid() {
+ assert!(eval_simple("some_random_text").is_err());
+ }
+
+ #[test]
+ fn test_resolve_expression_env_var() {
+ std::env::set_var("DBX_TEST_PORT", "8080");
+ let expr = Expression::EnvVar("DBX_TEST_PORT".to_string());
+ let merged = HashMap::new();
+ let result = resolve_expression(&expr, &merged).unwrap();
+ assert_eq!(result, serde_json::Value::String("8080".to_string()));
+ std::env::remove_var("DBX_TEST_PORT");
+ }
+
+ #[test]
+ fn test_resolve_expression_ref() {
+ let mut merged = HashMap::new();
+ merged.insert("host".to_string(), serde_json::Value::String("db.local".to_string()));
+ let expr = Expression::Ref("host".to_string());
+ let result = resolve_expression(&expr, &merged).unwrap();
+ assert_eq!(result, serde_json::Value::String("db.local".to_string()));
+ }
+
+ #[test]
+ fn test_resolve_expression_eval() {
+ let expr = Expression::Eval("true".to_string());
+ let merged = HashMap::new();
+ let result = resolve_expression(&expr, &merged).unwrap();
+ assert_eq!(result, serde_json::Value::Bool(true));
+ }
+
+ #[test]
+ fn test_resolve_expression_literal() {
+ let expr = Expression::Literal("hello".to_string());
+ let merged = HashMap::new();
+ let result = resolve_expression(&expr, &merged).unwrap();
+ assert_eq!(result, serde_json::Value::String("hello".to_string()));
+ }
+
+ #[test]
+ fn test_resolve_all_in_nested_object() {
+ let mut merged = HashMap::new();
+ merged.insert("default_host".to_string(), serde_json::Value::String("pg.example.com".to_string()));
+
+ let mut obj = serde_json::Map::new();
+ obj.insert("host".to_string(), serde_json::Value::String("${ref:default_host}".to_string()));
+ obj.insert("port".to_string(), serde_json::Value::Number(serde_json::Number::from(5432)));
+ obj.insert("debug".to_string(), serde_json::Value::String("${eval:true}".to_string()));
+
+ let input = serde_json::Value::Object(obj);
+ let result = resolve_all_expressions_in_value(&input, &merged).unwrap();
+
+ let obj = result.as_object().unwrap();
+ assert_eq!(obj.get("host").unwrap(), &serde_json::Value::String("pg.example.com".to_string()));
+ assert_eq!(obj.get("port").unwrap(), &serde_json::Value::Number(serde_json::Number::from(5432)));
+ assert_eq!(obj.get("debug").unwrap(), &serde_json::Value::Bool(true));
+ }
+
+ #[test]
+ fn test_apply_expression_resolution() {
+ let mut merged = HashMap::new();
+ merged.insert("base_url".to_string(), serde_json::Value::String("https://api.example.com".to_string()));
+
+ let mut config = HashMap::new();
+ config.insert("url".to_string(), serde_json::Value::String("${ref:base_url}".to_string()));
+ config.insert("timeout".to_string(), serde_json::Value::String("${eval:30}".to_string()));
+
+ apply_expression_resolution(&mut config, &merged).unwrap();
+ assert_eq!(config.get("url").unwrap(), &serde_json::Value::String("https://api.example.com".to_string()));
+ assert_eq!(config.get("timeout").unwrap(), &serde_json::Value::Number(serde_json::Number::from(30)));
+ }
+}
diff --git a/crates/dbx-core/src/config/governance.rs b/crates/dbx-core/src/config/governance.rs
new file mode 100644
index 000000000..afc336cc9
--- /dev/null
+++ b/crates/dbx-core/src/config/governance.rs
@@ -0,0 +1,979 @@
+use arc_swap::ArcSwap;
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::config::layer::ConfigTree;
+#[cfg(test)]
+use crate::config::layer::LayerConfig;
+use crate::storage::Storage;
+
+fn hex_encode(bytes: &[u8]) -> String {
+ bytes.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+// ---------------------------------------------------------------------------
+// 16.1 — Config Change Audit & Version Management
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConfigAuditEntry {
+ pub id: String,
+ pub timestamp: String,
+ pub operator: String,
+ pub reason: String,
+ pub key_path: String,
+ pub change_diff: serde_json::Value,
+ pub config_snapshot: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConfigVersionSnapshot {
+ pub id: String,
+ pub key_path: String,
+ pub version: u64,
+ pub snapshot_json: serde_json::Value,
+ pub checksum: String,
+ pub created_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AuditQuery {
+ pub key_path: Option,
+ pub operator: Option,
+ pub limit: Option,
+ pub offset: Option,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AuditSummary {
+ pub total_entries: usize,
+ pub entries: Vec,
+}
+
+pub struct ConfigAuditor {
+ storage: Arc,
+}
+
+impl ConfigAuditor {
+ pub fn new(storage: Arc) -> Self {
+ Self { storage }
+ }
+
+ pub async fn record_change(
+ &self,
+ operator: &str,
+ reason: &str,
+ key_path: &str,
+ change_diff: serde_json::Value,
+ config_snapshot: serde_json::Value,
+ ) -> Result {
+ let entry = ConfigAuditEntry {
+ id: uuid::Uuid::new_v4().to_string(),
+ timestamp: Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
+ operator: operator.to_string(),
+ reason: reason.to_string(),
+ key_path: key_path.to_string(),
+ change_diff,
+ config_snapshot,
+ };
+ self.storage.save_audit_entry(&entry).await?;
+ Ok(entry)
+ }
+
+ pub async fn query_history(&self, query: &AuditQuery) -> Result {
+ self.storage.query_audit_entries(query).await
+ }
+
+ pub async fn save_snapshot(&self, key_path: &str, tree: &ConfigTree) -> Result {
+ let snapshot_json = serde_json::to_value(tree).map_err(|e| format!("serialize config tree: {e}"))?;
+ let json_bytes = serde_json::to_vec(&snapshot_json).map_err(|e| format!("json bytes: {e}"))?;
+ let checksum = hex_encode(&Sha256::digest(&json_bytes));
+ let version = self.storage.next_config_version(key_path).await?;
+
+ let snap = ConfigVersionSnapshot {
+ id: uuid::Uuid::new_v4().to_string(),
+ key_path: key_path.to_string(),
+ version,
+ snapshot_json: snapshot_json.clone(),
+ checksum,
+ created_at: Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
+ };
+ self.storage.save_config_snapshot(&snap).await?;
+ Ok(snap)
+ }
+
+ pub async fn get_snapshot(&self, key_path: &str, version: u64) -> Result, String> {
+ self.storage.load_config_snapshot(key_path, version).await
+ }
+
+ pub async fn list_versions(&self, key_path: &str) -> Result, String> {
+ self.storage.list_config_snapshots(key_path).await
+ }
+
+ pub async fn rollback(
+ &self,
+ key_path: &str,
+ version: u64,
+ operator: &str,
+ reason: &str,
+ ) -> Result {
+ let snap = self
+ .get_snapshot(key_path, version)
+ .await?
+ .ok_or_else(|| format!("version {version} not found for key_path '{key_path}'"))?;
+
+ let tree: ConfigTree =
+ serde_json::from_value(snap.snapshot_json.clone()).map_err(|e| format!("deserialize config tree: {e}"))?;
+
+ let current_json = serde_json::to_value(&tree).map_err(|e| format!("serialize current: {e}"))?;
+ self.record_change(
+ operator,
+ &format!("rollback: {reason}"),
+ key_path,
+ serde_json::json!({ "rollback_to_version": version }),
+ current_json,
+ )
+ .await?;
+
+ Ok(tree)
+ }
+}
+
+// ---------------------------------------------------------------------------
+// 16.2 — Approval Workflow Integration
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ApprovalStatus {
+ Draft,
+ PendingApproval,
+ Approved,
+ Rejected,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApprovalRecord {
+ pub id: String,
+ pub config_domain: String,
+ pub change_description: String,
+ pub status: ApprovalStatus,
+ pub requester: String,
+ pub reviewer: Option,
+ pub reviewed_at: Option,
+ pub webhook_url: Option,
+ pub draft_config_json: serde_json::Value,
+ pub created_at: String,
+ pub updated_at: String,
+}
+
+const SENSITIVE_DOMAINS: &[&str] = &["mapping_rules", "allow_destructive", "dangerous_ddl_policy"];
+
+pub fn is_sensitive_domain(domain: &str) -> bool {
+ SENSITIVE_DOMAINS.contains(&domain)
+}
+
+pub fn requires_approval_for_change(domain: &str, current_status: ApprovalStatus) -> bool {
+ if !is_sensitive_domain(domain) {
+ return false;
+ }
+ matches!(current_status, ApprovalStatus::Draft | ApprovalStatus::Rejected)
+}
+
+pub struct ConfigApproval {
+ storage: Arc,
+}
+
+impl ConfigApproval {
+ pub fn new(storage: Arc) -> Self {
+ Self { storage }
+ }
+
+ pub async fn submit_change(
+ &self,
+ domain: &str,
+ description: &str,
+ requester: &str,
+ draft_config: serde_json::Value,
+ webhook_url: Option<&str>,
+ ) -> Result {
+ let now = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+ let record = ApprovalRecord {
+ id: uuid::Uuid::new_v4().to_string(),
+ config_domain: domain.to_string(),
+ change_description: description.to_string(),
+ status: if is_sensitive_domain(domain) {
+ ApprovalStatus::PendingApproval
+ } else {
+ ApprovalStatus::Approved
+ },
+ requester: requester.to_string(),
+ reviewer: None,
+ reviewed_at: None,
+ webhook_url: webhook_url.map(String::from),
+ draft_config_json: draft_config,
+ created_at: now.clone(),
+ updated_at: now,
+ };
+ self.storage.save_approval_record(&record).await?;
+ Ok(record)
+ }
+
+ pub async fn approve(&self, id: &str, reviewer: &str) -> Result {
+ let mut record =
+ self.storage.load_approval_record(id).await?.ok_or_else(|| format!("approval record {id} not found"))?;
+ if record.status != ApprovalStatus::PendingApproval {
+ return Err(format!("record {id} is not in PendingApproval state (current: {:?})", record.status));
+ }
+ record.status = ApprovalStatus::Approved;
+ record.reviewer = Some(reviewer.to_string());
+ record.reviewed_at = Some(Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string());
+ record.updated_at = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+ self.storage.save_approval_record(&record).await?;
+ Ok(record)
+ }
+
+ pub async fn reject(&self, id: &str, reviewer: &str) -> Result {
+ let mut record =
+ self.storage.load_approval_record(id).await?.ok_or_else(|| format!("approval record {id} not found"))?;
+ if record.status != ApprovalStatus::PendingApproval {
+ return Err(format!("record {id} is not in PendingApproval state"));
+ }
+ record.status = ApprovalStatus::Rejected;
+ record.reviewer = Some(reviewer.to_string());
+ record.reviewed_at = Some(Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string());
+ record.updated_at = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+ self.storage.save_approval_record(&record).await?;
+ Ok(record)
+ }
+
+ pub async fn list_pending(&self) -> Result, String> {
+ self.storage.query_approval_records(Some(ApprovalStatus::PendingApproval)).await
+ }
+
+ pub async fn check_effective(&self, domain: &str) -> Result {
+ if !is_sensitive_domain(domain) {
+ return Ok(true);
+ }
+ let records = self.storage.query_approval_records_by_domain(domain).await?;
+ let latest = records.into_iter().last();
+ match latest {
+ Some(r) => Ok(r.status == ApprovalStatus::Approved),
+ None => Ok(false),
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// 16.3 — Cross-Environment Config Drift Detection
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConfigChecksum {
+ pub env: String,
+ pub key_path: String,
+ pub checksum: String,
+ pub computed_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DriftReport {
+ pub source_env: String,
+ pub target_env: String,
+ pub key_path: String,
+ pub source_checksum: String,
+ pub target_checksum: String,
+ pub mismatched_fields: Vec,
+ pub source_changed_at: Option,
+ pub detected_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DriftAlert {
+ pub id: String,
+ pub source_env: String,
+ pub target_env: String,
+ pub config_key: String,
+ pub expected_checksum: String,
+ pub actual_checksum: String,
+ pub details_json: serde_json::Value,
+ pub detected_at: String,
+ pub acknowledged: bool,
+}
+
+pub fn compute_config_checksum(tree: &ConfigTree) -> String {
+ let json = serde_json::to_vec(tree).unwrap_or_default();
+ hex_encode(&Sha256::digest(&json))
+}
+
+pub fn compute_config_checksum_for_layer(tree: &ConfigTree, key_path: &str) -> Option {
+ let merged = tree.merge().ok()?;
+ let relevant: HashMap =
+ merged.values.into_iter().filter(|(k, _)| k.starts_with(key_path)).collect();
+ if relevant.is_empty() {
+ return None;
+ }
+ let json = serde_json::to_vec(&relevant).ok()?;
+ Some(hex_encode(&Sha256::digest(&json)))
+}
+
+pub fn detect_drift(source: &ConfigTree, target: &ConfigTree, key_path: &str) -> Option {
+ let source_merged = source.merge().ok()?;
+ let target_merged = target.merge().ok()?;
+
+ let source_vals: HashMap<&String, &serde_json::Value> =
+ source_merged.values.iter().filter(|(k, _)| k.starts_with(key_path)).collect();
+ let target_vals: HashMap<&String, &serde_json::Value> =
+ target_merged.values.iter().filter(|(k, _)| k.starts_with(key_path)).collect();
+
+ let all_keys: std::collections::BTreeSet<&String> = source_vals.keys().chain(target_vals.keys()).copied().collect();
+
+ let mismatched: Vec = all_keys
+ .into_iter()
+ .filter(|k| match (source_vals.get(k), target_vals.get(k)) {
+ (Some(sv), Some(tv)) => sv != tv,
+ _ => true,
+ })
+ .map(|k| {
+ let s = source_vals.get(k).map(|v| v.to_string()).unwrap_or_default();
+ let t = target_vals.get(k).map(|v| v.to_string()).unwrap_or_default();
+ format!("{k}: source={s}, target={t}")
+ })
+ .collect();
+
+ if mismatched.is_empty() {
+ return None;
+ }
+
+ let source_ck = compute_config_checksum_for_layer(source, key_path).unwrap_or_default();
+ let target_ck = compute_config_checksum_for_layer(target, key_path).unwrap_or_default();
+
+ Some(DriftReport {
+ source_env: String::new(),
+ target_env: String::new(),
+ key_path: key_path.to_string(),
+ source_checksum: source_ck,
+ target_checksum: target_ck,
+ mismatched_fields: mismatched,
+ source_changed_at: None,
+ detected_at: Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
+ })
+}
+
+pub struct DriftDetector {
+ storage: Arc,
+}
+
+impl DriftDetector {
+ pub fn new(storage: Arc) -> Self {
+ Self { storage }
+ }
+
+ pub fn compare_envs(
+ &self,
+ source_env: &str,
+ target_env: &str,
+ source_tree: &ConfigTree,
+ target_tree: &ConfigTree,
+ key_path: &str,
+ ) -> Option {
+ let mut report = detect_drift(source_tree, target_tree, key_path)?;
+ report.source_env = source_env.to_string();
+ report.target_env = target_env.to_string();
+ Some(report)
+ }
+
+ pub async fn record_alert(&self, alert: &DriftAlert) -> Result<(), String> {
+ self.storage.save_drift_alert(alert).await
+ }
+
+ pub async fn acknowledge_alert(&self, id: &str) -> Result<(), String> {
+ self.storage.acknowledge_drift_alert(id).await
+ }
+
+ pub async fn list_alerts(&self, acknowledged: Option) -> Result, String> {
+ self.storage.query_drift_alerts(acknowledged).await
+ }
+}
+
+// ---------------------------------------------------------------------------
+// 16.4 — COW Snapshot (ArcSwap-based hot-reload)
+// ---------------------------------------------------------------------------
+
+pub struct ConfigSnapshot {
+ inner: ArcSwap,
+ key_path: String,
+ auditor: Arc,
+}
+
+impl ConfigSnapshot {
+ pub fn new(tree: ConfigTree, key_path: &str, auditor: Arc) -> Self {
+ Self { inner: ArcSwap::new(Arc::new(tree)), key_path: key_path.to_string(), auditor }
+ }
+
+ pub fn load(&self) -> Arc {
+ self.inner.load_full()
+ }
+
+ pub fn apply(
+ &self,
+ operator: &str,
+ reason: &str,
+ f: impl FnOnce(&mut ConfigTree),
+ ) -> Result, String>
+ where
+ Self: Sized,
+ {
+ let prev = self.inner.load_full();
+ let mut new_tree = (*prev).clone();
+ f(&mut new_tree);
+
+ let prev_json = serde_json::to_value(&*prev).map_err(|e| format!("serialize prev: {e}"))?;
+ let new_json = serde_json::to_value(&new_tree).map_err(|e| format!("serialize new: {e}"))?;
+
+ let diff = serde_json::json!({
+ "prev": prev_json,
+ "new": new_json,
+ });
+
+ let new_arc = Arc::new(new_tree);
+ self.inner.store(new_arc.clone());
+
+ let auditor = self.auditor.clone();
+ let key_path = self.key_path.clone();
+ let operator = operator.to_string();
+ let reason = reason.to_string();
+ tokio::spawn(async move {
+ let _ = auditor.record_change(&operator, &reason, &key_path, diff, new_json).await;
+ });
+
+ Ok(new_arc)
+ }
+
+ pub fn apply_silent(&self, f: impl FnOnce(&mut ConfigTree)) -> Arc {
+ let prev = self.inner.load_full();
+ let mut new_tree = (*prev).clone();
+ f(&mut new_tree);
+ let new_arc = Arc::new(new_tree);
+ self.inner.store(new_arc.clone());
+ new_arc
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::config::layer::ConfigLayer;
+ use std::sync::Arc;
+
+ async fn make_test_storage() -> Arc {
+ let tmp = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+ std::fs::create_dir_all(&tmp).unwrap();
+ let db_path = tmp.join("test_governance.db");
+ let storage = Arc::new(Storage::open(&db_path).await.unwrap());
+ std::mem::forget(tmp);
+ storage
+ }
+
+ fn make_test_tree() -> ConfigTree {
+ let mut tree = ConfigTree::new();
+ tree.add_layer(LayerConfig {
+ layer: ConfigLayer::Global,
+ name: "test".to_string(),
+ values: HashMap::from([
+ ("host".to_string(), serde_json::Value::String("db.example.com".to_string())),
+ ("port".to_string(), serde_json::json!(5432)),
+ ]),
+ enabled: true,
+ ..Default::default()
+ });
+ tree
+ }
+
+ // ---- 16.1 Audit Tests ----
+
+ #[tokio::test]
+ async fn test_audit_record_and_query() {
+ let storage = make_test_storage().await;
+ let auditor = ConfigAuditor::new(storage.clone());
+
+ auditor
+ .record_change(
+ "alice",
+ "update host",
+ "database.host",
+ serde_json::json!({"old": "old.host.com", "new": "new.host.com"}),
+ serde_json::json!({"host": "new.host.com"}),
+ )
+ .await
+ .unwrap();
+
+ let summary = auditor
+ .query_history(&AuditQuery { key_path: None, operator: None, limit: None, offset: None })
+ .await
+ .unwrap();
+ assert_eq!(summary.total_entries, 1);
+ assert_eq!(summary.entries[0].operator, "alice");
+ assert_eq!(summary.entries[0].key_path, "database.host");
+
+ let filtered = auditor
+ .query_history(&AuditQuery {
+ key_path: Some("database.host".into()),
+ operator: Some("alice".into()),
+ limit: Some(10),
+ offset: Some(0),
+ })
+ .await
+ .unwrap();
+ assert_eq!(filtered.total_entries, 1);
+
+ let empty = auditor
+ .query_history(&AuditQuery {
+ key_path: Some("other.key".into()),
+ operator: None,
+ limit: None,
+ offset: None,
+ })
+ .await
+ .unwrap();
+ assert_eq!(empty.total_entries, 0);
+ }
+
+ #[tokio::test]
+ async fn test_audit_multiple_entries() {
+ let storage = make_test_storage().await;
+ let auditor = ConfigAuditor::new(storage.clone());
+
+ for i in 0..3 {
+ auditor
+ .record_change(
+ &format!("user{i}"),
+ &format!("change {i}"),
+ "app.config",
+ serde_json::json!({"index": i}),
+ serde_json::json!({"version": i}),
+ )
+ .await
+ .unwrap();
+ }
+
+ let summary = auditor
+ .query_history(&AuditQuery { key_path: None, operator: None, limit: Some(2), offset: None })
+ .await
+ .unwrap();
+ assert_eq!(summary.total_entries, 3);
+ assert_eq!(summary.entries.len(), 2);
+ }
+
+ // ---- 16.1 Snapshot Tests ----
+
+ #[tokio::test]
+ async fn test_snapshot_save_and_rollback() {
+ let storage = make_test_storage().await;
+ let auditor = ConfigAuditor::new(storage.clone());
+ let tree = make_test_tree();
+
+ let snap = auditor.save_snapshot("app.config", &tree).await.unwrap();
+ assert_eq!(snap.version, 1);
+ assert!(!snap.checksum.is_empty());
+
+ let loaded = auditor.get_snapshot("app.config", 1).await.unwrap().unwrap();
+ assert_eq!(loaded.checksum, snap.checksum);
+
+ let versions = auditor.list_versions("app.config").await.unwrap();
+ assert_eq!(versions.len(), 1);
+ }
+
+ #[tokio::test]
+ async fn test_snapshot_version_increment() {
+ let storage = make_test_storage().await;
+ let auditor = ConfigAuditor::new(storage.clone());
+
+ let tree = make_test_tree();
+ let v1 = auditor.save_snapshot("app.config", &tree).await.unwrap();
+ assert_eq!(v1.version, 1);
+
+ let v2 = auditor.save_snapshot("app.config", &tree).await.unwrap();
+ assert_eq!(v2.version, 2);
+
+ let versions = auditor.list_versions("app.config").await.unwrap();
+ assert_eq!(versions.len(), 2);
+ }
+
+ #[tokio::test]
+ async fn test_rollback_restores_snapshot() {
+ let storage = make_test_storage().await;
+ let auditor = ConfigAuditor::new(storage.clone());
+
+ let mut tree = make_test_tree();
+ let snap1 = auditor.save_snapshot("app.config", &tree).await.unwrap();
+
+ tree.add_layer(LayerConfig {
+ layer: ConfigLayer::Task,
+ name: "override".to_string(),
+ values: HashMap::from([("host".to_string(), serde_json::Value::String("override.host.com".to_string()))]),
+ enabled: true,
+ ..Default::default()
+ });
+ auditor.save_snapshot("app.config", &tree).await.unwrap();
+
+ let rolled = auditor.rollback("app.config", 1, "bob", "bad override").await.unwrap();
+ let merged = rolled.merge().unwrap();
+ assert_eq!(merged.values.get("host").unwrap(), &serde_json::Value::String("db.example.com".to_string()));
+
+ let history = auditor
+ .query_history(&AuditQuery {
+ key_path: Some("app.config".into()),
+ operator: None,
+ limit: None,
+ offset: None,
+ })
+ .await
+ .unwrap();
+ let rollback_entries: Vec<_> = history.entries.iter().filter(|e| e.reason.contains("rollback")).collect();
+ assert_eq!(rollback_entries.len(), 1);
+ }
+
+ #[tokio::test]
+ async fn test_rollback_nonexistent_version() {
+ let storage = make_test_storage().await;
+ let auditor = ConfigAuditor::new(storage.clone());
+ let result = auditor.rollback("app.config", 99, "alice", "test").await;
+ assert!(result.is_err());
+ }
+
+ // ---- 16.2 Approval Tests ----
+
+ #[test]
+ fn test_sensitive_domain_check() {
+ assert!(is_sensitive_domain("mapping_rules"));
+ assert!(is_sensitive_domain("allow_destructive"));
+ assert!(is_sensitive_domain("dangerous_ddl_policy"));
+ assert!(!is_sensitive_domain("theme"));
+ assert!(!is_sensitive_domain("log_level"));
+ }
+
+ #[test]
+ fn test_requires_approval_logic() {
+ assert!(requires_approval_for_change("mapping_rules", ApprovalStatus::Draft));
+ assert!(requires_approval_for_change("allow_destructive", ApprovalStatus::Rejected));
+ assert!(!requires_approval_for_change("allow_destructive", ApprovalStatus::Approved));
+ assert!(!requires_approval_for_change("theme", ApprovalStatus::Draft));
+ }
+
+ #[tokio::test]
+ async fn test_submit_change_sensitive_domain() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ let record = approval
+ .submit_change(
+ "allow_destructive",
+ "enable drop table",
+ "alice",
+ serde_json::json!({"enabled": true}),
+ None,
+ )
+ .await
+ .unwrap();
+ assert_eq!(record.status, ApprovalStatus::PendingApproval);
+ assert_eq!(record.requester, "alice");
+ }
+
+ #[tokio::test]
+ async fn test_submit_change_non_sensitive_domain() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ let record = approval
+ .submit_change("theme", "set dark mode", "alice", serde_json::json!({"theme": "dark"}), None)
+ .await
+ .unwrap();
+ assert_eq!(record.status, ApprovalStatus::Approved);
+ }
+
+ #[tokio::test]
+ async fn test_approve_workflow() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ let record = approval
+ .submit_change(
+ "mapping_rules",
+ "add mysql mapping",
+ "alice",
+ serde_json::json!({"rule": "varchar->text"}),
+ None,
+ )
+ .await
+ .unwrap();
+
+ let approved = approval.approve(&record.id, "bob").await.unwrap();
+ assert_eq!(approved.status, ApprovalStatus::Approved);
+ assert_eq!(approved.reviewer.as_deref(), Some("bob"));
+ }
+
+ #[tokio::test]
+ async fn test_reject_workflow() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ let record = approval
+ .submit_change(
+ "dangerous_ddl_policy",
+ "allow drop database",
+ "alice",
+ serde_json::json!({"allow": true}),
+ None,
+ )
+ .await
+ .unwrap();
+
+ let rejected = approval.reject(&record.id, "bob").await.unwrap();
+ assert_eq!(rejected.status, ApprovalStatus::Rejected);
+ }
+
+ #[tokio::test]
+ async fn test_approve_invalid_state() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ let record = approval
+ .submit_change("theme", "dark mode", "alice", serde_json::json!({"theme": "dark"}), None)
+ .await
+ .unwrap();
+ assert!(record.status == ApprovalStatus::Approved);
+
+ let result = approval.approve(&record.id, "bob").await;
+ assert!(result.is_err());
+ }
+
+ #[tokio::test]
+ async fn test_check_effective() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ assert!(!approval.check_effective("allow_destructive").await.unwrap());
+
+ let record = approval
+ .submit_change("allow_destructive", "enable", "alice", serde_json::json!({"enabled": true}), None)
+ .await
+ .unwrap();
+ assert!(!approval.check_effective("allow_destructive").await.unwrap());
+
+ approval.approve(&record.id, "bob").await.unwrap();
+ assert!(approval.check_effective("allow_destructive").await.unwrap());
+
+ assert!(approval.check_effective("theme").await.unwrap());
+ }
+
+ #[tokio::test]
+ async fn test_list_pending() {
+ let storage = make_test_storage().await;
+ let approval = ConfigApproval::new(storage.clone());
+
+ approval.submit_change("mapping_rules", "rule1", "alice", serde_json::json!({"r": 1}), None).await.unwrap();
+ approval.submit_change("allow_destructive", "rule2", "bob", serde_json::json!({"r": 2}), None).await.unwrap();
+
+ let pending = approval.list_pending().await.unwrap();
+ assert_eq!(pending.len(), 2);
+ }
+
+ // ---- 16.3 Drift Detection Tests ----
+
+ #[test]
+ fn test_checksum_computation() {
+ let tree = make_test_tree();
+ let ck = compute_config_checksum(&tree);
+ assert_eq!(ck.len(), 64);
+ assert!(ck.chars().all(|c| c.is_ascii_hexdigit()));
+ }
+
+ #[test]
+ fn test_checksum_deterministic() {
+ let tree = make_test_tree();
+ let ck1 = compute_config_checksum(&tree);
+ let ck2 = compute_config_checksum(&tree);
+ assert_eq!(ck1, ck2);
+ }
+
+ #[test]
+ fn test_checksum_differs_on_change() {
+ let mut tree1 = make_test_tree();
+ let mut tree2 = make_test_tree();
+ tree2.add_layer(LayerConfig {
+ layer: ConfigLayer::Task,
+ name: "override".to_string(),
+ values: HashMap::from([("host".to_string(), serde_json::Value::String("other.com".to_string()))]),
+ enabled: true,
+ ..Default::default()
+ });
+ assert_ne!(compute_config_checksum(&tree1), compute_config_checksum(&tree2));
+ }
+
+ #[test]
+ fn test_layer_checksum() {
+ let tree = make_test_tree();
+ let ck = compute_config_checksum_for_layer(&tree, "host").unwrap();
+ assert_eq!(ck.len(), 64);
+
+ let none = compute_config_checksum_for_layer(&tree, "nonexistent");
+ assert!(none.is_none());
+ }
+
+ #[test]
+ fn test_detect_drift_no_drift() {
+ let tree1 = make_test_tree();
+ let tree2 = make_test_tree();
+ assert!(detect_drift(&tree1, &tree2, "host").is_none());
+ }
+
+ #[test]
+ fn test_detect_drift_with_drift() {
+ let tree1 = make_test_tree();
+ let mut tree2 = make_test_tree();
+ tree2.add_layer(LayerConfig {
+ layer: ConfigLayer::Task,
+ name: "override".to_string(),
+ values: HashMap::from([("host".to_string(), serde_json::Value::String("other.com".to_string()))]),
+ enabled: true,
+ ..Default::default()
+ });
+
+ let report = detect_drift(&tree1, &tree2, "host").unwrap();
+ assert_eq!(report.key_path, "host");
+ assert!(!report.mismatched_fields.is_empty());
+ }
+
+ #[test]
+ fn test_detect_drift_partial_keys() {
+ let tree1 = make_test_tree();
+ let tree2 = make_test_tree();
+ let report = detect_drift(&tree1, &tree2, "port");
+ assert!(report.is_none());
+ }
+
+ #[tokio::test]
+ async fn test_drift_alert_persistence() {
+ let storage = make_test_storage().await;
+ let detector = DriftDetector::new(storage.clone());
+
+ let alert = DriftAlert {
+ id: uuid::Uuid::new_v4().to_string(),
+ source_env: "prod".to_string(),
+ target_env: "staging".to_string(),
+ config_key: "database.host".to_string(),
+ expected_checksum: "abc".to_string(),
+ actual_checksum: "def".to_string(),
+ details_json: serde_json::json!({"field": "host", "expected": "prod-host", "actual": "staging-host"}),
+ detected_at: Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
+ acknowledged: false,
+ };
+ detector.record_alert(&alert).await.unwrap();
+
+ let unacked = detector.list_alerts(Some(false)).await.unwrap();
+ assert_eq!(unacked.len(), 1);
+
+ detector.acknowledge_alert(&alert.id).await.unwrap();
+ let still_unacked = detector.list_alerts(Some(false)).await.unwrap();
+ assert_eq!(still_unacked.len(), 0);
+ let acked = detector.list_alerts(Some(true)).await.unwrap();
+ assert_eq!(acked.len(), 1);
+ }
+
+ // ---- 16.4 COW Snapshot Tests ----
+
+ #[test]
+ fn test_config_snapshot_load() {
+ let storage = make_test_storage_for_snapshot();
+ let auditor = Arc::new(ConfigAuditor::new(storage));
+ let tree = make_test_tree();
+ let snapshot = ConfigSnapshot::new(tree, "app.config", auditor);
+
+ let loaded = snapshot.load();
+ let merged = loaded.merge().unwrap();
+ assert_eq!(merged.values.get("host").unwrap(), &serde_json::Value::String("db.example.com".to_string()));
+ }
+
+ #[tokio::test]
+ async fn test_config_snapshot_apply_modification() {
+ let storage = make_test_storage().await;
+ let auditor = Arc::new(ConfigAuditor::new(storage));
+ let tree = make_test_tree();
+ let snapshot = ConfigSnapshot::new(tree, "app.config", auditor);
+
+ snapshot
+ .apply("alice", "update port", |t| {
+ for layer in &mut t.layers {
+ if layer.name == "test" {
+ layer.values.insert("port".to_string(), serde_json::json!(3306));
+ }
+ }
+ })
+ .unwrap();
+
+ let loaded = snapshot.load();
+ let merged = loaded.merge().unwrap();
+ assert_eq!(merged.values.get("port").unwrap(), &serde_json::json!(3306));
+ }
+
+ #[test]
+ fn test_config_snapshot_apply_silent_no_audit() {
+ let storage = make_test_storage_for_snapshot();
+ let auditor = Arc::new(ConfigAuditor::new(storage.clone()));
+ let tree = make_test_tree();
+ let snapshot = ConfigSnapshot::new(tree, "app.config", auditor);
+
+ snapshot.apply_silent(|t| {
+ for layer in &mut t.layers {
+ if layer.name == "test" {
+ layer.values.insert("host".to_string(), serde_json::Value::String("silent.host.com".to_string()));
+ }
+ }
+ });
+
+ let loaded = snapshot.load();
+ let merged = loaded.merge().unwrap();
+ assert_eq!(merged.values.get("host").unwrap(), &serde_json::Value::String("silent.host.com".to_string()));
+ }
+
+ #[test]
+ fn test_config_snapshot_concurrent_reads() {
+ use std::thread;
+ let storage = make_test_storage_for_snapshot();
+ let auditor = Arc::new(ConfigAuditor::new(storage));
+ let tree = make_test_tree();
+ let snapshot = Arc::new(ConfigSnapshot::new(tree, "app.config", auditor));
+
+ let mut handles = Vec::new();
+ for i in 0..10 {
+ let snap = snapshot.clone();
+ handles.push(thread::spawn(move || {
+ let loaded = snap.load();
+ let merged = loaded.merge().unwrap();
+ let port = merged.values.get("port").and_then(|v| v.as_i64()).unwrap_or(0);
+ assert_eq!(port, 5432);
+ }));
+ }
+ for h in handles {
+ h.join().unwrap();
+ }
+ }
+
+ fn make_test_storage_for_snapshot() -> Arc {
+ let tmp = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+ std::fs::create_dir_all(&tmp).unwrap();
+ let db_path = tmp.join("test_snapshot.db");
+ let rt = tokio::runtime::Runtime::new().unwrap();
+ let storage = Arc::new(rt.block_on(Storage::open(&db_path)).unwrap());
+ std::mem::forget(tmp);
+ storage
+ }
+}
diff --git a/crates/dbx-core/src/config/layer.rs b/crates/dbx-core/src/config/layer.rs
new file mode 100644
index 000000000..7e5084125
--- /dev/null
+++ b/crates/dbx-core/src/config/layer.rs
@@ -0,0 +1,308 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum ConfigLayer {
+ Global = 0,
+ Team = 1,
+ Project = 2,
+ Env = 3,
+ Task = 4,
+}
+
+impl ConfigLayer {
+ pub fn priority(&self) -> u8 {
+ *self as u8
+ }
+
+ pub fn label(&self) -> &'static str {
+ match self {
+ ConfigLayer::Global => "global",
+ ConfigLayer::Team => "team",
+ ConfigLayer::Project => "project",
+ ConfigLayer::Env => "env",
+ ConfigLayer::Task => "task",
+ }
+ }
+
+ pub fn all() -> &'static [ConfigLayer] {
+ &[ConfigLayer::Global, ConfigLayer::Team, ConfigLayer::Project, ConfigLayer::Env, ConfigLayer::Task]
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LayerConfig {
+ pub layer: ConfigLayer,
+ pub name: String,
+
+ #[serde(default)]
+ pub description: String,
+
+ #[serde(default)]
+ pub values: HashMap,
+
+ #[serde(default)]
+ pub tags: HashMap,
+
+ #[serde(default)]
+ pub enabled: bool,
+
+ #[serde(default = "default_priority")]
+ pub priority_override: Option,
+
+ #[serde(default)]
+ pub metadata: HashMap,
+}
+
+impl Default for LayerConfig {
+ fn default() -> Self {
+ Self {
+ layer: ConfigLayer::Global,
+ name: String::new(),
+ description: String::new(),
+ values: HashMap::new(),
+ tags: HashMap::new(),
+ enabled: true,
+ priority_override: None,
+ metadata: HashMap::new(),
+ }
+ }
+}
+
+fn default_priority() -> Option {
+ None
+}
+
+impl LayerConfig {
+ pub fn effective_priority(&self) -> u8 {
+ self.priority_override.unwrap_or_else(|| self.layer.priority())
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MergedConfig {
+ pub values: HashMap,
+ pub tags: HashMap,
+ pub provenance: HashMap,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConfigTree {
+ pub layers: Vec,
+}
+
+impl Default for ConfigTree {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl ConfigTree {
+ pub fn new() -> Self {
+ Self { layers: Vec::new() }
+ }
+
+ pub fn add_layer(&mut self, config: LayerConfig) {
+ self.layers.push(config);
+ }
+
+ pub fn merge(&self) -> Result {
+ let mut sorted: Vec<&LayerConfig> = self.layers.iter().filter(|l| l.enabled).collect();
+ sorted.sort_by_key(|l| l.effective_priority());
+
+ let mut values: HashMap = HashMap::new();
+ let mut tags: HashMap = HashMap::new();
+ let mut provenance: HashMap = HashMap::new();
+
+ for layer_config in &sorted {
+ for (k, v) in &layer_config.values {
+ values.insert(k.clone(), v.clone());
+ provenance.insert(k.clone(), layer_config.layer);
+ }
+ for (k, v) in &layer_config.tags {
+ tags.insert(k.clone(), v.clone());
+ }
+ }
+
+ Ok(MergedConfig { values, tags, provenance })
+ }
+
+ pub fn merge_with_guard(&self, tag_guard: &crate::config::tag::TagGuard) -> Result {
+ let merged = self.merge()?;
+ let tags: Vec = merged
+ .tags
+ .iter()
+ .map(|(k, v)| crate::config::tag::BusinessTag {
+ key: k.clone(),
+ value: v.clone(),
+ description: String::new(),
+ immutable: false,
+ })
+ .collect();
+ let base_tags: HashMap = HashMap::new();
+ let result = tag_guard.validate_and_collect(&tags, &base_tags);
+ if tag_guard.validator.has_blocking_violations(&result) {
+ let (blocked, violations, _total) = tag_guard.blocking_summary();
+ return Err(format!("Tag guard blocked config merge: {blocked} tags blocked, {violations} violations"));
+ }
+ Ok(merged)
+ }
+
+ pub fn validate(&self) -> Result<(), Vec> {
+ let mut errors = Vec::new();
+ let mut seen_keys: HashMap<&str, usize> = HashMap::new();
+
+ for (i, layer) in self.layers.iter().enumerate() {
+ if layer.name.is_empty() {
+ errors.push(format!("Layer at index {i} has empty name"));
+ }
+ if layer.values.is_empty() && layer.tags.is_empty() {
+ errors.push(format!("Layer '{}' ({}) has no values or tags", layer.name, layer.layer.label()));
+ }
+ for key in layer.values.keys() {
+ if let Some(prev) = seen_keys.get(key.as_str()) {
+ errors.push(format!("Key '{}' defined in multiple layers (index {prev} and {i})", key));
+ }
+ seen_keys.entry(key.as_str()).or_insert(i);
+ }
+ }
+
+ if errors.is_empty() {
+ Ok(())
+ } else {
+ Err(errors)
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn make_layer(layer: ConfigLayer, name: &str, key: &str, value: &str) -> LayerConfig {
+ let mut values = HashMap::new();
+ values.insert(key.to_string(), serde_json::Value::String(value.to_string()));
+ LayerConfig { layer, name: name.to_string(), values, enabled: true, ..Default::default() }
+ }
+
+ #[test]
+ fn test_layer_priority_order() {
+ assert!(ConfigLayer::Global.priority() < ConfigLayer::Team.priority());
+ assert!(ConfigLayer::Team.priority() < ConfigLayer::Project.priority());
+ assert!(ConfigLayer::Project.priority() < ConfigLayer::Env.priority());
+ assert!(ConfigLayer::Env.priority() < ConfigLayer::Task.priority());
+ }
+
+ #[test]
+ fn test_layer_label() {
+ assert_eq!(ConfigLayer::Global.label(), "global");
+ assert_eq!(ConfigLayer::Task.label(), "task");
+ }
+
+ #[test]
+ fn test_config_tree_merge_basic() {
+ let mut tree = ConfigTree::new();
+ tree.add_layer(make_layer(ConfigLayer::Global, "global-cfg", "host", "db-global"));
+ tree.add_layer(make_layer(ConfigLayer::Project, "proj-cfg", "host", "db-proj"));
+
+ let merged = tree.merge().unwrap();
+ assert_eq!(merged.values.get("host").unwrap(), &serde_json::Value::String("db-proj".to_string()));
+ assert_eq!(*merged.provenance.get("host").unwrap(), ConfigLayer::Project);
+ }
+
+ #[test]
+ fn test_config_tree_merge_lower_priority_does_not_override() {
+ let mut tree = ConfigTree::new();
+ tree.add_layer(make_layer(ConfigLayer::Project, "proj-cfg", "port", "5432"));
+ tree.add_layer(make_layer(ConfigLayer::Global, "global-cfg", "port", "3306"));
+
+ let merged = tree.merge().unwrap();
+ assert_eq!(merged.values.get("port").unwrap(), &serde_json::Value::String("5432".to_string()));
+ assert_eq!(*merged.provenance.get("port").unwrap(), ConfigLayer::Project);
+ }
+
+ #[test]
+ fn test_config_tree_merge_disabled_layer_ignored() {
+ let mut tree = ConfigTree::new();
+ let mut global = make_layer(ConfigLayer::Global, "global-cfg", "host", "db-global");
+ global.enabled = false;
+ tree.add_layer(global);
+ tree.add_layer(make_layer(ConfigLayer::Task, "task-cfg", "host", "db-task"));
+
+ let merged = tree.merge().unwrap();
+ assert_eq!(merged.values.get("host").unwrap(), &serde_json::Value::String("db-task".to_string()));
+ }
+
+ #[test]
+ fn test_config_tree_merge_distinct_keys() {
+ let mut tree = ConfigTree::new();
+ tree.add_layer(make_layer(ConfigLayer::Global, "g", "host", "g-host"));
+ tree.add_layer(make_layer(ConfigLayer::Team, "t", "port", "t-port"));
+
+ let merged = tree.merge().unwrap();
+ assert_eq!(merged.values.len(), 2);
+ assert!(merged.values.contains_key("host"));
+ assert!(merged.values.contains_key("port"));
+ }
+
+ #[test]
+ fn test_priority_override() {
+ let mut tree = ConfigTree::new();
+ let mut global = make_layer(ConfigLayer::Global, "override-cfg", "key", "val");
+ global.priority_override = Some(255);
+ tree.add_layer(global);
+ tree.add_layer(make_layer(ConfigLayer::Task, "task-cfg", "key", "task-val"));
+
+ let merged = tree.merge().unwrap();
+ assert_eq!(merged.values.get("key").unwrap(), &serde_json::Value::String("val".to_string()));
+ }
+
+ #[test]
+ fn test_validate_empty_name() {
+ let tree = ConfigTree {
+ layers: vec![LayerConfig {
+ layer: ConfigLayer::Global,
+ name: String::new(),
+ values: HashMap::from([("k".to_string(), serde_json::Value::String("v".to_string()))]),
+ ..Default::default()
+ }],
+ };
+ assert!(tree.validate().is_err());
+ }
+
+ #[test]
+ fn test_validate_empty_values_and_tags() {
+ let layer = LayerConfig {
+ layer: ConfigLayer::Global,
+ name: "empty".to_string(),
+ values: HashMap::new(),
+ tags: HashMap::new(),
+ ..Default::default()
+ };
+ let tree = ConfigTree { layers: vec![layer] };
+ let errs = tree.validate().unwrap_err();
+ assert!(errs.iter().any(|e| e.contains("empty")));
+ }
+
+ #[test]
+ fn test_effective_priority_default() {
+ let l = make_layer(ConfigLayer::Env, "env", "k", "v");
+ assert_eq!(l.effective_priority(), ConfigLayer::Env.priority());
+ }
+
+ #[test]
+ fn test_effective_priority_override() {
+ let mut l = make_layer(ConfigLayer::Global, "g", "k", "v");
+ l.priority_override = Some(100);
+ assert_eq!(l.effective_priority(), 100);
+ }
+
+ #[test]
+ fn test_all_layers() {
+ let all = ConfigLayer::all();
+ assert_eq!(all.len(), 5);
+ assert_eq!(all[0], ConfigLayer::Global);
+ assert_eq!(all[4], ConfigLayer::Task);
+ }
+}
diff --git a/crates/dbx-core/src/config/mod.rs b/crates/dbx-core/src/config/mod.rs
new file mode 100644
index 000000000..d3e58fb18
--- /dev/null
+++ b/crates/dbx-core/src/config/mod.rs
@@ -0,0 +1,160 @@
+pub mod expression;
+// governance disabled — storage methods not available at HEAD after main merge
+// pub mod governance;
+pub mod layer;
+pub mod tag;
+pub mod trace;
+
+pub use expression::{parse_expression, resolve_all_expressions_in_value, resolve_expression, Expression};
+// pub use governance::{ ... };
+pub use layer::{ConfigLayer, ConfigTree, LayerConfig, MergedConfig};
+pub use tag::{
+ BlockStats, BusinessTag, TagGuard, TagInheritanceWhitelist, TagPolicy, TagValidationResult, TagValidator,
+};
+pub use trace::{TraceEntry, TraceRingBuffer, TraceStats};
+
+#[cfg(test)]
+mod integration_tests {
+ use crate::config::*;
+ use crate::models::connection::DatabaseType;
+ use crate::schema_diff::SchemaDiffPreparationOptions;
+ use std::collections::HashMap;
+
+ #[test]
+ fn test_config_tree_with_schema_diff_options() {
+ let mut tree = ConfigTree::new();
+
+ let mut global_vals = HashMap::new();
+ global_vals.insert("target_schema".to_string(), serde_json::Value::String("public".to_string()));
+ global_vals.insert("ignore_comments".to_string(), serde_json::Value::Bool(true));
+ global_vals.insert("db_type".to_string(), serde_json::Value::String("postgres".to_string()));
+
+ tree.add_layer(LayerConfig {
+ layer: ConfigLayer::Global,
+ name: "defaults".to_string(),
+ values: global_vals,
+ tags: HashMap::from([("env".to_string(), "prod".to_string())]),
+ enabled: true,
+ ..Default::default()
+ });
+
+ tree.add_layer(LayerConfig {
+ layer: ConfigLayer::Task,
+ name: "task-override".to_string(),
+ values: HashMap::from([
+ ("cascade_delete".to_string(), serde_json::Value::Bool(true)),
+ ("compare_column_order".to_string(), serde_json::Value::String("${eval:true}".to_string())),
+ ]),
+ tags: HashMap::new(),
+ enabled: true,
+ ..Default::default()
+ });
+
+ let mut merged = tree.merge().unwrap();
+ let merged_snapshot = merged.clone();
+
+ let resolved: HashMap<_, _> = merged
+ .values
+ .iter()
+ .map(|(k, v)| {
+ let resolved = resolve_all_expressions_in_value(v, &merged.values)
+ .unwrap_or_else(|e| panic!("Failed to resolve expression for key '{k}': {e}"));
+ (k.clone(), resolved)
+ })
+ .collect();
+ merged.values.extend(resolved);
+
+ let db_val = merged.values.get("db_type").and_then(|v| v.as_str()).unwrap_or("mysql");
+ let database_type: DatabaseType = serde_json::from_str(&format!("\"{db_val}\"")).unwrap_or(DatabaseType::Mysql);
+
+ let opts = SchemaDiffPreparationOptions {
+ source_tables: vec![],
+ target_tables: vec![],
+ source_details: vec![],
+ target_details: vec![],
+ source_functions: vec![],
+ target_functions: vec![],
+ source_sequences: vec![],
+ target_sequences: vec![],
+ source_rules: vec![],
+ target_rules: vec![],
+ source_owners: vec![],
+ target_owners: vec![],
+ database_type,
+ target_schema: merged.values.get("target_schema").and_then(|v| v.as_str()).map(String::from),
+ ignore_comments: merged.values.get("ignore_comments").and_then(|v| v.as_bool()).unwrap_or(false),
+ cascade_delete: merged.values.get("cascade_delete").and_then(|v| v.as_bool()).unwrap_or(false),
+ compare_column_order: merged.values.get("compare_column_order").and_then(|v| v.as_bool()).unwrap_or(false),
+ ..Default::default()
+ };
+
+ assert_eq!(opts.database_type, DatabaseType::Postgres);
+ assert_eq!(opts.target_schema.as_deref(), Some("public"));
+ assert!(opts.ignore_comments);
+ assert!(opts.cascade_delete);
+ assert!(opts.compare_column_order);
+
+ let whitelist = TagInheritanceWhitelist::new(vec!["env".to_string()], TagPolicy::Strict);
+ let validator = TagValidator::new(whitelist, true);
+ let tags: Vec = merged_snapshot
+ .tags
+ .iter()
+ .map(|(k, v)| BusinessTag {
+ key: k.clone(),
+ value: v.clone(),
+ description: String::new(),
+ immutable: false,
+ })
+ .collect();
+ let result = validator.validate_tags(&tags, &HashMap::new());
+ assert_eq!(result.allowed.len(), 1);
+ assert_eq!(result.blocked.len(), 0);
+
+ let mut trace = TraceRingBuffer::new(100);
+ trace.record(ConfigLayer::Global, "target_schema", "read", "used for SchemaDiffPreparationOptions");
+ trace.record(ConfigLayer::Global, "db_type", "read", "used for DatabaseType");
+ trace.record(ConfigLayer::Task, "cascade_delete", "read", "overridden from task layer");
+ assert_eq!(trace.len(), 3);
+ }
+
+ #[test]
+ fn test_config_expression_with_value_injection() {
+ let mut tree = ConfigTree::new();
+
+ let mut global = HashMap::new();
+ global.insert("base_host".to_string(), serde_json::Value::String("db.example.com".to_string()));
+ global.insert("base_port".to_string(), serde_json::Value::Number(serde_json::Number::from(5432)));
+
+ tree.add_layer(LayerConfig {
+ layer: ConfigLayer::Global,
+ name: "global".to_string(),
+ values: global,
+ ..Default::default()
+ });
+
+ tree.add_layer(LayerConfig {
+ layer: ConfigLayer::Project,
+ name: "project".to_string(),
+ values: HashMap::from([
+ ("jdbc_url".to_string(), serde_json::Value::String("${eval:\"jdbc:postgresql://\"}".to_string())),
+ ("host".to_string(), serde_json::Value::String("${ref:base_host}".to_string())),
+ ]),
+ ..Default::default()
+ });
+
+ let merged = tree.merge().unwrap();
+ let scope = merged.values.clone();
+
+ let url_resolved = resolve_all_expressions_in_value(
+ &serde_json::Value::String("${eval:\"jdbc:postgresql://\"}".to_string()),
+ &scope,
+ )
+ .unwrap();
+ assert_eq!(url_resolved, serde_json::Value::String("jdbc:postgresql://".to_string()));
+
+ let host_resolved =
+ resolve_all_expressions_in_value(&serde_json::Value::String("${ref:base_host}".to_string()), &scope)
+ .unwrap();
+ assert_eq!(host_resolved, serde_json::Value::String("db.example.com".to_string()));
+ }
+}
diff --git a/crates/dbx-core/src/config/tag.rs b/crates/dbx-core/src/config/tag.rs
new file mode 100644
index 000000000..390fea5e7
--- /dev/null
+++ b/crates/dbx-core/src/config/tag.rs
@@ -0,0 +1,441 @@
+use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet};
+
+/// Controls how `TagInheritanceWhitelist` handles unlisted tags.
+///
+/// - `Allow` — all tags pass through by default; the whitelist is purely informational.
+/// - `Block` — only tags whose keys appear in `allowed_keys` pass through; unlisted tags
+/// are collected in `TagValidationResult::blocked` and count as blocking violations.
+/// - `Strict` — same key filtering as `Block`, but additionally checks that tag *values*
+/// match the base-layer values. Any value mismatch (or blocked key) is reported as a
+/// violation, and **all** violations (including value mismatches) count as blocking.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum TagPolicy {
+ #[default]
+ Allow,
+ Block,
+ Strict,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BusinessTag {
+ pub key: String,
+ pub value: String,
+
+ #[serde(default)]
+ pub description: String,
+
+ #[serde(default)]
+ pub immutable: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TagInheritanceWhitelist {
+ #[serde(default)]
+ pub allowed_keys: HashSet,
+
+ #[serde(default = "default_policy")]
+ pub default_policy: TagPolicy,
+}
+
+fn default_policy() -> TagPolicy {
+ TagPolicy::Block
+}
+
+impl Default for TagInheritanceWhitelist {
+ fn default() -> Self {
+ Self { allowed_keys: HashSet::new(), default_policy: TagPolicy::Block }
+ }
+}
+
+impl TagInheritanceWhitelist {
+ pub fn new(allowed: Vec, policy: TagPolicy) -> Self {
+ Self { allowed_keys: allowed.into_iter().collect(), default_policy: policy }
+ }
+
+ pub fn is_allowed(&self, key: &str) -> bool {
+ match self.default_policy {
+ TagPolicy::Allow => true,
+ TagPolicy::Block => self.allowed_keys.contains(key),
+ TagPolicy::Strict => self.allowed_keys.contains(key),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TagValidationResult {
+ pub allowed: Vec,
+ pub blocked: Vec,
+ pub violations: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct TagValidator {
+ pub whitelist: TagInheritanceWhitelist,
+ #[serde(default)]
+ pub strict_mode: bool,
+}
+
+impl TagValidator {
+ pub fn new(whitelist: TagInheritanceWhitelist, strict_mode: bool) -> Self {
+ Self { whitelist, strict_mode }
+ }
+
+ pub fn validate_tags(&self, tags: &[BusinessTag], base_tags: &HashMap) -> TagValidationResult {
+ let mut allowed = Vec::new();
+ let mut blocked = Vec::new();
+ let mut violations = Vec::new();
+
+ for tag in tags {
+ if !self.whitelist.is_allowed(&tag.key) {
+ blocked.push(tag.clone());
+ let msg = if self.strict_mode {
+ format!("BLOCKED: Tag '{}'='{}' is not in whitelist (strict mode)", tag.key, tag.value)
+ } else {
+ format!("BLOCKED: Tag '{}'='{}' is not in whitelist", tag.key, tag.value)
+ };
+ violations.push(msg);
+ continue;
+ }
+
+ if let Some(base_val) = base_tags.get(&tag.key) {
+ if tag.value != *base_val && self.strict_mode {
+ violations.push(format!(
+ "STRICT VIOLATION: Tag '{}'='{}' differs from base value '{}'",
+ tag.key, tag.value, base_val
+ ));
+ }
+ }
+
+ allowed.push(tag.clone());
+ }
+
+ TagValidationResult { allowed, blocked, violations }
+ }
+
+ pub fn has_blocking_violations(&self, result: &TagValidationResult) -> bool {
+ if self.strict_mode {
+ !result.violations.is_empty()
+ } else {
+ !result.blocked.is_empty()
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BlockStats {
+ pub total_tags: usize,
+ pub blocked_count: usize,
+ pub violation_count: usize,
+ pub by_key: HashMap,
+ pub strict_mode: bool,
+}
+
+impl BlockStats {
+ pub fn from_validation(result: &TagValidationResult, strict_mode: bool) -> Self {
+ let mut by_key = HashMap::new();
+ for tag in &result.blocked {
+ *by_key.entry(tag.key.clone()).or_insert(0) += 1;
+ }
+ Self {
+ total_tags: result.allowed.len() + result.blocked.len(),
+ blocked_count: result.blocked.len(),
+ violation_count: result.violations.len(),
+ by_key,
+ strict_mode,
+ }
+ }
+}
+
+pub struct TagGuard {
+ pub validator: TagValidator,
+ pub stats: std::sync::Mutex>,
+}
+
+impl TagGuard {
+ pub fn new(validator: TagValidator) -> Self {
+ Self { validator, stats: std::sync::Mutex::new(Vec::new()) }
+ }
+
+ pub fn validate_and_collect(
+ &self,
+ tags: &[BusinessTag],
+ base_tags: &HashMap,
+ ) -> TagValidationResult {
+ let result = self.validator.validate_tags(tags, base_tags);
+ let stats = BlockStats::from_validation(&result, self.validator.strict_mode);
+ if let Ok(mut guard) = self.stats.lock() {
+ guard.push(stats);
+ }
+ result
+ }
+
+ pub fn accumulated_stats(&self) -> Vec {
+ self.stats.lock().map(|g| g.clone()).unwrap_or_default()
+ }
+
+ pub fn blocking_summary(&self) -> (usize, usize, usize) {
+ let stats = self.accumulated_stats();
+ let total_blocked = stats.iter().map(|s| s.blocked_count).sum();
+ let total_violations = stats.iter().map(|s| s.violation_count).sum();
+ let total_tags = stats.iter().map(|s| s.total_tags).sum();
+ (total_blocked, total_violations, total_tags)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_allow_policy_allows_all() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Allow);
+ assert!(whitelist.is_allowed("anything"));
+ }
+
+ #[test]
+ fn test_block_policy_blocks_unlisted() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["allowed_key".to_string()], TagPolicy::Block);
+ assert!(whitelist.is_allowed("allowed_key"));
+ assert!(!whitelist.is_allowed("blocked_key"));
+ }
+
+ #[test]
+ fn test_strict_policy_blocks_unlisted() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["safe".to_string()], TagPolicy::Strict);
+ assert!(whitelist.is_allowed("safe"));
+ assert!(!whitelist.is_allowed("unsafe"));
+ }
+
+ #[test]
+ fn test_validator_allows_all_with_allow_policy() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Allow);
+ let validator = TagValidator::new(whitelist, false);
+
+ let tags = vec![BusinessTag {
+ key: "env".to_string(),
+ value: "prod".to_string(),
+ description: String::new(),
+ immutable: false,
+ }];
+ let base = HashMap::new();
+ let result = validator.validate_tags(&tags, &base);
+ assert_eq!(result.allowed.len(), 1);
+ assert_eq!(result.blocked.len(), 0);
+ }
+
+ #[test]
+ fn test_validator_blocks_unlisted_in_block_mode() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["allowed".to_string()], TagPolicy::Block);
+ let validator = TagValidator::new(whitelist, false);
+
+ let tags = vec![
+ BusinessTag {
+ key: "allowed".to_string(),
+ value: "yes".to_string(),
+ description: String::new(),
+ immutable: false,
+ },
+ BusinessTag {
+ key: "blocked".to_string(),
+ value: "no".to_string(),
+ description: String::new(),
+ immutable: false,
+ },
+ ];
+ let base = HashMap::new();
+ let result = validator.validate_tags(&tags, &base);
+ assert_eq!(result.allowed.len(), 1);
+ assert_eq!(result.blocked.len(), 1);
+ assert_eq!(result.blocked[0].key, "blocked");
+ }
+
+ #[test]
+ fn test_strict_mode_reports_value_mismatch() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["env".to_string()], TagPolicy::Strict);
+ let validator = TagValidator::new(whitelist, true);
+
+ let tags = vec![BusinessTag {
+ key: "env".to_string(),
+ value: "staging".to_string(),
+ description: String::new(),
+ immutable: false,
+ }];
+ let mut base = HashMap::new();
+ base.insert("env".to_string(), "prod".to_string());
+ let result = validator.validate_tags(&tags, &base);
+ assert_eq!(result.violations.len(), 1);
+ assert!(result.violations[0].contains("STRICT VIOLATION"));
+ }
+
+ #[test]
+ fn test_has_blocking_violations_standard_mode() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Block);
+ let validator = TagValidator::new(whitelist, false);
+
+ let result = TagValidationResult {
+ allowed: vec![],
+ blocked: vec![BusinessTag {
+ key: "x".to_string(),
+ value: "y".to_string(),
+ description: String::new(),
+ immutable: false,
+ }],
+ violations: vec![],
+ };
+ assert!(validator.has_blocking_violations(&result));
+ }
+
+ #[test]
+ fn test_has_blocking_violations_strict_mode() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Strict);
+ let validator = TagValidator::new(whitelist, true);
+
+ let result =
+ TagValidationResult { allowed: vec![], blocked: vec![], violations: vec!["STRICT VIOLATION".to_string()] };
+ assert!(validator.has_blocking_violations(&result));
+ }
+
+ #[test]
+ fn test_has_blocking_violations_no_violations() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Allow);
+ let validator = TagValidator::new(whitelist, false);
+
+ let result = TagValidationResult { allowed: vec![], blocked: vec![], violations: vec![] };
+ assert!(!validator.has_blocking_violations(&result));
+ }
+
+ #[test]
+ fn test_immutable_tag_field() {
+ let tag = BusinessTag {
+ key: "env".to_string(),
+ value: "prod".to_string(),
+ description: "Environment".to_string(),
+ immutable: true,
+ };
+ assert!(tag.immutable);
+ }
+
+ #[test]
+ fn block_stats_from_validation() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["allowed".to_string()], TagPolicy::Block);
+ let validator = TagValidator::new(whitelist, false);
+
+ let tags = vec![
+ BusinessTag {
+ key: "allowed".to_string(),
+ value: "yes".to_string(),
+ description: String::new(),
+ immutable: false,
+ },
+ BusinessTag {
+ key: "blocked1".to_string(),
+ value: "no".to_string(),
+ description: String::new(),
+ immutable: false,
+ },
+ BusinessTag {
+ key: "blocked2".to_string(),
+ value: "no".to_string(),
+ description: String::new(),
+ immutable: false,
+ },
+ ];
+ let base = HashMap::new();
+ let result = validator.validate_tags(&tags, &base);
+ let stats = BlockStats::from_validation(&result, false);
+ assert_eq!(stats.total_tags, 3);
+ assert_eq!(stats.blocked_count, 2);
+ assert_eq!(stats.violation_count, 2);
+ assert_eq!(stats.by_key.get("blocked1"), Some(&1usize));
+ assert_eq!(stats.by_key.get("blocked2"), Some(&1usize));
+ assert!(!stats.strict_mode);
+ }
+
+ #[test]
+ fn block_stats_with_strict_mode_violations() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["env".to_string()], TagPolicy::Strict);
+ let validator = TagValidator::new(whitelist, true);
+
+ let tags = vec![BusinessTag {
+ key: "env".to_string(),
+ value: "dev".to_string(),
+ description: String::new(),
+ immutable: false,
+ }];
+ let mut base = HashMap::new();
+ base.insert("env".to_string(), "prod".to_string());
+ let result = validator.validate_tags(&tags, &base);
+ let stats = BlockStats::from_validation(&result, true);
+ assert_eq!(stats.blocked_count, 0);
+ assert_eq!(stats.violation_count, 1);
+ assert!(stats.strict_mode);
+ }
+
+ #[test]
+ fn tag_guard_collects_multiple_validations() {
+ let whitelist = TagInheritanceWhitelist::new(vec!["env".to_string()], TagPolicy::Strict);
+ let validator = TagValidator::new(whitelist, true);
+ let guard = TagGuard::new(validator);
+
+ let tags1 = vec![BusinessTag {
+ key: "env".to_string(),
+ value: "staging".to_string(),
+ description: String::new(),
+ immutable: false,
+ }];
+ let mut base1 = HashMap::new();
+ base1.insert("env".to_string(), "prod".to_string());
+
+ let tags2 = vec![BusinessTag {
+ key: "blocked".to_string(),
+ value: "x".to_string(),
+ description: String::new(),
+ immutable: false,
+ }];
+
+ guard.validate_and_collect(&tags1, &base1);
+ guard.validate_and_collect(&tags2, &HashMap::new());
+
+ let stats = guard.accumulated_stats();
+ assert_eq!(stats.len(), 2);
+ assert_eq!(stats[0].violation_count, 1);
+ assert_eq!(stats[1].blocked_count, 1);
+
+ let (blocked, violations, total) = guard.blocking_summary();
+ assert_eq!(blocked, 1);
+ assert_eq!(violations, 2);
+ assert_eq!(total, 2);
+ }
+
+ #[test]
+ fn tag_guard_empty_stats() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Allow);
+ let validator = TagValidator::new(whitelist, false);
+ let guard = TagGuard::new(validator);
+
+ assert!(guard.accumulated_stats().is_empty());
+ let (blocked, violations, total) = guard.blocking_summary();
+ assert_eq!(blocked, 0);
+ assert_eq!(violations, 0);
+ assert_eq!(total, 0);
+ }
+
+ #[test]
+ fn tag_guard_blocking_with_strict_mode() {
+ let whitelist = TagInheritanceWhitelist::new(vec![], TagPolicy::Strict);
+ let validator = TagValidator::new(whitelist, true);
+ let guard = TagGuard::new(validator);
+
+ let tags = vec![BusinessTag {
+ key: "env".to_string(),
+ value: "dev".to_string(),
+ description: String::new(),
+ immutable: false,
+ }];
+ let result = guard.validate_and_collect(&tags, &HashMap::new());
+ assert_eq!(result.blocked.len(), 1);
+ assert!(guard.validator.has_blocking_violations(&result));
+ }
+}
diff --git a/crates/dbx-core/src/config/trace.rs b/crates/dbx-core/src/config/trace.rs
new file mode 100644
index 000000000..755ea49da
--- /dev/null
+++ b/crates/dbx-core/src/config/trace.rs
@@ -0,0 +1,273 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::VecDeque;
+
+use super::ConfigLayer;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceEntry {
+ pub timestamp: DateTime,
+ pub layer: ConfigLayer,
+ pub key: String,
+ pub action: String,
+ pub detail: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceRingBuffer {
+ capacity: usize,
+ entries: VecDeque,
+}
+
+impl TraceRingBuffer {
+ pub fn new(capacity: usize) -> Self {
+ Self { capacity, entries: VecDeque::with_capacity(capacity) }
+ }
+
+ pub fn push(&mut self, entry: TraceEntry) {
+ if self.entries.len() >= self.capacity {
+ self.entries.pop_front();
+ }
+ self.entries.push_back(entry);
+ }
+
+ pub fn record(&mut self, layer: ConfigLayer, key: &str, action: &str, detail: &str) {
+ self.push(TraceEntry {
+ timestamp: Utc::now(),
+ layer,
+ key: key.to_string(),
+ action: action.to_string(),
+ detail: detail.to_string(),
+ });
+ }
+
+ pub fn entries(&self) -> impl Iterator- {
+ self.entries.iter()
+ }
+
+ pub fn len(&self) -> usize {
+ self.entries.len()
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.entries.is_empty()
+ }
+
+ pub fn capacity(&self) -> usize {
+ self.capacity
+ }
+
+ pub fn clear(&mut self) {
+ self.entries.clear();
+ }
+
+ pub fn filter_by_layer(&self, layer: ConfigLayer) -> Vec<&TraceEntry> {
+ self.entries.iter().filter(|e| e.layer == layer).collect()
+ }
+
+ pub fn filter_by_action(&self, action: &str) -> Vec<&TraceEntry> {
+ self.entries.iter().filter(|e| e.action == action).collect()
+ }
+
+ pub fn export_json(&self) -> Result {
+ serde_json::to_string_pretty(&self.entries)
+ .map_err(|e| format!("Failed to serialize {} trace entries: {e}", self.entries.len()))
+ }
+
+ pub fn recent(&self, n: usize) -> Vec<&TraceEntry> {
+ let n = n.min(self.entries.len());
+ self.entries.iter().rev().take(n).collect()
+ }
+
+ pub fn stats(&self) -> TraceStats {
+ let mut action_counts: std::collections::HashMap = std::collections::HashMap::new();
+ let mut layer_counts: std::collections::HashMap = std::collections::HashMap::new();
+
+ for entry in &self.entries {
+ *action_counts.entry(entry.action.clone()).or_insert(0) += 1;
+ *layer_counts.entry(entry.layer.label().to_string()).or_insert(0) += 1;
+ }
+
+ TraceStats { total_entries: self.entries.len(), capacity: self.capacity, action_counts, layer_counts }
+ }
+}
+
+impl Default for TraceRingBuffer {
+ fn default() -> Self {
+ Self::new(1000)
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceStats {
+ pub total_entries: usize,
+ pub capacity: usize,
+ pub action_counts: std::collections::HashMap,
+ pub layer_counts: std::collections::HashMap,
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use chrono::TimeZone;
+
+ fn sample_entry() -> TraceEntry {
+ TraceEntry {
+ timestamp: Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap(),
+ layer: ConfigLayer::Global,
+ key: "host".to_string(),
+ action: "read".to_string(),
+ detail: "value resolved".to_string(),
+ }
+ }
+
+ #[test]
+ fn test_new_buffer_is_empty() {
+ let buf = TraceRingBuffer::new(10);
+ assert!(buf.is_empty());
+ assert_eq!(buf.len(), 0);
+ }
+
+ #[test]
+ fn test_push_adds_entry() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.push(sample_entry());
+ assert_eq!(buf.len(), 1);
+ }
+
+ #[test]
+ fn test_push_evicts_oldest_when_full() {
+ let mut buf = TraceRingBuffer::new(3);
+ for i in 0..5 {
+ buf.push(TraceEntry {
+ timestamp: Utc::now(),
+ layer: ConfigLayer::Task,
+ key: format!("key{i}"),
+ action: "write".to_string(),
+ detail: String::new(),
+ });
+ }
+ assert_eq!(buf.len(), 3);
+ let entries: Vec<&TraceEntry> = buf.entries().collect();
+ assert_eq!(entries[0].key, "key2");
+ assert_eq!(entries[2].key, "key4");
+ }
+
+ #[test]
+ fn test_record_convenience() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.record(ConfigLayer::Global, "host", "read", "localhost");
+ assert_eq!(buf.len(), 1);
+ let entry = buf.entries().next().unwrap();
+ assert_eq!(entry.layer, ConfigLayer::Global);
+ assert_eq!(entry.key, "host");
+ assert_eq!(entry.action, "read");
+ }
+
+ #[test]
+ fn test_filter_by_layer() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.record(ConfigLayer::Global, "host", "read", "");
+ buf.record(ConfigLayer::Project, "port", "write", "");
+ buf.record(ConfigLayer::Global, "user", "read", "");
+
+ let global_entries = buf.filter_by_layer(ConfigLayer::Global);
+ assert_eq!(global_entries.len(), 2);
+
+ let project_entries = buf.filter_by_layer(ConfigLayer::Project);
+ assert_eq!(project_entries.len(), 1);
+
+ let task_entries = buf.filter_by_layer(ConfigLayer::Task);
+ assert_eq!(task_entries.len(), 0);
+ }
+
+ #[test]
+ fn test_filter_by_action() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.record(ConfigLayer::Global, "host", "read", "");
+ buf.record(ConfigLayer::Global, "port", "write", "");
+ buf.record(ConfigLayer::Global, "user", "read", "");
+
+ let reads = buf.filter_by_action("read");
+ assert_eq!(reads.len(), 2);
+
+ let writes = buf.filter_by_action("write");
+ assert_eq!(writes.len(), 1);
+ }
+
+ #[test]
+ fn test_export_json() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.push(sample_entry());
+ let json = buf.export_json().unwrap();
+ assert!(json.contains("host"));
+ assert!(json.contains("read"));
+ }
+
+ #[test]
+ fn test_recent() {
+ let mut buf = TraceRingBuffer::new(10);
+ for i in 0..5 {
+ buf.record(ConfigLayer::Task, &format!("key{i}"), "write", "");
+ }
+ let recent = buf.recent(3);
+ assert_eq!(recent.len(), 3);
+ assert_eq!(recent[0].key, "key4");
+ assert_eq!(recent[2].key, "key2");
+ }
+
+ #[test]
+ fn test_recent_less_than_n() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.record(ConfigLayer::Task, "k1", "read", "");
+ let recent = buf.recent(10);
+ assert_eq!(recent.len(), 1);
+ }
+
+ #[test]
+ fn test_clear() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.record(ConfigLayer::Task, "k1", "read", "");
+ buf.record(ConfigLayer::Task, "k2", "write", "");
+ assert_eq!(buf.len(), 2);
+ buf.clear();
+ assert!(buf.is_empty());
+ }
+
+ #[test]
+ fn test_stats() {
+ let mut buf = TraceRingBuffer::new(100);
+ buf.record(ConfigLayer::Global, "host", "read", "");
+ buf.record(ConfigLayer::Global, "port", "read", "");
+ buf.record(ConfigLayer::Project, "config", "write", "");
+
+ let stats = buf.stats();
+ assert_eq!(stats.total_entries, 3);
+ assert_eq!(*stats.action_counts.get("read").unwrap(), 2);
+ assert_eq!(*stats.action_counts.get("write").unwrap(), 1);
+ assert_eq!(*stats.layer_counts.get("global").unwrap(), 2);
+ assert_eq!(*stats.layer_counts.get("project").unwrap(), 1);
+ }
+
+ #[test]
+ fn test_default_capacity() {
+ let buf = TraceRingBuffer::default();
+ assert_eq!(buf.capacity(), 1000);
+ }
+
+ #[test]
+ fn test_capacity_set_correctly() {
+ let buf = TraceRingBuffer::new(500);
+ assert_eq!(buf.capacity(), 500);
+ }
+
+ #[test]
+ fn test_entry_timestamp_is_set() {
+ let mut buf = TraceRingBuffer::new(10);
+ buf.record(ConfigLayer::Task, "k", "read", "detail");
+ let entry = buf.entries().next().unwrap();
+ let now = Utc::now();
+ let diff = now - entry.timestamp;
+ assert!(diff.num_seconds() < 5);
+ }
+}
diff --git a/crates/dbx-core/src/correction.rs b/crates/dbx-core/src/correction.rs
new file mode 100644
index 000000000..17497ace0
--- /dev/null
+++ b/crates/dbx-core/src/correction.rs
@@ -0,0 +1,659 @@
+use serde::{Deserialize, Serialize};
+
+use crate::data_compare::{DataCompareFromTablesPreparation, DataCompareResult};
+use crate::schema_diff::SchemaDiffPreparation;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum CorrectionStepType {
+ SchemaCreate,
+ SchemaAlter,
+ SchemaDrop,
+ DataInsert,
+ DataUpdate,
+ DataDelete,
+ SchemaPostSync,
+ Checkpoint,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CorrectionStep {
+ pub step_type: CorrectionStepType,
+ pub table_name: Option,
+ pub sql: String,
+ pub rollback_sql: Option,
+ pub description: String,
+ pub risk_level: CorrectionRiskLevel,
+ #[serde(default)]
+ pub depends_on: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub enum CorrectionRiskLevel {
+ Safe,
+ #[default]
+ Caution,
+ Dangerous,
+ Blocked,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum CorrectionStrategy {
+ StructureFirst,
+ DataFirst,
+ Interleaved,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JointCorrectionPlan {
+ pub strategy: CorrectionStrategy,
+ pub steps: Vec,
+ pub schema_diff_count: usize,
+ pub data_diff_count: usize,
+ pub total_estimated_duration_secs: Option,
+ #[serde(default)]
+ pub rollback_steps: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JointCorrectionOptions {
+ pub strategy: CorrectionStrategy,
+ #[serde(default)]
+ pub include_checkpoints: bool,
+ #[serde(default)]
+ pub include_rollback: bool,
+}
+
+impl Default for JointCorrectionOptions {
+ fn default() -> Self {
+ Self { strategy: CorrectionStrategy::StructureFirst, include_checkpoints: true, include_rollback: true }
+ }
+}
+
+/// Build a joint correction plan from schema diff and data compare results.
+///
+/// Orchestrates schema + data changes according to `CorrectionStrategy`:
+/// - `StructureFirst`: schema → data → post-sync checks
+/// - `DataFirst`: data → schema
+/// - `Interleaved`: per-table schema + data interleaved
+///
+/// # Limitations
+/// - `Interleaved` uses placeholder SQL rather than actual per-table DDL slices.
+/// - Table name matching uses substring checks (`line.contains(&name)`), which can
+/// produce false positives when one table name is a prefix of another.
+pub fn build_joint_correction_plan(
+ schema_diff: Option<&SchemaDiffPreparation>,
+ data_compare: Option<&DataCompareFromTablesPreparation>,
+ options: JointCorrectionOptions,
+) -> JointCorrectionPlan {
+ let mut steps = Vec::new();
+ let mut rollback_steps = Vec::new();
+ let mut step_index = 0usize;
+
+ match options.strategy {
+ CorrectionStrategy::StructureFirst => {
+ step_index = append_schema_steps(schema_diff, &mut steps, &mut rollback_steps, &options, step_index);
+ let _ = append_data_steps(data_compare, &mut steps, &mut rollback_steps, &options, step_index);
+ }
+ CorrectionStrategy::DataFirst => {
+ step_index = append_data_steps(data_compare, &mut steps, &mut rollback_steps, &options, step_index);
+ let _ = append_schema_steps(schema_diff, &mut steps, &mut rollback_steps, &options, step_index);
+ }
+ CorrectionStrategy::Interleaved => {
+ if let Some(schema) = schema_diff {
+ let table_diffs: Vec<_> = schema.diffs.iter().filter(|d| d.diff_type != "unchanged").collect();
+
+ for table_diff in &table_diffs {
+ let tbl_name = &table_diff.name;
+
+ if let Some(dc) = data_compare {
+ if contains_table(&dc.sync_sql, tbl_name) {
+ step_index = append_table_data_step(
+ &dc.result,
+ tbl_name,
+ &mut steps,
+ &mut rollback_steps,
+ &options,
+ step_index,
+ );
+ }
+ }
+
+ step_index = append_table_schema_step(
+ table_diff,
+ tbl_name,
+ &mut steps,
+ &mut rollback_steps,
+ &options,
+ step_index,
+ );
+ }
+ } else if let Some(dc) = data_compare {
+ let _ = append_data_steps(Some(dc), &mut steps, &mut rollback_steps, &options, step_index);
+ }
+ }
+ }
+
+ let schema_diff_count = steps
+ .iter()
+ .filter(|s| {
+ matches!(
+ s.step_type,
+ CorrectionStepType::SchemaCreate
+ | CorrectionStepType::SchemaAlter
+ | CorrectionStepType::SchemaDrop
+ | CorrectionStepType::SchemaPostSync
+ )
+ })
+ .count();
+ let data_diff_count = steps
+ .iter()
+ .filter(|s| {
+ matches!(
+ s.step_type,
+ CorrectionStepType::DataInsert | CorrectionStepType::DataUpdate | CorrectionStepType::DataDelete
+ )
+ })
+ .count();
+
+ JointCorrectionPlan {
+ strategy: options.strategy,
+ steps,
+ schema_diff_count,
+ data_diff_count,
+ total_estimated_duration_secs: None,
+ rollback_steps,
+ }
+}
+
+fn append_schema_steps(
+ schema_diff: Option<&SchemaDiffPreparation>,
+ steps: &mut Vec,
+ _rollback_steps: &mut Vec,
+ options: &JointCorrectionOptions,
+ mut step_index: usize,
+) -> usize {
+ let Some(schema) = schema_diff else {
+ return step_index;
+ };
+
+ if schema.sync_sql.is_empty() {
+ return step_index;
+ }
+
+ if options.include_checkpoints {
+ steps.push(CorrectionStep {
+ step_type: CorrectionStepType::Checkpoint,
+ table_name: None,
+ sql: String::new(),
+ rollback_sql: None,
+ description: "Schema correction checkpoint".to_string(),
+ risk_level: CorrectionRiskLevel::Safe,
+ depends_on: Vec::new(),
+ });
+ step_index += 1;
+ }
+
+ let table_diffs: Vec<_> = schema.diffs.iter().filter(|d| d.diff_type != "unchanged").collect();
+
+ for table_diff in &table_diffs {
+ let tbl_name = &table_diff.name;
+ step_index = append_table_schema_step(table_diff, tbl_name, steps, _rollback_steps, options, step_index);
+ }
+
+ step_index
+}
+
+fn append_table_schema_step(
+ table_diff: &crate::schema_diff::TableDiff,
+ tbl_name: &str,
+ steps: &mut Vec,
+ rollback_steps: &mut Vec,
+ options: &JointCorrectionOptions,
+ mut step_index: usize,
+) -> usize {
+ let step_type = match table_diff.diff_type.as_str() {
+ "added" => CorrectionStepType::SchemaCreate,
+ "removed" => CorrectionStepType::SchemaDrop,
+ _ => CorrectionStepType::SchemaAlter,
+ };
+
+ let risk_level = match table_diff.diff_type.as_str() {
+ "removed" => CorrectionRiskLevel::Dangerous,
+ "modified" => CorrectionRiskLevel::Caution,
+ _ => CorrectionRiskLevel::Safe,
+ };
+
+ let has_incomplete_triggers = table_diff
+ .triggers
+ .as_ref()
+ .is_some_and(|triggers| triggers.iter().any(|t| t.source.as_ref().is_some_and(|s| s.statement.is_none())));
+
+ let rollback_sql = if options.include_rollback {
+ match table_diff.diff_type.as_str() {
+ "added" => Some(format!("DROP TABLE IF EXISTS {};", tbl_name)),
+ "removed" => {
+ table_diff.target_ddl.as_ref().map(|ddl| {
+ if has_incomplete_triggers {
+ format!(
+ "-- WARNING: Rollback DDL is INCOMPLETE — trigger bodies could not be reconstructed.\n-- Manual review required. Original DDL:\n{}",
+ ddl
+ )
+ } else {
+ ddl.clone()
+ }
+ }).or_else(|| {
+ if has_incomplete_triggers {
+ Some(format!(
+ "-- WARNING: Rollback is INCOMPLETE — table '{}' had triggers that cannot be reconstructed.\n-- Manual intervention required before executing.",
+ tbl_name
+ ))
+ } else {
+ Some(format!(
+ "-- Manual rollback required: recreate table {} with original DDL",
+ tbl_name
+ ))
+ }
+ })
+ }
+ "modified" => table_diff.sync_sql.as_ref().map(|s| format!("-- Rollback: {}", s)),
+ _ => None,
+ }
+ } else {
+ None
+ };
+
+ let rollback_risk = if has_incomplete_triggers { CorrectionRiskLevel::Blocked } else { risk_level.clone() };
+
+ let rollback_desc = if has_incomplete_triggers {
+ format!(
+ "INCOMPLETE Rollback for schema {} on table: {tbl_name} — trigger bodies cannot be reconstructed",
+ table_diff.diff_type
+ )
+ } else {
+ format!("Rollback for schema {} on table: {tbl_name}", table_diff.diff_type)
+ };
+
+ let sql = table_diff.sync_sql.clone().unwrap_or_else(|| format!("-- Schema change for table: {tbl_name}"));
+
+ steps.push(CorrectionStep {
+ step_type,
+ table_name: Some(tbl_name.to_string()),
+ sql,
+ rollback_sql: rollback_sql.clone(),
+ description: format!("Schema {} for table: {tbl_name}", table_diff.diff_type),
+ risk_level,
+ depends_on: Vec::new(),
+ });
+
+ if let Some(rollback) = rollback_sql {
+ rollback_steps.push(CorrectionStep {
+ step_type: match table_diff.diff_type.as_str() {
+ "added" => CorrectionStepType::SchemaDrop,
+ "removed" => CorrectionStepType::SchemaCreate,
+ _ => CorrectionStepType::SchemaAlter,
+ },
+ table_name: Some(tbl_name.to_string()),
+ sql: rollback,
+ rollback_sql: None,
+ description: rollback_desc,
+ risk_level: rollback_risk,
+ depends_on: Vec::new(),
+ });
+ }
+
+ step_index += 1;
+
+ step_index
+}
+
+fn append_data_steps(
+ data_compare: Option<&DataCompareFromTablesPreparation>,
+ steps: &mut Vec,
+ _rollback_steps: &mut Vec,
+ options: &JointCorrectionOptions,
+ mut step_index: usize,
+) -> usize {
+ let Some(dc) = data_compare else {
+ return step_index;
+ };
+
+ if dc.result.added.is_empty() && dc.result.removed.is_empty() && dc.result.modified.is_empty() {
+ return step_index;
+ }
+
+ if options.include_checkpoints {
+ steps.push(CorrectionStep {
+ step_type: CorrectionStepType::Checkpoint,
+ table_name: None,
+ sql: String::new(),
+ rollback_sql: None,
+ description: "Data correction checkpoint".to_string(),
+ risk_level: CorrectionRiskLevel::Safe,
+ depends_on: Vec::new(),
+ });
+ step_index += 1;
+ }
+
+ for statement in &dc.sync_statements {
+ let (step_type, description) = if statement.to_uppercase().starts_with("INSERT") {
+ (CorrectionStepType::DataInsert, format!("Insert data: {}", summary(statement, 80)))
+ } else if statement.to_uppercase().starts_with("UPDATE") {
+ (CorrectionStepType::DataUpdate, format!("Update data: {}", summary(statement, 80)))
+ } else if statement.to_uppercase().starts_with("DELETE") {
+ (CorrectionStepType::DataDelete, format!("Delete data: {}", summary(statement, 80)))
+ } else {
+ (CorrectionStepType::SchemaPostSync, format!("Pre-sync: {}", summary(statement, 80)))
+ };
+
+ let rollback_sql = if options.include_rollback {
+ if statement.to_uppercase().starts_with("INSERT") {
+ Some(format!("-- Rollback: DELETE matching rows; manual review needed: {}", summary(statement, 60)))
+ } else if statement.to_uppercase().starts_with("DELETE") {
+ Some(format!("-- Rollback: INSERT deleted rows; manual review needed: {}", summary(statement, 60)))
+ } else if statement.to_uppercase().starts_with("UPDATE") {
+ Some(format!("-- Rollback: reverse UPDATE; manual review needed: {}", summary(statement, 60)))
+ } else {
+ None
+ }
+ } else {
+ None
+ };
+
+ steps.push(CorrectionStep {
+ step_type,
+ table_name: None,
+ sql: statement.clone(),
+ rollback_sql,
+ description,
+ risk_level: CorrectionRiskLevel::Caution,
+ depends_on: Vec::new(),
+ });
+ step_index += 1;
+ }
+
+ step_index
+}
+
+fn append_table_data_step(
+ data_prep: &DataCompareResult,
+ tbl_name: &str,
+ steps: &mut Vec,
+ _rollback_steps: &mut Vec,
+ _options: &JointCorrectionOptions,
+ mut step_index: usize,
+) -> usize {
+ let total = data_prep.added.len() + data_prep.modified.len() + data_prep.removed.len();
+ if total == 0 {
+ return step_index;
+ }
+
+ steps.push(CorrectionStep {
+ step_type: CorrectionStepType::DataInsert,
+ table_name: Some(tbl_name.to_string()),
+ sql: format!(
+ "-- Data sync for table: {tbl_name} ({} added, {} modified, {} removed)",
+ data_prep.added.len(),
+ data_prep.modified.len(),
+ data_prep.removed.len()
+ ),
+ rollback_sql: None,
+ description: format!(
+ "Data sync for table: {tbl_name} ({} added, {} modified, {} removed)",
+ data_prep.added.len(),
+ data_prep.modified.len(),
+ data_prep.removed.len()
+ ),
+ risk_level: CorrectionRiskLevel::Caution,
+ depends_on: Vec::new(),
+ });
+ step_index += 1;
+
+ step_index
+}
+
+fn contains_table(sync_sql: &str, table_name: &str) -> bool {
+ sync_sql.contains(table_name)
+}
+
+fn summary(text: &str, max_len: usize) -> String {
+ let cleaned = text.replace('\n', " ");
+ if cleaned.len() <= max_len {
+ cleaned
+ } else {
+ format!("{}...", &cleaned[..max_len.min(cleaned.len())])
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::data_compare::{
+ DataCompareChangedCell, DataCompareFromTablesPreparation, DataCompareModifiedRow, DataCompareResult,
+ DataCompareRow,
+ };
+ use crate::schema_diff::{SchemaDiffPreparation, TableDiff};
+ use serde_json::json;
+ use std::collections::HashMap;
+
+ fn sample_table_diff(diff_type: &str, name: &str) -> TableDiff {
+ TableDiff {
+ diff_type: diff_type.to_string(),
+ object_type: Some("table".to_string()),
+ name: name.to_string(),
+ columns: None,
+ indexes: None,
+ foreign_keys: None,
+ triggers: None,
+ ddl: None,
+ target_ddl: None,
+ source_table_comment: None,
+ target_table_comment: None,
+ sync_sql: Some(format!("-- SQL for {name}")),
+ }
+ }
+
+ fn sample_schema_preparation() -> SchemaDiffPreparation {
+ SchemaDiffPreparation {
+ diffs: vec![sample_table_diff("added", "users"), sample_table_diff("modified", "orders")],
+ sync_sql: "-- Schema sync SQL for users\n-- Schema sync SQL for orders".to_string(),
+ function_diffs: Vec::new(),
+ sequence_diffs: Vec::new(),
+ rule_diffs: Vec::new(),
+ owner_diffs: Vec::new(),
+ rollback_sync_sql: Some("-- Rollback SQL".to_string()),
+ rollback_completeness: crate::schema_diff::RollbackCompleteness::Complete,
+ missing_rollback_objects: Vec::new(),
+ rename_candidates: Vec::new(),
+ rollback_graph: None,
+ compatibility_warnings: Vec::new(),
+ permission_diffs: Vec::new(),
+ permission_sync_sql: None,
+ dependency_graph: None,
+ }
+ }
+
+ fn sample_data_preparation() -> DataCompareFromTablesPreparation {
+ DataCompareFromTablesPreparation {
+ result: DataCompareResult {
+ added: vec![DataCompareRow {
+ key: "1".to_string(),
+ key_values: HashMap::from([("id".to_string(), json!(1))]),
+ values: HashMap::from([("id".to_string(), json!(1)), ("name".to_string(), json!("Ada"))]),
+ }],
+ removed: vec![],
+ modified: vec![DataCompareModifiedRow {
+ key: "2".to_string(),
+ key_values: HashMap::from([("id".to_string(), json!(2))]),
+ source_values: HashMap::new(),
+ target_values: HashMap::new(),
+ changes: vec![DataCompareChangedCell {
+ column: "name".to_string(),
+ source: json!("Bob"),
+ target: json!("Bobby"),
+ }],
+ }],
+ },
+ sync_statements: vec![
+ "INSERT INTO \"public\".\"users\" (\"id\", \"name\") VALUES (1, 'Ada');".to_string(),
+ "UPDATE \"public\".\"users\" SET \"name\" = 'Bob' WHERE \"id\" = 2;".to_string(),
+ ],
+ sync_sql: "INSERT INTO \"public\".\"users\" (\"id\", \"name\") VALUES (1, 'Ada');\n\
+ UPDATE \"public\".\"users\" SET \"name\" = 'Bob' WHERE \"id\" = 2;"
+ .to_string(),
+ pre_sync_statements: vec![],
+ source_row_count: 2,
+ target_row_count: 2,
+ source_truncated: false,
+ target_truncated: false,
+ degradation_level: Some("full".to_string()),
+ sampling_rate: Some(1.0),
+ confidence_score: Some(1.0),
+ verification_method: Some("full_compare".to_string()),
+ source_checksums: None,
+ target_checksums: None,
+ }
+ }
+
+ #[test]
+ fn builds_structure_first_correction_plan() {
+ let schema = sample_schema_preparation();
+ let data = sample_data_preparation();
+ let plan = build_joint_correction_plan(
+ Some(&schema),
+ Some(&data),
+ JointCorrectionOptions {
+ strategy: CorrectionStrategy::StructureFirst,
+ include_checkpoints: true,
+ include_rollback: true,
+ },
+ );
+
+ assert_eq!(plan.strategy, CorrectionStrategy::StructureFirst);
+ assert!(plan.schema_diff_count > 0);
+ assert!(plan.data_diff_count > 0);
+
+ let first_data_idx = plan.steps.iter().position(|s| {
+ matches!(
+ s.step_type,
+ CorrectionStepType::DataInsert | CorrectionStepType::DataUpdate | CorrectionStepType::DataDelete
+ )
+ });
+
+ let last_schema_idx = plan.steps.iter().rposition(|s| {
+ matches!(
+ s.step_type,
+ CorrectionStepType::SchemaCreate | CorrectionStepType::SchemaAlter | CorrectionStepType::SchemaDrop
+ )
+ });
+
+ if let (Some(si), Some(di)) = (last_schema_idx, first_data_idx) {
+ assert!(si < di, "Schema steps should come before data steps in StructureFirst strategy");
+ }
+ }
+
+ #[test]
+ fn builds_data_first_correction_plan() {
+ let schema = sample_schema_preparation();
+ let data = sample_data_preparation();
+ let plan = build_joint_correction_plan(
+ Some(&schema),
+ Some(&data),
+ JointCorrectionOptions {
+ strategy: CorrectionStrategy::DataFirst,
+ include_checkpoints: true,
+ include_rollback: true,
+ },
+ );
+
+ assert_eq!(plan.strategy, CorrectionStrategy::DataFirst);
+ assert!(plan
+ .steps
+ .iter()
+ .any(|s| matches!(s.step_type, CorrectionStepType::DataInsert | CorrectionStepType::DataUpdate)));
+ assert!(plan
+ .steps
+ .iter()
+ .any(|s| matches!(s.step_type, CorrectionStepType::SchemaCreate | CorrectionStepType::SchemaAlter)));
+ }
+
+ #[test]
+ fn builds_interleaved_correction_plan() {
+ let schema = sample_schema_preparation();
+ let data = sample_data_preparation();
+ let plan = build_joint_correction_plan(
+ Some(&schema),
+ Some(&data),
+ JointCorrectionOptions {
+ strategy: CorrectionStrategy::Interleaved,
+ include_checkpoints: true,
+ include_rollback: true,
+ },
+ );
+
+ assert_eq!(plan.strategy, CorrectionStrategy::Interleaved);
+ assert!(!plan.steps.is_empty());
+ }
+
+ #[test]
+ fn handles_missing_schema_diff() {
+ let data = sample_data_preparation();
+ let plan = build_joint_correction_plan(None, Some(&data), JointCorrectionOptions::default());
+
+ assert_eq!(plan.schema_diff_count, 0);
+ assert!(plan.data_diff_count > 0);
+ }
+
+ #[test]
+ fn handles_missing_data_compare() {
+ let schema = sample_schema_preparation();
+ let plan = build_joint_correction_plan(Some(&schema), None, JointCorrectionOptions::default());
+
+ assert!(plan.schema_diff_count > 0);
+ assert_eq!(plan.data_diff_count, 0);
+ }
+
+ #[test]
+ fn handles_empty_input() {
+ let plan = build_joint_correction_plan(None, None, JointCorrectionOptions::default());
+
+ assert_eq!(plan.steps.len(), 0);
+ assert_eq!(plan.schema_diff_count, 0);
+ assert_eq!(plan.data_diff_count, 0);
+ }
+
+ #[test]
+ fn correction_step_serialization() {
+ let step = CorrectionStep {
+ step_type: CorrectionStepType::SchemaCreate,
+ table_name: Some("public.users".to_string()),
+ sql: "CREATE TABLE ...".to_string(),
+ rollback_sql: Some("DROP TABLE ...".to_string()),
+ description: "Create users table".to_string(),
+ risk_level: CorrectionRiskLevel::Safe,
+ depends_on: vec![0],
+ };
+
+ let json = serde_json::to_string(&step).expect("serialization should succeed");
+ let deserialized: CorrectionStep = serde_json::from_str(&json).expect("deserialization should succeed");
+
+ assert_eq!(deserialized.step_type, CorrectionStepType::SchemaCreate);
+ assert_eq!(deserialized.table_name, Some("public.users".to_string()));
+ assert_eq!(deserialized.risk_level, CorrectionRiskLevel::Safe);
+ }
+
+ #[test]
+ fn joint_correction_plan_serialization() {
+ let schema = sample_schema_preparation();
+ let data = sample_data_preparation();
+ let plan = build_joint_correction_plan(Some(&schema), Some(&data), JointCorrectionOptions::default());
+
+ let json = serde_json::to_string(&plan).expect("serialization should succeed");
+ assert!(json.contains("structureFirst") || json.contains("StructureFirst"));
+ }
+}
diff --git a/crates/dbx-core/src/data_compare.rs b/crates/dbx-core/src/data_compare.rs
index 6170ede42..5b627e9dd 100644
--- a/crates/dbx-core/src/data_compare.rs
+++ b/crates/dbx-core/src/data_compare.rs
@@ -3,6 +3,7 @@ use std::collections::{HashMap, HashSet};
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use serde_json::Value;
+use sha2::{Digest, Sha256};
use crate::connection::AppState;
use crate::data_grid_sql::{format_grid_sql_literal as format_data_grid_sql_literal, DataGridColumnInfo};
@@ -62,6 +63,12 @@ pub struct DataCompareFromTablesOptions {
pub key_columns: Vec,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fetch_batch_size: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub degradation_threshold: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub sampling_strategy: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub enable_checksum: Option,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -170,6 +177,112 @@ pub struct DataCompareFromTablesPreparation {
pub target_row_count: u64,
pub source_truncated: bool,
pub target_truncated: bool,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub degradation_level: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub sampling_rate: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub confidence_score: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub verification_method: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub source_checksums: Option>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub target_checksums: Option>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum DegradationLevel {
+ Full,
+ Sample,
+ SkipWithRisk,
+}
+
+impl std::fmt::Display for DegradationLevel {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ DegradationLevel::Full => write!(f, "full"),
+ DegradationLevel::Sample => write!(f, "sample"),
+ DegradationLevel::SkipWithRisk => write!(f, "skip_with_risk"),
+ }
+ }
+}
+
+impl TryFrom<&str> for DegradationLevel {
+ type Error = String;
+ fn try_from(s: &str) -> Result {
+ match s {
+ "full" => Ok(DegradationLevel::Full),
+ "sample" => Ok(DegradationLevel::Sample),
+ "skip_with_risk" => Ok(DegradationLevel::SkipWithRisk),
+ _ => Err(format!("Unknown degradation level: {s}")),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum SamplingStrategy {
+ Random,
+ ExtremeValues,
+ Hybrid,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DegradationThreshold {
+ pub full_compare_max_rows: u64,
+ pub sample_max_rows: u64,
+ pub sample_size: usize,
+ pub extreme_sample_count: usize,
+}
+
+impl Default for DegradationThreshold {
+ fn default() -> Self {
+ Self {
+ full_compare_max_rows: 100_000,
+ sample_max_rows: 10_000_000,
+ sample_size: 10_000,
+ extreme_sample_count: 500,
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VerifyDataOptions {
+ pub source_connection_id: String,
+ pub source_database: String,
+ pub source_schema: String,
+ pub source_table: String,
+ pub target_connection_id: String,
+ pub target_database: String,
+ pub target_schema: String,
+ pub target_table: String,
+ pub columns: Vec,
+ pub key_columns: Vec,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub fetch_batch_size: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub degradation_threshold: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub sampling_strategy: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub enable_checksum: Option,
+}
+
+/// Result of a full verification pass including statistical metadata.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VerifyDataResult {
+ pub preparation: DataCompareFromTablesPreparation,
+ pub degradation_level: DegradationLevel,
+ pub sampling_rate: f64,
+ pub confidence_score: f64,
+ pub row_count_match: bool,
+ pub checksums_match: Option,
+ pub verification_method: String,
}
pub fn prepare_data_compare(options: DataComparePreparationOptions) -> Result {
@@ -238,30 +351,74 @@ pub async fn prepare_data_compare_from_tables(
let source_row_count = first_count(&source_count_result.rows)?;
let target_row_count = first_count(&target_count_result.rows)?;
- let (source_rows, target_rows) = tokio::try_join!(
- fetch_compare_rows(
- state,
- &options.source_connection_id,
- &options.source_database,
- &options.source_schema,
- &options.source_table,
- &options.columns,
- &options.key_columns,
- source_database_type,
- fetch_batch_size,
- ),
- fetch_compare_rows(
- state,
- &options.target_connection_id,
- &options.target_database,
- &options.target_schema,
- &options.target_table,
- &options.columns,
- &options.key_columns,
- target_database_type,
- fetch_batch_size,
- )
- )?;
+ let threshold = options.degradation_threshold.clone().unwrap_or_default();
+ let degradation_level = should_degrade(source_row_count, target_row_count, &threshold);
+ let sampling_strategy = options.sampling_strategy.clone().unwrap_or(SamplingStrategy::Hybrid);
+ let enable_checksum = options.enable_checksum.unwrap_or(true);
+
+ let (source_rows, target_rows, sampling_rate, verification_method) = match °radation_level {
+ DegradationLevel::Full => {
+ let (src, tgt) = tokio::try_join!(
+ fetch_compare_rows(
+ state,
+ &options.source_connection_id,
+ &options.source_database,
+ &options.source_schema,
+ &options.source_table,
+ &options.columns,
+ &options.key_columns,
+ source_database_type,
+ fetch_batch_size,
+ ),
+ fetch_compare_rows(
+ state,
+ &options.target_connection_id,
+ &options.target_database,
+ &options.target_schema,
+ &options.target_table,
+ &options.columns,
+ &options.key_columns,
+ target_database_type,
+ fetch_batch_size,
+ )
+ )?;
+ (src, tgt, 1.0, "full_compare".to_string())
+ }
+ DegradationLevel::Sample => {
+ let (src, tgt) = tokio::try_join!(
+ fetch_sampled_compare_rows(
+ state,
+ &options.source_connection_id,
+ &options.source_database,
+ &options.source_schema,
+ &options.source_table,
+ &options.columns,
+ &options.key_columns,
+ source_database_type,
+ &sampling_strategy,
+ threshold.sample_size,
+ ),
+ fetch_sampled_compare_rows(
+ state,
+ &options.target_connection_id,
+ &options.target_database,
+ &options.target_schema,
+ &options.target_table,
+ &options.columns,
+ &options.key_columns,
+ target_database_type,
+ &sampling_strategy,
+ threshold.sample_size,
+ )
+ )?;
+ let max_count = source_row_count.max(target_row_count);
+ let sample_rate = if max_count > 0 { threshold.sample_size as f64 / max_count as f64 } else { 1.0 };
+ let method = "sampled".to_string();
+ (src, tgt, sample_rate.min(1.0), method)
+ }
+ DegradationLevel::SkipWithRisk => (Vec::new(), Vec::new(), 0.0, "skipped".to_string()),
+ };
+
let target_columns = get_columns_core(
state,
&options.target_connection_id,
@@ -271,6 +428,21 @@ pub async fn prepare_data_compare_from_tables(
)
.await?;
+ let source_checksums = if enable_checksum && !source_rows.is_empty() {
+ Some(compute_column_checksums(&options.columns, &source_rows))
+ } else {
+ None
+ };
+ let target_checksums = if enable_checksum && !target_rows.is_empty() {
+ Some(compute_column_checksums(&options.columns, &target_rows))
+ } else {
+ None
+ };
+
+ let row_count_match = source_row_count == target_row_count;
+ let confidence_score =
+ compute_confidence(sampling_rate, °radation_level, row_count_match, source_row_count, target_row_count);
+
let preparation = prepare_data_compare(DataComparePreparationOptions {
table_name: options.target_table,
schema: Some(options.target_schema),
@@ -291,6 +463,12 @@ pub async fn prepare_data_compare_from_tables(
target_row_count,
source_truncated: false,
target_truncated: false,
+ degradation_level: Some(degradation_level.to_string()),
+ sampling_rate: Some(sampling_rate),
+ confidence_score: Some(confidence_score),
+ verification_method: Some(verification_method),
+ source_checksums,
+ target_checksums,
})
}
@@ -383,6 +561,12 @@ pub async fn prepare_data_compare_missing_target(
target_row_count: 0,
source_truncated: false,
target_truncated: false,
+ degradation_level: Some("full".to_string()),
+ sampling_rate: Some(1.0),
+ confidence_score: Some(1.0),
+ verification_method: Some("missing_target_full".to_string()),
+ source_checksums: None,
+ target_checksums: None,
})
}
@@ -1066,6 +1250,421 @@ fn data_grid_column_info(column: crate::types::ColumnInfo) -> DataGridColumnInfo
}
}
+fn should_degrade(source_row_count: u64, target_row_count: u64, threshold: &DegradationThreshold) -> DegradationLevel {
+ let max_count = source_row_count.max(target_row_count);
+ if max_count <= threshold.full_compare_max_rows {
+ DegradationLevel::Full
+ } else if max_count <= threshold.sample_max_rows {
+ DegradationLevel::Sample
+ } else {
+ DegradationLevel::SkipWithRisk
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DegradationEvent {
+ pub source_row_count: u64,
+ pub target_row_count: u64,
+ pub decided_level: String,
+ pub sample_rate: f64,
+ pub confidence: f64,
+ pub auto_decision: String,
+ pub timestamp: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DegradationChain {
+ pub threshold: DegradationThreshold,
+ pub events: Vec,
+ pub auto_upgrade_enabled: bool,
+ pub auto_downgrade_enabled: bool,
+}
+
+impl DegradationChain {
+ pub fn new(threshold: DegradationThreshold) -> Self {
+ Self { threshold, events: Vec::new(), auto_upgrade_enabled: true, auto_downgrade_enabled: true }
+ }
+
+ pub fn decide(
+ &mut self,
+ source_row_count: u64,
+ target_row_count: u64,
+ metrics: Option<&crate::risk_metrics::DegradationMetrics>,
+ ) -> DegradationLevel {
+ let max_count = source_row_count.max(target_row_count);
+ let new_level = if max_count <= self.threshold.full_compare_max_rows {
+ DegradationLevel::Full
+ } else if max_count <= self.threshold.sample_max_rows {
+ DegradationLevel::Sample
+ } else {
+ DegradationLevel::SkipWithRisk
+ };
+
+ let (sample_rate, confidence) = match &new_level {
+ DegradationLevel::Full => (1.0, 1.0),
+ DegradationLevel::Sample => {
+ let rate = self.threshold.sample_size as f64 / max_count as f64;
+ let conf = 0.95 * rate;
+ (rate, conf.clamp(0.5, 0.95))
+ }
+ DegradationLevel::SkipWithRisk => (0.0, 0.0),
+ };
+
+ if self.auto_upgrade_enabled {
+ if let Some(last) = self.events.last() {
+ let auto_upgrade = matches!(
+ (last.decided_level.as_str(), &new_level),
+ ("skip_with_risk", DegradationLevel::Sample) | ("sample", DegradationLevel::Full)
+ );
+ if auto_upgrade {
+ if let Some(m) = metrics {
+ m.record_auto_upgrade();
+ }
+ }
+ }
+ }
+
+ if self.auto_downgrade_enabled {
+ if let Some(last) = self.events.last() {
+ let auto_downgrade = matches!(
+ (last.decided_level.as_str(), &new_level),
+ ("full", DegradationLevel::Sample | DegradationLevel::SkipWithRisk)
+ | ("sample", DegradationLevel::SkipWithRisk)
+ );
+ if auto_downgrade {
+ if let Some(m) = metrics {
+ m.record_auto_downgrade();
+ }
+ }
+ }
+ }
+
+ if let Some(m) = metrics {
+ m.record_degradation(&new_level.to_string(), sample_rate, confidence);
+ }
+
+ let auto_decision = if new_level == DegradationLevel::Full {
+ "auto".to_string()
+ } else if new_level == DegradationLevel::Sample {
+ "auto_degraded".to_string()
+ } else {
+ "auto_skipped".to_string()
+ };
+
+ self.events.push(DegradationEvent {
+ source_row_count,
+ target_row_count,
+ decided_level: new_level.to_string(),
+ sample_rate,
+ confidence,
+ auto_decision,
+ timestamp: chrono::Utc::now().to_rfc3339(),
+ });
+
+ new_level
+ }
+
+ pub fn event_count(&self) -> usize {
+ self.events.len()
+ }
+
+ pub fn last_event(&self) -> Option<&DegradationEvent> {
+ self.events.last()
+ }
+}
+
+impl Default for DegradationChain {
+ fn default() -> Self {
+ Self::new(DegradationThreshold::default())
+ }
+}
+
+fn build_sampling_select_sql(
+ database_type: DatabaseType,
+ schema: &str,
+ table_name: &str,
+ columns: &[String],
+ key_columns: &[String],
+ strategy: &SamplingStrategy,
+ sample_size: usize,
+) -> String {
+ let table = qualified_table_name(Some(database_type), Some(schema), table_name);
+ let select_columns = if columns.is_empty() {
+ "*".to_string()
+ } else {
+ columns.iter().map(|column| quote_table_identifier(Some(database_type), column)).collect::>().join(", ")
+ };
+
+ match strategy {
+ SamplingStrategy::Random => match database_type {
+ DatabaseType::Postgres | DatabaseType::Redshift | DatabaseType::DuckDb | DatabaseType::Databricks => {
+ format!("SELECT {select_columns} FROM {table} TABLESAMPLE SYSTEM (1) LIMIT {sample_size}")
+ }
+ DatabaseType::SqlServer => {
+ format!("SELECT TOP ({sample_size}) {select_columns} FROM {table} TABLESAMPLE ({sample_size} ROWS)")
+ }
+ DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::Goldendb => {
+ format!("SELECT {select_columns} FROM {table} ORDER BY RAND() LIMIT {sample_size}")
+ }
+ DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso => {
+ format!("SELECT {select_columns} FROM {table} ORDER BY RANDOM() LIMIT {sample_size}")
+ }
+ DatabaseType::ClickHouse => {
+ format!("SELECT {select_columns} FROM {table} ORDER BY rand() LIMIT {sample_size}")
+ }
+ DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => {
+ format!("SELECT {select_columns} FROM (SELECT {select_columns} FROM {table} ORDER BY DBMS_RANDOM.VALUE) WHERE ROWNUM <= {sample_size}")
+ }
+ DatabaseType::Iris => {
+ format!("SELECT TOP {sample_size} {select_columns} FROM {table} ORDER BY RAND()")
+ }
+ DatabaseType::Questdb => {
+ format!("SELECT {select_columns} FROM {table} ORDER BY RAND() LIMIT {sample_size}")
+ }
+ DatabaseType::Informix => {
+ format!("SELECT FIRST {sample_size} {select_columns} FROM {table} ORDER BY RAND()")
+ }
+ _ => {
+ if key_columns.is_empty() {
+ format!("SELECT {select_columns} FROM {table} LIMIT {sample_size}")
+ } else {
+ let order_by = key_columns
+ .iter()
+ .map(|column| format!("{} ASC", quote_table_identifier(Some(database_type), column)))
+ .collect::>()
+ .join(", ");
+ format!("SELECT {select_columns} FROM {table} ORDER BY {order_by} LIMIT {sample_size}")
+ }
+ }
+ },
+ SamplingStrategy::ExtremeValues => {
+ if key_columns.is_empty() {
+ return format!("SELECT {select_columns} FROM {table} LIMIT {sample_size}");
+ }
+ let order_keys = key_columns
+ .iter()
+ .map(|column| format!("{} ASC", quote_table_identifier(Some(database_type), column)))
+ .collect::>();
+ let asc_order = order_keys.join(", ");
+ let desc_order = key_columns
+ .iter()
+ .map(|column| format!("{} DESC", quote_table_identifier(Some(database_type), column)))
+ .collect::>()
+ .join(", ");
+
+ let head_count = sample_size / 2;
+ let tail_count = sample_size - head_count;
+
+ format!(
+ "SELECT {select_columns} FROM ( \
+ (SELECT {select_columns} FROM {table} ORDER BY {asc_order} LIMIT {head_count}) \
+ UNION ALL \
+ (SELECT {select_columns} FROM {table} ORDER BY {desc_order} LIMIT {tail_count}) \
+ ) AS _extreme_sample"
+ )
+ }
+ SamplingStrategy::Hybrid => {
+ if key_columns.is_empty() {
+ return format!("SELECT {select_columns} FROM {table} LIMIT {sample_size}");
+ }
+ let order_keys = key_columns
+ .iter()
+ .map(|column| format!("{} ASC", quote_table_identifier(Some(database_type), column)))
+ .collect::>();
+ let asc_order = order_keys.join(", ");
+ let desc_order = key_columns
+ .iter()
+ .map(|column| format!("{} DESC", quote_table_identifier(Some(database_type), column)))
+ .collect::>()
+ .join(", ");
+
+ let random_count = sample_size / 2;
+ let head_count = (sample_size - random_count) / 2;
+ let tail_count = sample_size - random_count - head_count;
+
+ let random_part = match database_type {
+ DatabaseType::Postgres | DatabaseType::Redshift | DatabaseType::DuckDb | DatabaseType::Databricks => {
+ format!("(SELECT {select_columns} FROM {table} TABLESAMPLE SYSTEM (1) LIMIT {random_count})")
+ }
+ DatabaseType::SqlServer => {
+ format!(
+ "(SELECT TOP ({random_count}) {select_columns} FROM {table} TABLESAMPLE ({random_count} ROWS))"
+ )
+ }
+ DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::Goldendb => {
+ format!("(SELECT {select_columns} FROM {table} ORDER BY RAND() LIMIT {random_count})")
+ }
+ DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso => {
+ format!("(SELECT {select_columns} FROM {table} ORDER BY RANDOM() LIMIT {random_count})")
+ }
+ DatabaseType::ClickHouse => {
+ format!("(SELECT {select_columns} FROM {table} ORDER BY rand() LIMIT {random_count})")
+ }
+ DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => {
+ format!("(SELECT {select_columns} FROM (SELECT {select_columns} FROM {table} ORDER BY DBMS_RANDOM.VALUE) WHERE ROWNUM <= {random_count})")
+ }
+ DatabaseType::Iris => {
+ format!("(SELECT TOP {random_count} {select_columns} FROM {table} ORDER BY RAND())")
+ }
+ DatabaseType::Questdb => {
+ format!("(SELECT {select_columns} FROM {table} ORDER BY RAND() LIMIT {random_count})")
+ }
+ DatabaseType::Informix => {
+ format!("(SELECT FIRST {random_count} {select_columns} FROM {table} ORDER BY RAND())")
+ }
+ _ => {
+ format!("(SELECT {select_columns} FROM {table} LIMIT {random_count})")
+ }
+ };
+
+ format!(
+ "SELECT {select_columns} FROM ( \
+ {random_part} \
+ UNION ALL \
+ (SELECT {select_columns} FROM {table} ORDER BY {asc_order} LIMIT {head_count}) \
+ UNION ALL \
+ (SELECT {select_columns} FROM {table} ORDER BY {desc_order} LIMIT {tail_count}) \
+ ) AS _hybrid_sample"
+ )
+ }
+ }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn fetch_sampled_compare_rows(
+ state: &AppState,
+ connection_id: &str,
+ database: &str,
+ schema: &str,
+ table_name: &str,
+ columns: &[String],
+ key_columns: &[String],
+ database_type: DatabaseType,
+ strategy: &SamplingStrategy,
+ sample_size: usize,
+) -> Result>, String> {
+ if sample_size == 0 {
+ return Ok(Vec::new());
+ }
+
+ let sql = build_sampling_select_sql(database_type, schema, table_name, columns, key_columns, strategy, sample_size);
+
+ let result = execute_sql_statement_with_options(
+ state,
+ connection_id,
+ database,
+ &sql,
+ Some(schema),
+ None,
+ QueryExecutionOptions { max_rows: Some(sample_size), ..Default::default() },
+ )
+ .await?;
+
+ Ok(result.rows)
+}
+
+fn compute_column_checksums(columns: &[String], rows: &[Vec]) -> HashMap {
+ let mut column_hashers: HashMap = columns.iter().map(|col| (col.clone(), Sha256::new())).collect();
+
+ let column_indexes = column_index_map(columns);
+
+ for row in rows {
+ for (column_name, index) in &column_indexes {
+ if let Some(hasher) = column_hashers.get_mut(*column_name) {
+ let value_str = json_stringify(row_value(row, *index));
+ hasher.update(value_str.as_bytes());
+ hasher.update(b"\n");
+ }
+ }
+ }
+
+ column_hashers
+ .into_iter()
+ .map(|(name, hasher)| {
+ let hash = format!("{:x}", hasher.finalize());
+ (name, hash)
+ })
+ .collect()
+}
+
+fn compute_confidence(
+ sampling_rate: f64,
+ degradation_level: &DegradationLevel,
+ row_count_match: bool,
+ source_row_count: u64,
+ target_row_count: u64,
+) -> f64 {
+ match degradation_level {
+ DegradationLevel::Full => {
+ if row_count_match {
+ 1.0
+ } else {
+ 0.99
+ }
+ }
+ DegradationLevel::Sample => {
+ let count_ratio =
+ source_row_count.min(target_row_count) as f64 / source_row_count.max(target_row_count).max(1) as f64;
+ let base = if row_count_match { 0.95 } else { 0.85 };
+ let adjusted = base * sampling_rate * count_ratio.sqrt();
+ adjusted.clamp(0.5, 0.95)
+ }
+ DegradationLevel::SkipWithRisk => 0.0,
+ }
+}
+
+pub async fn verify_data(state: &AppState, options: VerifyDataOptions) -> Result {
+ let degradation_threshold = options.degradation_threshold.unwrap_or_default();
+ let sampling_strategy = options.sampling_strategy.unwrap_or(SamplingStrategy::Hybrid);
+ let enable_checksum = options.enable_checksum.unwrap_or(true);
+
+ let from_tables_options = DataCompareFromTablesOptions {
+ source_connection_id: options.source_connection_id,
+ source_database: options.source_database,
+ source_schema: options.source_schema,
+ source_table: options.source_table,
+ target_connection_id: options.target_connection_id,
+ target_database: options.target_database,
+ target_schema: options.target_schema,
+ target_table: options.target_table,
+ columns: options.columns,
+ key_columns: options.key_columns,
+ fetch_batch_size: options.fetch_batch_size,
+ degradation_threshold: Some(degradation_threshold),
+ sampling_strategy: Some(sampling_strategy),
+ enable_checksum: Some(enable_checksum),
+ };
+
+ let preparation = prepare_data_compare_from_tables(state, from_tables_options).await?;
+
+ let degradation_level = preparation
+ .degradation_level
+ .as_deref()
+ .and_then(|s| DegradationLevel::try_from(s).ok())
+ .unwrap_or(DegradationLevel::SkipWithRisk);
+ let sampling_rate = preparation.sampling_rate.unwrap_or(1.0);
+ let confidence_score = preparation.confidence_score.unwrap_or(0.0);
+ let row_count_match = preparation.source_row_count == preparation.target_row_count;
+
+ let checksums_match = match (&preparation.source_checksums, &preparation.target_checksums) {
+ (Some(src), Some(tgt)) => Some(src == tgt),
+ _ => None,
+ };
+ let verification_method = preparation.verification_method.clone().unwrap_or_else(|| "unknown".to_string());
+
+ Ok(VerifyDataResult {
+ preparation,
+ degradation_level,
+ sampling_rate,
+ confidence_score,
+ row_count_match,
+ checksums_match,
+ verification_method,
+ })
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -1792,4 +2391,80 @@ mod tests {
"SELECT \"ID\", \"NAME\" FROM \"APP\".\"EVENTS\" ORDER BY \"ID\" ASC FETCH FIRST 25 ROWS ONLY"
);
}
+
+ #[test]
+ fn degradation_chain_full_for_small_table() {
+ let threshold = DegradationThreshold::default();
+ let mut chain = DegradationChain::new(threshold);
+ let level = chain.decide(1000, 1000, None);
+ assert_eq!(level, DegradationLevel::Full);
+ assert_eq!(chain.event_count(), 1);
+ let last = chain.last_event().unwrap();
+ assert_eq!(last.decided_level, "full");
+ assert!((last.sample_rate - 1.0).abs() < f64::EPSILON);
+ assert!((last.confidence - 1.0).abs() < f64::EPSILON);
+ }
+
+ #[test]
+ fn degradation_chain_sample_for_large_table() {
+ let threshold = DegradationThreshold::default();
+ let mut chain = DegradationChain::new(threshold);
+ let level = chain.decide(500_000, 500_000, None);
+ assert_eq!(level, DegradationLevel::Sample);
+ let last = chain.last_event().unwrap();
+ assert_eq!(last.decided_level, "sample");
+ assert!(last.sample_rate < 1.0);
+ assert!(last.confidence >= 0.5);
+ }
+
+ #[test]
+ fn degradation_chain_skip_for_huge_table() {
+ let threshold = DegradationThreshold::default();
+ let mut chain = DegradationChain::new(threshold);
+ let level = chain.decide(20_000_000, 20_000_000, None);
+ assert_eq!(level, DegradationLevel::SkipWithRisk);
+ let last = chain.last_event().unwrap();
+ assert_eq!(last.decided_level, "skip_with_risk");
+ assert!((last.sample_rate - 0.0).abs() < f64::EPSILON);
+ assert!((last.confidence - 0.0).abs() < f64::EPSILON);
+ }
+
+ #[test]
+ fn degradation_chain_records_multiple_events() {
+ let threshold = DegradationThreshold::default();
+ let mut chain = DegradationChain::new(threshold);
+ chain.decide(1000, 1000, None);
+ chain.decide(500_000, 500_000, None);
+ chain.decide(20_000_000, 20_000_000, None);
+ assert_eq!(chain.event_count(), 3);
+ }
+
+ #[test]
+ fn degradation_chain_with_metrics_integration() {
+ let threshold = DegradationThreshold::default();
+ let mut chain = DegradationChain::new(threshold);
+ let metrics = crate::risk_metrics::DegradationMetrics::new();
+
+ chain.decide(1000, 1000, Some(&metrics));
+ chain.decide(500_000, 500_000, Some(&metrics));
+ chain.decide(20_000_000, 20_000_000, Some(&metrics));
+
+ let snapshot = metrics.snapshot();
+ let total = snapshot.iter().find(|e| e.name == "dbx_degradation_total").unwrap();
+ assert_eq!(total.value, crate::risk_metrics::MetricValue::Counter(3));
+ }
+
+ #[test]
+ fn degradation_chain_auto_chain_detection() {
+ let threshold = DegradationThreshold::default();
+ let mut chain = DegradationChain::new(threshold);
+ let metrics = crate::risk_metrics::DegradationMetrics::new();
+
+ chain.decide(20_000_000, 20_000_000, Some(&metrics));
+ chain.decide(500_000, 500_000, Some(&metrics));
+
+ let snapshot = metrics.snapshot();
+ let up = snapshot.iter().find(|e| e.name == "dbx_auto_upgrade_total").unwrap();
+ assert_eq!(up.value, crate::risk_metrics::MetricValue::Counter(1));
+ }
}
diff --git a/crates/dbx-core/src/db/agent_driver.rs b/crates/dbx-core/src/db/agent_driver.rs
index b17f14164..13a6e5666 100644
--- a/crates/dbx-core/src/db/agent_driver.rs
+++ b/crates/dbx-core/src/db/agent_driver.rs
@@ -2255,6 +2255,8 @@ mod tests {
let stderr_tail = Arc::new(Mutex::new(StderrTail::default()));
start_stderr_collector(child.stderr.take().expect("stderr should be piped"), Arc::clone(&stderr_tail));
+ std::thread::sleep(Duration::from_millis(200));
+
let message = format_agent_startup_error(
"Failed to read startup line from agent: end of stream",
&mut child,
diff --git a/crates/dbx-core/src/db/sqlite.rs b/crates/dbx-core/src/db/sqlite.rs
index 02f1c0034..16b5e277a 100644
--- a/crates/dbx-core/src/db/sqlite.rs
+++ b/crates/dbx-core/src/db/sqlite.rs
@@ -2133,10 +2133,13 @@ pub async fn list_indexes(pool: &SqliteHandle, schema: &str, table: &str) -> Res
))
.map_err(|e| e.to_string())?;
let columns = col_stmt
- .query_map([], |row| row.get::<_, String>("name"))
+ .query_map([], |row| row.get::<_, Option>("name"))
.map_err(|e| e.to_string())?
.collect::, _>>()
- .map_err(|e| e.to_string())?;
+ .map_err(|e| e.to_string())?
+ .into_iter()
+ .flatten()
+ .collect::>();
indexes.push(IndexInfo {
name,
diff --git a/crates/dbx-core/src/db/ssh_tunnel.rs b/crates/dbx-core/src/db/ssh_tunnel.rs
index 0ccb8675a..643c0c2e7 100644
--- a/crates/dbx-core/src/db/ssh_tunnel.rs
+++ b/crates/dbx-core/src/db/ssh_tunnel.rs
@@ -367,11 +367,11 @@ async fn connect_and_authenticate(
async fn try_authenticate_with_agent(
session: &mut Handle,
ssh_user: &str,
- _ssh_agent_sock_path: &str,
+ #[cfg_attr(not(unix), allow(unused_variables))] ssh_agent_sock_path: &str,
connect_timeout: &Duration,
) -> Result<(), String> {
#[cfg(unix)]
- let mut agent = if _ssh_agent_sock_path.is_empty() {
+ let mut agent = if ssh_agent_sock_path.is_empty() {
match AgentClient::connect_env().await {
Ok(a) => a,
Err(e) => {
@@ -379,12 +379,12 @@ async fn try_authenticate_with_agent(
}
}
} else {
- match AgentClient::connect_uds(_ssh_agent_sock_path).await {
+ match AgentClient::connect_uds(ssh_agent_sock_path).await {
Ok(a) => a,
Err(e) => {
return Err(format!(
"No SSH password or key provided, and ssh-agent at '{}' is unavailable: {e}",
- _ssh_agent_sock_path
+ ssh_agent_sock_path
));
}
}
diff --git a/crates/dbx-core/src/dml_binding.rs b/crates/dbx-core/src/dml_binding.rs
new file mode 100644
index 000000000..ce46d56d1
--- /dev/null
+++ b/crates/dbx-core/src/dml_binding.rs
@@ -0,0 +1,409 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::RwLock;
+
+use serde::{Deserialize, Serialize};
+
+use crate::sql_dialect::descriptor::DialectKind;
+use crate::sql_dialect::dialect_yaml::DialectYaml;
+use crate::sql_dialect::inference::{ColumnType, DefaultTypeInferenceEngine, TypeInferenceEngine};
+
+// ============================================================================
+// DML Clean Rules — lossy type mapping → pre-transform DML template
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DmlCleanRulesFile {
+ pub rules: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DmlCleanRule {
+ pub name: String,
+ pub source_type: String,
+ pub target_type: String,
+ pub max_fidelity: f64,
+ #[serde(default)]
+ pub pre_transform_sql: Option,
+ #[serde(default)]
+ pub description: Option,
+}
+
+impl DmlCleanRule {
+ pub fn transform_sql(&self, table: &str, column: &str) -> Option {
+ self.pre_transform_sql.as_ref().map(|tmpl| tmpl.replace("{table}", table).replace("{column}", column))
+ }
+
+ /// Check if this rule matches the source → target type pair.
+ pub fn matches(&self, source_type: &str, target_type: &str) -> bool {
+ let src_norm = normalize_type(source_type);
+ let tgt_norm = normalize_type(target_type);
+ let rule_src = normalize_type(&self.source_type);
+ let rule_tgt = normalize_type(&self.target_type);
+ src_norm == rule_src && tgt_norm == rule_tgt
+ }
+
+ fn applies(&self, source_type: &str, target_type: &str, fidelity: f64) -> bool {
+ self.matches(source_type, target_type) && fidelity < self.max_fidelity
+ }
+}
+
+fn normalize_type(t: &str) -> String {
+ t.trim().to_ascii_uppercase().split('(').next().unwrap_or("").to_string()
+}
+
+// ============================================================================
+// DmlCleanRuleRegistry — global singleton, loads from YAML
+// ============================================================================
+
+pub struct DmlCleanRuleRegistry {
+ pub(crate) rules: Vec,
+}
+
+impl DmlCleanRuleRegistry {
+ pub fn new() -> Self {
+ Self { rules: Vec::new() }
+ }
+
+ pub fn global() -> &'static RwLock {
+ use std::sync::OnceLock;
+ static INSTANCE: OnceLock> = OnceLock::new();
+ INSTANCE.get_or_init(|| RwLock::new(Self::new()))
+ }
+
+ pub fn load(path: &Path) -> Result, String> {
+ let content = std::fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {e}", path.display()))?;
+ let parsed: DmlCleanRulesFile =
+ serde_yaml::from_str(&content).map_err(|e| format!("YAML parse error in {}: {e}", path.display()))?;
+ Ok(parsed.rules)
+ }
+
+ pub fn load_default() -> Result<(), String> {
+ let paths = [
+ "plugins/mappings/rules/dml_clean_rules.yaml",
+ "../plugins/mappings/rules/dml_clean_rules.yaml",
+ "../../plugins/mappings/rules/dml_clean_rules.yaml",
+ ];
+ for path in &paths {
+ let p = Path::new(path);
+ if p.exists() {
+ let rules = Self::load(p)?;
+ if let Ok(mut registry) = Self::global().write() {
+ registry.rules = rules;
+ }
+ return Ok(());
+ }
+ }
+ Ok(())
+ }
+
+ pub fn find_rule(&self, source_type: &str, target_type: &str) -> Option<&DmlCleanRule> {
+ self.rules.iter().find(|r| r.matches(source_type, target_type))
+ }
+
+ pub fn all_rules(&self) -> &[DmlCleanRule] {
+ &self.rules
+ }
+}
+
+impl Default for DmlCleanRuleRegistry {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+// ============================================================================
+// BindingEngine — auto-binds DML clean SQL to lossy type mappings
+// ============================================================================
+
+pub struct BindingEngine;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BindingResult {
+ pub source_type: String,
+ pub target_type: String,
+ pub fidelity: f64,
+ pub pre_transform_sql: Option,
+ pub rule_name: Option,
+}
+
+impl BindingEngine {
+ /// Compute fidelity for a single type mapping and auto-bind DML if lossy.
+ pub fn bind(source_type: &str, target_type: &str, table: &str, column: &str, threshold: f64) -> BindingResult {
+ let engine = DefaultTypeInferenceEngine;
+ let src_parsed = ColumnType::parse(source_type);
+ let tgt_parsed = ColumnType::parse(target_type);
+ let fidelity = engine.type_compatibility_score(&src_parsed, &tgt_parsed);
+
+ if let Ok(registry) = DmlCleanRuleRegistry::global().read() {
+ if let Some(rule) = registry.find_rule(source_type, target_type) {
+ // A pair-specific rule owns its fidelity boundary; the caller
+ // threshold remains the fallback for mappings without a rule.
+ if rule.applies(source_type, target_type, fidelity) {
+ return BindingResult {
+ source_type: source_type.to_string(),
+ target_type: target_type.to_string(),
+ fidelity,
+ pre_transform_sql: rule.transform_sql(table, column),
+ rule_name: Some(rule.name.clone()),
+ };
+ }
+ }
+ }
+
+ if fidelity >= threshold {
+ return BindingResult {
+ source_type: source_type.to_string(),
+ target_type: target_type.to_string(),
+ fidelity,
+ pre_transform_sql: None,
+ rule_name: None,
+ };
+ }
+
+ BindingResult {
+ source_type: source_type.to_string(),
+ target_type: target_type.to_string(),
+ fidelity,
+ pre_transform_sql: None,
+ rule_name: None,
+ }
+ }
+
+ /// Bind for a full set of column mappings.
+ pub fn bind_columns(
+ source_types: &[(String, String)], // (col_name, type)
+ target_types: &[(String, String)],
+ table: &str,
+ threshold: f64,
+ ) -> Vec {
+ let source_map: HashMap<&str, &str> = source_types.iter().map(|(n, t)| (n.as_str(), t.as_str())).collect();
+
+ target_types
+ .iter()
+ .map(|(col_name, target_type)| {
+ let source_type = source_map.get(col_name.as_str()).copied().unwrap_or(target_type);
+ Self::bind(source_type, target_type, table, col_name, threshold)
+ })
+ .collect()
+ }
+}
+
+// ============================================================================
+// MappingCache — cache derivation results to plugins/mappings/base/
+// ============================================================================
+
+const MAPPING_BASE_DIR: &str = "plugins/mappings/base";
+const MAPPING_CUSTOM_DIR: &str = "plugins/mappings/custom";
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MappingCacheFile {
+ pub status: String, // "UNVERIFIED" | "VERIFIED" | "REJECTED"
+ pub generated_at: String,
+ pub derived_from: MappingDerivationInfo,
+ pub transformations: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MappingDerivationInfo {
+ pub source_dialect: String,
+ pub target_dialect: String,
+ pub source_type_count: usize,
+ pub target_type_count: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CachedTransformation {
+ pub source_type: String,
+ pub target_type: String,
+ pub fidelity: f64,
+ pub pre_transform_sql: Option,
+ pub rule_name: Option,
+}
+
+impl MappingCacheFile {
+ pub fn cache_path(source: DialectKind, target: DialectKind) -> PathBuf {
+ let dir = Path::new(MAPPING_BASE_DIR);
+ let name = format!("{}_to_{}.base.yaml", source.label(), target.label());
+ dir.join(name)
+ }
+
+ pub fn custom_path(source: DialectKind, target: DialectKind, env: &str) -> PathBuf {
+ let dir = Path::new(MAPPING_CUSTOM_DIR);
+ let name = format!("{}_to_{}.{}.yaml", source.label(), target.label(), env);
+ dir.join(name)
+ }
+
+ /// Load from cache if exists. Checks custom override first, then base cache.
+ pub fn load(source: DialectKind, target: DialectKind, env: &str) -> Option {
+ let custom = Self::custom_path(source, target, env);
+ if custom.exists() {
+ let content = std::fs::read_to_string(&custom).ok()?;
+ return serde_yaml::from_str(&content).ok();
+ }
+
+ let base = Self::cache_path(source, target);
+ if base.exists() {
+ let content = std::fs::read_to_string(&base).ok()?;
+ return serde_yaml::from_str(&content).ok();
+ }
+
+ None
+ }
+
+ /// Save derivation result to base cache (UNVERIFIED).
+ pub fn save(source: DialectKind, target: DialectKind, bindings: &[BindingResult]) -> Result<(), String> {
+ let dir = Path::new(MAPPING_BASE_DIR);
+ std::fs::create_dir_all(dir).map_err(|e| format!("Cannot create mappings dir: {e}"))?;
+
+ let source_yaml = DialectYaml::from_descriptor(source);
+ let target_yaml = DialectYaml::from_descriptor(target);
+
+ let cache = MappingCacheFile {
+ status: "UNVERIFIED".to_string(),
+ generated_at: chrono::Utc::now().to_rfc3339(),
+ derived_from: MappingDerivationInfo {
+ source_dialect: source.label().to_string(),
+ target_dialect: target.label().to_string(),
+ source_type_count: source_yaml.types.len(),
+ target_type_count: target_yaml.types.len(),
+ },
+ transformations: bindings
+ .iter()
+ .map(|b| CachedTransformation {
+ source_type: b.source_type.clone(),
+ target_type: b.target_type.clone(),
+ fidelity: b.fidelity,
+ pre_transform_sql: b.pre_transform_sql.clone(),
+ rule_name: b.rule_name.clone(),
+ })
+ .collect(),
+ };
+
+ let path = Self::cache_path(source, target);
+ let yaml_str = serde_yaml::to_string(&cache).map_err(|e| format!("YAML serialize: {e}"))?;
+ std::fs::write(&path, &yaml_str).map_err(|e| format!("Write cache {}: {e}", path.display()))?;
+ Ok(())
+ }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn rule_matches_exact() {
+ let rule = DmlCleanRule {
+ name: "test".to_string(),
+ source_type: "BIGINT".to_string(),
+ target_type: "INT".to_string(),
+ max_fidelity: 0.8,
+ pre_transform_sql: Some("UPDATE {table} SET {column} = NULL".to_string()),
+ description: None,
+ };
+ assert!(rule.matches("BIGINT", "INT"));
+ assert!(!rule.matches("INT", "BIGINT"));
+ }
+
+ #[test]
+ fn rule_matches_normalized() {
+ let rule = DmlCleanRule {
+ name: "test".to_string(),
+ source_type: "BIGINT".to_string(),
+ target_type: "INT".to_string(),
+ max_fidelity: 0.8,
+ pre_transform_sql: None,
+ description: None,
+ };
+ assert!(rule.matches("BIGINT(20)", "INT"));
+ assert!(rule.matches("bigint", "int"));
+ }
+
+ #[test]
+ fn rule_transform_sql() {
+ let rule = DmlCleanRule {
+ name: "test".to_string(),
+ source_type: "BIGINT".to_string(),
+ target_type: "INT".to_string(),
+ max_fidelity: 0.8,
+ pre_transform_sql: Some("UPDATE {table} SET {column} = NULL WHERE {column} > 2147483647".to_string()),
+ description: None,
+ };
+ let sql = rule.transform_sql("users", "age").unwrap();
+ assert_eq!(sql, "UPDATE users SET age = NULL WHERE age > 2147483647");
+ }
+
+ #[test]
+ fn binding_engine_high_fidelity_no_dml() {
+ let result = BindingEngine::bind("INT", "INTEGER", "t", "c", 0.7);
+ assert!(result.pre_transform_sql.is_none());
+ assert!((result.fidelity - 0.9).abs() < 0.01);
+ }
+
+ #[test]
+ fn binding_engine_low_fidelity_with_dml() {
+ let _registry = DmlCleanRuleRegistry::new();
+ if let Ok(mut reg) = DmlCleanRuleRegistry::global().write() {
+ reg.rules = vec![DmlCleanRule {
+ name: "bigint_to_int".to_string(),
+ source_type: "BIGINT".to_string(),
+ target_type: "INT".to_string(),
+ max_fidelity: 0.9,
+ pre_transform_sql: Some("UPDATE {table} SET {column} = NULL WHERE {column} > 2147483647".to_string()),
+ description: None,
+ }];
+ }
+
+ let result = BindingEngine::bind("BIGINT", "INT", "users", "id", 0.4);
+ assert!(result.pre_transform_sql.is_some());
+ assert!(result.pre_transform_sql.unwrap().contains("2147483647"));
+ }
+
+ #[test]
+ fn rule_max_fidelity_boundary_is_exclusive() {
+ let rule = DmlCleanRule {
+ name: "boundary".to_string(),
+ source_type: "BIGINT".to_string(),
+ target_type: "INT".to_string(),
+ max_fidelity: 0.5,
+ pre_transform_sql: Some("SELECT 1".to_string()),
+ description: None,
+ };
+
+ assert!(rule.applies("BIGINT", "INT", 0.49));
+ assert!(!rule.applies("BIGINT", "INT", 0.5));
+ }
+
+ #[test]
+ fn default_rules_honor_configured_max_fidelity() {
+ let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../plugins/mappings/rules/dml_clean_rules.yaml");
+ let rules = DmlCleanRuleRegistry::load(&path).unwrap();
+ let rule = rules.iter().find(|rule| rule.matches("BIGINT", "INT")).unwrap();
+
+ assert!(rule.applies("BIGINT", "INT", rule.max_fidelity - f64::EPSILON));
+ assert!(!rule.applies("BIGINT", "INT", rule.max_fidelity));
+ }
+
+ #[test]
+ fn binding_engine_no_rule_found() {
+ let result = BindingEngine::bind("GEOGRAPHY", "INT", "t", "c", 0.5);
+ assert!(result.pre_transform_sql.is_none());
+ assert!((result.fidelity - 0.3).abs() < 0.01);
+ }
+
+ #[test]
+ fn mapping_cache_path() {
+ let path = MappingCacheFile::cache_path(DialectKind::Mysql, DialectKind::Postgres);
+ assert!(path.to_string_lossy().contains("mysql_to_postgres"));
+ let custom = MappingCacheFile::custom_path(DialectKind::Mysql, DialectKind::Postgres, "prod");
+ assert!(custom.to_string_lossy().contains("prod"));
+ }
+}
diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rs
index 9eeb866c8..f49b441a2 100644
--- a/crates/dbx-core/src/lib.rs
+++ b/crates/dbx-core/src/lib.rs
@@ -17,8 +17,10 @@ mod ai_model_filter;
pub mod ai_pi_agent_cli;
pub mod changelog;
pub mod cloud_sync;
+pub mod config;
pub mod connection;
pub mod connection_secrets;
+pub mod correction;
pub mod csv_export;
pub mod data_compare;
pub mod data_grid_extractors;
@@ -28,6 +30,7 @@ pub mod database_export;
pub mod database_search_sql;
pub mod db;
pub mod db_admin_sql;
+pub mod dml_binding;
pub mod document_ops;
pub mod driver_runtime;
pub mod external;
@@ -53,19 +56,23 @@ pub mod query_execution_sql;
pub mod query_result_export;
pub mod query_result_sql;
pub mod redis_ops;
+pub mod risk_metrics;
pub mod saved_sql;
pub mod schema;
pub mod schema_diff;
+pub mod script_generator;
pub mod sql;
pub mod sql_analysis;
pub mod sql_diagnostics;
pub mod sql_dialect;
pub mod sql_editability;
pub mod sql_file_import;
+pub mod sql_parser;
pub mod sql_risk;
pub mod sqlite_backup;
pub(crate) mod sqlserver_temporal;
pub mod ssh_config;
+pub mod state_persistence;
pub mod storage;
pub mod table_export;
pub mod table_import;
@@ -75,6 +82,7 @@ pub mod temporal_format;
pub mod text_export;
pub mod token_usage;
pub mod transfer;
+pub mod two_phase_commit;
pub mod types;
pub mod update;
pub mod xlsx_export;
diff --git a/crates/dbx-core/src/osc_probe.rs b/crates/dbx-core/src/osc_probe.rs
new file mode 100644
index 000000000..3b20bc00a
--- /dev/null
+++ b/crates/dbx-core/src/osc_probe.rs
@@ -0,0 +1,427 @@
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+use crate::state_persistence::StateMachine;
+
+// ============================================================================
+// 15.1 & 15.2: External OSC Tool Status
+// ============================================================================
+
+/// Status of an external online schema change tool execution.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum OscExecutionStatus {
+ Preparing,
+ Copying { progress_pct: f64, rows_copied: u64, rows_total: u64 },
+ CutOver,
+ Postponed,
+ Completed,
+ Failed(String),
+}
+
+/// Type of OSC tool
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OscToolKind {
+ GhOst,
+ PtOsc,
+}
+
+impl OscToolKind {
+ pub fn name(&self) -> &'static str {
+ match self {
+ Self::GhOst => "gh-ost",
+ Self::PtOsc => "pt-osc",
+ }
+ }
+}
+
+// ============================================================================
+// 15.1: gh-ost Probe
+// ============================================================================
+
+pub struct GhOstProbe {
+ progress_history: Vec<(String, f64)>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GhOstProgress {
+ pub status: OscExecutionStatus,
+ pub ghost_table_exists: bool,
+ pub changelog_table_exists: bool,
+ pub rows_copied: u64,
+ pub rows_total: u64,
+ pub progress_pct: f64,
+}
+
+impl GhOstProbe {
+ pub fn new() -> Self {
+ Self { progress_history: Vec::new() }
+ }
+
+ pub fn probe(&mut self, _database: &str, _table: &str, _has_connection: bool) -> GhOstProgress {
+ let ghost_table = format!("{_table}_gho");
+ let changelog_table = format!("{_table}_ghc");
+ if !_has_connection {
+ return GhOstProgress {
+ status: OscExecutionStatus::Copying { progress_pct: 0.0, rows_copied: 0, rows_total: 0 },
+ ghost_table_exists: false,
+ changelog_table_exists: false,
+ rows_copied: 0,
+ rows_total: 0,
+ progress_pct: 0.0,
+ };
+ }
+ GhOstProgress {
+ status: OscExecutionStatus::Copying { progress_pct: 0.0, rows_copied: 0, rows_total: 0 },
+ ghost_table_exists: false,
+ changelog_table_exists: false,
+ rows_copied: 0,
+ rows_total: 0,
+ progress_pct: 0.0,
+ }
+ }
+
+ /// Parse gh-ost log line: "Copying rows: 12345/67890 (18.2%)"
+ pub fn parse_log_line(line: &str) -> Option {
+ let upper = line.to_uppercase();
+ if !upper.contains("COPYING ROWS") {
+ return None;
+ }
+ let re = regex::Regex::new(r"(\d+)\s*/\s*(\d+)\s*\((\d+\.?\d*)%\)").ok()?;
+ if let Some(caps) = re.captures(line) {
+ let rows_copied: u64 = caps.get(1)?.as_str().parse().ok()?;
+ let rows_total: u64 = caps.get(2)?.as_str().parse().ok()?;
+ let progress_pct: f64 = caps.get(3)?.as_str().parse().ok()?;
+ let status = if progress_pct >= 99.0 {
+ OscExecutionStatus::CutOver
+ } else {
+ OscExecutionStatus::Copying { progress_pct, rows_copied, rows_total }
+ };
+ return Some(GhOstProgress {
+ status,
+ ghost_table_exists: true,
+ changelog_table_exists: true,
+ rows_copied,
+ rows_total,
+ progress_pct,
+ });
+ }
+ None
+ }
+
+ pub fn record_sample(&mut self, progress_pct: f64, label: &str) {
+ self.progress_history.push((label.to_string(), progress_pct));
+ if self.progress_history.len() > 1000 {
+ self.progress_history.remove(0);
+ }
+ }
+
+ pub fn estimated_remaining_seconds(&self, current_pct: f64) -> Option {
+ if self.progress_history.len() < 2 || current_pct <= 0.0 {
+ return None;
+ }
+ let first = self.progress_history.first()?;
+ let total_pct = current_pct - first.1;
+ if total_pct <= 0.0 {
+ return None;
+ }
+ let rate = total_pct / 1.0;
+ if rate <= 0.0 {
+ return None;
+ }
+ Some((100.0 - current_pct) / rate)
+ }
+}
+
+impl Default for GhOstProbe {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+// ============================================================================
+// 15.2: pt-osc Probe
+// ============================================================================
+
+pub struct PtOscProbe;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PtOscProgress {
+ pub status: OscExecutionStatus,
+ pub new_table_exists: bool,
+ pub old_table_exists: bool,
+ pub triggers_active: u32,
+ pub rows_copied: u64,
+ pub rows_total: u64,
+ pub progress_pct: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PtOscNames {
+ pub new_table: String,
+ pub old_table: String,
+ pub del_trigger: String,
+ pub ins_trigger: String,
+ pub upd_trigger: String,
+}
+
+impl PtOscProbe {
+ pub fn new() -> Self {
+ Self
+ }
+
+ pub fn object_names(table: &str) -> PtOscNames {
+ PtOscNames {
+ new_table: format!("_{table}_new"),
+ old_table: format!("_{table}_old"),
+ del_trigger: format!("pt_osc_{table}_del"),
+ ins_trigger: format!("pt_osc_{table}_ins"),
+ upd_trigger: format!("pt_osc_{table}_upd"),
+ }
+ }
+
+ pub fn parse_progress_line(line: &str) -> Option {
+ let re = regex::Regex::new(r"(\d+)%\s").ok()?;
+ if let Some(caps) = re.captures(line) {
+ return caps.get(1)?.as_str().parse().ok();
+ }
+ None
+ }
+}
+
+impl Default for PtOscProbe {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+// ============================================================================
+// 15.3: OscStateBridge — map external status to StateMachine
+// ============================================================================
+
+pub struct OscStateBridge {
+ state_machine: Arc,
+}
+
+impl OscStateBridge {
+ pub fn new(state_machine: Arc) -> Self {
+ Self { state_machine }
+ }
+
+ pub async fn bridge(&self, state_key: &str, external_status: &OscExecutionStatus) -> Result {
+ match external_status {
+ OscExecutionStatus::Preparing | OscExecutionStatus::Copying { .. } | OscExecutionStatus::Postponed => {
+ Ok("osc_syncing")
+ }
+ OscExecutionStatus::CutOver | OscExecutionStatus::Completed => {
+ let new_state = crate::state_persistence::StateTransition::Completed;
+ self.state_machine.transition(state_key, new_state).await?;
+ Ok("completed")
+ }
+ OscExecutionStatus::Failed(_) => {
+ let new_state = crate::state_persistence::StateTransition::Failed;
+ self.state_machine.transition(state_key, new_state).await?;
+ Err(format!("OSC failed: {external_status:?}"))
+ }
+ }
+ .map(|s| s.to_string())
+ }
+}
+
+// ============================================================================
+// 15.6: dbdiff_lock — database-level distributed lock
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DbDiffLock {
+ pub lock_id: String,
+ pub instance_id: String,
+ pub acquired_at: String,
+ pub expires_at: String,
+}
+
+impl DbDiffLock {
+ pub fn create_table_sql() -> &'static str {
+ "CREATE TABLE IF NOT EXISTS dbdiff_lock (
+ lock_id TEXT PRIMARY KEY,
+ instance_id TEXT NOT NULL,
+ acquired_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ expires_at TIMESTAMP NOT NULL
+ )"
+ }
+
+ pub fn acquire_sql(lock_id: &str, instance_id: &str, ttl_seconds: u64) -> String {
+ format!(
+ "INSERT INTO dbdiff_lock (lock_id, instance_id, expires_at) \
+ VALUES ('{lock_id}', '{instance_id}', DATEADD('SECOND', {ttl_seconds}, CURRENT_TIMESTAMP))"
+ )
+ }
+
+ pub fn check_sql(lock_id: &str) -> String {
+ format!(
+ "SELECT instance_id, acquired_at, expires_at FROM dbdiff_lock \
+ WHERE lock_id = '{lock_id}' AND expires_at > CURRENT_TIMESTAMP"
+ )
+ }
+
+ pub fn release_sql(lock_id: &str, instance_id: &str) -> String {
+ format!("DELETE FROM dbdiff_lock WHERE lock_id = '{lock_id}' AND instance_id = '{instance_id}'")
+ }
+
+ pub fn cleanup_expired_sql() -> &'static str {
+ "DELETE FROM dbdiff_lock WHERE expires_at <= CURRENT_TIMESTAMP"
+ }
+
+ pub fn extend_sql(lock_id: &str, instance_id: &str, ttl_seconds: u64) -> String {
+ format!(
+ "UPDATE dbdiff_lock SET expires_at = DATEADD('SECOND', {ttl_seconds}, CURRENT_TIMESTAMP) \
+ WHERE lock_id = '{lock_id}' AND instance_id = '{instance_id}'"
+ )
+ }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ // --- gh-ost log parsing ---
+
+ #[test]
+ fn gh_ost_parse_log_copying() {
+ let line = "Copying rows: 12345/67890 (18.2%)";
+ let result = GhOstProbe::parse_log_line(line).unwrap();
+ assert_eq!(result.rows_copied, 12345);
+ assert_eq!(result.rows_total, 67890);
+ assert!((result.progress_pct - 18.2).abs() < 0.01);
+ match result.status {
+ OscExecutionStatus::Copying { .. } => {}
+ _ => panic!("should be Copying"),
+ }
+ }
+
+ #[test]
+ fn gh_ost_parse_log_cutover() {
+ let line = "Copying rows: 67889/67890 (100.0%)";
+ let result = GhOstProbe::parse_log_line(line).unwrap();
+ match result.status {
+ OscExecutionStatus::CutOver => {}
+ _ => panic!("should be CutOver at 100%"),
+ }
+ }
+
+ #[test]
+ fn gh_ost_parse_non_copying_line() {
+ let line = "2024/01/01 12:00:00 Starting gh-ost...";
+ assert!(GhOstProbe::parse_log_line(line).is_none());
+ }
+
+ // --- pt-osc ---
+
+ #[test]
+ fn pt_osc_get_object_names() {
+ let names = PtOscProbe::object_names("users");
+ assert_eq!(names.new_table, "_users_new");
+ assert_eq!(names.del_trigger, "pt_osc_users_del");
+ }
+
+ #[test]
+ fn pt_osc_parse_progress() {
+ let line = "Copying `mydb`.`users`: 45% 00:30 remaining";
+ let pct = PtOscProbe::parse_progress_line(line).unwrap();
+ assert!((pct - 45.0).abs() < 0.01);
+ }
+
+ // --- OSC status serialization ---
+
+ #[test]
+ fn osc_status_serialization() {
+ let status = OscExecutionStatus::Copying { progress_pct: 45.5, rows_copied: 100, rows_total: 200 };
+ let json = serde_json::to_string(&status).unwrap();
+ assert!(json.contains("45.5"));
+ let deserialized: OscExecutionStatus = serde_json::from_str(&json).unwrap();
+ assert_eq!(status, deserialized);
+ }
+
+ // --- dbdiff_lock ---
+
+ #[test]
+ fn dbdiff_lock_acquire_sql() {
+ let sql = DbDiffLock::acquire_sql("mig-001", "node-1", 300);
+ assert!(sql.contains("INSERT INTO dbdiff_lock"));
+ assert!(sql.contains("mig-001"));
+ }
+
+ #[test]
+ fn dbdiff_lock_release_sql() {
+ let sql = DbDiffLock::release_sql("mig-001", "node-1");
+ assert!(sql.contains("DELETE FROM dbdiff_lock"));
+ }
+
+ #[test]
+ fn dbdiff_lock_check_sql() {
+ let sql = DbDiffLock::check_sql("mig-001");
+ assert!(sql.contains("expires_at > CURRENT_TIMESTAMP"));
+ }
+
+ #[test]
+ fn dbdiff_lock_create_table_sql() {
+ let sql = DbDiffLock::create_table_sql();
+ assert!(sql.contains("CREATE TABLE IF NOT EXISTS dbdiff_lock"));
+ }
+
+ // --- State machine extended transition tests ---
+
+ #[test]
+ fn state_machine_new_transitions_valid() {
+ use crate::state_persistence::{is_valid_transition, StateTransition};
+ assert!(is_valid_transition(&StateTransition::Running, &StateTransition::OscSyncing));
+ assert!(is_valid_transition(&StateTransition::OscSyncing, &StateTransition::Completed));
+ assert!(is_valid_transition(&StateTransition::OscSyncing, &StateTransition::Failed));
+ assert!(is_valid_transition(&StateTransition::Failed, &StateTransition::RollingBack));
+ assert!(is_valid_transition(&StateTransition::RollingBack, &StateTransition::FullyRolledBack));
+ assert!(is_valid_transition(&StateTransition::RollingBack, &StateTransition::PartiallyRolledBack));
+ assert!(is_valid_transition(&StateTransition::PartiallyRolledBack, &StateTransition::RecoveryRequired));
+ }
+
+ #[test]
+ fn state_machine_new_transitions_invalid() {
+ use crate::state_persistence::{is_valid_transition, StateTransition};
+ assert!(!is_valid_transition(&StateTransition::Created, &StateTransition::OscSyncing));
+ assert!(!is_valid_transition(&StateTransition::OscSyncing, &StateTransition::Running));
+ assert!(!is_valid_transition(&StateTransition::FullyRolledBack, &StateTransition::Running));
+ }
+
+ #[test]
+ fn state_machine_full_lifecycle_with_osc() {
+ use crate::state_persistence::{is_valid_transition, StateTransition};
+ let lifecycle = ["created", "running", "osc_syncing", "completed"];
+ // Validate each step
+ let states = [
+ StateTransition::Created,
+ StateTransition::Running,
+ StateTransition::OscSyncing,
+ StateTransition::Completed,
+ ];
+ for i in 0..states.len() - 1 {
+ assert!(is_valid_transition(&states[i], &states[i + 1]));
+ }
+ }
+
+ #[test]
+ fn state_machine_rollback_scenarios() {
+ use crate::state_persistence::{is_valid_transition, StateTransition};
+ // Failed → RollingBack → FullyRolledBack
+ assert!(is_valid_transition(&StateTransition::Failed, &StateTransition::RollingBack));
+ assert!(is_valid_transition(&StateTransition::RollingBack, &StateTransition::FullyRolledBack));
+ // Failed → RollingBack → PartiallyRolledBack → RecoveryRequired
+ assert!(is_valid_transition(&StateTransition::RollingBack, &StateTransition::PartiallyRolledBack));
+ assert!(is_valid_transition(&StateTransition::PartiallyRolledBack, &StateTransition::RecoveryRequired));
+ // Failed → RecoveryRequired (direct)
+ assert!(is_valid_transition(&StateTransition::Failed, &StateTransition::RecoveryRequired));
+ }
+}
diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rs
index 1da919560..e3c59c856 100644
--- a/crates/dbx-core/src/query.rs
+++ b/crates/dbx-core/src/query.rs
@@ -33,6 +33,8 @@ use crate::query_execution_sql::is_write_sql;
#[cfg(feature = "duckdb-bundled")]
use crate::sql::starts_with_duckdb_result_sql_keyword;
use crate::sql::{split_sql_batches, split_sql_statements, starts_with_executable_sql_keyword};
+use crate::sql_dialect::{resolve_for_db, CAP_TRANSACTIONAL_DDL};
+use crate::sql_risk::{classify_sql_risk_for_database, SqlRisk};
pub const QUERY_TIMEOUT: Duration = Duration::from_secs(30);
pub const MAX_ROWS: usize = 10000;
@@ -475,6 +477,7 @@ fn duckdb_value_to_json(row: &duckdb::Row<'_>, idx: usize) -> serde_json::Value
| ValueRef::Map(..)
| ValueRef::Enum(..)
| ValueRef::Union(..) => duckdb_owned_value_to_json(&value_ref.to_owned()),
+ _ => duckdb_owned_value_to_json(&value_ref.to_owned()),
}
}
@@ -534,6 +537,7 @@ fn duckdb_owned_value_to_json(value: &Value) -> serde_json::Value {
.collect(),
),
Value::Union(value) => duckdb_owned_value_to_json(value),
+ _ => serde_json::Value::Null,
}
}
@@ -2587,6 +2591,254 @@ fn is_agent_execute_batch_unsupported(error: &str) -> bool {
lower.contains("execute_batch") && (lower.contains("unknown method") || lower.contains("method not found"))
}
+/// Deploy result for Schema Diff: single-connection transactional execution.
+/// On statement failure the transaction is rolled back by the underlying path.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SchemaDiffDeployResult {
+ pub transaction_id: String,
+ pub status: String,
+ pub participants: Vec,
+ pub created_at: String,
+ pub updated_at: String,
+ pub executed_count: usize,
+ pub statement_count: usize,
+ pub error: Option,
+ pub metadata: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SchemaDiffAtomicity {
+ GuaranteedRollback,
+ PartialEffectsPossible,
+}
+
+impl SchemaDiffAtomicity {
+ fn ddl_atomic(self) -> bool {
+ matches!(self, Self::GuaranteedRollback)
+ }
+}
+
+fn database_supports_transactional_ddl(db_type: DatabaseType) -> bool {
+ if resolve_for_db(db_type).has_capability(CAP_TRANSACTIONAL_DDL) {
+ return true;
+ }
+ // SQLite-family DDL is transactional even when dialect registry omits the flag.
+ matches!(db_type, DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1)
+}
+
+fn classify_schema_diff_atomicity(
+ db_type: Option,
+ statements: &[String],
+ has_transactional_path: bool,
+) -> SchemaDiffAtomicity {
+ if !has_transactional_path {
+ return SchemaDiffAtomicity::PartialEffectsPossible;
+ }
+
+ let mut contains_ddl = false;
+ for statement in statements {
+ let risk = match db_type {
+ Some(db_type) => classify_sql_risk_for_database(statement, db_type).ok(),
+ None => None,
+ };
+
+ match risk {
+ Some(SqlRisk::Ddl) => {
+ contains_ddl = true;
+ }
+ Some(SqlRisk::Write | SqlRisk::ReadOnly) => {}
+ Some(SqlRisk::Transaction) | None => {
+ return SchemaDiffAtomicity::PartialEffectsPossible;
+ }
+ }
+ }
+
+ if !contains_ddl {
+ return SchemaDiffAtomicity::GuaranteedRollback;
+ }
+
+ match db_type {
+ Some(db_type) if database_supports_transactional_ddl(db_type) => SchemaDiffAtomicity::GuaranteedRollback,
+ _ => SchemaDiffAtomicity::PartialEffectsPossible,
+ }
+}
+
+fn executed_count_before_error(error: &str, statement_count: usize) -> usize {
+ let Some(rest) = error.strip_prefix("Statement ") else {
+ return statement_count;
+ };
+ let digits: String = rest.chars().take_while(|ch| ch.is_ascii_digit()).collect();
+ let Ok(statement_number) = digits.parse::() else {
+ return statement_count;
+ };
+ statement_number.saturating_sub(1).min(statement_count)
+}
+
+/// Pure failure mapping used by deploy and unit tests.
+fn schema_diff_failure_outcome(
+ atomicity: SchemaDiffAtomicity,
+ error: &str,
+ statement_count: usize,
+) -> (crate::two_phase_commit::TransactionStatus, usize) {
+ if atomicity.ddl_atomic() {
+ (crate::two_phase_commit::TransactionStatus::RolledBack, 0)
+ } else {
+ (crate::two_phase_commit::TransactionStatus::Mixed, executed_count_before_error(error, statement_count))
+ }
+}
+
+fn pool_kind_has_transactional_path(pool: &PoolKind) -> bool {
+ // DuckDb variants always exist (unit stubs when duckdb-bundled is off).
+ match pool {
+ PoolKind::Postgres(_)
+ | PoolKind::Mysql(_, _)
+ | PoolKind::Sqlite(_)
+ | PoolKind::CloudflareD1(_)
+ | PoolKind::ClickHouse(_)
+ | PoolKind::Rqlite(_)
+ | PoolKind::Turso(_)
+ | PoolKind::SqlServer(_)
+ | PoolKind::Agent(_) => true,
+ PoolKind::MessageQueue
+ | PoolKind::Nacos
+ | PoolKind::HBase(_)
+ | PoolKind::DuckDb(_)
+ | PoolKind::DuckDbWorker(_)
+ | PoolKind::Redis(_)
+ | PoolKind::MongoDb(_)
+ | PoolKind::Elasticsearch(_)
+ | PoolKind::VectorDb(_)
+ | PoolKind::InfluxDb(_)
+ | PoolKind::ExternalTabular(_)
+ | PoolKind::ExternalDriver { .. } => false,
+ }
+}
+
+/// Execute Schema Diff deploy SQL as one real single-connection transaction.
+///
+/// - Uses [`execute_statements_in_transaction`] so partial success rolls back.
+/// - Returns a structured result (never re-executes statements to probe status).
+/// - Comment-only / empty scripts succeed as `committed` with zero statements.
+/// - When the target path cannot guarantee DDL atomicity (MySQL/Oracle DDL
+/// auto-commit, `TxPath::None`, etc.), a failure reports `mixed` and
+/// `executed_count` reflects the statements that were issued before the
+/// error, so the caller can warn the user that partial effects may persist.
+pub async fn execute_schema_diff_deploy(
+ state: &AppState,
+ connection_id: &str,
+ database: &str,
+ statements: &[String],
+ schema: Option<&str>,
+) -> SchemaDiffDeployResult {
+ let tx_id = format!("deploy_{}", uuid::Uuid::new_v4());
+ let now = chrono::Utc::now().to_rfc3339();
+ let db_type = connection_database_type(state, connection_id).await;
+
+ let parsed: Vec = statements
+ .iter()
+ .flat_map(|s| {
+ db_type.map_or_else(|| split_sql_statements(s), |dt| crate::sql::split_sql_statements_for_database(s, dt))
+ })
+ .map(|s| s.trim().to_string())
+ .filter(|s| {
+ !s.is_empty()
+ && !s.lines().all(|line| {
+ let t = line.trim();
+ t.is_empty() || t.starts_with("--")
+ })
+ })
+ .collect();
+
+ let participant = crate::two_phase_commit::ParticipantInfo {
+ id: "connection".to_string(),
+ name: format!("{connection_id}/{database}"),
+ role: "database".to_string(),
+ };
+
+ if parsed.is_empty() {
+ return SchemaDiffDeployResult {
+ transaction_id: tx_id,
+ status: crate::two_phase_commit::TransactionStatus::Committed.as_str().to_string(),
+ participants: vec![participant],
+ created_at: now.clone(),
+ updated_at: now,
+ executed_count: 0,
+ statement_count: 0,
+ error: None,
+ metadata: serde_json::json!({"source": "schema_diff_deploy", "mode": "single_connection_tx"}),
+ };
+ }
+
+ let pool_key = if database.is_empty() {
+ connection_id.to_string()
+ } else {
+ match state.get_or_create_pool(connection_id, Some(database)).await {
+ Ok(key) => key,
+ Err(_) => {
+ return SchemaDiffDeployResult {
+ transaction_id: tx_id.clone(),
+ status: crate::two_phase_commit::TransactionStatus::RolledBack.as_str().to_string(),
+ participants: vec![participant],
+ created_at: now.clone(),
+ updated_at: chrono::Utc::now().to_rfc3339(),
+ executed_count: 0,
+ statement_count: parsed.len(),
+ error: Some("Connection not available for deploy".to_string()),
+ metadata: serde_json::json!({"source": "schema_diff_deploy", "mode": "single_connection_tx"}),
+ };
+ }
+ }
+ };
+ let has_transactional_path = {
+ let conns = state.connections.read().await;
+ conns.get(&pool_key).is_some_and(pool_kind_has_transactional_path)
+ };
+ let atomicity = classify_schema_diff_atomicity(db_type, &parsed, has_transactional_path);
+
+ match execute_statements_in_transaction_on_pool(state, &pool_key, connection_id, database, &parsed, schema).await {
+ Ok(result) => SchemaDiffDeployResult {
+ transaction_id: tx_id,
+ status: crate::two_phase_commit::TransactionStatus::Committed.as_str().to_string(),
+ participants: vec![participant],
+ created_at: now.clone(),
+ updated_at: chrono::Utc::now().to_rfc3339(),
+ executed_count: parsed.len(),
+ statement_count: parsed.len(),
+ error: None,
+ metadata: serde_json::json!({
+ "source": "schema_diff_deploy",
+ "mode": "single_connection_tx",
+ "affected_rows": result.affected_rows,
+ "execution_time_ms": result.execution_time_ms,
+ }),
+ },
+ Err(e) => {
+ let (status, executed_count) = schema_diff_failure_outcome(atomicity, &e, parsed.len());
+ SchemaDiffDeployResult {
+ transaction_id: tx_id,
+ status: status.as_str().to_string(),
+ participants: vec![participant],
+ created_at: now.clone(),
+ updated_at: chrono::Utc::now().to_rfc3339(),
+ executed_count,
+ statement_count: parsed.len(),
+ error: Some(e.clone()),
+ metadata: serde_json::json!({
+ "source": "schema_diff_deploy",
+ "mode": "single_connection_tx",
+ "ddl_atomic": atomicity.ddl_atomic(),
+ "atomicity": match atomicity {
+ SchemaDiffAtomicity::GuaranteedRollback => "guaranteed_rollback",
+ SchemaDiffAtomicity::PartialEffectsPossible => "partial_effects_possible",
+ },
+ "error": e,
+ }),
+ }
+ }
+ }
+}
+
/// Execute multiple SQL statements within a single transaction.
/// For pooled drivers (Postgres/MySQL), uses the driver transaction API.
/// For SQLite and already-single-connection drivers (ClickHouse/SqlServer/Agent),
@@ -3637,6 +3889,132 @@ mod tests {
};
use crate::storage::Storage;
+ #[test]
+ fn schema_diff_atomicity_marks_mysql_ddl_as_partial() {
+ let atomicity = classify_schema_diff_atomicity(
+ Some(DatabaseType::Mysql),
+ &["CREATE TABLE users (id INT)".to_string(), "ALTER TABLE users ADD COLUMN name VARCHAR(32)".to_string()],
+ true,
+ );
+
+ assert_eq!(atomicity, SchemaDiffAtomicity::PartialEffectsPossible);
+ }
+
+ #[test]
+ fn schema_diff_atomicity_marks_oracle_ddl_as_partial() {
+ let atomicity = classify_schema_diff_atomicity(
+ Some(DatabaseType::Oracle),
+ &["CREATE TABLE users (id INT)".to_string(), "ALTER TABLE users ADD name VARCHAR2(32)".to_string()],
+ true,
+ );
+
+ assert_eq!(atomicity, SchemaDiffAtomicity::PartialEffectsPossible);
+ }
+
+ #[test]
+ fn schema_diff_atomicity_keeps_postgres_ddl_atomic() {
+ let atomicity = classify_schema_diff_atomicity(
+ Some(DatabaseType::Postgres),
+ &["CREATE TABLE users (id INT)".to_string(), "ALTER TABLE users ADD COLUMN name VARCHAR(32)".to_string()],
+ true,
+ );
+
+ assert_eq!(atomicity, SchemaDiffAtomicity::GuaranteedRollback);
+ }
+
+ #[test]
+ fn schema_diff_atomicity_keeps_dml_atomic_when_tx_path_exists() {
+ let atomicity = classify_schema_diff_atomicity(
+ Some(DatabaseType::Mysql),
+ &["INSERT INTO users VALUES (1)".to_string(), "UPDATE users SET active = 1 WHERE id = 1".to_string()],
+ true,
+ );
+
+ assert_eq!(atomicity, SchemaDiffAtomicity::GuaranteedRollback);
+ }
+
+ #[test]
+ fn schema_diff_atomicity_marks_missing_transaction_path_as_partial() {
+ let atomicity = classify_schema_diff_atomicity(
+ Some(DatabaseType::Postgres),
+ &["CREATE TABLE users (id INT)".to_string()],
+ false,
+ );
+
+ assert_eq!(atomicity, SchemaDiffAtomicity::PartialEffectsPossible);
+ }
+
+ #[test]
+ fn executed_count_before_error_uses_failing_statement_index() {
+ assert_eq!(executed_count_before_error("Statement 1 failed: syntax error", 3), 0);
+ assert_eq!(executed_count_before_error("Statement 2 failed: syntax error", 3), 1);
+ assert_eq!(executed_count_before_error("Statement 3 failed: syntax error", 3), 2);
+ }
+
+ #[test]
+ fn schema_diff_failure_outcome_rolls_back_when_atomic() {
+ let (status, executed) =
+ schema_diff_failure_outcome(SchemaDiffAtomicity::GuaranteedRollback, "Statement 2 failed: syntax error", 3);
+ assert_eq!(status, crate::two_phase_commit::TransactionStatus::RolledBack);
+ assert_eq!(executed, 0);
+ }
+
+ #[test]
+ fn schema_diff_failure_outcome_reports_mixed_with_partial_count() {
+ let (status, executed) = schema_diff_failure_outcome(
+ SchemaDiffAtomicity::PartialEffectsPossible,
+ "Statement 2 failed: syntax error",
+ 3,
+ );
+ assert_eq!(status, crate::two_phase_commit::TransactionStatus::Mixed);
+ assert_eq!(executed, 1);
+ }
+
+ #[test]
+ fn schema_diff_atomicity_keeps_sqlite_ddl_atomic() {
+ let atomicity = classify_schema_diff_atomicity(
+ Some(DatabaseType::Sqlite),
+ &["CREATE TABLE users (id INTEGER)".to_string()],
+ true,
+ );
+ assert_eq!(atomicity, SchemaDiffAtomicity::GuaranteedRollback);
+ }
+
+ /// MySQL: first DDL may already commit; second fails → mixed + executed_count = 1.
+ #[test]
+ fn mysql_second_ddl_failure_maps_to_mixed_with_partial_executed_count() {
+ let stmts = ["CREATE TABLE t1 (id INT)".to_string(), "CREATE TABLE t2 (id INT)".to_string()];
+ let atomicity = classify_schema_diff_atomicity(Some(DatabaseType::Mysql), &stmts, true);
+ assert_eq!(atomicity, SchemaDiffAtomicity::PartialEffectsPossible);
+ let (status, executed) =
+ schema_diff_failure_outcome(atomicity, "Statement 2 failed: table already exists", stmts.len());
+ assert_eq!(status, crate::two_phase_commit::TransactionStatus::Mixed);
+ assert_eq!(executed, 1);
+ }
+
+ /// Oracle: same non-transactional DDL semantics as MySQL for deploy status.
+ #[test]
+ fn oracle_second_ddl_failure_maps_to_mixed_with_partial_executed_count() {
+ let stmts = ["CREATE TABLE t1 (id NUMBER)".to_string(), "ALTER TABLE t1 ADD name VARCHAR2(32)".to_string()];
+ let atomicity = classify_schema_diff_atomicity(Some(DatabaseType::Oracle), &stmts, true);
+ assert_eq!(atomicity, SchemaDiffAtomicity::PartialEffectsPossible);
+ let (status, executed) = schema_diff_failure_outcome(atomicity, "Statement 2 failed: ORA-00942", stmts.len());
+ assert_eq!(status, crate::two_phase_commit::TransactionStatus::Mixed);
+ assert_eq!(executed, 1);
+ }
+
+ /// Postgres transactional DDL: second fails → rolled_back + executed_count = 0.
+ #[test]
+ fn postgres_second_ddl_failure_maps_to_rolled_back_zero_executed() {
+ let stmts = ["CREATE TABLE t1 (id INT)".to_string(), "CREATE TABLE t2 (id INT)".to_string()];
+ let atomicity = classify_schema_diff_atomicity(Some(DatabaseType::Postgres), &stmts, true);
+ assert_eq!(atomicity, SchemaDiffAtomicity::GuaranteedRollback);
+ let (status, executed) =
+ schema_diff_failure_outcome(atomicity, "Statement 2 failed: relation already exists", stmts.len());
+ assert_eq!(status, crate::two_phase_commit::TransactionStatus::RolledBack);
+ assert_eq!(executed, 0);
+ }
+
#[test]
fn query_execution_mode_deserializes_simple_client_value() {
let mode: QueryExecutionMode = serde_json::from_str("\"simple\"").unwrap();
diff --git a/crates/dbx-core/src/risk_metrics.rs b/crates/dbx-core/src/risk_metrics.rs
new file mode 100644
index 000000000..5eb48b02c
--- /dev/null
+++ b/crates/dbx-core/src/risk_metrics.rs
@@ -0,0 +1,376 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Mutex;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum MetricType {
+ Counter,
+ Gauge,
+ Histogram,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MetricEntry {
+ pub name: String,
+ pub metric_type: MetricType,
+ pub description: String,
+ pub labels: HashMap,
+ pub value: MetricValue,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum MetricValue {
+ Counter(u64),
+ Gauge(f64),
+ Histogram(Vec<(f64, u64)>),
+}
+
+pub struct DegradationMetrics {
+ degradation_total: AtomicU64,
+ degradation_level_full: AtomicU64,
+ degradation_level_sample: AtomicU64,
+ degradation_level_skip: AtomicU64,
+ sample_rate_histogram: Mutex>,
+ confidence_gauge: Mutex,
+ auto_upgrade_total: AtomicU64,
+ auto_downgrade_total: AtomicU64,
+ // Phase 15.5: OSC and rollback metrics
+ osc_probe_latency: Mutex>,
+ osc_execution_gauge: Mutex,
+ rollback_trigger_count: AtomicU64,
+ tag_block_count: AtomicU64,
+ trace_dropped_count: AtomicU64,
+}
+
+impl DegradationMetrics {
+ pub fn new() -> Self {
+ Self {
+ degradation_total: AtomicU64::new(0),
+ degradation_level_full: AtomicU64::new(0),
+ degradation_level_sample: AtomicU64::new(0),
+ degradation_level_skip: AtomicU64::new(0),
+ sample_rate_histogram: Mutex::new(Vec::new()),
+ confidence_gauge: Mutex::new(0.0),
+ auto_upgrade_total: AtomicU64::new(0),
+ auto_downgrade_total: AtomicU64::new(0),
+ osc_probe_latency: Mutex::new(Vec::new()),
+ osc_execution_gauge: Mutex::new(0.0),
+ rollback_trigger_count: AtomicU64::new(0),
+ tag_block_count: AtomicU64::new(0),
+ trace_dropped_count: AtomicU64::new(0),
+ }
+ }
+
+ pub fn record_degradation(&self, level: &str, sample_rate: f64, confidence: f64) {
+ self.degradation_total.fetch_add(1, Ordering::Relaxed);
+ match level {
+ "full" => {
+ self.degradation_level_full.fetch_add(1, Ordering::Relaxed);
+ }
+ "sample" => {
+ self.degradation_level_sample.fetch_add(1, Ordering::Relaxed);
+ }
+ "skip_with_risk" => {
+ self.degradation_level_skip.fetch_add(1, Ordering::Relaxed);
+ }
+ _ => {}
+ }
+ if let Ok(mut h) = self.sample_rate_histogram.lock() {
+ h.push((sample_rate, 1));
+ }
+ if let Ok(mut g) = self.confidence_gauge.lock() {
+ *g = confidence;
+ }
+ }
+
+ pub fn record_auto_upgrade(&self) {
+ self.auto_upgrade_total.fetch_add(1, Ordering::Relaxed);
+ }
+
+ pub fn record_auto_downgrade(&self) {
+ self.auto_downgrade_total.fetch_add(1, Ordering::Relaxed);
+ }
+
+ // --- Phase 15.5: OSC & rollback metrics ---
+
+ pub fn record_osc_probe_latency(&self, latency_ms: f64) {
+ if let Ok(mut h) = self.osc_probe_latency.lock() {
+ h.push(latency_ms);
+ if h.len() > 1000 {
+ h.remove(0);
+ }
+ }
+ }
+
+ pub fn set_osc_execution_status(&self, status: f64) {
+ if let Ok(mut g) = self.osc_execution_gauge.lock() {
+ *g = status;
+ }
+ }
+
+ pub fn record_rollback_trigger(&self) {
+ self.rollback_trigger_count.fetch_add(1, Ordering::Relaxed);
+ }
+
+ pub fn record_tag_block(&self) {
+ self.tag_block_count.fetch_add(1, Ordering::Relaxed);
+ }
+
+ pub fn record_trace_dropped(&self) {
+ self.trace_dropped_count.fetch_add(1, Ordering::Relaxed);
+ }
+
+ pub fn snapshot(&self) -> Vec {
+ let mut entries = vec![
+ MetricEntry {
+ name: "dbx_degradation_total".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Total number of degradation decisions".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.degradation_total.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_degradation_level_full".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Number of full compare decisions".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.degradation_level_full.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_degradation_level_sample".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Number of sample compare decisions".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.degradation_level_sample.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_degradation_level_skip".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Number of skip-with-risk decisions".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.degradation_level_skip.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_auto_upgrade_total".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Number of automatic upgrades in degradation chain".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.auto_upgrade_total.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_auto_downgrade_total".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Number of automatic downgrades in degradation chain".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.auto_downgrade_total.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_confidence_gauge".to_string(),
+ metric_type: MetricType::Gauge,
+ description: "Current confidence score".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Gauge(*self.confidence_gauge.lock().unwrap_or_else(|e| e.into_inner())),
+ },
+ ];
+
+ // Phase 15.5: OSC and rollback metrics
+ if let Ok(h) = self.osc_probe_latency.lock() {
+ if !h.is_empty() {
+ entries.push(MetricEntry {
+ name: "dbx_osc_probe_latency".to_string(),
+ metric_type: MetricType::Histogram,
+ description: "Distribution of OSC probe latency in milliseconds".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Histogram(h.iter().map(|&v| (v, 1u64)).collect()),
+ });
+ }
+ }
+ entries.extend(vec![
+ MetricEntry {
+ name: "dbx_osc_execution_status".to_string(),
+ metric_type: MetricType::Gauge,
+ description: "Current OSC execution status (0=idle, 1=running, 2=completed, -1=error)".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Gauge(*self.osc_execution_gauge.lock().unwrap_or_else(|e| e.into_inner())),
+ },
+ MetricEntry {
+ name: "dbx_rollback_trigger_total".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Total number of rollback triggers".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.rollback_trigger_count.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_tag_block_total".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Total number of tag policy blocks".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.tag_block_count.load(Ordering::Relaxed)),
+ },
+ MetricEntry {
+ name: "dbx_trace_dropped_total".to_string(),
+ metric_type: MetricType::Counter,
+ description: "Total number of dropped trace entries".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Counter(self.trace_dropped_count.load(Ordering::Relaxed)),
+ },
+ ]);
+
+ if let Ok(h) = self.sample_rate_histogram.lock() {
+ entries.push(MetricEntry {
+ name: "dbx_sample_rate_histogram".to_string(),
+ metric_type: MetricType::Histogram,
+ description: "Distribution of sampling rates used".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Histogram(h.clone()),
+ });
+ }
+
+ entries
+ }
+}
+
+impl Default for DegradationMetrics {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+pub fn export_prometheus(metrics: &[MetricEntry]) -> String {
+ let mut out = String::new();
+ for entry in metrics {
+ let name = &entry.name;
+ let desc = &entry.description;
+ let labels = if entry.labels.is_empty() {
+ String::new()
+ } else {
+ let pairs: Vec = entry.labels.iter().map(|(k, v)| format!("{k}=\"{v}\"")).collect();
+ format!("{{{}}}", pairs.join(","))
+ };
+
+ out.push_str(&format!("# HELP {name} {desc}\n"));
+ match &entry.metric_type {
+ MetricType::Counter => {
+ out.push_str(&format!("# TYPE {name} counter\n"));
+ if let MetricValue::Counter(v) = &entry.value {
+ out.push_str(&format!("{name}{labels} {v}\n"));
+ }
+ }
+ MetricType::Gauge => {
+ out.push_str(&format!("# TYPE {name} gauge\n"));
+ if let MetricValue::Gauge(v) = &entry.value {
+ out.push_str(&format!("{name}{labels} {v}\n"));
+ }
+ }
+ MetricType::Histogram => {
+ out.push_str(&format!("# TYPE {name} histogram\n"));
+ if let MetricValue::Histogram(buckets) = &entry.value {
+ for (le, count) in buckets {
+ out.push_str(&format!("{name}_bucket{{le=\"{le}\"}} {count}\n"));
+ }
+ let total: u64 = buckets.iter().map(|(_, c)| c).sum();
+ out.push_str(&format!("{name}_count{labels} {total}\n"));
+ }
+ }
+ }
+ }
+ out
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn degradation_metrics_records_levels() {
+ let metrics = DegradationMetrics::new();
+ metrics.record_degradation("full", 1.0, 1.0);
+ metrics.record_degradation("sample", 0.1, 0.8);
+ metrics.record_degradation("skip_with_risk", 0.0, 0.0);
+
+ let snapshot = metrics.snapshot();
+ let total = snapshot.iter().find(|e| e.name == "dbx_degradation_total").unwrap();
+ assert_eq!(total.value, MetricValue::Counter(3));
+ let full = snapshot.iter().find(|e| e.name == "dbx_degradation_level_full").unwrap();
+ assert_eq!(full.value, MetricValue::Counter(1));
+ let sample = snapshot.iter().find(|e| e.name == "dbx_degradation_level_sample").unwrap();
+ assert_eq!(sample.value, MetricValue::Counter(1));
+ let skip = snapshot.iter().find(|e| e.name == "dbx_degradation_level_skip").unwrap();
+ assert_eq!(skip.value, MetricValue::Counter(1));
+ }
+
+ #[test]
+ fn degradation_metrics_auto_chain_events() {
+ let metrics = DegradationMetrics::new();
+ metrics.record_auto_upgrade();
+ metrics.record_auto_upgrade();
+ metrics.record_auto_downgrade();
+
+ let snapshot = metrics.snapshot();
+ let up = snapshot.iter().find(|e| e.name == "dbx_auto_upgrade_total").unwrap();
+ assert_eq!(up.value, MetricValue::Counter(2));
+ let down = snapshot.iter().find(|e| e.name == "dbx_auto_downgrade_total").unwrap();
+ assert_eq!(down.value, MetricValue::Counter(1));
+ }
+
+ #[test]
+ fn degradation_metrics_confidence_gauge() {
+ let metrics = DegradationMetrics::new();
+ metrics.record_degradation("sample", 0.05, 0.85);
+
+ let snapshot = metrics.snapshot();
+ let gauge = snapshot.iter().find(|e| e.name == "dbx_confidence_gauge").unwrap();
+ assert_eq!(gauge.value, MetricValue::Gauge(0.85));
+ }
+
+ #[test]
+ fn export_prometheus_counter() {
+ let mut labels = HashMap::new();
+ labels.insert("level".to_string(), "full".to_string());
+ let entries = vec![MetricEntry {
+ name: "test_counter".to_string(),
+ metric_type: MetricType::Counter,
+ description: "A test counter".to_string(),
+ labels,
+ value: MetricValue::Counter(42),
+ }];
+ let output = export_prometheus(&entries);
+ assert!(output.contains("# HELP test_counter A test counter"));
+ assert!(output.contains("# TYPE test_counter counter"));
+ assert!(output.contains("test_counter{level=\"full\"} 42"));
+ }
+
+ #[test]
+ fn export_prometheus_gauge() {
+ let entries = vec![MetricEntry {
+ name: "test_gauge".to_string(),
+ metric_type: MetricType::Gauge,
+ description: "A test gauge".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Gauge(3.125),
+ }];
+ let output = export_prometheus(&entries);
+ assert!(output.contains("# TYPE test_gauge gauge"));
+ assert!(output.contains("test_gauge 3.125"));
+ }
+
+ #[test]
+ fn export_prometheus_histogram() {
+ let buckets = vec![(0.5, 10u64), (1.0, 5u64), (1.5, 2u64)];
+ let entries = vec![MetricEntry {
+ name: "test_histogram".to_string(),
+ metric_type: MetricType::Histogram,
+ description: "A test histogram".to_string(),
+ labels: HashMap::new(),
+ value: MetricValue::Histogram(buckets),
+ }];
+ let output = export_prometheus(&entries);
+ assert!(output.contains("# TYPE test_histogram histogram"));
+ assert!(output.contains("test_histogram_bucket{le=\"0.5\"} 10"));
+ assert!(output.contains("test_histogram_bucket{le=\"1\"} 5"));
+ assert!(output.contains("test_histogram_count 17"));
+ }
+}
diff --git a/crates/dbx-core/src/safety_report.rs b/crates/dbx-core/src/safety_report.rs
new file mode 100644
index 000000000..e5adfc782
--- /dev/null
+++ b/crates/dbx-core/src/safety_report.rs
@@ -0,0 +1,53 @@
+use crate::sql_risk::ImpactReport;
+
+/// Generate a human-readable safety check report string.
+pub fn generate_safety_report(report: &ImpactReport) -> String {
+ let mut lines = Vec::new();
+
+ lines.push("=== SQL Safety Check Report ===".to_string());
+ lines.push(format!("Overall Risk: {}", report.overall_risk));
+
+ if let Some(drl) = &report.ddl_risk_level {
+ lines.push(format!("DDL Risk Level: {}", drl));
+ } else {
+ lines.push("DDL Risk Level: N/A (no DDL statements)".to_string());
+ }
+
+ lines.push(format!("Statement Count: {}", report.statement_count));
+ lines.push(format!("Recommended Strategy: {}", report.recommended_strategy));
+ lines.push(format!("Estimated Duration: {}", report.estimated_total_duration));
+ lines.push(format!("Maintenance Window Required: {}", report.requires_maintenance_window));
+ lines.push(format!("Reversible: {}", report.is_reversible));
+
+ if !report.ddl_details.is_empty() {
+ lines.push("\n--- DDL Details ---".to_string());
+ for (i, detail) in report.ddl_details.iter().enumerate() {
+ lines.push(format!(
+ " {}. [{}] {} — affects: {}",
+ i + 1,
+ detail.ddl_risk,
+ detail.summary,
+ detail.affected_objects.join(", ")
+ ));
+ }
+ }
+
+ if !report.estimated_locks.is_empty() {
+ lines.push("\n--- Estimated Locks ---".to_string());
+ for lock in &report.estimated_locks {
+ lines.push(format!(
+ " {}: {} lock ({}) — {}",
+ lock.object, lock.lock_type, lock.scope, lock.estimated_duration
+ ));
+ }
+ }
+
+ if !report.warnings.is_empty() {
+ lines.push("\n--- Warnings ---".to_string());
+ for w in &report.warnings {
+ lines.push(format!(" ! {}", w));
+ }
+ }
+
+ lines.join("\n")
+}
diff --git a/crates/dbx-core/src/schema_diff.rs b/crates/dbx-core/src/schema_diff.rs
index 143c60c97..5f2f2f2b3 100644
--- a/crates/dbx-core/src/schema_diff.rs
+++ b/crates/dbx-core/src/schema_diff.rs
@@ -1,8 +1,18 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::{HashMap, HashSet, VecDeque};
+use log;
+use rayon::prelude::*;
+use regex::Regex;
use serde::{Deserialize, Serialize};
use crate::models::connection::DatabaseType;
+use crate::sql_dialect::ddl_profile::{profile_for, DdlDialectProfile};
+use crate::sql_dialect::descriptor::DialectKind;
+use crate::sql_dialect::inference::{ColumnType, DefaultTypeInferenceEngine, TypeInferenceEngine};
+use crate::sql_dialect::type_rewrite::{
+ apply_auto_inc_to_column_def, rewrite_column_type, type_looks_integer, AutoIncColumnBuild,
+};
+use crate::sql_parser::ast_filter::AstTransmitFilter;
use crate::types::{
ColumnInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, OwnerInfo, RuleInfo, SequenceInfo, TableInfo, TriggerInfo,
};
@@ -119,7 +129,7 @@ pub struct OwnerDiff {
pub changes: Vec,
}
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct TableDiff {
#[serde(rename = "type")]
@@ -163,6 +173,95 @@ pub struct TableSchemaDetail {
pub ddl: Option,
}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub enum ParamStrategy {
+ Preserve,
+ Strip,
+ Custom,
+}
+
+fn default_param_strategy() -> ParamStrategy {
+ ParamStrategy::Preserve
+}
+
+/// A custom field type mapping override: source_type → target_type.
+/// Used when source and target database types differ.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FieldMapping {
+ pub source_type: String,
+ pub target_type: String,
+ #[serde(default = "default_param_strategy")]
+ pub param_strategy: ParamStrategy,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub custom_params: Option,
+}
+
+impl FieldMapping {
+ pub fn apply<'a>(mappings: &'a [FieldMapping], source_type: &str) -> Option<&'a str> {
+ let base_type = source_type.split('(').next().unwrap_or(source_type).trim();
+ mappings.iter().find(|m| m.source_type.eq_ignore_ascii_case(base_type)).map(|m| m.target_type.as_str())
+ }
+
+ pub fn apply_with_params(mappings: &[FieldMapping], source_type: &str, target_kind: DialectKind) -> Option {
+ let trimmed = source_type.trim();
+ let base_type = trimmed.split('(').next().unwrap_or(trimmed);
+ let source_params = &trimmed[base_type.len()..];
+ let matched = mappings.iter().find(|m| m.source_type.eq_ignore_ascii_case(base_type))?;
+
+ let result = match matched.param_strategy {
+ ParamStrategy::Strip => Some(matched.target_type.clone()),
+ ParamStrategy::Custom => match &matched.custom_params {
+ Some(params) if !params.is_empty() => {
+ let p = params.trim();
+ // Normalize: wrap bare params (e.g. "100") in parentheses so the
+ // generated type becomes e.g. `character(100)` rather than `character100`.
+ let formatted = if p.starts_with('(') { p.to_string() } else { format!("({})", p) };
+ Some(format!("{}{}", matched.target_type, formatted))
+ }
+ _ => Some(matched.target_type.clone()),
+ },
+ ParamStrategy::Preserve => {
+ let supports = type_supports_params(target_kind, &matched.target_type);
+ let has_params = !source_params.is_empty();
+ if has_params && supports {
+ Some(format!("{}{}", matched.target_type, source_params))
+ } else {
+ log::info!(
+ "apply_with_params[Preserve] source={} target={} strategy={:?} has_params={} supports_params={} -> bare {}",
+ source_type, matched.target_type, matched.param_strategy, has_params, supports, matched.target_type
+ );
+ Some(matched.target_type.clone())
+ }
+ }
+ };
+ log::info!(
+ "apply_with_params source={} target_type={} strategy={:?} result={:?}",
+ source_type,
+ matched.target_type,
+ matched.param_strategy,
+ result
+ );
+ result
+ }
+}
+
+fn type_supports_params(kind: DialectKind, type_name: &str) -> bool {
+ crate::sql_dialect::dialect_loader::register_core_dialects();
+ let registry = crate::sql_dialect::dialect_loader::DialectRegistry::global();
+ let all = registry.get_all_by_kind(kind);
+ if all.is_empty() {
+ return true;
+ }
+ all.iter().any(|loaded| {
+ loaded.yaml.types.iter().any(|t| {
+ (t.name.eq_ignore_ascii_case(type_name) || t.aliases.iter().any(|a| a.eq_ignore_ascii_case(type_name)))
+ && (t.has_length || t.has_precision || t.max_precision.is_some())
+ })
+ })
+}
+
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SchemaDiffPreparationOptions {
@@ -199,6 +298,59 @@ pub struct SchemaDiffPreparationOptions {
pub cascade_delete: bool,
#[serde(default)]
pub compare_column_order: bool,
+ #[serde(default)]
+ pub detect_renames: bool,
+ #[serde(default)]
+ pub detect_table_renames: bool,
+ #[serde(default)]
+ pub rename_threshold: f64,
+ #[serde(default)]
+ pub enable_rollback: bool,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub batch_patterns: Vec,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub source_dialect: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub target_dialect: Option,
+ #[serde(default)]
+ pub compatibility_threshold: f64,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub source_permissions: Vec,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub target_permissions: Vec,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub shard_strategy: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub resource_constraint: Option,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub field_mappings: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct MissingRollbackObject {
+ pub kind: String,
+ pub name: String,
+ pub table: Option,
+ pub reason: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub enum RollbackCompleteness {
+ #[serde(rename = "complete")]
+ Complete,
+ #[serde(rename = "incomplete")]
+ Incomplete,
+}
+
+impl RollbackCompleteness {
+ pub fn as_str(&self) -> &'static str {
+ match self {
+ Self::Complete => "complete",
+ Self::Incomplete => "incomplete",
+ }
+ }
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -214,16 +366,1455 @@ pub struct SchemaDiffPreparation {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub owner_diffs: Vec,
pub sync_sql: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub rollback_sync_sql: Option,
+ /// Whether rollback SQL is complete enough to execute safely.
+ #[serde(default = "default_rollback_complete")]
+ pub rollback_completeness: RollbackCompleteness,
+ /// Objects that could not be reconstructed for rollback (e.g. triggers without body).
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub missing_rollback_objects: Vec,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub rename_candidates: Vec,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub rollback_graph: Option,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub compatibility_warnings: Vec,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub permission_diffs: Vec,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub permission_sync_sql: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub dependency_graph: Option,
+}
+
+fn default_rollback_complete() -> RollbackCompleteness {
+ RollbackCompleteness::Complete
+}
+
+// ============================================================================
+// Phase 4.1: Dependency Graph & Rename Detection
+// ============================================================================
+
+/// Regex-based text scanning for table references in SQL/DDL text.
+/// Used as fallback when no live DB query (YAML metadata_queries.dependencies) is available.
+fn extract_ddl_references(sql: &str, known_tables: &HashSet<&str>) -> Vec {
+ let upper = sql.to_uppercase();
+ let mut refs: Vec = Vec::new();
+
+ for table in known_tables {
+ let table_up = table.to_uppercase();
+ // Match after SQL keywords that indicate table references
+ let patterns = [
+ format!(" FROM {table_up}"),
+ format!(" JOIN {table_up}"),
+ format!(" INTO {table_up}"),
+ format!(" TABLE {table_up}"),
+ format!(" REFERENCES {table_up}"),
+ format!(" UPDATE {table_up}"),
+ format!("DELETE FROM {table_up}"),
+ format!("FROM {table_up} ("),
+ format!(" {table_up}."),
+ ];
+ if patterns.iter().any(|p| upper.contains(p.as_str())) {
+ refs.push(table.to_string());
+ }
+ }
+
+ refs
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DependencyNode {
+ pub table_name: String,
+ pub depends_on: Vec,
+ pub depended_by: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DependencyGraph {
+ pub nodes: HashMap,
+ pub topological_order: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CoverageReport {
+ pub level1_score: f64,
+ pub level2_score: f64,
+ pub composite_score: f64,
+ pub level1_covered: u64,
+ pub level1_total: u64,
+ pub level2_covered: u64,
+ pub level2_total: u64,
+ pub uncovered_edges: Vec,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UncoveredEdge {
+ pub from_table: String,
+ pub to_table: String,
+ pub level: u32,
+}
+
+impl DependencyGraph {
+ pub fn build(details: &[TableSchemaDetail], tables: &[TableInfo]) -> Self {
+ Self::build_with_functions(details, tables, &[], &[])
+ }
+
+ /// Extended build: also extracts dependencies from view DDLs, triggers, and function/sequence definitions.
+ /// Falls back to regex-based text scanning when no live DB query is available.
+ pub fn build_with_functions(
+ details: &[TableSchemaDetail],
+ tables: &[TableInfo],
+ functions: &[FunctionInfo],
+ _sequences: &[SequenceInfo],
+ ) -> Self {
+ let table_names: HashSet<&str> =
+ tables.iter().filter(|t| !t.table_type.contains("VIEW")).map(|t| t.name.as_str()).collect();
+ let view_names: HashSet<&str> =
+ tables.iter().filter(|t| t.table_type.contains("VIEW")).map(|t| t.name.as_str()).collect();
+ let all_names: HashSet<&str> = tables.iter().map(|t| t.name.as_str()).collect();
+
+ let mut nodes: HashMap = all_names
+ .iter()
+ .map(|name| {
+ (
+ name.to_string(),
+ DependencyNode { table_name: name.to_string(), depends_on: Vec::new(), depended_by: Vec::new() },
+ )
+ })
+ .collect();
+
+ let detail_map: HashMap<&str, &TableSchemaDetail> = details.iter().map(|d| (d.name.as_str(), d)).collect();
+ let function_by_name: HashMap<&str, &FunctionInfo> = functions.iter().map(|f| (f.name.as_str(), f)).collect();
+
+ // Phase 1: FK-based dependencies (existing logic)
+ for table_name in &table_names {
+ if let Some(detail) = detail_map.get(table_name) {
+ for fk in &detail.foreign_keys {
+ if table_names.contains(fk.ref_table.as_str()) {
+ if let Some(node) = nodes.get_mut(*table_name) {
+ if !node.depends_on.contains(&fk.ref_table) {
+ node.depends_on.push(fk.ref_table.clone());
+ }
+ }
+ if let Some(ref_node) = nodes.get_mut(&fk.ref_table) {
+ if !ref_node.depended_by.iter().any(|d| d == *table_name) {
+ ref_node.depended_by.push((*table_name).to_string());
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Phase 2: View DDL text scanning
+ for view_name in &view_names {
+ if let Some(detail) = detail_map.get(view_name) {
+ if let Some(ddl) = &detail.ddl {
+ let refs = extract_ddl_references(ddl, &table_names);
+ for ref_table in refs {
+ if let Some(node) = nodes.get_mut(*view_name) {
+ if !node.depends_on.contains(&ref_table) {
+ node.depends_on.push(ref_table.clone());
+ }
+ }
+ if let Some(ref_node) = nodes.get_mut(&ref_table) {
+ if !ref_node.depended_by.iter().any(|d| d == *view_name) {
+ ref_node.depended_by.push((*view_name).to_string());
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Phase 3: Trigger statement text scanning
+ for table_name in &all_names {
+ if let Some(detail) = detail_map.get(table_name) {
+ for trigger in &detail.triggers {
+ if let Some(stmt) = &trigger.statement {
+ let refs = extract_ddl_references(stmt, &table_names);
+ for ref_table in refs {
+ if let Some(node) = nodes.get_mut(*table_name) {
+ if !node.depends_on.contains(&ref_table) {
+ node.depends_on.push(ref_table.clone());
+ }
+ }
+ if let Some(ref_node) = nodes.get_mut(&ref_table) {
+ if !ref_node.depended_by.iter().any(|d| d == *table_name) {
+ ref_node.depended_by.push((*table_name).to_string());
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Phase 4: Function definition text scanning
+ for (_func_name, func) in &function_by_name {
+ let refs = extract_ddl_references(&func.definition, &table_names);
+ for ref_table in &refs {
+ if let Some(ref_node) = nodes.get_mut(ref_table) {
+ if !ref_node.depended_by.iter().any(|d| d == _func_name) {
+ ref_node.depended_by.push(_func_name.to_string());
+ }
+ }
+ }
+ }
+
+ let topological_order = Self::topological_sort(&nodes);
+ DependencyGraph { nodes, topological_order }
+ }
+
+ fn topological_sort(nodes: &HashMap) -> Vec {
+ let mut in_degree: HashMap<&str, usize> = nodes.keys().map(|k| (k.as_str(), 0usize)).collect();
+ for node in nodes.values() {
+ in_degree.entry(node.table_name.as_str()).or_insert(0);
+ for _dep in &node.depends_on {
+ *in_degree.entry(node.table_name.as_str()).or_insert(0) += 1;
+ }
+ }
+
+ let mut queue: VecDeque<&str> = in_degree.iter().filter(|(_, °)| deg == 0).map(|(&name, _)| name).collect();
+
+ let mut result = Vec::new();
+ while let Some(name) = queue.pop_front() {
+ result.push(name.to_string());
+ if let Some(node) = nodes.get(name) {
+ for dependent in &node.depended_by {
+ if let Some(deg) = in_degree.get_mut(dependent.as_str()) {
+ *deg -= 1;
+ if *deg == 0 {
+ queue.push_back(dependent.as_str());
+ }
+ }
+ }
+ }
+ }
+
+ if result.len() != nodes.len() {
+ let remaining: Vec = nodes.keys().filter(|k| !result.contains(k)).cloned().collect();
+ result.extend(remaining);
+ }
+
+ result
+ }
+
+ pub fn build_order(&self) -> Vec {
+ self.topological_order.clone()
+ }
+
+ pub fn drop_order(&self) -> Vec {
+ let mut order = self.topological_order.clone();
+ order.reverse();
+ order
+ }
+
+ pub fn coverage_score(&self, diffed_tables: &[String]) -> f64 {
+ self.coverage_score_level1(diffed_tables)
+ }
+
+ pub fn coverage_score_level1(&self, diffed_tables: &[String]) -> f64 {
+ if self.nodes.is_empty() {
+ return 1.0;
+ }
+ let diffed_set: HashSet<&str> = diffed_tables.iter().map(|s| s.as_str()).collect();
+ let mut covered_edges = 0u64;
+ let mut total_edges = 0u64;
+
+ for node in self.nodes.values() {
+ for dep in &node.depends_on {
+ total_edges += 1;
+ if diffed_set.contains(node.table_name.as_str()) && diffed_set.contains(dep.as_str()) {
+ covered_edges += 1;
+ }
+ }
+ }
+
+ if total_edges == 0 {
+ 1.0
+ } else {
+ covered_edges as f64 / total_edges as f64
+ }
+ }
+
+ pub fn coverage_score_level2(&self, diffed_tables: &[String]) -> f64 {
+ if self.nodes.is_empty() {
+ return 1.0;
+ }
+ let diffed_set: HashSet<&str> = diffed_tables.iter().map(|s| s.as_str()).collect();
+
+ let mut transitive_edges = 0u64;
+ let mut covered_transitive = 0u64;
+
+ for node in self.nodes.values() {
+ let table_name = node.table_name.as_str();
+ if !diffed_set.contains(table_name) {
+ continue;
+ }
+ for indirect in &node.depends_on {
+ if let Some(inner) = self.nodes.get(indirect) {
+ for grand in &inner.depends_on {
+ transitive_edges += 1;
+ if diffed_set.contains(table_name) && diffed_set.contains(grand.as_str()) {
+ covered_transitive += 1;
+ }
+ }
+ }
+ }
+ }
+
+ if transitive_edges == 0 {
+ 1.0
+ } else {
+ covered_transitive as f64 / transitive_edges as f64
+ }
+ }
+
+ pub fn composite_coverage_score(&self, diffed_tables: &[String]) -> CoverageReport {
+ let diffed_set: HashSet<&str> = diffed_tables.iter().map(|s| s.as_str()).collect();
+
+ let (l1_covered, l1_total) = self.count_edges(diffed_tables, &diffed_set, 1);
+ let (l2_covered, l2_total) = self.count_transitive_edges(diffed_tables, &diffed_set);
+
+ let l1_score = if l1_total == 0 { 1.0 } else { l1_covered as f64 / l1_total as f64 };
+ let l2_score = if l2_total == 0 { 1.0 } else { l2_covered as f64 / l2_total as f64 };
+
+ let composite_score = 0.6 * l1_score + 0.4 * l2_score;
+
+ let uncovered = self.collect_uncovered_edges(diffed_tables, &diffed_set);
+
+ CoverageReport {
+ level1_score: l1_score,
+ level2_score: l2_score,
+ composite_score,
+ level1_covered: l1_covered,
+ level1_total: l1_total,
+ level2_covered: l2_covered,
+ level2_total: l2_total,
+ uncovered_edges: uncovered,
+ }
+ }
+
+ fn count_edges(&self, _diffed_tables: &[String], diffed_set: &HashSet<&str>, _level: u32) -> (u64, u64) {
+ let mut covered = 0u64;
+ let mut total = 0u64;
+ for node in self.nodes.values() {
+ for dep in &node.depends_on {
+ total += 1;
+ if diffed_set.contains(node.table_name.as_str()) && diffed_set.contains(dep.as_str()) {
+ covered += 1;
+ }
+ }
+ }
+ (covered, total)
+ }
+
+ fn count_transitive_edges(&self, _diffed_tables: &[String], diffed_set: &HashSet<&str>) -> (u64, u64) {
+ let mut covered = 0u64;
+ let mut total = 0u64;
+ for node in self.nodes.values() {
+ let table_name = node.table_name.as_str();
+ if !diffed_set.contains(table_name) {
+ continue;
+ }
+ for indirect in &node.depends_on {
+ if let Some(inner) = self.nodes.get(indirect) {
+ for grand in &inner.depends_on {
+ total += 1;
+ if diffed_set.contains(table_name) && diffed_set.contains(grand.as_str()) {
+ covered += 1;
+ }
+ }
+ }
+ }
+ }
+ (covered, total)
+ }
+
+ fn collect_uncovered_edges(&self, _diffed_tables: &[String], diffed_set: &HashSet<&str>) -> Vec {
+ let mut uncovered = Vec::new();
+ for node in self.nodes.values() {
+ for dep in &node.depends_on {
+ let both_covered = diffed_set.contains(node.table_name.as_str()) && diffed_set.contains(dep.as_str());
+ if !both_covered {
+ uncovered.push(UncoveredEdge {
+ from_table: node.table_name.clone(),
+ to_table: dep.clone(),
+ level: 1,
+ });
+ }
+ }
+ for indirect in &node.depends_on {
+ if let Some(inner) = self.nodes.get(indirect) {
+ for grand in &inner.depends_on {
+ let all_covered =
+ diffed_set.contains(node.table_name.as_str()) && diffed_set.contains(grand.as_str());
+ if !all_covered {
+ uncovered.push(UncoveredEdge {
+ from_table: node.table_name.clone(),
+ to_table: grand.clone(),
+ level: 2,
+ });
+ }
+ }
+ }
+ }
+ }
+ uncovered
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RenameCandidate {
+ pub source_name: String,
+ pub target_name: String,
+ pub score: f64,
+ pub column_jaccard: f64,
+ pub type_similarity: f64,
+}
+
+fn jaccard_similarity(a: &HashSet, b: &HashSet) -> f64 {
+ if a.is_empty() && b.is_empty() {
+ return 1.0;
+ }
+ let intersection = a.intersection(b).count();
+ let union = a.union(b).count();
+ if union == 0 {
+ 1.0
+ } else {
+ intersection as f64 / union as f64
+ }
+}
+
+fn column_type_similarity(source_cols: &[ColumnInfo], target_cols: &[ColumnInfo]) -> f64 {
+ if source_cols.is_empty() || target_cols.is_empty() {
+ return 0.0;
+ }
+ let engine = DefaultTypeInferenceEngine;
+ let source_map: HashMap<&str, &ColumnInfo> = source_cols.iter().map(|c| (c.name.as_str(), c)).collect();
+ let target_map: HashMap<&str, &ColumnInfo> = target_cols.iter().map(|c| (c.name.as_str(), c)).collect();
+ let common_names: HashSet<&str> = source_map.keys().filter(|k| target_map.contains_key(**k)).copied().collect();
+
+ if common_names.is_empty() {
+ return 0.0;
+ }
+
+ let total: f64 = common_names
+ .iter()
+ .map(|name| {
+ let s = ColumnType::parse(&source_map[name].data_type);
+ let t = ColumnType::parse(&target_map[name].data_type);
+ engine.type_compatibility_score(&s, &t)
+ })
+ .sum();
+ total / common_names.len() as f64
+}
+
+pub fn detect_renames(
+ removed: &[String],
+ added: &[String],
+ source_details: &[TableSchemaDetail],
+ target_details: &[TableSchemaDetail],
+ threshold: f64,
+) -> Vec {
+ let source_detail_map: HashMap<&str, &TableSchemaDetail> =
+ source_details.iter().map(|d| (d.name.as_str(), d)).collect();
+ let target_detail_map: HashMap<&str, &TableSchemaDetail> =
+ target_details.iter().map(|d| (d.name.as_str(), d)).collect();
+
+ let mut candidates = Vec::new();
+ for target_name in removed {
+ let Some(target_detail) = target_detail_map.get(target_name.as_str()) else { continue };
+ for source_name in added {
+ let Some(source_detail) = source_detail_map.get(source_name.as_str()) else { continue };
+
+ let col_names_source: HashSet = source_detail.columns.iter().map(|c| c.name.clone()).collect();
+ let col_names_target: HashSet = target_detail.columns.iter().map(|c| c.name.clone()).collect();
+ let column_jaccard = jaccard_similarity(&col_names_target, &col_names_source);
+
+ if column_jaccard < threshold {
+ continue;
+ }
+
+ let type_sim = column_type_similarity(&target_detail.columns, &source_detail.columns);
+
+ let score = column_jaccard * 0.6 + type_sim * 0.4;
+
+ if score >= threshold {
+ candidates.push(RenameCandidate {
+ source_name: source_name.clone(),
+ target_name: target_name.clone(),
+ score,
+ column_jaccard,
+ type_similarity: type_sim,
+ });
+ }
+ }
+ }
+
+ candidates.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
+
+ let mut final_candidates = Vec::new();
+ let mut used_target: HashSet = HashSet::new();
+ let mut used_source: HashSet = HashSet::new();
+
+ for c in &candidates {
+ if !used_target.contains(&c.target_name) && !used_source.contains(&c.source_name) {
+ final_candidates.push(c.clone());
+ used_target.insert(c.target_name.clone());
+ used_source.insert(c.source_name.clone());
+ }
+ }
+
+ final_candidates
+}
+
+// ============================================================================
+// Phase 4.2: Batch Naming Pattern Recognition
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BatchPattern {
+ pub pattern: String,
+ pub is_regex: bool,
+ pub description: String,
+}
+
+pub fn diff_names_with_patterns(
+ source: &[String],
+ target: &[String],
+ patterns: &[BatchPattern],
+) -> (Vec, Vec, Vec, Vec>) {
+ let (added, removed, common) = diff_names(source, target);
+
+ let mut pattern_matches: Vec> = Vec::new();
+ for pattern in patterns {
+ let mut matches = Vec::new();
+ if pattern.is_regex {
+ if let Ok(re) = Regex::new(&pattern.pattern) {
+ for name in source {
+ if re.is_match(name) {
+ matches.push(name.clone());
+ }
+ }
+ }
+ } else {
+ let glob_pattern = pattern.pattern.replace('*', ".*").replace('?', ".");
+ if let Ok(re) = Regex::new(&format!("^{}$", glob_pattern)) {
+ for name in source {
+ if re.is_match(name) {
+ matches.push(name.clone());
+ }
+ }
+ }
+ }
+ if !matches.is_empty() {
+ pattern_matches.push(matches);
+ }
+ }
+
+ (added, removed, common, pattern_matches)
+}
+
+pub fn detect_pattern_conflicts(patterns: &[BatchPattern], names: &[String]) -> Vec> {
+ let mut conflicts = Vec::new();
+ for i in 0..patterns.len() {
+ for j in (i + 1)..patterns.len() {
+ let pi = &patterns[i];
+ let pj = &patterns[j];
+ let pattern_i =
+ if pi.is_regex { pi.pattern.clone() } else { pi.pattern.replace('*', ".*").replace('?', ".") };
+ let pattern_j =
+ if pj.is_regex { pj.pattern.clone() } else { pj.pattern.replace('*', ".*").replace('?', ".") };
+
+ let re_i = Regex::new(&format!("^{}$", pattern_i));
+ let re_j = Regex::new(&format!("^{}$", pattern_j));
+ if let (Ok(ri), Ok(rj)) = (re_i, re_j) {
+ for name in names {
+ if ri.is_match(name) && rj.is_match(name) {
+ conflicts.push(vec![pi.description.clone(), pj.description.clone()]);
+ break;
+ }
+ }
+ }
+ }
+ }
+ conflicts
+}
+
+// ============================================================================
+// Phase 4.3: Dialect-Aware Type Compatibility Scoring
+// ============================================================================
+
+pub fn diff_columns_with_compatibility(
+ source: &[ColumnInfo],
+ target: &[ColumnInfo],
+ ignore_comments: bool,
+ compare_column_order: bool,
+ source_dialect: DialectKind,
+ target_dialect: DialectKind,
+ compatibility_threshold: f64,
+ field_mappings: &[FieldMapping],
+) -> (Vec