From d650d91d8228f51987028e2fd622c62c668ec06c Mon Sep 17 00:00:00 2001
From: "SPRINX0\\prochazka" <jan.prochazka@sprinx.com>
Date: Mon, 1 Dec 2025 10:08:00 +0100
Subject: [PATCH 1/4] table restore script WIP

---
 packages/sqltree/src/dumpSqlCommand.ts        |  7 ++-
 packages/sqltree/src/types.ts                 |  1 +
 .../src/appobj/DatabaseObjectAppObject.svelte | 55 +++++++++++++++----
 .../web/src/utility/tableRestoreScript.ts     | 45 +++++++++++++++
 packages/web/src/widgets/SqlObjectList.svelte |  2 +-
 5 files changed, 95 insertions(+), 15 deletions(-)
 create mode 100644 packages/web/src/utility/tableRestoreScript.ts

diff --git a/packages/sqltree/src/dumpSqlCommand.ts b/packages/sqltree/src/dumpSqlCommand.ts
index e8286bafb..b3b9373a4 100644
--- a/packages/sqltree/src/dumpSqlCommand.ts
+++ b/packages/sqltree/src/dumpSqlCommand.ts
@@ -1,7 +1,7 @@
 import type { SqlDumper } from 'dbgate-types';
 import { Command, Select, Update, Delete, Insert } from './types';
 import { dumpSqlExpression } from './dumpSqlExpression';
-import { dumpSqlFromDefinition, dumpSqlSourceRef } from './dumpSqlSource';
+import { dumpSqlFromDefinition, dumpSqlSourceDef, dumpSqlSourceRef } from './dumpSqlSource';
 import { dumpSqlCondition } from './dumpSqlCondition';
 
 export function dumpSqlSelect(dmp: SqlDumper, cmd: Select) {
@@ -115,7 +115,10 @@ export function dumpSqlInsert(dmp: SqlDumper, cmd: Insert) {
       cmd.fields.map(x => x.targetColumn)
     );
     dmp.putCollection(',', cmd.fields, x => dumpSqlExpression(dmp, x));
-    if (dmp.dialect.requireFromDual) {
+    if (cmd.whereNotExistsSource) {
+      dmp.put(' ^from ');
+      dumpSqlSourceDef(dmp, cmd.whereNotExistsSource);
+    } else if (dmp.dialect.requireFromDual) {
       dmp.put(' ^from ^dual ');
     }
     dmp.put(' ^where ^not ^exists (^select * ^from %f ^where ', cmd.targetTable);
diff --git a/packages/sqltree/src/types.ts b/packages/sqltree/src/types.ts
index bce0e61d3..493745059 100644
--- a/packages/sqltree/src/types.ts
+++ b/packages/sqltree/src/types.ts
@@ -44,6 +44,7 @@ export interface Insert {
   fields: UpdateField[];
   targetTable: NamedObjectInfo;
   insertWhereNotExistsCondition?: Condition;
+  whereNotExistsSource?: Source;
 }
 
 export interface AllowIdentityInsert {
diff --git a/packages/web/src/appobj/DatabaseObjectAppObject.svelte b/packages/web/src/appobj/DatabaseObjectAppObject.svelte
index 6dfc28d17..3ea5c6037 100644
--- a/packages/web/src/appobj/DatabaseObjectAppObject.svelte
+++ b/packages/web/src/appobj/DatabaseObjectAppObject.svelte
@@ -1,6 +1,7 @@
 <script lang="ts" context="module">
   import { copyTextToClipboard } from '../utility/clipboard';
   import { _t, _tval, DefferedTranslationResult } from '../translations';
+  import sqlFormatter from 'sql-formatter';
 
   export const extractKey = ({ schemaName, pureName }) => (schemaName ? `${schemaName}.${pureName}` : pureName);
   export const createMatcher =
@@ -88,7 +89,8 @@
     isRename?: boolean;
     isTruncate?: boolean;
     isCopyTableName?: boolean;
-    isDuplicateTable?: boolean;
+    isTableBackup?: boolean;
+    isTableRestore?: boolean;
     isDiagram?: boolean;
     functionName?: string;
     isExport?: boolean;
@@ -106,6 +108,8 @@
   }
 
   function createMenusCore(objectTypeField, driver, data): DbObjMenuItem[] {
+    const backupMatch = data.objectTypeField === 'tables' ? data.pureName.match(TABLE_BACKUP_REGEX) : null;
+
     switch (objectTypeField) {
       case 'tables':
         return [
@@ -175,11 +179,18 @@
             isCopyTableName: true,
             requiresWriteAccess: false,
           },
-          hasPermission('dbops/table/backup') && {
-            label: _t('dbObject.createTableBackup', { defaultMessage: 'Create table backup' }),
-            isDuplicateTable: true,
-            requiresWriteAccess: true,
-          },
+          hasPermission('dbops/table/backup') &&
+            !backupMatch && {
+              label: _t('dbObject.createTableBackup', { defaultMessage: 'Create table backup' }),
+              isTableBackup: true,
+              requiresWriteAccess: true,
+            },
+          hasPermission('dbops/table/restore') &&
+            backupMatch && {
+              label: _t('dbObject.createRestoreScript', { defaultMessage: 'Create restore script' }),
+              isTableRestore: true,
+              requiresWriteAccess: true,
+            },
           hasPermission('dbops/model/view') && {
             label: _t('dbObject.showDiagram', { defaultMessage: 'Show diagram' }),
             isDiagram: true,
@@ -637,7 +648,7 @@
           });
         },
       });
-    } else if (menu.isDuplicateTable) {
+    } else if (menu.isTableBackup) {
       const driver = await getDriver();
       const dmp = driver.createDumper();
       const newTable = _.cloneDeep(data);
@@ -671,6 +682,25 @@
         },
         engine: driver.engine,
       });
+    } else if (menu.isTableRestore) {
+      const backupMatch = data.objectTypeField === 'tables' ? data.pureName.match(TABLE_BACKUP_REGEX) : null;
+
+      const driver = await getDriver();
+      const dmp = driver.createDumper();
+      const db = await getDatabaseInfo(data);
+      if (db) {
+        const originalTable = db?.tables?.find(x => x.pureName == backupMatch[1] && x.schemaName == data.schemaName);
+        if (originalTable) {
+          createTableRestoreScript(data, originalTable, dmp);
+          newQuery({
+            title: _t('dbObject.restoreScript', {
+              defaultMessage: 'Restore {name} #',
+              values: { name: backupMatch[1] },
+            }),
+            initialData: sqlFormatter.format(dmp.s),
+          });
+        }
+      }
     } else if (menu.isImport) {
       const { conid, database } = data;
       openImportExportTab({
@@ -1008,6 +1038,8 @@
 
     return handleDatabaseObjectClick(data, { forceNewTab, tabPreviewMode, focusTab });
   }
+
+  export const TABLE_BACKUP_REGEX = /^_(.*)_(\d\d\d\d)-(\d\d)-(\d\d)-(\d\d)-(\d\d)-(\d\d)$/;
 </script>
 
 <script lang="ts">
@@ -1025,7 +1057,7 @@
   } from '../stores';
   import openNewTab from '../utility/openNewTab';
   import { extractDbNameFromComposite, filterNameCompoud, getConnectionLabel } from 'dbgate-tools';
-  import { getConnectionInfo } from '../utility/metadataLoaders';
+  import { getConnectionInfo, getDatabaseInfo } from '../utility/metadataLoaders';
   import fullDisplayName from '../utility/fullDisplayName';
   import { showModal } from '../modals/modalTools';
   import { findEngineDriver } from 'dbgate-tools';
@@ -1047,6 +1079,8 @@
   import { getBoolSettingsValue, getOpenDetailOnArrowsSettings } from '../settings/settingsTools';
   import { isProApp } from '../utility/proTools';
   import formatFileSize from '../utility/formatFileSize';
+  import { createTableRestoreScript } from '../utility/tableRestoreScript';
+  import newQuery from '../query/newQuery';
 
   export let data;
   export let passProps;
@@ -1087,10 +1121,7 @@
 
   $: isPinned = !!$pinnedTables.find(x => testEqual(data, x));
 
-  $: backupParsed =
-    data.objectTypeField === 'tables'
-      ? data.pureName.match(/^_(.*)_(\d\d\d\d)-(\d\d)-(\d\d)-(\d\d)-(\d\d)-(\d\d)$/)
-      : null;
+  $: backupParsed = data.objectTypeField === 'tables' ? data.pureName.match(TABLE_BACKUP_REGEX) : null;
   $: backupTitle =
     backupParsed != null
       ? `${backupParsed[1]} (${backupParsed[2]}-${backupParsed[3]}-${backupParsed[4]} ${backupParsed[5]}:${backupParsed[6]}:${backupParsed[7]})`
diff --git a/packages/web/src/utility/tableRestoreScript.ts b/packages/web/src/utility/tableRestoreScript.ts
new file mode 100644
index 000000000..ba0b9ea89
--- /dev/null
+++ b/packages/web/src/utility/tableRestoreScript.ts
@@ -0,0 +1,45 @@
+import _ from 'lodash';
+import { dumpSqlInsert, Insert } from 'dbgate-sqltree';
+import { TableInfo, SqlDumper } from 'dbgate-types';
+
+export function createTableRestoreScript(backupTable: TableInfo, originalTable: TableInfo, dmp: SqlDumper) {
+  const bothColumns = _.intersection(
+    backupTable.columns.map(x => x.columnName),
+    originalTable.columns.map(x => x.columnName)
+  );
+  const keyColumns = _.intersection(
+    originalTable.primaryKey?.columns?.map(x => x.columnName) || [],
+    backupTable.columns.map(x => x.columnName)
+  );
+  const insert: Insert = {
+    commandType: 'insert',
+    targetTable: originalTable,
+    fields: bothColumns.map(colName => ({
+      targetColumn: colName,
+      exprType: 'column',
+      columnName: colName,
+      source: { alias: 'bak' },
+    })),
+    whereNotExistsSource: { name: backupTable, alias: 'bak' },
+    insertWhereNotExistsCondition: {
+      conditionType: 'and',
+      conditions: keyColumns.map(colName => ({
+        conditionType: 'binary',
+        operator: '=',
+        left: {
+          exprType: 'column',
+          columnName: colName,
+          source: { name: originalTable },
+        },
+        right: {
+          exprType: 'column',
+          columnName: colName,
+          source: { alias: 'bak' },
+        },
+      })),
+    },
+  };
+
+  dumpSqlInsert(dmp, insert);
+  dmp.endCommand();
+}
diff --git a/packages/web/src/widgets/SqlObjectList.svelte b/packages/web/src/widgets/SqlObjectList.svelte
index fa24ff1d8..793bcb3b4 100644
--- a/packages/web/src/widgets/SqlObjectList.svelte
+++ b/packages/web/src/widgets/SqlObjectList.svelte
@@ -235,7 +235,7 @@
 
   function getAppObjectGroup(data) {
     if (data.objectTypeField == 'tables') {
-      if (data.pureName.match(/^_(.*)_\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d$/)) {
+      if (data.pureName.match(databaseObjectAppObject.TABLE_BACKUP_REGEX)) {
         return _t('dbObject.tableBackups', { defaultMessage: 'Table Backups' });
       }
     }

From 8ae64a9dcfff5f5d1c140ea025f1966bd2da3e78 Mon Sep 17 00:00:00 2001
From: "SPRINX0\\prochazka" <jan.prochazka@sprinx.com>
Date: Mon, 1 Dec 2025 11:06:18 +0100
Subject: [PATCH 2/4] restore script - update

---
 packages/sqltree/src/dumpSqlExpression.ts     |  7 ++
 packages/sqltree/src/types.ts                 |  8 +-
 .../web/src/utility/tableRestoreScript.ts     | 82 +++++++++++++++----
 3 files changed, 80 insertions(+), 17 deletions(-)

diff --git a/packages/sqltree/src/dumpSqlExpression.ts b/packages/sqltree/src/dumpSqlExpression.ts
index aeaf3b288..f9447f792 100644
--- a/packages/sqltree/src/dumpSqlExpression.ts
+++ b/packages/sqltree/src/dumpSqlExpression.ts
@@ -2,6 +2,7 @@ import _ from 'lodash';
 import type { SqlDumper } from 'dbgate-types';
 import { Expression, ColumnRefExpression } from './types';
 import { dumpSqlSourceRef } from './dumpSqlSource';
+import { dumpSqlSelect } from './dumpSqlCommand';
 
 export function dumpSqlExpression(dmp: SqlDumper, expr: Expression) {
   switch (expr.exprType) {
@@ -67,5 +68,11 @@ export function dumpSqlExpression(dmp: SqlDumper, expr: Expression) {
       });
       dmp.put(')');
       break;
+
+    case 'select':
+      dmp.put('(');
+      dumpSqlSelect(dmp, expr.select);
+      dmp.put(')');
+      break;
   }
 }
diff --git a/packages/sqltree/src/types.ts b/packages/sqltree/src/types.ts
index 493745059..ea7c5c994 100644
--- a/packages/sqltree/src/types.ts
+++ b/packages/sqltree/src/types.ts
@@ -227,6 +227,11 @@ export interface RowNumberExpression {
   orderBy: OrderByExpression[];
 }
 
+export interface SelectExpression {
+  exprType: 'select';
+  select: Select;
+}
+
 export type Expression =
   | ColumnRefExpression
   | ValueExpression
@@ -236,7 +241,8 @@ export type Expression =
   | CallExpression
   | MethodCallExpression
   | TranformExpression
-  | RowNumberExpression;
+  | RowNumberExpression
+  | SelectExpression;
 export type OrderByExpression = Expression & { direction: 'ASC' | 'DESC' };
 
 export type ResultField = Expression & { alias?: string };
diff --git a/packages/web/src/utility/tableRestoreScript.ts b/packages/web/src/utility/tableRestoreScript.ts
index ba0b9ea89..6d9d6fd1e 100644
--- a/packages/web/src/utility/tableRestoreScript.ts
+++ b/packages/web/src/utility/tableRestoreScript.ts
@@ -1,5 +1,5 @@
-import _ from 'lodash';
-import { dumpSqlInsert, Insert } from 'dbgate-sqltree';
+import _, { cond } from 'lodash';
+import { Condition, dumpSqlInsert, dumpSqlUpdate, Insert, Update } from 'dbgate-sqltree';
 import { TableInfo, SqlDumper } from 'dbgate-types';
 
 export function createTableRestoreScript(backupTable: TableInfo, originalTable: TableInfo, dmp: SqlDumper) {
@@ -11,6 +11,69 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
     originalTable.primaryKey?.columns?.map(x => x.columnName) || [],
     backupTable.columns.map(x => x.columnName)
   );
+  const valueColumns = _.difference(bothColumns, keyColumns);
+
+  function makeColumnCond(colName: string, operator: '=' | '<>' | '<' | '>' | '<=' | '>=' = '='): Condition {
+    return {
+      conditionType: 'binary',
+      operator,
+      left: {
+        exprType: 'column',
+        columnName: colName,
+        source: { name: originalTable },
+      },
+      right: {
+        exprType: 'column',
+        columnName: colName,
+        source: { alias: 'bak' },
+      },
+    };
+  }
+
+  const update: Update = {
+    commandType: 'update',
+    from: { name: originalTable },
+    fields: valueColumns.map(colName => ({
+      exprType: 'select',
+      select: {
+        commandType: 'select',
+        from: { name: backupTable, alias: 'bak' },
+        columns: [
+          {
+            exprType: 'column',
+            columnName: colName,
+            source: { alias: 'bak' },
+          },
+        ],
+        where: {
+          conditionType: 'and',
+          conditions: keyColumns.map(colName => makeColumnCond(colName)),
+        },
+      },
+      targetColumn: colName,
+    })),
+    where: {
+      conditionType: 'exists',
+      subQuery: {
+        commandType: 'select',
+        from: { name: backupTable, alias: 'bak' },
+        selectAll: true,
+        where: {
+          conditionType: 'and',
+          conditions: [
+            ...keyColumns.map(keyColName => makeColumnCond(keyColName)),
+            {
+              conditionType: 'or',
+              conditions: valueColumns.map(colName => makeColumnCond(colName, '<>')),
+            },
+          ],
+        },
+      },
+    },
+  };
+  dumpSqlUpdate(dmp, update);
+  dmp.endCommand();
+
   const insert: Insert = {
     commandType: 'insert',
     targetTable: originalTable,
@@ -23,20 +86,7 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
     whereNotExistsSource: { name: backupTable, alias: 'bak' },
     insertWhereNotExistsCondition: {
       conditionType: 'and',
-      conditions: keyColumns.map(colName => ({
-        conditionType: 'binary',
-        operator: '=',
-        left: {
-          exprType: 'column',
-          columnName: colName,
-          source: { name: originalTable },
-        },
-        right: {
-          exprType: 'column',
-          columnName: colName,
-          source: { alias: 'bak' },
-        },
-      })),
+      conditions: keyColumns.map(colName => makeColumnCond(colName)),
     },
   };
 

From b912190c5e42eb546c6b2dd61847c6378bce358a Mon Sep 17 00:00:00 2001
From: "SPRINX0\\prochazka" <jan.prochazka@sprinx.com>
Date: Mon, 1 Dec 2025 12:07:44 +0100
Subject: [PATCH 3/4] delete part of restore script

---
 .../web/src/utility/tableRestoreScript.ts     | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/packages/web/src/utility/tableRestoreScript.ts b/packages/web/src/utility/tableRestoreScript.ts
index 6d9d6fd1e..072d8a441 100644
--- a/packages/web/src/utility/tableRestoreScript.ts
+++ b/packages/web/src/utility/tableRestoreScript.ts
@@ -1,5 +1,5 @@
-import _, { cond } from 'lodash';
-import { Condition, dumpSqlInsert, dumpSqlUpdate, Insert, Update } from 'dbgate-sqltree';
+import _ from 'lodash';
+import { Condition, dumpSqlInsert, dumpSqlUpdate, Insert, Update, Delete, dumpSqlDelete } from 'dbgate-sqltree';
 import { TableInfo, SqlDumper } from 'dbgate-types';
 
 export function createTableRestoreScript(backupTable: TableInfo, originalTable: TableInfo, dmp: SqlDumper) {
@@ -74,6 +74,25 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
   dumpSqlUpdate(dmp, update);
   dmp.endCommand();
 
+  const delcmd: Delete = {
+    commandType: 'delete',
+    from: { name: originalTable },
+    where: {
+      conditionType: 'notExists',
+      subQuery: {
+        commandType: 'select',
+        from: { name: backupTable, alias: 'bak' },
+        selectAll: true,
+        where: {
+          conditionType: 'and',
+          conditions: keyColumns.map(colName => makeColumnCond(colName)),
+        },
+      },
+    },
+  };
+  dumpSqlDelete(dmp, delcmd);
+  dmp.endCommand();
+
   const insert: Insert = {
     commandType: 'insert',
     targetTable: originalTable,

From 6bd81cbff59c67f3a40f6efce9467ad27dca3d2c Mon Sep 17 00:00:00 2001
From: "SPRINX0\\prochazka" <jan.prochazka@sprinx.com>
Date: Mon, 1 Dec 2025 12:17:00 +0100
Subject: [PATCH 4/4] restore table - comments

---
 packages/types/dumper.d.ts                     |  1 +
 packages/web/src/utility/tableRestoreScript.ts | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/packages/types/dumper.d.ts b/packages/types/dumper.d.ts
index 746cbbfc2..c5f380a22 100644
--- a/packages/types/dumper.d.ts
+++ b/packages/types/dumper.d.ts
@@ -16,6 +16,7 @@ export interface SqlDumper extends AlterProcessor {
   transform(type: TransformType, dumpExpr: () => void);
   createDatabase(name: string);
   dropDatabase(name: string);
+  comment(value: string);
 
   callableTemplate(func: CallableObjectInfo);
 
diff --git a/packages/web/src/utility/tableRestoreScript.ts b/packages/web/src/utility/tableRestoreScript.ts
index 072d8a441..ae768f5ea 100644
--- a/packages/web/src/utility/tableRestoreScript.ts
+++ b/packages/web/src/utility/tableRestoreScript.ts
@@ -30,6 +30,21 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
     };
   }
 
+  function putTitle(title: string) {
+    dmp.putRaw('\n\n');
+    dmp.comment(`******************** ${title} ********************`);
+    dmp.putRaw('\n');
+  }
+
+  dmp.comment(`Restoring data into table ${originalTable.pureName} from backup table ${backupTable.pureName}`);
+  dmp.putRaw('\n');
+  dmp.comment(`Key columns: ${keyColumns.join(', ')}`);
+  dmp.putRaw('\n');
+  dmp.comment(`Value columns: ${valueColumns.join(', ')}`);
+  dmp.putRaw('\n');
+  dmp.comment(`Follows UPDATE, DELETE, INSERT statements to restore data`);
+  dmp.putRaw('\n');
+
   const update: Update = {
     commandType: 'update',
     from: { name: originalTable },
@@ -71,6 +86,7 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
       },
     },
   };
+  putTitle('UPDATE');
   dumpSqlUpdate(dmp, update);
   dmp.endCommand();
 
@@ -90,6 +106,7 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
       },
     },
   };
+  putTitle('DELETE');
   dumpSqlDelete(dmp, delcmd);
   dmp.endCommand();
 
@@ -109,6 +126,7 @@ export function createTableRestoreScript(backupTable: TableInfo, originalTable:
     },
   };
 
+  putTitle('INSERT');
   dumpSqlInsert(dmp, insert);
   dmp.endCommand();
 }