forge-sql-orm 2.1.2 → 2.1.4

package/dist/ForgeSQLORM.js

@@ -36,11 +36,16 @@ const parseDateTime = (value, format) => {
     if (dt.isValid) {
       result = dt.toJSDate();
     } else {
-      const isoDt = luxon.DateTime.fromISO(value);
-      if (isoDt.isValid) {
-        result = isoDt.toJSDate();
+      const sqlDt = luxon.DateTime.fromSQL(value);
+      if (sqlDt.isValid) {
+        result = sqlDt.toJSDate();
       } else {
-        result = new Date(value);
+        const isoDt = luxon.DateTime.fromRFC2822(value);
+        if (isoDt.isValid) {
+          result = isoDt.toJSDate();
+        } else {
+          result = new Date(value);
+        }
       }
     }
   }
@@ -49,7 +54,7 @@ const parseDateTime = (value, format) => {
   }
   return result;
 };
-function formatDateTime(value, format) {
+function formatDateTime(value, format, isTimeStamp) {
   let dt = null;
   if (value instanceof Date) {
     dt = luxon.DateTime.fromJSDate(value);
@@ -77,6 +82,20 @@ function formatDateTime(value, format) {
   if (!dt?.isValid) {
     throw new Error("Invalid Date");
   }
+  const minDate = luxon.DateTime.fromSeconds(1);
+  const maxDate = luxon.DateTime.fromMillis(2147483647 * 1e3);
+  if (isTimeStamp) {
+    if (dt < minDate) {
+      throw new Error(
+        "Atlassian Forge does not support zero or negative timestamps. Allowed range: from '1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'."
+      );
+    }
+    if (dt > maxDate) {
+      throw new Error(
+        "Atlassian Forge does not support timestamps beyond 2038-01-19 03:14:07.999999. Please use a smaller date within the supported range."
+      );
+    }
+  }
   return dt.toFormat(format);
 }
 function getPrimaryKeys(table2) {
@@ -480,7 +499,9 @@ async function clearExpiredCache(options) {
     );
   } finally {
     const duration = luxon.DateTime.now().toSeconds() - startTime.toSeconds();
-    console.info(`Cleared ${totalRecords} expired cache records in ${duration} seconds`);
+    if (options?.logRawSqlQuery) {
+      console.debug(`Cleared ${totalRecords} expired cache records in ${duration} seconds`);
+    }
   }
 }
 async function getFromCache(query, options) {
@@ -567,7 +588,7 @@ async function saveQueryLocalCacheQuery(query, rows, options) {
     };
     if (options.logRawSqlQuery) {
       const q = sql2.toSQL();
-      console.log(
+      console.debug(
         `[forge-sql-orm][local-cache][SAVE] Stored result in cache. sql="${q.sql}", params=${JSON.stringify(q.params)}`
       );
     }
@@ -584,7 +605,7 @@ async function getQueryLocalCacheQuery(query, options) {
     if (context.cache[key] && context.cache[key].sql === sql2.toSQL().sql.toLowerCase()) {
       if (options.logRawSqlQuery) {
         const q = sql2.toSQL();
-        console.log(
+        console.debug(
           `[forge-sql-orm][local-cache][HIT] Returned cached result. sql="${q.sql}", params=${JSON.stringify(q.params)}`
         );
       }
@@ -1014,28 +1035,23 @@ class ForgeSQLSelectOperations {
   }
 }
 const forgeDriver = async (query, params, method) => {
-  try {
-    if (method == "execute") {
-      const sqlStatement = sql$1.sql.prepare(query);
-      if (params) {
-        sqlStatement.bindParams(...params);
-      }
-      const updateQueryResponseResults = await sqlStatement.execute();
-      let result = updateQueryResponseResults.rows;
-      return { ...result, rows: [result] };
-    } else {
-      const sqlStatement = await sql$1.sql.prepare(query);
-      if (params) {
-        await sqlStatement.bindParams(...params);
-      }
-      const result = await sqlStatement.execute();
-      let rows;
-      rows = result.rows.map((r) => Object.values(r));
-      return { rows };
+  if (method == "execute") {
+    const sqlStatement = sql$1.sql.prepare(query);
+    if (params) {
+      sqlStatement.bindParams(...params);
     }
-  } catch (error) {
-    console.error("SQL Error:", JSON.stringify(error));
-    throw error;
+    const updateQueryResponseResults = await sqlStatement.execute();
+    let result = updateQueryResponseResults.rows;
+    return { ...result, rows: [result] };
+  } else {
+    const sqlStatement = await sql$1.sql.prepare(query);
+    if (params) {
+      await sqlStatement.bindParams(...params);
+    }
+    const result = await sqlStatement.execute();
+    let rows;
+    rows = result.rows.map((r) => Object.values(r));
+    return { rows };
   }
 };
 function injectSqlHints(query, hints) {
@@ -1072,9 +1088,16 @@ function createForgeDriverProxy(options, logRawSqlQuery) {
   return async (query, params, method) => {
     const modifiedQuery = injectSqlHints(query, options);
     if (options && logRawSqlQuery && modifiedQuery !== query) {
-      console.warn("modified query: " + modifiedQuery);
+      console.debug("injected Hints: " + modifiedQuery);
+    }
+    try {
+      return await forgeDriver(modifiedQuery, params, method);
+    } catch (error) {
+      if (logRawSqlQuery) {
+        console.debug("SQL Error:", JSON.stringify(error));
+      }
+      throw error;
     }
-    return forgeDriver(modifiedQuery, params, method);
   };
 }
 const NON_CACHE_CLEARING_ERROR_CODES = ["VALIDATION_ERROR", "CONSTRAINT_ERROR"];
@@ -1109,8 +1132,8 @@ async function handleSuccessfulExecution(rows, onfulfilled, table2, options, isC
     if (shouldClearCacheOnError(error)) {
       await evictLocalCacheQuery(table2, options);
       if (isCached) {
-        await clearCache(table2, options).catch(() => {
-          console.warn("Ignore cache clear errors");
+        await clearCache(table2, options).catch((e) => {
+          console.warn("Ignore cache clear errors", e);
         });
       } else {
         await saveTableIfInsideCacheContext(table2);
@@ -2572,10 +2595,10 @@ const forgeDateTimeString = mysqlCore.customType({
     return "datetime";
   },
   toDriver(value) {
-    return formatDateTime(value, "yyyy-LL-dd' 'HH:mm:ss.SSS");
+    return formatDateTime(value, "yyyy-MM-dd' 'HH:mm:ss.SSS", false);
   },
   fromDriver(value) {
-    const format = "yyyy-LL-dd'T'HH:mm:ss.SSS";
+    const format = "yyyy-MM-dd' 'HH:mm:ss.SSS";
     return parseDateTime(value, format);
   }
 });
@@ -2584,10 +2607,10 @@ const forgeTimestampString = mysqlCore.customType({
     return "timestamp";
   },
   toDriver(value) {
-    return formatDateTime(value, "yyyy-LL-dd' 'HH:mm:ss.SSS");
+    return formatDateTime(value, "yyyy-MM-dd' 'HH:mm:ss.SSS", true);
   },
   fromDriver(value) {
-    const format = "yyyy-LL-dd'T'HH:mm:ss.SSS";
+    const format = "yyyy-MM-dd' 'HH:mm:ss.SSS";
     return parseDateTime(value, format);
   }
 });
@@ -2596,10 +2619,10 @@ const forgeDateString = mysqlCore.customType({
     return "date";
   },
   toDriver(value) {
-    return formatDateTime(value, "yyyy-LL-dd");
+    return formatDateTime(value, "yyyy-MM-dd", false);
   },
   fromDriver(value) {
-    const format = "yyyy-LL-dd";
+    const format = "yyyy-MM-dd";
     return parseDateTime(value, format);
   }
 });
@@ -2608,7 +2631,7 @@ const forgeTimeString = mysqlCore.customType({
     return "time";
   },
   toDriver(value) {
-    return formatDateTime(value, "HH:mm:ss.SSS");
+    return formatDateTime(value, "HH:mm:ss.SSS", false);
   },
   fromDriver(value) {
     return parseDateTime(value, "HH:mm:ss.SSS");
@@ -2619,6 +2642,435 @@ const migrations = mysqlCore.mysqlTable("__migrations", {
   name: mysqlCore.varchar("name", { length: 255 }).notNull(),
   migratedAt: mysqlCore.timestamp("migratedAt").defaultNow().notNull()
 });
+const informationSchema = mysqlCore.mysqlSchema("information_schema");
+const slowQuery = informationSchema.table("SLOW_QUERY", {
+  time: mysqlCore.timestamp("Time", { fsp: 6, mode: "string" }).notNull(),
+  // Timestamp when the slow query was recorded
+  txnStartTs: mysqlCore.bigint("Txn_start_ts", { mode: "bigint", unsigned: true }),
+  // Transaction start timestamp (TSO)
+  user: mysqlCore.varchar("User", { length: 64 }),
+  // User executing the query
+  host: mysqlCore.varchar("Host", { length: 64 }),
+  // Host from which the query originated
+  connId: mysqlCore.bigint("Conn_ID", { mode: "bigint", unsigned: true }),
+  // Connection ID
+  sessionAlias: mysqlCore.varchar("Session_alias", { length: 64 }),
+  // Session alias
+  execRetryCount: mysqlCore.bigint("Exec_retry_count", { mode: "bigint", unsigned: true }),
+  // Number of retries during execution
+  execRetryTime: mysqlCore.double("Exec_retry_time"),
+  // Time spent in retries
+  queryTime: mysqlCore.double("Query_time"),
+  // Total execution time
+  parseTime: mysqlCore.double("Parse_time"),
+  // Time spent parsing SQL
+  compileTime: mysqlCore.double("Compile_time"),
+  // Time spent compiling query plan
+  rewriteTime: mysqlCore.double("Rewrite_time"),
+  // Time spent rewriting query
+  preprocSubqueries: mysqlCore.bigint("Preproc_subqueries", { mode: "bigint", unsigned: true }),
+  // Number of subqueries preprocessed
+  preprocSubqueriesTime: mysqlCore.double("Preproc_subqueries_time"),
+  // Time spent preprocessing subqueries
+  optimizeTime: mysqlCore.double("Optimize_time"),
+  // Time spent in optimizer
+  waitTs: mysqlCore.double("Wait_TS"),
+  // Wait time for getting TSO
+  prewriteTime: mysqlCore.double("Prewrite_time"),
+  // Time spent in prewrite phase
+  waitPrewriteBinlogTime: mysqlCore.double("Wait_prewrite_binlog_time"),
+  // Time waiting for binlog prewrite
+  commitTime: mysqlCore.double("Commit_time"),
+  // Commit duration
+  getCommitTsTime: mysqlCore.double("Get_commit_ts_time"),
+  // Time waiting for commit TSO
+  commitBackoffTime: mysqlCore.double("Commit_backoff_time"),
+  // Backoff time during commit
+  backoffTypes: mysqlCore.varchar("Backoff_types", { length: 64 }),
+  // Types of backoff occurred
+  resolveLockTime: mysqlCore.double("Resolve_lock_time"),
+  // Time resolving locks
+  localLatchWaitTime: mysqlCore.double("Local_latch_wait_time"),
+  // Time waiting on local latch
+  writeKeys: mysqlCore.bigint("Write_keys", { mode: "bigint" }),
+  // Number of keys written
+  writeSize: mysqlCore.bigint("Write_size", { mode: "bigint" }),
+  // Amount of data written
+  prewriteRegion: mysqlCore.bigint("Prewrite_region", { mode: "bigint" }),
+  // Regions involved in prewrite
+  txnRetry: mysqlCore.bigint("Txn_retry", { mode: "bigint" }),
+  // Transaction retry count
+  copTime: mysqlCore.double("Cop_time"),
+  // Time spent in coprocessor
+  processTime: mysqlCore.double("Process_time"),
+  // Processing time
+  waitTime: mysqlCore.double("Wait_time"),
+  // Wait time in TiKV
+  backoffTime: mysqlCore.double("Backoff_time"),
+  // Backoff wait time
+  lockKeysTime: mysqlCore.double("LockKeys_time"),
+  // Time spent waiting for locks
+  requestCount: mysqlCore.bigint("Request_count", { mode: "bigint", unsigned: true }),
+  // Total number of requests
+  totalKeys: mysqlCore.bigint("Total_keys", { mode: "bigint", unsigned: true }),
+  // Total keys scanned
+  processKeys: mysqlCore.bigint("Process_keys", { mode: "bigint", unsigned: true }),
+  // Keys processed
+  rocksdbDeleteSkippedCount: mysqlCore.bigint("Rocksdb_delete_skipped_count", {
+    mode: "bigint",
+    unsigned: true
+  }),
+  // RocksDB delete skips
+  rocksdbKeySkippedCount: mysqlCore.bigint("Rocksdb_key_skipped_count", { mode: "bigint", unsigned: true }),
+  // RocksDB key skips
+  rocksdbBlockCacheHitCount: mysqlCore.bigint("Rocksdb_block_cache_hit_count", {
+    mode: "bigint",
+    unsigned: true
+  }),
+  // RocksDB block cache hits
+  rocksdbBlockReadCount: mysqlCore.bigint("Rocksdb_block_read_count", { mode: "bigint", unsigned: true }),
+  // RocksDB block reads
+  rocksdbBlockReadByte: mysqlCore.bigint("Rocksdb_block_read_byte", { mode: "bigint", unsigned: true }),
+  // RocksDB block read bytes
+  db: mysqlCore.varchar("DB", { length: 64 }),
+  // Database name
+  indexNames: mysqlCore.varchar("Index_names", { length: 100 }),
+  // Indexes used
+  isInternal: mysqlCore.boolean("Is_internal"),
+  // Whether the query is internal
+  digest: mysqlCore.varchar("Digest", { length: 64 }),
+  // SQL digest hash
+  stats: mysqlCore.varchar("Stats", { length: 512 }),
+  // Stats used during planning
+  copProcAvg: mysqlCore.double("Cop_proc_avg"),
+  // Coprocessor average processing time
+  copProcP90: mysqlCore.double("Cop_proc_p90"),
+  // Coprocessor 90th percentile processing time
+  copProcMax: mysqlCore.double("Cop_proc_max"),
+  // Coprocessor max processing time
+  copProcAddr: mysqlCore.varchar("Cop_proc_addr", { length: 64 }),
+  // Coprocessor address for processing
+  copWaitAvg: mysqlCore.double("Cop_wait_avg"),
+  // Coprocessor average wait time
+  copWaitP90: mysqlCore.double("Cop_wait_p90"),
+  // Coprocessor 90th percentile wait time
+  copWaitMax: mysqlCore.double("Cop_wait_max"),
+  // Coprocessor max wait time
+  copWaitAddr: mysqlCore.varchar("Cop_wait_addr", { length: 64 }),
+  // Coprocessor address for wait
+  memMax: mysqlCore.bigint("Mem_max", { mode: "bigint" }),
+  // Max memory usage
+  diskMax: mysqlCore.bigint("Disk_max", { mode: "bigint" }),
+  // Max disk usage
+  kvTotal: mysqlCore.double("KV_total"),
+  // Total KV request time
+  pdTotal: mysqlCore.double("PD_total"),
+  // Total PD request time
+  backoffTotal: mysqlCore.double("Backoff_total"),
+  // Total backoff time
+  writeSqlResponseTotal: mysqlCore.double("Write_sql_response_total"),
+  // SQL response write time
+  resultRows: mysqlCore.bigint("Result_rows", { mode: "bigint" }),
+  // Rows returned
+  warnings: mysqlCore.longtext("Warnings"),
+  // Warnings during execution
+  backoffDetail: mysqlCore.varchar("Backoff_Detail", { length: 4096 }),
+  // Detailed backoff info
+  prepared: mysqlCore.boolean("Prepared"),
+  // Whether query was prepared
+  succ: mysqlCore.boolean("Succ"),
+  // Success flag
+  isExplicitTxn: mysqlCore.boolean("IsExplicitTxn"),
+  // Whether explicit transaction
+  isWriteCacheTable: mysqlCore.boolean("IsWriteCacheTable"),
+  // Whether wrote to cache table
+  planFromCache: mysqlCore.boolean("Plan_from_cache"),
+  // Plan was from cache
+  planFromBinding: mysqlCore.boolean("Plan_from_binding"),
+  // Plan was from binding
+  hasMoreResults: mysqlCore.boolean("Has_more_results"),
+  // Query returned multiple results
+  resourceGroup: mysqlCore.varchar("Resource_group", { length: 64 }),
+  // Resource group name
+  requestUnitRead: mysqlCore.double("Request_unit_read"),
+  // RU consumed for read
+  requestUnitWrite: mysqlCore.double("Request_unit_write"),
+  // RU consumed for write
+  timeQueuedByRc: mysqlCore.double("Time_queued_by_rc"),
+  // Time queued by resource control
+  tidbCpuTime: mysqlCore.double("Tidb_cpu_time"),
+  // TiDB CPU time
+  tikvCpuTime: mysqlCore.double("Tikv_cpu_time"),
+  // TiKV CPU time
+  plan: mysqlCore.longtext("Plan"),
+  // Query execution plan
+  planDigest: mysqlCore.varchar("Plan_digest", { length: 128 }),
+  // Plan digest hash
+  binaryPlan: mysqlCore.longtext("Binary_plan"),
+  // Binary execution plan
+  prevStmt: mysqlCore.longtext("Prev_stmt"),
+  // Previous statement in session
+  query: mysqlCore.longtext("Query")
+  // Original SQL query
+});
+const createClusterStatementsSummarySchema = () => ({
+  instance: mysqlCore.varchar("INSTANCE", { length: 64 }),
+  // TiDB/TiKV instance address
+  summaryBeginTime: mysqlCore.timestamp("SUMMARY_BEGIN_TIME", { mode: "string" }).notNull(),
+  // Begin time of this summary window
+  summaryEndTime: mysqlCore.timestamp("SUMMARY_END_TIME", { mode: "string" }).notNull(),
+  // End time of this summary window
+  stmtType: mysqlCore.varchar("STMT_TYPE", { length: 64 }).notNull(),
+  // Statement type (e.g., Select/Insert/Update)
+  schemaName: mysqlCore.varchar("SCHEMA_NAME", { length: 64 }),
+  // Current schema name
+  digest: mysqlCore.varchar("DIGEST", { length: 64 }),
+  // SQL digest (normalized hash)
+  digestText: mysqlCore.text("DIGEST_TEXT").notNull(),
+  // Normalized SQL text
+  tableNames: mysqlCore.text("TABLE_NAMES"),
+  // Involved table names
+  indexNames: mysqlCore.text("INDEX_NAMES"),
+  // Used index names
+  sampleUser: mysqlCore.varchar("SAMPLE_USER", { length: 64 }),
+  // Sampled user who executed the statements
+  execCount: mysqlCore.bigint("EXEC_COUNT", { mode: "bigint", unsigned: true }).notNull(),
+  // Total executions
+  sumErrors: mysqlCore.int("SUM_ERRORS", { unsigned: true }).notNull(),
+  // Sum of errors
+  sumWarnings: mysqlCore.int("SUM_WARNINGS", { unsigned: true }).notNull(),
+  // Sum of warnings
+  sumLatency: mysqlCore.bigint("SUM_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum of latency (ns)
+  maxLatency: mysqlCore.bigint("MAX_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Max latency (ns)
+  minLatency: mysqlCore.bigint("MIN_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Min latency (ns)
+  avgLatency: mysqlCore.bigint("AVG_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg latency (ns)
+  avgParseLatency: mysqlCore.bigint("AVG_PARSE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg parse time (ns)
+  maxParseLatency: mysqlCore.bigint("MAX_PARSE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Max parse time (ns)
+  avgCompileLatency: mysqlCore.bigint("AVG_COMPILE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg compile time (ns)
+  maxCompileLatency: mysqlCore.bigint("MAX_COMPILE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Max compile time (ns)
+  sumCopTaskNum: mysqlCore.bigint("SUM_COP_TASK_NUM", { mode: "bigint", unsigned: true }).notNull(),
+  // Total number of cop tasks
+  maxCopProcessTime: mysqlCore.bigint("MAX_COP_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV coprocessor processing time (ns)
+  maxCopProcessAddress: mysqlCore.varchar("MAX_COP_PROCESS_ADDRESS", { length: 256 }),
+  // Address of cop task with max processing time
+  maxCopWaitTime: mysqlCore.bigint("MAX_COP_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV coprocessor wait time (ns)
+  maxCopWaitAddress: mysqlCore.varchar("MAX_COP_WAIT_ADDRESS", { length: 256 }),
+  // Address of cop task with max wait time
+  avgProcessTime: mysqlCore.bigint("AVG_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiKV processing time (ns)
+  maxProcessTime: mysqlCore.bigint("MAX_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV processing time (ns)
+  avgWaitTime: mysqlCore.bigint("AVG_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiKV wait time (ns)
+  maxWaitTime: mysqlCore.bigint("MAX_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV wait time (ns)
+  avgBackoffTime: mysqlCore.bigint("AVG_BACKOFF_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg backoff time before retry (ns)
+  maxBackoffTime: mysqlCore.bigint("MAX_BACKOFF_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max backoff time before retry (ns)
+  avgTotalKeys: mysqlCore.bigint("AVG_TOTAL_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg scanned keys
+  maxTotalKeys: mysqlCore.bigint("MAX_TOTAL_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Max scanned keys
+  avgProcessedKeys: mysqlCore.bigint("AVG_PROCESSED_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg processed keys
+  maxProcessedKeys: mysqlCore.bigint("MAX_PROCESSED_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Max processed keys
+  avgRocksdbDeleteSkippedCount: mysqlCore.double("AVG_ROCKSDB_DELETE_SKIPPED_COUNT").notNull(),
+  // Avg RocksDB deletes skipped
+  maxRocksdbDeleteSkippedCount: mysqlCore.int("MAX_ROCKSDB_DELETE_SKIPPED_COUNT", {
+    unsigned: true
+  }).notNull(),
+  // Max RocksDB deletes skipped
+  avgRocksdbKeySkippedCount: mysqlCore.double("AVG_ROCKSDB_KEY_SKIPPED_COUNT").notNull(),
+  // Avg RocksDB keys skipped
+  maxRocksdbKeySkippedCount: mysqlCore.int("MAX_ROCKSDB_KEY_SKIPPED_COUNT", { unsigned: true }).notNull(),
+  // Max RocksDB keys skipped
+  avgRocksdbBlockCacheHitCount: mysqlCore.double("AVG_ROCKSDB_BLOCK_CACHE_HIT_COUNT").notNull(),
+  // Avg RocksDB block cache hits
+  maxRocksdbBlockCacheHitCount: mysqlCore.int("MAX_ROCKSDB_BLOCK_CACHE_HIT_COUNT", {
+    unsigned: true
+  }).notNull(),
+  // Max RocksDB block cache hits
+  avgRocksdbBlockReadCount: mysqlCore.double("AVG_ROCKSDB_BLOCK_READ_COUNT").notNull(),
+  // Avg RocksDB block reads
+  maxRocksdbBlockReadCount: mysqlCore.int("MAX_ROCKSDB_BLOCK_READ_COUNT", { unsigned: true }).notNull(),
+  // Max RocksDB block reads
+  avgRocksdbBlockReadByte: mysqlCore.double("AVG_ROCKSDB_BLOCK_READ_BYTE").notNull(),
+  // Avg RocksDB block read bytes
+  maxRocksdbBlockReadByte: mysqlCore.int("MAX_ROCKSDB_BLOCK_READ_BYTE", { unsigned: true }).notNull(),
+  // Max RocksDB block read bytes
+  avgPrewriteTime: mysqlCore.bigint("AVG_PREWRITE_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg prewrite phase time (ns)
+  maxPrewriteTime: mysqlCore.bigint("MAX_PREWRITE_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max prewrite phase time (ns)
+  avgCommitTime: mysqlCore.bigint("AVG_COMMIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg commit phase time (ns)
+  maxCommitTime: mysqlCore.bigint("MAX_COMMIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max commit phase time (ns)
+  avgGetCommitTsTime: mysqlCore.bigint("AVG_GET_COMMIT_TS_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg get commit_ts time (ns)
+  maxGetCommitTsTime: mysqlCore.bigint("MAX_GET_COMMIT_TS_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max get commit_ts time (ns)
+  avgCommitBackoffTime: mysqlCore.bigint("AVG_COMMIT_BACKOFF_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg backoff during commit (ns)
+  maxCommitBackoffTime: mysqlCore.bigint("MAX_COMMIT_BACKOFF_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max backoff during commit (ns)
+  avgResolveLockTime: mysqlCore.bigint("AVG_RESOLVE_LOCK_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg resolve lock time (ns)
+  maxResolveLockTime: mysqlCore.bigint("MAX_RESOLVE_LOCK_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max resolve lock time (ns)
+  avgLocalLatchWaitTime: mysqlCore.bigint("AVG_LOCAL_LATCH_WAIT_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg local latch wait (ns)
+  maxLocalLatchWaitTime: mysqlCore.bigint("MAX_LOCAL_LATCH_WAIT_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max local latch wait (ns)
+  avgWriteKeys: mysqlCore.double("AVG_WRITE_KEYS").notNull(),
+  // Avg number of written keys
+  maxWriteKeys: mysqlCore.bigint("MAX_WRITE_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Max written keys
+  avgWriteSize: mysqlCore.double("AVG_WRITE_SIZE").notNull(),
+  // Avg written bytes
+  maxWriteSize: mysqlCore.bigint("MAX_WRITE_SIZE", { mode: "bigint", unsigned: true }).notNull(),
+  // Max written bytes
+  avgPrewriteRegions: mysqlCore.double("AVG_PREWRITE_REGIONS").notNull(),
+  // Avg regions in prewrite
+  maxPrewriteRegions: mysqlCore.int("MAX_PREWRITE_REGIONS", { unsigned: true }).notNull(),
+  // Max regions in prewrite
+  avgTxnRetry: mysqlCore.double("AVG_TXN_RETRY").notNull(),
+  // Avg transaction retry count
+  maxTxnRetry: mysqlCore.int("MAX_TXN_RETRY", { unsigned: true }).notNull(),
+  // Max transaction retry count
+  sumExecRetry: mysqlCore.bigint("SUM_EXEC_RETRY", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum of execution retries (pessimistic)
+  sumExecRetryTime: mysqlCore.bigint("SUM_EXEC_RETRY_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum time of execution retries (ns)
+  sumBackoffTimes: mysqlCore.bigint("SUM_BACKOFF_TIMES", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum of backoff retries
+  backoffTypes: mysqlCore.varchar("BACKOFF_TYPES", { length: 1024 }),
+  // Backoff types with counts
+  avgMem: mysqlCore.bigint("AVG_MEM", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg memory used (bytes)
+  maxMem: mysqlCore.bigint("MAX_MEM", { mode: "bigint", unsigned: true }).notNull(),
+  // Max memory used (bytes)
+  avgDisk: mysqlCore.bigint("AVG_DISK", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg disk used (bytes)
+  maxDisk: mysqlCore.bigint("MAX_DISK", { mode: "bigint", unsigned: true }).notNull(),
+  // Max disk used (bytes)
+  avgKvTime: mysqlCore.bigint("AVG_KV_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg time spent in TiKV (ns)
+  avgPdTime: mysqlCore.bigint("AVG_PD_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg time spent in PD (ns)
+  avgBackoffTotalTime: mysqlCore.bigint("AVG_BACKOFF_TOTAL_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg total backoff time (ns)
+  avgWriteSqlRespTime: mysqlCore.bigint("AVG_WRITE_SQL_RESP_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg write SQL response time (ns)
+  avgTidbCpuTime: mysqlCore.bigint("AVG_TIDB_CPU_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiDB CPU time (ns)
+  avgTikvCpuTime: mysqlCore.bigint("AVG_TIKV_CPU_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiKV CPU time (ns)
+  maxResultRows: mysqlCore.bigint("MAX_RESULT_ROWS", { mode: "bigint" }).notNull(),
+  // Max number of result rows
+  minResultRows: mysqlCore.bigint("MIN_RESULT_ROWS", { mode: "bigint" }).notNull(),
+  // Min number of result rows
+  avgResultRows: mysqlCore.bigint("AVG_RESULT_ROWS", { mode: "bigint" }).notNull(),
+  // Avg number of result rows
+  prepared: mysqlCore.boolean("PREPARED").notNull(),
+  // Whether statements are prepared
+  avgAffectedRows: mysqlCore.double("AVG_AFFECTED_ROWS").notNull(),
+  // Avg affected rows
+  firstSeen: mysqlCore.timestamp("FIRST_SEEN", { mode: "string" }).notNull(),
+  // First time statements observed
+  lastSeen: mysqlCore.timestamp("LAST_SEEN", { mode: "string" }).notNull(),
+  // Last time statements observed
+  planInCache: mysqlCore.boolean("PLAN_IN_CACHE").notNull(),
+  // Whether last stmt hit plan cache
+  planCacheHits: mysqlCore.bigint("PLAN_CACHE_HITS", { mode: "bigint" }).notNull(),
+  // Number of plan cache hits
+  planInBinding: mysqlCore.boolean("PLAN_IN_BINDING").notNull(),
+  // Whether matched bindings
+  querySampleText: mysqlCore.text("QUERY_SAMPLE_TEXT"),
+  // Sampled original SQL
+  prevSampleText: mysqlCore.text("PREV_SAMPLE_TEXT"),
+  // Sampled previous SQL before commit
+  planDigest: mysqlCore.varchar("PLAN_DIGEST", { length: 64 }),
+  // Plan digest hash
+  plan: mysqlCore.text("PLAN"),
+  // Sampled textual plan
+  binaryPlan: mysqlCore.text("BINARY_PLAN"),
+  // Sampled binary plan
+  charset: mysqlCore.varchar("CHARSET", { length: 64 }),
+  // Sampled charset
+  collation: mysqlCore.varchar("COLLATION", { length: 64 }),
+  // Sampled collation
+  planHint: mysqlCore.varchar("PLAN_HINT", { length: 64 }),
+  // Sampled plan hint
+  maxRequestUnitRead: mysqlCore.double("MAX_REQUEST_UNIT_READ").notNull(),
+  // Max RU cost (read)
+  avgRequestUnitRead: mysqlCore.double("AVG_REQUEST_UNIT_READ").notNull(),
+  // Avg RU cost (read)
+  maxRequestUnitWrite: mysqlCore.double("MAX_REQUEST_UNIT_WRITE").notNull(),
+  // Max RU cost (write)
+  avgRequestUnitWrite: mysqlCore.double("AVG_REQUEST_UNIT_WRITE").notNull(),
+  // Avg RU cost (write)
+  maxQueuedRcTime: mysqlCore.bigint("MAX_QUEUED_RC_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max queued time waiting for RU (ns)
+  avgQueuedRcTime: mysqlCore.bigint("AVG_QUEUED_RC_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg queued time waiting for RU (ns)
+  resourceGroup: mysqlCore.varchar("RESOURCE_GROUP", { length: 64 }),
+  // Bound resource group name
+  planCacheUnqualified: mysqlCore.bigint("PLAN_CACHE_UNQUALIFIED", { mode: "bigint" }).notNull(),
+  // Times not eligible for plan cache
+  planCacheUnqualifiedLastReason: mysqlCore.text("PLAN_CACHE_UNQUALIFIED_LAST_REASON")
+  // Last reason of plan cache ineligibility
+});
+const clusterStatementsSummaryHistory = informationSchema.table(
+  "CLUSTER_STATEMENTS_SUMMARY_HISTORY",
+  createClusterStatementsSummarySchema()
+);
+const clusterStatementsSummary = informationSchema.table(
+  "CLUSTER_STATEMENTS_SUMMARY",
+  createClusterStatementsSummarySchema()
+);
 async function getTables() {
   const tables = await sql$1.sql.executeDDL("SHOW TABLES");
   return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
@@ -2629,7 +3081,7 @@ async function dropSchemaMigrations() {
     const tables = await getTables();
     const dropStatements = generateDropTableStatements(tables, { sequence: true, table: true });
     for (const statement of dropStatements) {
-      console.warn(statement);
+      console.debug(`execute DDL: ${statement}`);
       await sql$1.sql.executeDDL(statement);
     }
     return getHttpResponse(
@@ -2637,8 +3089,8 @@ async function dropSchemaMigrations() {
       "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone."
     );
   } catch (error) {
-    console.error(error);
-    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
+    console.error(errorMessage);
     return getHttpResponse(500, errorMessage);
   }
 }
@@ -2654,7 +3106,13 @@ const applySchemaMigrations = async (migration) => {
     const successfulMigrations = await migrations2.run();
     console.info("Migrations applied:", successfulMigrations);
     const migrationList = await sql$1.migrationRunner.list();
-    const migrationHistory = Array.isArray(migrationList) && migrationList.length > 0 ? migrationList.sort((a, b) => a.migratedAt.getTime() - b.migratedAt.getTime()).map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n") : "No migrations found";
+    let migrationHistory = "No migrations found";
+    if (Array.isArray(migrationList) && migrationList.length > 0) {
+      const sortedMigrations = migrationList.toSorted(
+        (a, b) => a.migratedAt.getTime() - b.migratedAt.getTime()
+      );
+      migrationHistory = sortedMigrations.map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n");
+    }
     console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
     return {
       headers: { "Content-Type": ["application/json"] },
@@ -2663,17 +3121,13 @@ const applySchemaMigrations = async (migration) => {
       body: "Migrations successfully executed"
     };
   } catch (error) {
-    try {
-      console.error("Error during migration:", JSON.stringify(error));
-    } catch (e) {
-      console.trace("Error stringify:", e);
-      console.error("Error during migration:", error);
-    }
+    const errorMessage = error?.cause?.context?.debug?.sqlMessage ?? error?.cause?.context?.debug?.message ?? error?.debug?.context?.sqlMessage ?? error?.debug?.context?.message ?? error.message ?? "Unknown error occurred";
+    console.error("Error during migration:", errorMessage);
     return {
       headers: { "Content-Type": ["application/json"] },
       statusCode: 500,
       statusText: "Internal Server Error",
-      body: error instanceof Error ? error.message : "Unknown error during migration"
+      body: error instanceof Error ? errorMessage : "Unknown error during migration"
     };
   }
 };
@@ -2684,8 +3138,8 @@ async function fetchSchemaWebTrigger() {
     const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);
     return getHttpResponse(200, sqlStatements.join(";\n"));
   } catch (error) {
-    console.error(JSON.stringify(error));
-    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
+    console.error(errorMessage);
     return getHttpResponse(500, errorMessage);
   }
 }
@@ -2712,7 +3166,7 @@ async function dropTableSchemaMigrations() {
     const tables = await getTables();
     const dropStatements = generateDropTableStatements(tables, { sequence: false, table: true });
     for (const statement of dropStatements) {
-      console.warn(statement);
+      console.debug(`execute DDL: ${statement}`);
       await sql$1.sql.executeDDL(statement);
     }
     return getHttpResponse(
@@ -2720,8 +3174,8 @@ async function dropTableSchemaMigrations() {
       "⚠️ All data in these tables has been permanently deleted. This operation cannot be undone."
     );
   } catch (error) {
-    console.error(error);
-    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
+    console.error(errorMessage);
     return getHttpResponse(500, errorMessage);
   }
 }
@@ -2764,6 +3218,169 @@ const clearCacheSchedulerTrigger = async (options) => {
     };
   }
 };
+const topSlowestStatementLastHourTrigger = async (orm, warnThresholdMs = 300, memoryThresholdBytes = 8 * 1024 * 1024) => {
+  const nsToMs = (v) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? n / 1e6 : NaN;
+  };
+  const bytesToMB = (v) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? n / (1024 * 1024) : NaN;
+  };
+  const jsonSafeStringify = (value) => JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v);
+  const TOP_N = 1;
+  try {
+    const summaryHistory = clusterStatementsSummaryHistory;
+    const summary = clusterStatementsSummary;
+    const selectShape = (t) => ({
+      digest: t.digest,
+      stmtType: t.stmtType,
+      schemaName: t.schemaName,
+      execCount: t.execCount,
+      avgLatencyNs: t.avgLatency,
+      maxLatencyNs: t.maxLatency,
+      minLatencyNs: t.minLatency,
+      avgProcessTimeNs: t.avgProcessTime,
+      avgWaitTimeNs: t.avgWaitTime,
+      avgBackoffTimeNs: t.avgBackoffTime,
+      avgTotalKeys: t.avgTotalKeys,
+      firstSeen: t.firstSeen,
+      lastSeen: t.lastSeen,
+      planInCache: t.planInCache,
+      planCacheHits: t.planCacheHits,
+      digestText: t.digestText,
+      plan: t.plan,
+      avgMemBytes: t.avgMem,
+      maxMemBytes: t.maxMem
+    });
+    const lastHourFilterHistory = drizzleOrm.gte(
+      summaryHistory.summaryEndTime,
+      drizzleOrm.sql`DATE_SUB(NOW(), INTERVAL 1 HOUR)`
+    );
+    const lastHourFilterSummary = drizzleOrm.gte(
+      summary.summaryEndTime,
+      drizzleOrm.sql`DATE_SUB(NOW(), INTERVAL 1 HOUR)`
+    );
+    const qHistory = orm.getDrizzleQueryBuilder().select(selectShape(summaryHistory)).from(summaryHistory).where(lastHourFilterHistory);
+    const qSummary = orm.getDrizzleQueryBuilder().select(selectShape(summary)).from(summary).where(lastHourFilterSummary);
+    const combined = mysqlCore.unionAll(qHistory, qSummary).as("combined");
+    const thresholdNs = Math.floor(warnThresholdMs * 1e6);
+    const grouped = orm.getDrizzleQueryBuilder().select({
+      digest: combined.digest,
+      stmtType: combined.stmtType,
+      schemaName: combined.schemaName,
+      execCount: drizzleOrm.sql`SUM(${combined.execCount})`.as("execCount"),
+      avgLatencyNs: drizzleOrm.sql`MAX(${combined.avgLatencyNs})`.as("avgLatencyNs"),
+      maxLatencyNs: drizzleOrm.sql`MAX(${combined.maxLatencyNs})`.as("maxLatencyNs"),
+      minLatencyNs: drizzleOrm.sql`MIN(${combined.minLatencyNs})`.as("minLatencyNs"),
+      avgProcessTimeNs: drizzleOrm.sql`MAX(${combined.avgProcessTimeNs})`.as("avgProcessTimeNs"),
+      avgWaitTimeNs: drizzleOrm.sql`MAX(${combined.avgWaitTimeNs})`.as("avgWaitTimeNs"),
+      avgBackoffTimeNs: drizzleOrm.sql`MAX(${combined.avgBackoffTimeNs})`.as("avgBackoffTimeNs"),
+      avgMemBytes: drizzleOrm.sql`MAX(${combined.avgMemBytes})`.as("avgMemBytes"),
+      maxMemBytes: drizzleOrm.sql`MAX(${combined.maxMemBytes})`.as("maxMemBytes"),
+      avgTotalKeys: drizzleOrm.sql`MAX(${combined.avgTotalKeys})`.as("avgTotalKeys"),
+      firstSeen: drizzleOrm.sql`MIN(${combined.firstSeen})`.as("firstSeen"),
+      lastSeen: drizzleOrm.sql`MAX(${combined.lastSeen})`.as("lastSeen"),
+      planInCache: drizzleOrm.sql`MAX(${combined.planInCache})`.as("planInCache"),
+      planCacheHits: drizzleOrm.sql`SUM(${combined.planCacheHits})`.as("planCacheHits"),
+      // Prefer a non-empty sample text/plan via MAX; acceptable for de-dup
+      digestText: drizzleOrm.sql`MAX(${combined.digestText})`.as("digestText"),
+      plan: drizzleOrm.sql`MAX(${combined.plan})`.as("plan")
+    }).from(combined).where(
+      drizzleOrm.sql`COALESCE(${combined.digest}, '') <> '' AND COALESCE(${combined.digestText}, '') <> '' AND COALESCE(${combined.stmtType}, '') NOT IN ('Use','Set','Show')`
+    ).groupBy(combined.digest, combined.stmtType, combined.schemaName).as("grouped");
+    const rows = await orm.getDrizzleQueryBuilder().select({
+      digest: grouped.digest,
+      stmtType: grouped.stmtType,
+      schemaName: grouped.schemaName,
+      execCount: grouped.execCount,
+      avgLatencyNs: grouped.avgLatencyNs,
+      maxLatencyNs: grouped.maxLatencyNs,
+      minLatencyNs: grouped.minLatencyNs,
+      avgProcessTimeNs: grouped.avgProcessTimeNs,
+      avgWaitTimeNs: grouped.avgWaitTimeNs,
+      avgBackoffTimeNs: grouped.avgBackoffTimeNs,
+      avgMemBytes: grouped.avgMemBytes,
+      maxMemBytes: grouped.maxMemBytes,
+      avgTotalKeys: grouped.avgTotalKeys,
+      firstSeen: grouped.firstSeen,
+      lastSeen: grouped.lastSeen,
+      planInCache: grouped.planInCache,
+      planCacheHits: grouped.planCacheHits,
+      digestText: grouped.digestText,
+      plan: grouped.plan
+    }).from(grouped).where(
+      drizzleOrm.sql`${grouped.avgLatencyNs} > ${thresholdNs} OR ${grouped.avgMemBytes} > ${memoryThresholdBytes}`
+    ).orderBy(drizzleOrm.desc(grouped.avgLatencyNs)).limit(formatLimitOffset(TOP_N));
+    const formatted = rows.map((r, i) => ({
+      rank: i + 1,
+      // 1-based rank in the top N
+      digest: r.digest,
+      stmtType: r.stmtType,
+      schemaName: r.schemaName,
+      execCount: r.execCount,
+      avgLatencyMs: nsToMs(r.avgLatencyNs),
+      // Convert ns to ms for readability
+      maxLatencyMs: nsToMs(r.maxLatencyNs),
+      minLatencyMs: nsToMs(r.minLatencyNs),
+      avgProcessTimeMs: nsToMs(r.avgProcessTimeNs),
+      avgWaitTimeMs: nsToMs(r.avgWaitTimeNs),
+      avgBackoffTimeMs: nsToMs(r.avgBackoffTimeNs),
+      avgMemMB: bytesToMB(r.avgMemBytes),
+      maxMemMB: bytesToMB(r.maxMemBytes),
+      avgMemBytes: r.avgMemBytes,
+      maxMemBytes: r.maxMemBytes,
+      avgTotalKeys: r.avgTotalKeys,
+      firstSeen: r.firstSeen,
+      lastSeen: r.lastSeen,
+      planInCache: r.planInCache,
+      planCacheHits: r.planCacheHits,
+      digestText: r.digestText,
+      plan: r.plan
+    }));
+    for (const f of formatted) {
+      console.warn(
+        `${f.rank}. ${f.stmtType}  avg=${f.avgLatencyMs?.toFixed?.(2)}ms  max=${f.maxLatencyMs?.toFixed?.(2)}ms  mem≈${f.avgMemMB?.toFixed?.(2)}MB(max ${f.maxMemMB?.toFixed?.(2)}MB)  exec=${f.execCount} 
+   digest=${f.digest}
+   sql=${(f.digestText || "").slice(0, 300)}${f.digestText && f.digestText.length > 300 ? "…" : ""}`
+      );
+      if (f.plan) {
+        console.warn(`   full plan:
+${f.plan}`);
+      }
+    }
+    return {
+      headers: { "Content-Type": ["application/json"] },
+      statusCode: 200,
+      statusText: "OK",
+      body: jsonSafeStringify({
+        success: true,
+        window: "last_1h",
+        top: TOP_N,
+        warnThresholdMs,
+        memoryThresholdBytes,
+        rows: formatted,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    };
+  } catch (error) {
+    console.error(
+      "Error in topSlowestStatementLastHourTrigger:",
+      error?.cause?.context?.debug?.sqlMessage ?? error?.cause ?? error
+    );
+    return {
+      headers: { "Content-Type": ["application/json"] },
+      statusCode: 500,
+      statusText: "Internal Server Error",
+      body: jsonSafeStringify({
+        success: false,
+        message: "Failed to fetch or log slow queries",
+        error: error?.cause?.context?.debug?.sqlMessage ?? error?.cause?.message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    };
+  }
+};
 const getHttpResponse = (statusCode, body) => {
   let statusText = "";
   if (statusCode === 200) {
@@ -2783,6 +3400,8 @@ exports.ForgeSQLSelectOperations = ForgeSQLSelectOperations;
 exports.applyFromDriverTransform = applyFromDriverTransform;
 exports.applySchemaMigrations = applySchemaMigrations;
 exports.clearCacheSchedulerTrigger = clearCacheSchedulerTrigger;
+exports.clusterStatementsSummary = clusterStatementsSummary;
+exports.clusterStatementsSummaryHistory = clusterStatementsSummaryHistory;
 exports.default = ForgeSQLORM;
 exports.dropSchemaMigrations = dropSchemaMigrations;
 exports.dropTableSchemaMigrations = dropTableSchemaMigrations;
@@ -2806,4 +3425,6 @@ exports.migrations = migrations;
 exports.nextVal = nextVal;
 exports.parseDateTime = parseDateTime;
 exports.patchDbWithSelectAliased = patchDbWithSelectAliased;
+exports.slowQuery = slowQuery;
+exports.topSlowestStatementLastHourTrigger = topSlowestStatementLastHourTrigger;
 //# sourceMappingURL=ForgeSQLORM.js.map