delete cascade WIP

packages/datalib/src/ChangeSet.ts

@@ -11,6 +11,11 @@ export interface ChangeSetItem {
   fields?: { [column: string]: string };
 }
 
+export interface ChangeSetDeleteCascade {
+  title: string;
+  commands: Command[];
+}
+
 export interface ChangeSet {
   inserts: ChangeSetItem[];
   updates: ChangeSetItem[];
@@ -118,7 +123,11 @@ export function setChangeSetValue(
   };
 }
 
-export function setChangeSetRowData(changeSet: ChangeSet, definition: ChangeSetRowDefinition, document: any): ChangeSet {
+export function setChangeSetRowData(
+  changeSet: ChangeSet,
+  definition: ChangeSetRowDefinition,
+  document: any
+): ChangeSet {
   if (!changeSet || !definition) return changeSet;
   let [fieldName, existingItem] = findExistingChangeSetItem(changeSet, definition);
   if (fieldName == 'deletes') {
@@ -257,7 +266,7 @@ function insertToSql(
   ];
 }
 
-function extractCondition(item: ChangeSetItem): Condition {
+function extractCondition(item: ChangeSetItem, alias?: string): Condition {
   return {
     conditionType: 'and',
     conditions: _.keys(item.condition).map(columnName => ({
@@ -271,6 +280,7 @@ function extractCondition(item: ChangeSetItem): Condition {
             pureName: item.pureName,
             schemaName: item.schemaName,
           },
+          alias,
         },
       },
       right: {
@@ -318,6 +328,102 @@ export function changeSetToSql(changeSet: ChangeSet, dbinfo: DatabaseInfo): Comm
   );
 }
 
+export function getDeleteCascades(changeSet: ChangeSet, dbinfo: DatabaseInfo): ChangeSetDeleteCascade[] {
+  const res: ChangeSetDeleteCascade[] = [];
+  const allForeignKeys = _.flatten(dbinfo.tables.map(x => x.foreignKeys));
+  for (const baseCmd of changeSet.deletes) {
+    const table = dbinfo.tables.find(x => x.pureName == baseCmd.pureName && x.schemaName == baseCmd.schemaName);
+    const dependencies = allForeignKeys.filter(
+      x => x.refSchemaName == table.schemaName && x.refTableName == table.pureName
+    );
+    for (const fk of dependencies) {
+      const refCmd: Delete = {
+        commandType: 'delete',
+        from: {
+          name: {
+            pureName: fk.pureName,
+            schemaName: fk.schemaName,
+          },
+        },
+        where: {
+          conditionType: 'exists',
+          subQuery: {
+            commandType: 'select',
+            from: {
+              name: {
+                pureName: fk.pureName,
+                schemaName: fk.schemaName,
+              },
+              alias: 't1',
+              relations: [
+                {
+                  joinType: 'INNER JOIN',
+                  alias: 't2',
+                  name: {
+                    pureName: fk.refTableName,
+                    schemaName: fk.refSchemaName,
+                  },
+                  conditions: fk.columns.map(column => ({
+                    conditionType: 'binary',
+                    operator: '=',
+                    left: {
+                      exprType: 'column',
+                      columnName: column.columnName,
+                      source: { alias: 't1' },
+                    },
+                    right: {
+                      exprType: 'column',
+                      columnName: column.refColumnName,
+                      source: { alias: 't2' },
+                    },
+                  })),
+                },
+              ],
+            },
+            where: {
+              conditionType: 'and',
+              conditions: [
+                extractCondition(baseCmd, 't2'),
+                // @ts-ignore
+                ...fk.columns.map(column => ({
+                  conditionType: 'binary',
+                  operator: '=',
+                  left: {
+                    exprType: 'column',
+                    columnName: column.columnName,
+                    source: { alias: 't1' },
+                  },
+                  right: {
+                    exprType: 'column',
+                    columnName: column.refColumnName,
+                    source: {
+                      name: {
+                        pureName: fk.refTableName,
+                        schemaName: fk.refSchemaName,
+                      },
+                    },
+                  },
+                })),
+              ],
+            },
+          },
+        },
+      };
+      let resItem = res.find(x => x.title == fk.pureName);
+      if (!resItem) {
+        resItem = {
+          title: fk.pureName,
+          commands: [],
+        };
+        res.push(resItem);
+      }
+      resItem.commands.push(refCmd);
+    }
+  }
+
+  return res;
+}
+
 export function revertChangeSetRowChanges(changeSet: ChangeSet, definition: ChangeSetRowDefinition): ChangeSet {
   // console.log('definition', definition);
   const [field, item] = findExistingChangeSetItem(changeSet, definition);

packages/web/src/modals/ConfirmSqlModal.svelte

@@ -1,5 +1,6 @@
 <script>
-  import _ from 'lodash';
+  import { keys } from 'localforage';
+  import _, { isEmpty } from 'lodash';
   import FormStyledButton from '../elements/FormStyledButton.svelte';
   import FormCheckboxField from '../forms/FormCheckboxField.svelte';
   import FormProvider from '../forms/FormProvider.svelte';
@@ -15,6 +16,7 @@
   export let onConfirm;
   export let engine;
   export let recreates;
+  export let deleteCascadesScripts;
 
   $: isRecreated = _.sum(_.values(recreates || {})) > 0;
 
@@ -26,9 +28,41 @@
     <div slot="header">Save changes</div>
 
     <div class="editor">
-      <SqlEditor {engine} value={sql} readOnly />
+      <FormValues let:values>
+        <SqlEditor
+          {engine}
+          value={values.deleteReferencesCascade
+            ? deleteCascadesScripts
+                .filter(({ script, title }) => values[`deleteReferences_${title}`] !== false)
+                .map(({ script, title }) => script)
+                .join('\n')
+            : sql}
+          readOnly
+        />
+      </FormValues>
     </div>
 
+    {#if !_.isEmpty(deleteCascadesScripts)}
+      <FormCheckboxField
+        templateProps={{ noMargin: true }}
+        label="Delete references CASCADE"
+        name="deleteReferencesCascade"
+      />
+    {/if}
+
+    <FormValues let:values>
+      {#if values.deleteReferencesCascade}
+        {#each _.sortBy(deleteCascadesScripts, 'title') as deleteTable}
+          <FormCheckboxField
+            defaultValue={true}
+            templateProps={{ noMargin: true }}
+            label={deleteTable.title}
+            name={`deleteReferences_${deleteTable.title}`}
+          />
+        {/each}
+      {/if}
+    </FormValues>
+
     {#if isRecreated}
       <div class="form-margin">
         <div>

packages/web/src/tabs/TableDataTab.svelte

@@ -16,10 +16,10 @@
 
   export const matchingProps = ['conid', 'database', 'schemaName', 'pureName'];
   export const allowAddToFavorites = props => true;
-
 </script>
 
 <script lang="ts">
+  import _ from 'lodash';
   import App from '../App.svelte';
   import TableDataGrid from '../datagrid/TableDataGrid.svelte';
   import useGridConfig from '../utility/useGridConfig';
@@ -29,6 +29,7 @@
     createChangeSet,
     createGridCache,
     createGridConfig,
+    getDeleteCascades,
     TableFormViewDisplay,
     TableGridDisplay,
   } from 'dbgate-datalib';
@@ -87,11 +88,18 @@
   export function save() {
     const driver = findEngineDriver($connection, $extensions);
     const script = changeSetToSql($changeSetStore?.value, $dbinfo);
+    const deleteCascades = getDeleteCascades($changeSetStore?.value, $dbinfo);
     const sql = scriptToSql(driver, script);
+    const deleteCascadesScripts = _.map(deleteCascades, ({ title, commands }) => ({
+      title,
+      script: scriptToSql(driver, commands),
+    }));
+    console.log('deleteCascadesScripts', deleteCascadesScripts);
     showModal(ConfirmSqlModal, {
       sql,
       onConfirm: () => handleConfirmSql(sql),
       engine: driver.engine,
+      deleteCascadesScripts,
     });
   }
 
@@ -105,7 +113,6 @@
   }
 
   registerMenu({ command: 'tableData.save', tag: 'save' });
-
 </script>
 
 <TableDataGrid