prostgles-server 4.2.235 → 4.2.237

package/lib/PubSubManager/PubSubManager.ts

@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as crypto from "crypto";
 import {
   DBHandlerServer,
   DboBuilder,
@@ -12,9 +11,13 @@ import {
   TableOrViewInfo,
 } from "../DboBuilder/DboBuilder";
 import { PostgresNotifListenManager } from "../PostgresNotifListenManager";
-import { DB, getIsSuperUser } from "../Prostgles";
+import { DB } from "../Prostgles";
 import { addSync } from "./addSync";
+import { addTrigger } from "./addTrigger";
+import { initialiseEventTriggers } from "./initialiseEventTriggers";
 import { initPubSubManager } from "./initPubSubManager";
+import { refreshTriggers } from "./refreshTriggers";
+import { deleteOrphanedTriggers } from "./deleteOrphanedTriggers";
 
 import * as pgPromise from "pg-promise";
 import pg from "pg-promise/typescript/pg-subset";
@@ -28,20 +31,17 @@ import {
   WAL,
 } from "prostgles-types";
 
-import { find, pickKeys, tryCatch, tryCatchV2 } from "prostgles-types/dist/util";
+import { find, pickKeys } from "prostgles-types/dist/util";
 import { LocalFuncs, getOnDataFunc, matchesLocalFuncs } from "../DboBuilder/ViewHandler/subscribe";
-import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
 import { EventTypes } from "../Logging";
 import { TableRule } from "../PublishParser/PublishParser";
 import { syncData } from "../SyncReplication";
 import { addSub } from "./addSub";
-import { DB_OBJ_NAMES } from "./getPubSubManagerInitQuery";
 import { notifListener } from "./notifListener";
-import { DELETE_DISCONNECTED_APPS_QUERY } from "./orphanTriggerCheck";
 import { pushSubData } from "./pushSubData";
 
 type PGP = pgPromise.IMain<{}, pg.IClient>;
-const pgp: PGP = pgPromise({});
+export const pgp: PGP = pgPromise({});
 export const asValue = (v: any) => pgp.as.format("$1", [v]);
 export const DEFAULT_SYNC_BATCH_SIZE = 50;
 
@@ -156,6 +156,8 @@ export type Subscription = Pick<
   }[];
 };
 
+export type PubSubManagerTriggers = Record<string, { condition: string; hash: string }[]>;
+
 /**
  * Used to facilitate table subscribe and sync
  */
@@ -183,7 +185,7 @@ export class PubSubManager {
   }
 
   dboBuilder: DboBuilder;
-  _triggers: Record<string, string[]> | undefined;
+  _triggers: PubSubManagerTriggers | undefined;
   sockets: AnyObject = {};
 
   subs: Subscription[] = [];
@@ -232,92 +234,7 @@ export class PubSubManager {
 
   appChecking = false;
   checkedListenerTableCond?: string[];
-
-  initialiseEventTriggers = async () => {
-    const { watchSchema } = this.dboBuilder.prostgles.opts;
-    if (watchSchema && !(await getIsSuperUser(this.db))) {
-      console.warn(
-        "prostgles watchSchema requires superuser db user. Will not watch using event triggers"
-      );
-    }
-
-    try {
-      /** We use these names because they include schema where necessary */
-      const allTableNames = Object.keys(this.dbo).filter((k) => this.dbo[k]?.tableOrViewInfo);
-      const tableFilterQuery =
-        allTableNames.length ?
-          `OR table_name NOT IN (${allTableNames.map((tblName) => asValue(tblName)).join(", ")})`
-        : "";
-      const query = pgp.as.format(
-        `
-        BEGIN;--  ISOLATION LEVEL SERIALIZABLE;
-        
-        /**                                 
-         * ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
-         *  Drop stale triggers
-         * */
-        DO
-        $do$
-          DECLARE trg RECORD;
-            q   TEXT;
-            ev_trg_needed BOOLEAN := FALSE;
-            ev_trg_exists BOOLEAN := FALSE;
-            is_super_user BOOLEAN := FALSE;
-        BEGIN
-
-            /**
-             *  Delete disconnected app records, this will delete related triggers
-             * */
-            ${DELETE_DISCONNECTED_APPS_QUERY};
-
-            DELETE FROM prostgles.app_triggers
-            WHERE app_id NOT IN (SELECT id FROM prostgles.apps)
-            ${tableFilterQuery}
-            ;
-            
-            /** IS THIS STILL NEEDED? Delete existing triggers without locking 
-            */
-              LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
-              EXECUTE format(
-                $q$
-
-                  CREATE TEMP TABLE %1$I AS --ON COMMIT DROP AS
-                  SELECT * FROM prostgles.app_triggers;
-
-                  DELETE FROM prostgles.app_triggers;
-
-                  INSERT INTO prostgles.app_triggers
-                  SELECT * FROM %1$I;
-
-                  DROP TABLE IF EXISTS %1$I;
-                $q$, 
-                ${asValue("triggers_" + this.appId)}
-              );
-            
-            ${SCHEMA_WATCH_EVENT_TRIGGER_QUERY}
-            
-        END
-        $do$; 
-
-
-        COMMIT;
-      `,
-        { EVENT_TRIGGER_TAGS }
-      );
-
-      await this.db
-        .tx((t) => t.any(query))
-        .catch((e: any) => {
-          console.error("prepareTriggers failed: ", e);
-          throw e;
-        });
-
-      return true;
-    } catch (e) {
-      console.error("prepareTriggers failed: ", e);
-      throw e;
-    }
-  };
+  initialiseEventTriggers = initialiseEventTriggers.bind(this);
 
   getClientSubs({
     channel_name,
@@ -359,6 +276,16 @@ export class PubSubManager {
 
   notifListener = notifListener.bind(this);
 
+  getTriggerInfo = (tableName: string) => {
+    const tableTriggerConditions = this._triggers?.[tableName]?.map((cond, idx) => ({
+      idx,
+      ...cond,
+      subs: this.getTriggerSubs(tableName, cond.condition),
+      syncs: this.getSyncs(tableName, cond.condition),
+    }));
+    return tableTriggerConditions;
+  };
+
   getSubData = async (
     sub: Subscription
   ): Promise<{ data: any[]; err?: undefined } | { data?: undefined; err: any }> => {
@@ -457,184 +384,15 @@ export class PubSubManager {
   /**
    * Sync triggers with database
    *  */
-  refreshTriggers = async () => {
-    const triggers: {
-      table_name: string;
-      condition: string;
-    }[] = await this.db.any(
-      `
-        SELECT *
-        FROM prostgles.v_triggers
-        WHERE app_id = $1
-        ORDER BY table_name, condition
-      `,
-      [this.dboBuilder.prostgles.appId]
-    );
+  refreshTriggers = refreshTriggers.bind(this);
 
-    this._triggers = {};
-    triggers.map((t) => {
-      this._triggers ??= {};
-      this._triggers[t.table_name] ??= [];
-      if (!this._triggers[t.table_name]?.includes(t.condition)) {
-        this._triggers[t.table_name]?.push(t.condition);
-      }
-    });
-  };
+  deleteOrphanedTriggers = debounce(deleteOrphanedTriggers.bind(this), 1000);
 
   addingTrigger: any;
   addTriggerPool?: Record<string, string[]> = undefined;
-  async addTrigger(
-    params: { table_name: string; condition: string },
-    viewOptions: ViewSubscriptionOptions | undefined,
-    socket: PRGLIOSocket | undefined
-  ) {
-    const addedTrigger = await tryCatchV2(async () => {
-      const { table_name } = { ...params };
-      let { condition } = { ...params };
-      if (!table_name) throw "MISSING table_name";
-
-      if (!condition || !condition.trim().length) {
-        condition = "TRUE";
-      }
-
-      if (this.dbo[table_name]?.tableOrViewInfo?.isHyperTable) {
-        throw "Triggers do not work on timescaledb hypertables due to bug:\nhttps://github.com/timescale/timescaledb/issues/1084";
-      }
-
-      const trgVals = {
-        tbl: asValue(table_name),
-        cond: asValue(condition),
-        condHash: asValue(crypto.createHash("md5").update(condition).digest("hex")),
-      };
-
-      await this.db.tx((t) =>
-        t.any(`
-        BEGIN WORK;
-        /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
-        /* why is this lock level needed? */
-        --LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
-
-        /** app_triggers is not refreshed when tables are dropped */
-        DELETE FROM prostgles.app_triggers at
-        WHERE app_id = ${asValue(this.appId)} 
-        AND NOT EXISTS (
-          SELECT 1  
-          FROM pg_catalog.pg_trigger t
-          WHERE tgname like format('prostgles_triggers_%s_', at.table_name) || '%'
-          AND tgenabled = 'O'
-        );
-
-        INSERT INTO prostgles.app_triggers (
-          table_name, 
-          condition, 
-          condition_hash, 
-          app_id, 
-          related_view_name, 
-          related_view_def
-        ) 
-        VALUES (
-          ${trgVals.tbl}, 
-          ${trgVals.cond},
-          ${trgVals.condHash},
-          ${asValue(this.appId)}, 
-          ${asValue(viewOptions?.viewName ?? null)}, 
-          ${asValue(viewOptions?.definition ?? null)}
-        )
-        ON CONFLICT DO NOTHING;
-
-        COMMIT WORK;
-      `)
-      );
-
-      /** This might be redundant due to trigger on app_triggers */
-      await this.refreshTriggers();
-
-      return trgVals;
-    });
-
-    await this._log({
-      type: "syncOrSub",
-      command: "addTrigger",
-      condition: addedTrigger.data?.cond ?? params.condition,
-      duration: addedTrigger.duration,
-      socketId: socket?.id,
-      state: !addedTrigger.data?.tbl ? "fail" : "ok",
-      error: addedTrigger.error,
-      sid: socket && this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket }),
-      tableName: addedTrigger.data?.tbl ?? params.table_name,
-      connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
-      localParams: socket && { clientReq: { socket } },
-      triggers: this._triggers,
-    });
-
-    if (addedTrigger.error) throw addedTrigger.error;
-
-    return addedTrigger;
-  }
+  addTrigger = addTrigger.bind(this);
 }
 
-const SCHEMA_WATCH_EVENT_TRIGGER_QUERY = `
-
-  is_super_user := EXISTS (select 1 from pg_user where usename = CURRENT_USER AND usesuper IS TRUE);
-
-  /* DROP the old buggy schema watch trigger */
-  IF EXISTS (
-    SELECT 1 FROM pg_catalog.pg_event_trigger
-    WHERE evtname = 'prostgles_schema_watch_trigger'
-  ) AND is_super_user IS TRUE 
-  THEN
-    DROP EVENT TRIGGER IF EXISTS prostgles_schema_watch_trigger;
-  END IF;
-
-  ev_trg_needed := EXISTS (
-    SELECT 1 FROM prostgles.apps 
-    WHERE watching_schema_tag_names IS NOT NULL
-  );
-  ev_trg_exists := EXISTS (
-    SELECT 1 FROM pg_catalog.pg_event_trigger
-    WHERE evtname = ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
-  );
-
-  /* DROP stale event trigger */
-  IF 
-    is_super_user IS TRUE 
-    AND ev_trg_needed IS FALSE 
-    AND ev_trg_exists IS TRUE 
-  THEN
-
-      SELECT format(
-        $$ 
-          DROP EVENT TRIGGER IF EXISTS %I ; 
-          DROP EVENT TRIGGER IF EXISTS %I ; 
-        $$
-        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
-        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger_drop)}
-      )
-      INTO q;
-      EXECUTE q;
-
-  /* CREATE event trigger */
-  ELSIF 
-      is_super_user IS TRUE 
-      AND ev_trg_needed IS TRUE 
-      AND ev_trg_exists IS FALSE 
-  THEN
-
-      DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger};
-      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger} 
-      ON ddl_command_end
-      WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
-      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
-
-      DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger_drop};
-      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger_drop} 
-      ON sql_drop
-      --WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
-      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
-
-  END IF;
-`;
-
 export const NOTIF_TYPE = {
   data: "data_has_changed",
   data_trigger_change: "data_watch_triggers_have_changed",
@@ -650,6 +408,19 @@ export const NOTIF_CHANNEL = {
   },
 };
 
+function debounce<Params extends any[]>(
+  func: (...args: Params) => any,
+  timeout: number
+): (...args: Params) => void {
+  let timer: NodeJS.Timeout;
+  return (...args: Params) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func(...args);
+    }, timeout);
+  };
+}
+
 export const parseCondition = (condition: string): string =>
   condition && condition.trim().length ? condition : "TRUE";
 

package/lib/PubSubManager/addTrigger.ts

@@ -0,0 +1,94 @@
+import { tryCatchV2 } from "prostgles-types";
+import { asValue, PubSubManager, ViewSubscriptionOptions } from "./PubSubManager";
+import * as crypto from "crypto";
+import { PRGLIOSocket } from "../DboBuilder/DboBuilderTypes";
+
+export async function addTrigger(
+  this: PubSubManager,
+  params: { table_name: string; condition: string },
+  viewOptions: ViewSubscriptionOptions | undefined,
+  socket: PRGLIOSocket | undefined
+) {
+  const addedTrigger = await tryCatchV2(async () => {
+    const { table_name } = { ...params };
+    let { condition } = { ...params };
+    if (!table_name) throw "MISSING table_name";
+
+    if (!condition || !condition.trim().length) {
+      condition = "TRUE";
+    }
+
+    if (this.dbo[table_name]?.tableOrViewInfo?.isHyperTable) {
+      throw "Triggers do not work on timescaledb hypertables due to bug:\nhttps://github.com/timescale/timescaledb/issues/1084";
+    }
+
+    const trgVals = {
+      tbl: asValue(table_name),
+      cond: asValue(condition),
+      condHash: asValue(crypto.createHash("md5").update(condition).digest("hex")),
+    };
+
+    await this.db.tx((t) =>
+      t.any(`
+      BEGIN WORK;
+      /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+      /* why is this lock level needed? */
+      --LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
+
+      /** app_triggers is not refreshed when tables are dropped */
+      DELETE FROM prostgles.app_triggers at
+      WHERE app_id = ${asValue(this.appId)} 
+      AND NOT EXISTS (
+        SELECT 1  
+        FROM pg_catalog.pg_trigger t
+        WHERE tgname like format('prostgles_triggers_%s_', at.table_name) || '%'
+        AND tgenabled = 'O'
+      );
+
+      INSERT INTO prostgles.app_triggers (
+        table_name, 
+        condition, 
+        condition_hash, 
+        app_id, 
+        related_view_name, 
+        related_view_def
+      ) 
+      VALUES (
+        ${trgVals.tbl}, 
+        ${trgVals.cond},
+        ${trgVals.condHash},
+        ${asValue(this.appId)}, 
+        ${asValue(viewOptions?.viewName ?? null)}, 
+        ${asValue(viewOptions?.definition ?? null)}
+      )
+      ON CONFLICT DO NOTHING;
+
+      COMMIT WORK;
+    `)
+    );
+
+    /** This might be redundant due to trigger on app_triggers */
+    await this.refreshTriggers();
+
+    return trgVals;
+  });
+
+  await this._log({
+    type: "syncOrSub",
+    command: "addTrigger",
+    condition: addedTrigger.data?.cond ?? params.condition,
+    duration: addedTrigger.duration,
+    socketId: socket?.id,
+    state: !addedTrigger.data?.tbl ? "fail" : "ok",
+    error: addedTrigger.error,
+    sid: socket && this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket }),
+    tableName: addedTrigger.data?.tbl ?? params.table_name,
+    connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
+    localParams: socket && { clientReq: { socket } },
+    triggers: this._triggers,
+  });
+
+  if (addedTrigger.error) throw addedTrigger.error;
+
+  return addedTrigger;
+}

package/lib/PubSubManager/deleteOrphanedTriggers.ts

@@ -0,0 +1,33 @@
+import { PubSubManager } from "./PubSubManager";
+
+export async function deleteOrphanedTriggers(this: PubSubManager, tableName: string) {
+  const activeConditions = (this.getTriggerInfo(tableName) ?? []).filter(
+    (c) => c.subs.length || c.syncs.length
+  );
+
+  this.db
+    .any(
+      `
+        /* Delete removed subscriptions */
+        /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+        DELETE FROM prostgles.app_triggers at
+        WHERE EXISTS (
+          SELECT 1
+          FROM prostgles.v_triggers t
+          WHERE t.table_name = $1  
+          AND t.condition_hash NOT IN ($2:csv)
+          AND t.app_id = $3
+          AND at.app_id = t.app_id
+          AND at.table_name = t.table_name
+          AND at.condition = t.condition
+        ) 
+        `,
+      [tableName, activeConditions.map((c) => c.hash), this.appId]
+    )
+    .then(() => {
+      return this.refreshTriggers();
+    })
+    .catch((e) => {
+      console.error("Error deleting orphaned triggers", e);
+    });
+}

package/lib/PubSubManager/initialiseEventTriggers.ts

@@ -0,0 +1,156 @@
+import * as pgp from "pg-promise";
+import { PubSubManager } from "./PubSubManager";
+import { getIsSuperUser } from "../Prostgles";
+import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
+import { DELETE_DISCONNECTED_APPS_QUERY } from "./orphanTriggerCheck";
+import { DB_OBJ_NAMES } from "./getPubSubManagerInitQuery";
+
+const asValue = (v: any) => pgp.as.format("$1", [v]);
+
+export async function initialiseEventTriggers(this: PubSubManager) {
+  const { watchSchema } = this.dboBuilder.prostgles.opts;
+  if (watchSchema && !(await getIsSuperUser(this.db))) {
+    console.warn(
+      "prostgles watchSchema requires superuser db user. Will not watch using event triggers"
+    );
+  }
+
+  try {
+    /** We use these names because they include schema where necessary */
+    const allTableNames = Object.keys(this.dbo).filter((k) => this.dbo[k]?.tableOrViewInfo);
+    const tableFilterQuery =
+      allTableNames.length ?
+        `OR table_name NOT IN (${allTableNames.map((tblName) => asValue(tblName)).join(", ")})`
+      : "";
+    const query = pgp.as.format(
+      `
+        BEGIN;--  ISOLATION LEVEL SERIALIZABLE;
+        
+        /**                                 
+         * ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+         *  Drop stale triggers
+         * */
+        DO
+        $do$
+          DECLARE trg RECORD;
+            q   TEXT;
+            ev_trg_needed BOOLEAN := FALSE;
+            ev_trg_exists BOOLEAN := FALSE;
+            is_super_user BOOLEAN := FALSE;
+        BEGIN
+
+            /**
+             *  Delete disconnected app records, this will delete related triggers
+             * */
+            ${DELETE_DISCONNECTED_APPS_QUERY};
+
+            DELETE FROM prostgles.app_triggers
+            WHERE app_id NOT IN (SELECT id FROM prostgles.apps)
+            ${tableFilterQuery}
+            ;
+            
+            /** IS THIS STILL NEEDED? Delete existing triggers without locking 
+            */
+              LOCK TABLE prostgles.app_triggers IN ACCESS EXCLUSIVE MODE;
+              EXECUTE format(
+                $q$
+
+                  CREATE TEMP TABLE %1$I AS --ON COMMIT DROP AS
+                  SELECT * FROM prostgles.app_triggers;
+
+                  DELETE FROM prostgles.app_triggers;
+
+                  INSERT INTO prostgles.app_triggers
+                  SELECT * FROM %1$I;
+
+                  DROP TABLE IF EXISTS %1$I;
+                $q$, 
+                ${asValue("triggers_" + this.appId)}
+              );
+            
+            ${SCHEMA_WATCH_EVENT_TRIGGER_QUERY}
+            
+        END
+        $do$; 
+
+
+        COMMIT;
+      `,
+      { EVENT_TRIGGER_TAGS }
+    );
+
+    await this.db
+      .tx((t) => t.any(query))
+      .catch((e: any) => {
+        console.error("prepareTriggers failed: ", e);
+        throw e;
+      });
+
+    return true;
+  } catch (e) {
+    console.error("prepareTriggers failed: ", e);
+    throw e;
+  }
+}
+
+const SCHEMA_WATCH_EVENT_TRIGGER_QUERY = `
+
+  is_super_user := EXISTS (select 1 from pg_user where usename = CURRENT_USER AND usesuper IS TRUE);
+
+  /* DROP the old buggy schema watch trigger */
+  IF EXISTS (
+    SELECT 1 FROM pg_catalog.pg_event_trigger
+    WHERE evtname = 'prostgles_schema_watch_trigger'
+  ) AND is_super_user IS TRUE 
+  THEN
+    DROP EVENT TRIGGER IF EXISTS prostgles_schema_watch_trigger;
+  END IF;
+
+  ev_trg_needed := EXISTS (
+    SELECT 1 FROM prostgles.apps 
+    WHERE watching_schema_tag_names IS NOT NULL
+  );
+  ev_trg_exists := EXISTS (
+    SELECT 1 FROM pg_catalog.pg_event_trigger
+    WHERE evtname = ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
+  );
+
+  /* DROP stale event trigger */
+  IF 
+    is_super_user IS TRUE 
+    AND ev_trg_needed IS FALSE 
+    AND ev_trg_exists IS TRUE 
+  THEN
+
+      SELECT format(
+        $$ 
+          DROP EVENT TRIGGER IF EXISTS %I ; 
+          DROP EVENT TRIGGER IF EXISTS %I ; 
+        $$
+        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger)}
+        , ${asValue(DB_OBJ_NAMES.schema_watch_trigger_drop)}
+      )
+      INTO q;
+      EXECUTE q;
+
+  /* CREATE event trigger */
+  ELSIF 
+      is_super_user IS TRUE 
+      AND ev_trg_needed IS TRUE 
+      AND ev_trg_exists IS FALSE 
+  THEN
+
+      DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger};
+      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger} 
+      ON ddl_command_end
+      WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
+      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
+
+      DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger_drop};
+      CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger_drop} 
+      ON sql_drop
+      --WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
+      EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
+
+  END IF;
+`;