forge-sql-orm 2.1.2 → 2.1.4

package/dist/ForgeSQLORM.mjs

@@ -1,4 +1,4 @@
-import { isTable, sql, eq, and, getTableColumns } from "drizzle-orm";
+import { isTable, sql, eq, and, getTableColumns, gte, desc } from "drizzle-orm";
 import { DateTime } from "luxon";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -7,7 +7,7 @@ import * as crypto from "crypto";
 import { kvs, WhereConditions, Filter, FilterConditions } from "@forge/kvs";
 import { sql as sql$1, migrationRunner } from "@forge/sql";
 import { drizzle } from "drizzle-orm/mysql-proxy";
-import { customType, mysqlTable, timestamp, varchar, bigint } from "drizzle-orm/mysql-core";
+import { customType, mysqlTable, timestamp, varchar, bigint, mysqlSchema, longtext, double, boolean, text, int, unionAll } from "drizzle-orm/mysql-core";
 const parseDateTime = (value, format) => {
   let result;
   if (value instanceof Date) {
@@ -17,11 +17,16 @@ const parseDateTime = (value, format) => {
     if (dt.isValid) {
       result = dt.toJSDate();
     } else {
-      const isoDt = DateTime.fromISO(value);
-      if (isoDt.isValid) {
-        result = isoDt.toJSDate();
+      const sqlDt = DateTime.fromSQL(value);
+      if (sqlDt.isValid) {
+        result = sqlDt.toJSDate();
       } else {
-        result = new Date(value);
+        const isoDt = DateTime.fromRFC2822(value);
+        if (isoDt.isValid) {
+          result = isoDt.toJSDate();
+        } else {
+          result = new Date(value);
+        }
       }
     }
   }
@@ -30,7 +35,7 @@ const parseDateTime = (value, format) => {
   }
   return result;
 };
-function formatDateTime(value, format) {
+function formatDateTime(value, format, isTimeStamp) {
   let dt = null;
   if (value instanceof Date) {
     dt = DateTime.fromJSDate(value);
@@ -58,6 +63,20 @@ function formatDateTime(value, format) {
   if (!dt?.isValid) {
     throw new Error("Invalid Date");
   }
+  const minDate = DateTime.fromSeconds(1);
+  const maxDate = 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(table) {
@@ -461,7 +480,9 @@ async function clearExpiredCache(options) {
     );
   } finally {
     const duration = 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) {
@@ -548,7 +569,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)}`
       );
     }
@@ -565,7 +586,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)}`
         );
       }
@@ -995,28 +1016,23 @@ class ForgeSQLSelectOperations {
   }
 }
 const forgeDriver = async (query, params, method) => {
-  try {
-    if (method == "execute") {
-      const sqlStatement = sql$1.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.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.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.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) {
@@ -1053,9 +1069,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"];
@@ -1090,8 +1113,8 @@ async function handleSuccessfulExecution(rows, onfulfilled, table, options, isCa
     if (shouldClearCacheOnError(error)) {
       await evictLocalCacheQuery(table, options);
       if (isCached) {
-        await clearCache(table, options).catch(() => {
-          console.warn("Ignore cache clear errors");
+        await clearCache(table, options).catch((e) => {
+          console.warn("Ignore cache clear errors", e);
         });
       } else {
         await saveTableIfInsideCacheContext(table);
@@ -2553,10 +2576,10 @@ const forgeDateTimeString = 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);
   }
 });
@@ -2565,10 +2588,10 @@ const forgeTimestampString = 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);
   }
 });
@@ -2577,10 +2600,10 @@ const forgeDateString = 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);
   }
 });
@@ -2589,7 +2612,7 @@ const forgeTimeString = 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");
@@ -2600,6 +2623,435 @@ const migrations = mysqlTable("__migrations", {
   name: varchar("name", { length: 255 }).notNull(),
   migratedAt: timestamp("migratedAt").defaultNow().notNull()
 });
+const informationSchema = mysqlSchema("information_schema");
+const slowQuery = informationSchema.table("SLOW_QUERY", {
+  time: timestamp("Time", { fsp: 6, mode: "string" }).notNull(),
+  // Timestamp when the slow query was recorded
+  txnStartTs: bigint("Txn_start_ts", { mode: "bigint", unsigned: true }),
+  // Transaction start timestamp (TSO)
+  user: varchar("User", { length: 64 }),
+  // User executing the query
+  host: varchar("Host", { length: 64 }),
+  // Host from which the query originated
+  connId: bigint("Conn_ID", { mode: "bigint", unsigned: true }),
+  // Connection ID
+  sessionAlias: varchar("Session_alias", { length: 64 }),
+  // Session alias
+  execRetryCount: bigint("Exec_retry_count", { mode: "bigint", unsigned: true }),
+  // Number of retries during execution
+  execRetryTime: double("Exec_retry_time"),
+  // Time spent in retries
+  queryTime: double("Query_time"),
+  // Total execution time
+  parseTime: double("Parse_time"),
+  // Time spent parsing SQL
+  compileTime: double("Compile_time"),
+  // Time spent compiling query plan
+  rewriteTime: double("Rewrite_time"),
+  // Time spent rewriting query
+  preprocSubqueries: bigint("Preproc_subqueries", { mode: "bigint", unsigned: true }),
+  // Number of subqueries preprocessed
+  preprocSubqueriesTime: double("Preproc_subqueries_time"),
+  // Time spent preprocessing subqueries
+  optimizeTime: double("Optimize_time"),
+  // Time spent in optimizer
+  waitTs: double("Wait_TS"),
+  // Wait time for getting TSO
+  prewriteTime: double("Prewrite_time"),
+  // Time spent in prewrite phase
+  waitPrewriteBinlogTime: double("Wait_prewrite_binlog_time"),
+  // Time waiting for binlog prewrite
+  commitTime: double("Commit_time"),
+  // Commit duration
+  getCommitTsTime: double("Get_commit_ts_time"),
+  // Time waiting for commit TSO
+  commitBackoffTime: double("Commit_backoff_time"),
+  // Backoff time during commit
+  backoffTypes: varchar("Backoff_types", { length: 64 }),
+  // Types of backoff occurred
+  resolveLockTime: double("Resolve_lock_time"),
+  // Time resolving locks
+  localLatchWaitTime: double("Local_latch_wait_time"),
+  // Time waiting on local latch
+  writeKeys: bigint("Write_keys", { mode: "bigint" }),
+  // Number of keys written
+  writeSize: bigint("Write_size", { mode: "bigint" }),
+  // Amount of data written
+  prewriteRegion: bigint("Prewrite_region", { mode: "bigint" }),
+  // Regions involved in prewrite
+  txnRetry: bigint("Txn_retry", { mode: "bigint" }),
+  // Transaction retry count
+  copTime: double("Cop_time"),
+  // Time spent in coprocessor
+  processTime: double("Process_time"),
+  // Processing time
+  waitTime: double("Wait_time"),
+  // Wait time in TiKV
+  backoffTime: double("Backoff_time"),
+  // Backoff wait time
+  lockKeysTime: double("LockKeys_time"),
+  // Time spent waiting for locks
+  requestCount: bigint("Request_count", { mode: "bigint", unsigned: true }),
+  // Total number of requests
+  totalKeys: bigint("Total_keys", { mode: "bigint", unsigned: true }),
+  // Total keys scanned
+  processKeys: bigint("Process_keys", { mode: "bigint", unsigned: true }),
+  // Keys processed
+  rocksdbDeleteSkippedCount: bigint("Rocksdb_delete_skipped_count", {
+    mode: "bigint",
+    unsigned: true
+  }),
+  // RocksDB delete skips
+  rocksdbKeySkippedCount: bigint("Rocksdb_key_skipped_count", { mode: "bigint", unsigned: true }),
+  // RocksDB key skips
+  rocksdbBlockCacheHitCount: bigint("Rocksdb_block_cache_hit_count", {
+    mode: "bigint",
+    unsigned: true
+  }),
+  // RocksDB block cache hits
+  rocksdbBlockReadCount: bigint("Rocksdb_block_read_count", { mode: "bigint", unsigned: true }),
+  // RocksDB block reads
+  rocksdbBlockReadByte: bigint("Rocksdb_block_read_byte", { mode: "bigint", unsigned: true }),
+  // RocksDB block read bytes
+  db: varchar("DB", { length: 64 }),
+  // Database name
+  indexNames: varchar("Index_names", { length: 100 }),
+  // Indexes used
+  isInternal: boolean("Is_internal"),
+  // Whether the query is internal
+  digest: varchar("Digest", { length: 64 }),
+  // SQL digest hash
+  stats: varchar("Stats", { length: 512 }),
+  // Stats used during planning
+  copProcAvg: double("Cop_proc_avg"),
+  // Coprocessor average processing time
+  copProcP90: double("Cop_proc_p90"),
+  // Coprocessor 90th percentile processing time
+  copProcMax: double("Cop_proc_max"),
+  // Coprocessor max processing time
+  copProcAddr: varchar("Cop_proc_addr", { length: 64 }),
+  // Coprocessor address for processing
+  copWaitAvg: double("Cop_wait_avg"),
+  // Coprocessor average wait time
+  copWaitP90: double("Cop_wait_p90"),
+  // Coprocessor 90th percentile wait time
+  copWaitMax: double("Cop_wait_max"),
+  // Coprocessor max wait time
+  copWaitAddr: varchar("Cop_wait_addr", { length: 64 }),
+  // Coprocessor address for wait
+  memMax: bigint("Mem_max", { mode: "bigint" }),
+  // Max memory usage
+  diskMax: bigint("Disk_max", { mode: "bigint" }),
+  // Max disk usage
+  kvTotal: double("KV_total"),
+  // Total KV request time
+  pdTotal: double("PD_total"),
+  // Total PD request time
+  backoffTotal: double("Backoff_total"),
+  // Total backoff time
+  writeSqlResponseTotal: double("Write_sql_response_total"),
+  // SQL response write time
+  resultRows: bigint("Result_rows", { mode: "bigint" }),
+  // Rows returned
+  warnings: longtext("Warnings"),
+  // Warnings during execution
+  backoffDetail: varchar("Backoff_Detail", { length: 4096 }),
+  // Detailed backoff info
+  prepared: boolean("Prepared"),
+  // Whether query was prepared
+  succ: boolean("Succ"),
+  // Success flag
+  isExplicitTxn: boolean("IsExplicitTxn"),
+  // Whether explicit transaction
+  isWriteCacheTable: boolean("IsWriteCacheTable"),
+  // Whether wrote to cache table
+  planFromCache: boolean("Plan_from_cache"),
+  // Plan was from cache
+  planFromBinding: boolean("Plan_from_binding"),
+  // Plan was from binding
+  hasMoreResults: boolean("Has_more_results"),
+  // Query returned multiple results
+  resourceGroup: varchar("Resource_group", { length: 64 }),
+  // Resource group name
+  requestUnitRead: double("Request_unit_read"),
+  // RU consumed for read
+  requestUnitWrite: double("Request_unit_write"),
+  // RU consumed for write
+  timeQueuedByRc: double("Time_queued_by_rc"),
+  // Time queued by resource control
+  tidbCpuTime: double("Tidb_cpu_time"),
+  // TiDB CPU time
+  tikvCpuTime: double("Tikv_cpu_time"),
+  // TiKV CPU time
+  plan: longtext("Plan"),
+  // Query execution plan
+  planDigest: varchar("Plan_digest", { length: 128 }),
+  // Plan digest hash
+  binaryPlan: longtext("Binary_plan"),
+  // Binary execution plan
+  prevStmt: longtext("Prev_stmt"),
+  // Previous statement in session
+  query: longtext("Query")
+  // Original SQL query
+});
+const createClusterStatementsSummarySchema = () => ({
+  instance: varchar("INSTANCE", { length: 64 }),
+  // TiDB/TiKV instance address
+  summaryBeginTime: timestamp("SUMMARY_BEGIN_TIME", { mode: "string" }).notNull(),
+  // Begin time of this summary window
+  summaryEndTime: timestamp("SUMMARY_END_TIME", { mode: "string" }).notNull(),
+  // End time of this summary window
+  stmtType: varchar("STMT_TYPE", { length: 64 }).notNull(),
+  // Statement type (e.g., Select/Insert/Update)
+  schemaName: varchar("SCHEMA_NAME", { length: 64 }),
+  // Current schema name
+  digest: varchar("DIGEST", { length: 64 }),
+  // SQL digest (normalized hash)
+  digestText: text("DIGEST_TEXT").notNull(),
+  // Normalized SQL text
+  tableNames: text("TABLE_NAMES"),
+  // Involved table names
+  indexNames: text("INDEX_NAMES"),
+  // Used index names
+  sampleUser: varchar("SAMPLE_USER", { length: 64 }),
+  // Sampled user who executed the statements
+  execCount: bigint("EXEC_COUNT", { mode: "bigint", unsigned: true }).notNull(),
+  // Total executions
+  sumErrors: int("SUM_ERRORS", { unsigned: true }).notNull(),
+  // Sum of errors
+  sumWarnings: int("SUM_WARNINGS", { unsigned: true }).notNull(),
+  // Sum of warnings
+  sumLatency: bigint("SUM_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum of latency (ns)
+  maxLatency: bigint("MAX_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Max latency (ns)
+  minLatency: bigint("MIN_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Min latency (ns)
+  avgLatency: bigint("AVG_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg latency (ns)
+  avgParseLatency: bigint("AVG_PARSE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg parse time (ns)
+  maxParseLatency: bigint("MAX_PARSE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Max parse time (ns)
+  avgCompileLatency: bigint("AVG_COMPILE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg compile time (ns)
+  maxCompileLatency: bigint("MAX_COMPILE_LATENCY", { mode: "bigint", unsigned: true }).notNull(),
+  // Max compile time (ns)
+  sumCopTaskNum: bigint("SUM_COP_TASK_NUM", { mode: "bigint", unsigned: true }).notNull(),
+  // Total number of cop tasks
+  maxCopProcessTime: bigint("MAX_COP_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV coprocessor processing time (ns)
+  maxCopProcessAddress: varchar("MAX_COP_PROCESS_ADDRESS", { length: 256 }),
+  // Address of cop task with max processing time
+  maxCopWaitTime: bigint("MAX_COP_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV coprocessor wait time (ns)
+  maxCopWaitAddress: varchar("MAX_COP_WAIT_ADDRESS", { length: 256 }),
+  // Address of cop task with max wait time
+  avgProcessTime: bigint("AVG_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiKV processing time (ns)
+  maxProcessTime: bigint("MAX_PROCESS_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV processing time (ns)
+  avgWaitTime: bigint("AVG_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiKV wait time (ns)
+  maxWaitTime: bigint("MAX_WAIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max TiKV wait time (ns)
+  avgBackoffTime: bigint("AVG_BACKOFF_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg backoff time before retry (ns)
+  maxBackoffTime: bigint("MAX_BACKOFF_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max backoff time before retry (ns)
+  avgTotalKeys: bigint("AVG_TOTAL_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg scanned keys
+  maxTotalKeys: bigint("MAX_TOTAL_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Max scanned keys
+  avgProcessedKeys: bigint("AVG_PROCESSED_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg processed keys
+  maxProcessedKeys: bigint("MAX_PROCESSED_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Max processed keys
+  avgRocksdbDeleteSkippedCount: double("AVG_ROCKSDB_DELETE_SKIPPED_COUNT").notNull(),
+  // Avg RocksDB deletes skipped
+  maxRocksdbDeleteSkippedCount: int("MAX_ROCKSDB_DELETE_SKIPPED_COUNT", {
+    unsigned: true
+  }).notNull(),
+  // Max RocksDB deletes skipped
+  avgRocksdbKeySkippedCount: double("AVG_ROCKSDB_KEY_SKIPPED_COUNT").notNull(),
+  // Avg RocksDB keys skipped
+  maxRocksdbKeySkippedCount: int("MAX_ROCKSDB_KEY_SKIPPED_COUNT", { unsigned: true }).notNull(),
+  // Max RocksDB keys skipped
+  avgRocksdbBlockCacheHitCount: double("AVG_ROCKSDB_BLOCK_CACHE_HIT_COUNT").notNull(),
+  // Avg RocksDB block cache hits
+  maxRocksdbBlockCacheHitCount: int("MAX_ROCKSDB_BLOCK_CACHE_HIT_COUNT", {
+    unsigned: true
+  }).notNull(),
+  // Max RocksDB block cache hits
+  avgRocksdbBlockReadCount: double("AVG_ROCKSDB_BLOCK_READ_COUNT").notNull(),
+  // Avg RocksDB block reads
+  maxRocksdbBlockReadCount: int("MAX_ROCKSDB_BLOCK_READ_COUNT", { unsigned: true }).notNull(),
+  // Max RocksDB block reads
+  avgRocksdbBlockReadByte: double("AVG_ROCKSDB_BLOCK_READ_BYTE").notNull(),
+  // Avg RocksDB block read bytes
+  maxRocksdbBlockReadByte: int("MAX_ROCKSDB_BLOCK_READ_BYTE", { unsigned: true }).notNull(),
+  // Max RocksDB block read bytes
+  avgPrewriteTime: bigint("AVG_PREWRITE_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg prewrite phase time (ns)
+  maxPrewriteTime: bigint("MAX_PREWRITE_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max prewrite phase time (ns)
+  avgCommitTime: bigint("AVG_COMMIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg commit phase time (ns)
+  maxCommitTime: bigint("MAX_COMMIT_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max commit phase time (ns)
+  avgGetCommitTsTime: bigint("AVG_GET_COMMIT_TS_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg get commit_ts time (ns)
+  maxGetCommitTsTime: bigint("MAX_GET_COMMIT_TS_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max get commit_ts time (ns)
+  avgCommitBackoffTime: bigint("AVG_COMMIT_BACKOFF_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg backoff during commit (ns)
+  maxCommitBackoffTime: bigint("MAX_COMMIT_BACKOFF_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max backoff during commit (ns)
+  avgResolveLockTime: bigint("AVG_RESOLVE_LOCK_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg resolve lock time (ns)
+  maxResolveLockTime: bigint("MAX_RESOLVE_LOCK_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max resolve lock time (ns)
+  avgLocalLatchWaitTime: bigint("AVG_LOCAL_LATCH_WAIT_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg local latch wait (ns)
+  maxLocalLatchWaitTime: bigint("MAX_LOCAL_LATCH_WAIT_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Max local latch wait (ns)
+  avgWriteKeys: double("AVG_WRITE_KEYS").notNull(),
+  // Avg number of written keys
+  maxWriteKeys: bigint("MAX_WRITE_KEYS", { mode: "bigint", unsigned: true }).notNull(),
+  // Max written keys
+  avgWriteSize: double("AVG_WRITE_SIZE").notNull(),
+  // Avg written bytes
+  maxWriteSize: bigint("MAX_WRITE_SIZE", { mode: "bigint", unsigned: true }).notNull(),
+  // Max written bytes
+  avgPrewriteRegions: double("AVG_PREWRITE_REGIONS").notNull(),
+  // Avg regions in prewrite
+  maxPrewriteRegions: int("MAX_PREWRITE_REGIONS", { unsigned: true }).notNull(),
+  // Max regions in prewrite
+  avgTxnRetry: double("AVG_TXN_RETRY").notNull(),
+  // Avg transaction retry count
+  maxTxnRetry: int("MAX_TXN_RETRY", { unsigned: true }).notNull(),
+  // Max transaction retry count
+  sumExecRetry: bigint("SUM_EXEC_RETRY", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum of execution retries (pessimistic)
+  sumExecRetryTime: bigint("SUM_EXEC_RETRY_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum time of execution retries (ns)
+  sumBackoffTimes: bigint("SUM_BACKOFF_TIMES", { mode: "bigint", unsigned: true }).notNull(),
+  // Sum of backoff retries
+  backoffTypes: varchar("BACKOFF_TYPES", { length: 1024 }),
+  // Backoff types with counts
+  avgMem: bigint("AVG_MEM", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg memory used (bytes)
+  maxMem: bigint("MAX_MEM", { mode: "bigint", unsigned: true }).notNull(),
+  // Max memory used (bytes)
+  avgDisk: bigint("AVG_DISK", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg disk used (bytes)
+  maxDisk: bigint("MAX_DISK", { mode: "bigint", unsigned: true }).notNull(),
+  // Max disk used (bytes)
+  avgKvTime: bigint("AVG_KV_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg time spent in TiKV (ns)
+  avgPdTime: bigint("AVG_PD_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg time spent in PD (ns)
+  avgBackoffTotalTime: bigint("AVG_BACKOFF_TOTAL_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg total backoff time (ns)
+  avgWriteSqlRespTime: bigint("AVG_WRITE_SQL_RESP_TIME", {
+    mode: "bigint",
+    unsigned: true
+  }).notNull(),
+  // Avg write SQL response time (ns)
+  avgTidbCpuTime: bigint("AVG_TIDB_CPU_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiDB CPU time (ns)
+  avgTikvCpuTime: bigint("AVG_TIKV_CPU_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg TiKV CPU time (ns)
+  maxResultRows: bigint("MAX_RESULT_ROWS", { mode: "bigint" }).notNull(),
+  // Max number of result rows
+  minResultRows: bigint("MIN_RESULT_ROWS", { mode: "bigint" }).notNull(),
+  // Min number of result rows
+  avgResultRows: bigint("AVG_RESULT_ROWS", { mode: "bigint" }).notNull(),
+  // Avg number of result rows
+  prepared: boolean("PREPARED").notNull(),
+  // Whether statements are prepared
+  avgAffectedRows: double("AVG_AFFECTED_ROWS").notNull(),
+  // Avg affected rows
+  firstSeen: timestamp("FIRST_SEEN", { mode: "string" }).notNull(),
+  // First time statements observed
+  lastSeen: timestamp("LAST_SEEN", { mode: "string" }).notNull(),
+  // Last time statements observed
+  planInCache: boolean("PLAN_IN_CACHE").notNull(),
+  // Whether last stmt hit plan cache
+  planCacheHits: bigint("PLAN_CACHE_HITS", { mode: "bigint" }).notNull(),
+  // Number of plan cache hits
+  planInBinding: boolean("PLAN_IN_BINDING").notNull(),
+  // Whether matched bindings
+  querySampleText: text("QUERY_SAMPLE_TEXT"),
+  // Sampled original SQL
+  prevSampleText: text("PREV_SAMPLE_TEXT"),
+  // Sampled previous SQL before commit
+  planDigest: varchar("PLAN_DIGEST", { length: 64 }),
+  // Plan digest hash
+  plan: text("PLAN"),
+  // Sampled textual plan
+  binaryPlan: text("BINARY_PLAN"),
+  // Sampled binary plan
+  charset: varchar("CHARSET", { length: 64 }),
+  // Sampled charset
+  collation: varchar("COLLATION", { length: 64 }),
+  // Sampled collation
+  planHint: varchar("PLAN_HINT", { length: 64 }),
+  // Sampled plan hint
+  maxRequestUnitRead: double("MAX_REQUEST_UNIT_READ").notNull(),
+  // Max RU cost (read)
+  avgRequestUnitRead: double("AVG_REQUEST_UNIT_READ").notNull(),
+  // Avg RU cost (read)
+  maxRequestUnitWrite: double("MAX_REQUEST_UNIT_WRITE").notNull(),
+  // Max RU cost (write)
+  avgRequestUnitWrite: double("AVG_REQUEST_UNIT_WRITE").notNull(),
+  // Avg RU cost (write)
+  maxQueuedRcTime: bigint("MAX_QUEUED_RC_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Max queued time waiting for RU (ns)
+  avgQueuedRcTime: bigint("AVG_QUEUED_RC_TIME", { mode: "bigint", unsigned: true }).notNull(),
+  // Avg queued time waiting for RU (ns)
+  resourceGroup: varchar("RESOURCE_GROUP", { length: 64 }),
+  // Bound resource group name
+  planCacheUnqualified: bigint("PLAN_CACHE_UNQUALIFIED", { mode: "bigint" }).notNull(),
+  // Times not eligible for plan cache
+  planCacheUnqualifiedLastReason: 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.executeDDL("SHOW TABLES");
   return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
@@ -2610,7 +3062,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.executeDDL(statement);
     }
     return getHttpResponse(
@@ -2618,8 +3070,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);
   }
 }
@@ -2635,7 +3087,13 @@ const applySchemaMigrations = async (migration) => {
     const successfulMigrations = await migrations2.run();
     console.info("Migrations applied:", successfulMigrations);
     const migrationList = await 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"] },
@@ -2644,17 +3102,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"
     };
   }
 };
@@ -2665,8 +3119,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);
   }
 }
@@ -2693,7 +3147,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.executeDDL(statement);
     }
     return getHttpResponse(
@@ -2701,8 +3155,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);
   }
 }
@@ -2745,6 +3199,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 = gte(
+      summaryHistory.summaryEndTime,
+      sql`DATE_SUB(NOW(), INTERVAL 1 HOUR)`
+    );
+    const lastHourFilterSummary = gte(
+      summary.summaryEndTime,
+      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 = 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: sql`SUM(${combined.execCount})`.as("execCount"),
+      avgLatencyNs: sql`MAX(${combined.avgLatencyNs})`.as("avgLatencyNs"),
+      maxLatencyNs: sql`MAX(${combined.maxLatencyNs})`.as("maxLatencyNs"),
+      minLatencyNs: sql`MIN(${combined.minLatencyNs})`.as("minLatencyNs"),
+      avgProcessTimeNs: sql`MAX(${combined.avgProcessTimeNs})`.as("avgProcessTimeNs"),
+      avgWaitTimeNs: sql`MAX(${combined.avgWaitTimeNs})`.as("avgWaitTimeNs"),
+      avgBackoffTimeNs: sql`MAX(${combined.avgBackoffTimeNs})`.as("avgBackoffTimeNs"),
+      avgMemBytes: sql`MAX(${combined.avgMemBytes})`.as("avgMemBytes"),
+      maxMemBytes: sql`MAX(${combined.maxMemBytes})`.as("maxMemBytes"),
+      avgTotalKeys: sql`MAX(${combined.avgTotalKeys})`.as("avgTotalKeys"),
+      firstSeen: sql`MIN(${combined.firstSeen})`.as("firstSeen"),
+      lastSeen: sql`MAX(${combined.lastSeen})`.as("lastSeen"),
+      planInCache: sql`MAX(${combined.planInCache})`.as("planInCache"),
+      planCacheHits: sql`SUM(${combined.planCacheHits})`.as("planCacheHits"),
+      // Prefer a non-empty sample text/plan via MAX; acceptable for de-dup
+      digestText: sql`MAX(${combined.digestText})`.as("digestText"),
+      plan: sql`MAX(${combined.plan})`.as("plan")
+    }).from(combined).where(
+      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(
+      sql`${grouped.avgLatencyNs} > ${thresholdNs} OR ${grouped.avgMemBytes} > ${memoryThresholdBytes}`
+    ).orderBy(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) {
@@ -2765,6 +3382,8 @@ export {
   applyFromDriverTransform,
   applySchemaMigrations,
   clearCacheSchedulerTrigger,
+  clusterStatementsSummary,
+  clusterStatementsSummaryHistory,
   ForgeSQLORM as default,
   dropSchemaMigrations,
   dropTableSchemaMigrations,
@@ -2787,6 +3406,8 @@ export {
   migrations,
   nextVal,
   parseDateTime,
-  patchDbWithSelectAliased
+  patchDbWithSelectAliased,
+  slowQuery,
+  topSlowestStatementLastHourTrigger
 };
 //# sourceMappingURL=ForgeSQLORM.mjs.map