forge-sql-orm 2.1.3 → 2.1.5

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) {
@@ -391,7 +391,7 @@ async function clearCursorCache(tables, cursor, options) {
     entityQueryBuilder = entityQueryBuilder.cursor(cursor);
   }
   const listResult = await entityQueryBuilder.limit(100).getMany();
-  if (options.logRawSqlQuery) {
+  if (options.logCache) {
     console.warn(`clear cache Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
   }
   await deleteCacheEntriesInBatches(listResult.results, cacheEntityName);
@@ -412,7 +412,7 @@ async function clearExpirationCursorCache(cursor, options) {
     entityQueryBuilder = entityQueryBuilder.cursor(cursor);
   }
   const listResult = await entityQueryBuilder.limit(100).getMany();
-  if (options.logRawSqlQuery) {
+  if (options.logCache) {
     console.warn(`clear expired Records: ${JSON.stringify(listResult.results.map((r) => r.key))}`);
   }
   await deleteCacheEntriesInBatches(listResult.results, cacheEntityName);
@@ -461,7 +461,7 @@ async function clearTablesCache(tables, options) {
       "clearing cache"
     );
   } finally {
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       const duration = DateTime.now().toSeconds() - startTime.toSeconds();
       console.info(`Cleared ${totalRecords} cache records in ${duration} seconds`);
     }
@@ -480,7 +480,7 @@ async function clearExpiredCache(options) {
     );
   } finally {
     const duration = DateTime.now().toSeconds() - startTime.toSeconds();
-    if (options?.logRawSqlQuery) {
+    if (options?.logCache) {
       console.debug(`Cleared ${totalRecords} expired cache records in ${duration} seconds`);
     }
   }
@@ -495,7 +495,7 @@ async function getFromCache(query, options) {
   const sqlQuery = query.toSQL();
   const key = hashKey(sqlQuery);
   if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       console.warn(`Context contains value to clear. Skip getting from cache`);
     }
     return void 0;
@@ -503,7 +503,7 @@ async function getFromCache(query, options) {
   try {
     const cacheResult = await kvs.entity(options.cacheEntityName).get(key);
     if (cacheResult && cacheResult[expirationName] >= getCurrentTime() && sqlQuery.sql.toLowerCase() === cacheResult[entityQueryName]) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         console.warn(`Get value from cache, cacheKey: ${key}`);
       }
       const results = cacheResult[dataName];
@@ -524,7 +524,7 @@ async function setCacheResult(query, options, results, cacheTtl) {
     const dataName = options.cacheEntityDataName ?? CACHE_CONSTANTS.DEFAULT_DATA_NAME;
     const sqlQuery = query.toSQL();
     if (await isTableContainsTableInCacheContext(sqlQuery.sql, options)) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         console.warn(`Context contains value to clear. Skip setting from cache`);
       }
       return;
@@ -539,7 +539,7 @@ async function setCacheResult(query, options, results, cacheTtl) {
       },
       { entityName: options.cacheEntityName }
     ).execute();
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       console.warn(`Store value to cache, cacheKey: ${key}`);
     }
   } catch (error) {
@@ -567,7 +567,7 @@ async function saveQueryLocalCacheQuery(query, rows, options) {
       sql: sql2.toSQL().sql.toLowerCase(),
       data: rows
     };
-    if (options.logRawSqlQuery) {
+    if (options.logCache) {
       const q = sql2.toSQL();
       console.debug(
         `[forge-sql-orm][local-cache][SAVE] Stored result in cache. sql="${q.sql}", params=${JSON.stringify(q.params)}`
@@ -584,7 +584,7 @@ async function getQueryLocalCacheQuery(query, options) {
     const sql2 = query;
     const key = hashKey(sql2.toSQL());
     if (context.cache[key] && context.cache[key].sql === sql2.toSQL().sql.toLowerCase()) {
-      if (options.logRawSqlQuery) {
+      if (options.logCache) {
         const q = sql2.toSQL();
         console.debug(
           `[forge-sql-orm][local-cache][HIT] Returned cached result. sql="${q.sql}", params=${JSON.stringify(q.params)}`
@@ -1015,6 +1015,18 @@ class ForgeSQLSelectOperations {
     return updateQueryResponseResults.rows;
   }
 }
+const metadataQueryContext = new AsyncLocalStorage();
+async function saveMetaDataInContextContext(metadata) {
+  const context = metadataQueryContext.getStore();
+  if (context && metadata) {
+    context.totalResponseSize += metadata.responseSize;
+    context.totalDbExecutionTime += metadata.dbExecutionTime;
+    context.lastMetadata = metadata;
+  }
+}
+async function getLastestMetadata() {
+  return metadataQueryContext.getStore();
+}
 const forgeDriver = async (query, params, method) => {
   if (method == "execute") {
     const sqlStatement = sql$1.prepare(query);
@@ -1030,6 +1042,7 @@ const forgeDriver = async (query, params, method) => {
       await sqlStatement.bindParams(...params);
     }
     const result = await sqlStatement.execute();
+    await saveMetaDataInContextContext(result.metadata);
     let rows;
     rows = result.rows.map((r) => Object.values(r));
     return { rows };
@@ -1779,6 +1792,7 @@ class ForgeSQLORMImpl {
     try {
       const newOptions = options ?? {
         logRawSqlQuery: false,
+        logCache: false,
         disableOptimisticLocking: false,
         cacheWrapTable: true,
         cacheTTL: 120,
@@ -1804,6 +1818,42 @@ class ForgeSQLORMImpl {
       throw error;
     }
   }
+  /**
+   * Executes a query and provides access to execution metadata.
+   * This method allows you to capture detailed information about query execution
+   * including database execution time, response size, and Forge SQL metadata.
+   *
+   * @template T - The return type of the query
+   * @param query - A function that returns a Promise with the query result
+   * @param onMetadata - Callback function that receives execution metadata
+   * @returns Promise with the query result
+   * @example
+   * ```typescript
+   * const result = await forgeSQL.executeWithMetadata(
+   *   async () => await forgeSQL.select().from(users).where(eq(users.id, 1)),
+   *   (dbTime, responseSize, metadata) => {
+   *     console.log(`DB execution time: ${dbTime}ms`);
+   *     console.log(`Response size: ${responseSize} bytes`);
+   *     console.log('Forge metadata:', metadata);
+   *   }
+   * );
+   * ```
+   */
+  async executeWithMetadata(query, onMetadata) {
+    return metadataQueryContext.run({
+      totalDbExecutionTime: 0,
+      totalResponseSize: 0
+    }, async () => {
+      try {
+        return await query();
+      } finally {
+        const metadata = await getLastestMetadata();
+        if (metadata && metadata.lastMetadata) {
+          await onMetadata(metadata.totalDbExecutionTime, metadata.totalResponseSize, metadata.lastMetadata);
+        }
+      }
+    });
+  }
   /**
    * Executes operations within a cache context that collects cache eviction events.
    * All clearCache calls within the context are collected and executed in batch at the end.
@@ -2251,6 +2301,30 @@ class ForgeSQLORM {
   constructor(options) {
     this.ormInstance = ForgeSQLORMImpl.getInstance(options);
   }
+  /**
+   * Executes a query and provides access to execution metadata.
+   * This method allows you to capture detailed information about query execution
+   * including database execution time, response size, and Forge SQL metadata.
+   *
+   * @template T - The return type of the query
+   * @param query - A function that returns a Promise with the query result
+   * @param onMetadata - Callback function that receives execution metadata
+   * @returns Promise with the query result
+   * @example
+   * ```typescript
+   * const result = await forgeSQL.executeWithMetadata(
+   *   async () => await forgeSQL.select().from(users).where(eq(users.id, 1)),
+   *   (dbTime, responseSize, metadata) => {
+   *     console.log(`DB execution time: ${dbTime}ms`);
+   *     console.log(`Response size: ${responseSize} bytes`);
+   *     console.log('Forge metadata:', metadata);
+   *   }
+   * );
+   * ```
+   */
+  async executeWithMetadata(query, onMetadata) {
+    return this.ormInstance.executeWithMetadata(query, onMetadata);
+  }
   selectCacheable(fields, cacheTTL) {
     return this.ormInstance.selectCacheable(fields, cacheTTL);
   }
@@ -2623,6 +2697,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));
@@ -2673,13 +3176,13 @@ const applySchemaMigrations = async (migration) => {
       body: "Migrations successfully executed"
     };
   } catch (error) {
-    const errorMessage = error?.debug?.sqlMessage ?? error?.debug?.message ?? error.message ?? "Unknown error occurred";
+    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"
     };
   }
 };
@@ -2770,6 +3273,200 @@ const clearCacheSchedulerTrigger = async (options) => {
     };
   }
 };
+const DEFAULT_MEMORY_THRESHOLD = 8 * 1024 * 1024;
+const DEFAULT_TIMEOUT = 300;
+const topSlowestStatementLastHourTrigger = async (orm, options) => {
+  if (!orm) {
+    return {
+      statusCode: 500,
+      headers: { "Content-Type": ["application/json"] },
+      body: JSON.stringify({
+        success: false,
+        message: "ORM instance is required",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    };
+  }
+  let newOptions = options ?? {
+    warnThresholdMs: DEFAULT_TIMEOUT,
+    memoryThresholdBytes: DEFAULT_MEMORY_THRESHOLD,
+    showPlan: false
+  };
+  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);
+  function sanitizeSQL(sql2, maxLen = 1e3) {
+    let s = sql2;
+    s = s.replace(/--[^\n\r]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    s = s.replace(/'(?:\\'|[^'])*'/g, "?");
+    s = s.replace(/\b-?\d+(?:\.\d+)?\b/g, "?");
+    s = s.replace(/\s+/g, " ").trim();
+    if (s.length > maxLen) {
+      s = s.slice(0, maxLen) + " …[truncated]";
+    }
+    return s;
+  }
+  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((newOptions.warnThresholdMs ?? DEFAULT_TIMEOUT) * 1e6);
+    const memoryThresholdBytes = newOptions.memoryThresholdBytes ?? DEFAULT_MEMORY_THRESHOLD;
+    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: sanitizeSQL(r.digestText),
+      plan: newOptions.showPlan ? r.plan : void 0
+    }));
+    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 (newOptions.showPlan && 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: newOptions.warnThresholdMs,
+        memoryThresholdBytes: newOptions.memoryThresholdBytes,
+        showPlan: newOptions.showPlan,
+        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) {
@@ -2790,6 +3487,8 @@ export {
   applyFromDriverTransform,
   applySchemaMigrations,
   clearCacheSchedulerTrigger,
+  clusterStatementsSummary,
+  clusterStatementsSummaryHistory,
   ForgeSQLORM as default,
   dropSchemaMigrations,
   dropTableSchemaMigrations,
@@ -2812,6 +3511,8 @@ export {
   migrations,
   nextVal,
   parseDateTime,
-  patchDbWithSelectAliased
+  patchDbWithSelectAliased,
+  slowQuery,
+  topSlowestStatementLastHourTrigger
 };
 //# sourceMappingURL=ForgeSQLORM.mjs.map