@crvouga/sqlite-mem 1.0.0 → 1.1.0

package/dist/index.js

@@ -9190,8 +9190,579 @@ function executeDetach(stmt, env) {
   return emptyResult(0, env.state.lastInsertRowid);
 }
 
-// src/functions/table-valued.ts
+// src/functions/window.ts
+function rowsEqual(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => {
+    const other = right[index];
+    return value === null && other === null || other !== void 0 && compareSql(value, other) === 0;
+  });
+}
+function rowNumber(_partition, index) {
+  return index + 1;
+}
+function rank(partition, index, orderKeys = partition) {
+  if (index <= 0) return 1;
+  let firstPeer = index;
+  while (firstPeer > 0 && rowsEqual(orderKeys[firstPeer], orderKeys[firstPeer - 1])) firstPeer--;
+  return firstPeer + 1;
+}
+function denseRank(partition, index, orderKeys = partition) {
+  if (index <= 0) return 1;
+  let result = 1;
+  for (let i = 1; i <= index; i++) {
+    if (!rowsEqual(orderKeys[i], orderKeys[i - 1])) result++;
+  }
+  return result;
+}
+function lag(partition, index, valueIndex = 0, offset = 1, defaultValue = null) {
+  const target = index - Math.max(0, Math.trunc(offset));
+  return target < 0 ? defaultValue : partition[target]?.[valueIndex] ?? null;
+}
+function lead(partition, index, valueIndex = 0, offset = 1, defaultValue = null) {
+  const target = index + Math.max(0, Math.trunc(offset));
+  return target >= partition.length ? defaultValue : partition[target]?.[valueIndex] ?? null;
+}
+function firstValue(partition, valueIndex = 0, frameStart = 0) {
+  return partition[frameStart]?.[valueIndex] ?? null;
+}
+function lastValue(partition, valueIndex = 0, frameEnd = partition.length - 1) {
+  return partition[frameEnd]?.[valueIndex] ?? null;
+}
+function nthValue(partition, n, valueIndex = 0, frameStart = 0) {
+  const offset = Math.trunc(n);
+  if (offset <= 0) return null;
+  return partition[frameStart + offset - 1]?.[valueIndex] ?? null;
+}
+var windowFunctions = {
+  row_number: rowNumber,
+  rank,
+  dense_rank: denseRank,
+  lag,
+  lead,
+  first_value: firstValue,
+  last_value: lastValue,
+  nth_value: nthValue,
+  ntile: () => 0,
+  cume_dist: () => 0,
+  percent_rank: () => 0
+};
+
+// src/executor/pragma-engine.ts
+var PRAGMA_TVF_NAMES = [
+  "analysis_limit",
+  "application_id",
+  "auto_vacuum",
+  "automatic_index",
+  "busy_timeout",
+  "cache_size",
+  "cache_spill",
+  "cell_size_check",
+  "checkpoint_fullfsync",
+  "collation_list",
+  "compile_options",
+  "count_changes",
+  "data_version",
+  "database_list",
+  "default_cache_size",
+  "defer_foreign_keys",
+  "empty_result_callbacks",
+  "encoding",
+  "foreign_key_check",
+  "foreign_key_list",
+  "foreign_keys",
+  "freelist_count",
+  "full_column_names",
+  "fullfsync",
+  "function_list",
+  "hard_heap_limit",
+  "ignore_check_constraints",
+  "index_info",
+  "index_list",
+  "index_xinfo",
+  "integrity_check",
+  "journal_mode",
+  "journal_size_limit",
+  "legacy_alter_table",
+  "locking_mode",
+  "max_page_count",
+  "module_list",
+  "optimize",
+  "page_count",
+  "page_size",
+  "pragma_list",
+  "query_only",
+  "quick_check",
+  "read_uncommitted",
+  "recursive_triggers",
+  "reverse_unordered_selects",
+  "schema_version",
+  "secure_delete",
+  "short_column_names",
+  "soft_heap_limit",
+  "synchronous",
+  "table_info",
+  "table_list",
+  "table_xinfo",
+  "temp_store",
+  "threads",
+  "trusted_schema",
+  "user_version",
+  "writable_schema"
+];
+var PRAGMA_LIST_NAMES = [
+  "activate_extensions",
+  ...PRAGMA_TVF_NAMES,
+  "case_sensitive_like",
+  "hexkey",
+  "hexrekey",
+  "incremental_vacuum",
+  "key",
+  "lock_proxy_file",
+  "mmap_size",
+  "rekey",
+  "shrink_memory",
+  "temp_store_directory",
+  "textkey",
+  "textrekey",
+  "wal_autocheckpoint",
+  "wal_checkpoint"
+].sort((a, b) => a.localeCompare(b));
+var MEMORY_VTABLE_MODULES = [
+  "bytecode",
+  "dbstat",
+  "fts3",
+  "fts3tokenize",
+  "fts4",
+  "fts4aux",
+  "fts5",
+  "fts5vocab",
+  "json_each",
+  "json_tree",
+  "rtree",
+  "rtree_i32",
+  "tables_used"
+];
+var COMPILE_OPTIONS2 = [
+  "COMPILER=typescript",
+  "ENABLE_FTS3",
+  "ENABLE_FTS4",
+  "ENABLE_FTS5",
+  "ENABLE_JSON1",
+  "ENABLE_RTREE",
+  "THREADSAFE=0"
+];
+var STORAGE_DEFAULTS = {
+  analysis_limit: { column: "analysis_limit", value: 0 },
+  application_id: { column: "application_id", value: 0 },
+  auto_vacuum: { column: "auto_vacuum", value: 0 },
+  automatic_index: { column: "automatic_index", value: 1 },
+  busy_timeout: { column: "timeout", value: 0 },
+  cache_size: { column: "cache_size", value: 2e3 },
+  cache_spill: { column: "cache_spill", value: 2e4 },
+  cell_size_check: { column: "cell_size_check", value: 0 },
+  checkpoint_fullfsync: { column: "checkpoint_fullfsync", value: 1 },
+  count_changes: { column: "count_changes", value: 0 },
+  data_version: { column: "data_version", value: 1 },
+  default_cache_size: { column: "cache_size", value: 2e3 },
+  defer_foreign_keys: { column: "defer_foreign_keys", value: 0 },
+  empty_result_callbacks: { column: "empty_result_callbacks", value: 0 },
+  encoding: { column: "encoding", value: "UTF-8" },
+  freelist_count: { column: "freelist_count", value: 0 },
+  full_column_names: { column: "full_column_names", value: 0 },
+  fullfsync: { column: "fullfsync", value: 0 },
+  hard_heap_limit: { column: "hard_heap_limit", value: 0 },
+  ignore_check_constraints: { column: "ignore_check_constraints", value: 0 },
+  journal_mode: { column: "journal_mode", value: "memory" },
+  journal_size_limit: { column: "journal_size_limit", value: 32768 },
+  legacy_alter_table: { column: "legacy_alter_table", value: 1 },
+  locking_mode: { column: "locking_mode", value: "normal" },
+  max_page_count: { column: "max_page_count", value: 1073741823 },
+  page_size: { column: "page_size", value: 4096 },
+  query_only: { column: "query_only", value: 0 },
+  read_uncommitted: { column: "read_uncommitted", value: 0 },
+  recursive_triggers: { column: "recursive_triggers", value: 0 },
+  reverse_unordered_selects: { column: "reverse_unordered_selects", value: 0 },
+  secure_delete: { column: "secure_delete", value: 2 },
+  short_column_names: { column: "short_column_names", value: 1 },
+  soft_heap_limit: { column: "soft_heap_limit", value: 0 },
+  synchronous: { column: "synchronous", value: 2 },
+  temp_store: { column: "temp_store", value: 0 },
+  threads: { column: "threads", value: 0 },
+  trusted_schema: { column: "trusted_schema", value: 1 },
+  writable_schema: { column: "writable_schema", value: 0 }
+};
+function isPragmaTvfName(name) {
+  const lower = name.toLowerCase();
+  if (PRAGMA_TVF_NAMES.includes(lower)) return true;
+  if (lower.startsWith("pragma_")) {
+    return PRAGMA_TVF_NAMES.includes(lower.slice("pragma_".length));
+  }
+  return false;
+}
+function normalizePragmaKey(name) {
+  const lower = name.toLowerCase();
+  if (PRAGMA_TVF_NAMES.includes(lower)) return lower;
+  if (lower.startsWith("pragma_")) {
+    const stripped = lower.slice("pragma_".length);
+    if (PRAGMA_TVF_NAMES.includes(stripped)) return stripped;
+    return stripped;
+  }
+  return lower;
+}
+function queryPragma(name, args, env) {
+  const key = normalizePragmaKey(name);
+  switch (key) {
+    case "foreign_keys":
+      return single("foreign_keys", env.state.foreignKeysEnabled ? 1 : 0);
+    case "user_version":
+      return single("user_version", env.state.userVersion);
+    case "schema_version":
+      return single("schema_version", env.state.schemaVersion);
+    case "table_info":
+      return pragmaTableInfo(args, env, false);
+    case "table_xinfo":
+      return pragmaTableInfo(args, env, true);
+    case "index_list":
+      return pragmaIndexList(args, env);
+    case "index_info":
+      return pragmaIndexInfo(args, env, false);
+    case "index_xinfo":
+      return pragmaIndexInfo(args, env, true);
+    case "foreign_key_list":
+      return pragmaForeignKeyList(args, env);
+    case "foreign_key_check":
+      return pragmaForeignKeyCheck(args, env);
+    case "database_list":
+      return pragmaDatabaseList(env);
+    case "table_list":
+      return pragmaTableList(env);
+    case "collation_list":
+      return {
+        columns: ["seq", "name"],
+        rows: [
+          [0, "RTRIM"],
+          [1, "NOCASE"],
+          [2, "BINARY"]
+        ]
+      };
+    case "compile_options":
+      return { columns: ["compile_options"], rows: COMPILE_OPTIONS2.map((opt) => [opt]) };
+    case "function_list":
+      return pragmaFunctionList();
+    case "module_list":
+      return pragmaModuleList();
+    case "pragma_list":
+      return { columns: ["name"], rows: PRAGMA_LIST_NAMES.map((n) => [n]) };
+    case "integrity_check":
+    case "quick_check":
+      return single(key, "ok");
+    case "optimize":
+      return { columns: ["optimize"], rows: [] };
+    case "page_count":
+      return single("page_count", estimatePageCount(env));
+    default: {
+      const storage = STORAGE_DEFAULTS[key];
+      if (storage) return single(storage.column, storage.value);
+      return { columns: [], rows: [] };
+    }
+  }
+}
+function single(column, value) {
+  return { columns: [column], rows: [[value]] };
+}
+function estimatePageCount(env) {
+  const objects = env.state.tables.size + env.state.indexes.size + env.state.views.size + env.state.virtualTables.size;
+  return objects === 0 ? 0 : Math.max(1, objects);
+}
+function pragmaTableInfo(args, env, xinfo) {
+  const tableName = requireNameArg(args, "table_info");
+  const table = env.state.tables.get(tableName.toLowerCase());
+  if (!table) return { columns: xinfoColumns(xinfo), rows: [] };
+  const rows = table.columns.map((column, cid) => {
+    const pkIndex = table.columns.filter((c) => c.primaryKey).findIndex((c) => c.name === column.name);
+    const pk = column.primaryKey ? pkIndex >= 0 ? pkIndex + 1 : 1 : 0;
+    const dflt = column.defaultExpr ? defaultLiteral(column.defaultExpr) : null;
+    const base = [cid, column.name, column.typeName ?? "", column.notNull ? 1 : 0, dflt, pk];
+    if (xinfo) {
+      let hidden = 0;
+      if (column.generated && !column.generated.stored) hidden = 2;
+      if (column.generated?.stored) hidden = 3;
+      base.push(hidden);
+    }
+    return base;
+  });
+  return { columns: xinfoColumns(xinfo), rows };
+}
+function xinfoColumns(xinfo) {
+  return xinfo ? ["cid", "name", "type", "notnull", "dflt_value", "pk", "hidden"] : ["cid", "name", "type", "notnull", "dflt_value", "pk"];
+}
+function defaultLiteral(expr) {
+  if (expr.type === "literal")
+    return typeof expr.value === "string" ? `'${expr.value.replace(/'/g, "''")}'` : expr.value;
+  if (expr.type === "null") return "NULL";
+  return null;
+}
+function pragmaIndexList(args, env) {
+  const tableName = requireNameArg(args, "index_list");
+  const table = env.state.tables.get(tableName.toLowerCase());
+  if (!table) return { columns: ["seq", "name", "unique", "origin", "partial"], rows: [] };
+  const rows = [];
+  let seq = 0;
+  for (const name of table.indexes) {
+    const index = env.state.indexes.get(name.toLowerCase());
+    if (!index) continue;
+    rows.push([seq++, index.name, index.unique ? 1 : 0, indexOrigin(index), index.where ? 1 : 0]);
+  }
+  return { columns: ["seq", "name", "unique", "origin", "partial"], rows };
+}
+function indexOrigin(index) {
+  if (index.originalSql) return "c";
+  if (index.name.toLowerCase().startsWith("sqlite_autoindex_") && index.unique) return "u";
+  return "c";
+}
+function pragmaIndexInfo(args, env, xinfo) {
+  const indexName = requireNameArg(args, "index_info");
+  const index = env.state.indexes.get(indexName.toLowerCase());
+  const columns = xinfo ? ["seqno", "cid", "name", "desc", "coll", "key"] : ["seqno", "cid", "name"];
+  if (!index) return { columns, rows: [] };
+  const table = env.state.tables.get(index.tableName.toLowerCase());
+  const rows = index.columns.map((column, seqno) => {
+    const cid = table?.columns.findIndex((c) => c.name.toLowerCase() === column.name.toLowerCase()) ?? -1;
+    const base = [seqno, cid, column.name];
+    if (xinfo) {
+      base.push(column.order === "DESC" ? 1 : 0, (column.collate ?? "BINARY").toUpperCase(), 1);
+    }
+    return base;
+  });
+  if (xinfo) {
+    rows.push([index.columns.length, -1, null, 0, "BINARY", 0]);
+  }
+  return { columns, rows };
+}
+function pragmaForeignKeyList(args, env) {
+  const tableName = requireNameArg(args, "foreign_key_list");
+  const table = env.state.tables.get(tableName.toLowerCase());
+  const columns = ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"];
+  if (!table) return { columns, rows: [] };
+  const rows = [];
+  let id = 0;
+  for (const constraint of table.constraints) {
+    if (constraint.type !== "foreign_key") continue;
+    const refColumns = constraint.refColumns ?? env.state.tables.get(constraint.refTable.toLowerCase())?.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];
+    constraint.columns.forEach((column, seq) => {
+      rows.push([
+        id,
+        seq,
+        constraint.refTable,
+        column,
+        refColumns[seq] ?? null,
+        constraint.onUpdate ?? "NO ACTION",
+        constraint.onDelete ?? "NO ACTION",
+        "NONE"
+      ]);
+    });
+    id++;
+  }
+  return { columns, rows };
+}
+function pragmaForeignKeyCheck(args, env) {
+  const columns = ["table", "rowid", "parent", "fkid"];
+  const filter = args[0] != null && args[0] !== null ? String(args[0]).toLowerCase() : null;
+  const rows = [];
+  for (const table of env.state.tables.values()) {
+    if (filter && table.name.toLowerCase() !== filter) continue;
+    let fkid = 0;
+    for (const constraint of table.constraints) {
+      if (constraint.type !== "foreign_key") continue;
+      const parent = env.state.tables.get(constraint.refTable.toLowerCase());
+      const refColumns = constraint.refColumns ?? parent?.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];
+      for (const row of table.scan()) {
+        let allNull = true;
+        const childValues = [];
+        for (const col of constraint.columns) {
+          const value = row.values.get(col.toLowerCase()) ?? null;
+          childValues.push(value);
+          if (value !== null) allNull = false;
+        }
+        if (allNull) continue;
+        if (!parent || !parentHasMatch(parent, refColumns, childValues)) {
+          rows.push([table.name, row.rowid, constraint.refTable, fkid]);
+        }
+      }
+      fkid++;
+    }
+  }
+  return { columns, rows };
+}
+function parentHasMatch(parent, refColumns, childValues) {
+  if (refColumns.length === 0) return false;
+  for (const row of parent.scan()) {
+    let ok = true;
+    for (let i = 0; i < refColumns.length; i++) {
+      const parentVal = row.values.get(refColumns[i].toLowerCase()) ?? null;
+      if (!sqlValuesEqual(parentVal, childValues[i] ?? null)) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return true;
+  }
+  return false;
+}
+function sqlValuesEqual(a, b) {
+  if (a === null || b === null) return a === b;
+  if (typeof a === "number" && typeof b === "number") return a === b;
+  if (typeof a === "bigint" || typeof b === "bigint") {
+    return BigInt(a) === BigInt(b);
+  }
+  if (a instanceof Uint8Array || b instanceof Uint8Array) return false;
+  return String(a) === String(b);
+}
+function pragmaDatabaseList(env) {
+  const rows = [[0, "main", ""]];
+  let seq = 2;
+  for (const [name, attached] of env.state.attached) {
+    const file = attached.filename === ":memory:" ? "" : attached.filename;
+    rows.push([seq++, name, file]);
+  }
+  return { columns: ["seq", "name", "file"], rows };
+}
+function pragmaTableList(env) {
+  const columns = ["schema", "name", "type", "ncol", "wr", "strict"];
+  const rows = [];
+  for (const table of env.state.tables.values()) {
+    rows.push(["main", table.name, "table", table.columns.length, table.withoutRowid ? 1 : 0, table.strict ? 1 : 0]);
+  }
+  for (const view of env.state.views.values()) {
+    const ncol = view.columns?.length ?? 0;
+    rows.push(["main", view.name, "view", ncol, 0, 0]);
+  }
+  for (const vt of env.state.virtualTables.values()) {
+    rows.push(["main", vt.name, "virtual", vt.columns.length, 0, 0]);
+  }
+  rows.push(["main", "sqlite_schema", "table", 5, 0, 0]);
+  rows.push(["temp", "sqlite_temp_schema", "table", 5, 0, 0]);
+  for (const [schema] of env.state.attached) {
+    rows.push([schema, "sqlite_schema", "table", 5, 0, 0]);
+  }
+  return { columns, rows };
+}
+function pragmaFunctionList() {
+  const columns = ["name", "builtin", "type", "enc", "narg", "flags"];
+  const rows = [];
+  const add = (name, type, narg, flags) => {
+    rows.push([name, 1, type, "utf8", narg, flags]);
+  };
+  for (const name of Object.keys(getScalarFunctions())) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(dateTimeFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(jsonScalarFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(mathFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(ftsAuxFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(rtreeAuxFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(aggregateFunctions)) {
+    add(name, "w", name === "count" ? 0 : 1, 2097152);
+    if (name === "count") add(name, "w", 1, 2097152);
+  }
+  for (const name of Object.keys(jsonAggregateFunctions)) add(name, "w", -1, 2097152);
+  for (const name of Object.keys(windowFunctions)) add(name, "w", -1, 2097152);
+  for (const name of ["generate_series", "json_each", "json_tree"]) {
+    add(name, "s", -1, 2099200);
+  }
+  rows.sort((a, b) => String(a[0]).localeCompare(String(b[0])) || Number(a[4]) - Number(b[4]));
+  return { columns, rows };
+}
+function pragmaModuleList() {
+  const names = /* @__PURE__ */ new Set([
+    ...MEMORY_VTABLE_MODULES,
+    ...PRAGMA_TVF_NAMES.map((n) => `pragma_${n}`),
+    "generate_series",
+    "json_each",
+    "json_tree"
+  ]);
+  return {
+    columns: ["name"],
+    rows: [...names].sort((a, b) => a.localeCompare(b)).map((name) => [name])
+  };
+}
+function requireNameArg(args, pragma) {
+  if (args.length === 0 || args[0] == null) {
+    throw new SqliteError(`missing pragma argument for ${pragma}`, "misuse");
+  }
+  const value = args[0];
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint") return String(value);
+  throw new SqliteError(`invalid pragma argument for ${pragma}`, "misuse");
+}
+function evalPragmaArgs(expr, env) {
+  if (expr === null) return [];
+  if (expr.type === "column" && expr.table === null) return [expr.name];
+  if (expr.type === "literal") return [expr.value];
+  return [evalExpr(expr, env.createEvalContext())];
+}
+function evalPragmaSetValue(expr, env) {
+  if (expr.type === "column" && expr.table === null) {
+    const keyword = expr.name.toLowerCase();
+    if (keyword === "on" || keyword === "true" || keyword === "yes") return 1;
+    if (keyword === "off" || keyword === "false" || keyword === "no") return 0;
+    return expr.name;
+  }
+  return evalExpr(expr, env.createEvalContext());
+}
+function coercePragmaInt(value) {
+  if (typeof value === "number") return Math.trunc(value);
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : 0;
+  }
+  const asInt = toInteger(value);
+  return asInt === null ? 0 : typeof asInt === "bigint" ? Number(asInt) : asInt;
+}
+function coercePragmaTruthy(value) {
+  return isTruthySql(value) === true;
+}
+
+// src/functions/table-valued-registry.ts
 var registry = /* @__PURE__ */ new Map();
+function registerTableValuedFunction(name, fn) {
+  registry.set(name.toLowerCase(), fn);
+}
+function getTableValuedFunction(name) {
+  return registry.get(name.toLowerCase());
+}
+function hasRegisteredTableValuedFunction(name) {
+  return registry.has(name.toLowerCase());
+}
+
+// src/functions/pragma-tvf.ts
+function toTvfResult(alias, defaultName, columns, rows) {
+  const table = alias ?? defaultName;
+  return {
+    columns,
+    rows: rows.map((row) => ({
+      cells: columns.map((name, index) => ({
+        table,
+        name,
+        value: row[index] ?? null
+      }))
+    }))
+  };
+}
+var registered = false;
+function ensurePragmaTvfsRegistered() {
+  if (registered) return;
+  registered = true;
+  for (const baseName of PRAGMA_TVF_NAMES) {
+    const tvfName = `pragma_${baseName}`;
+    registerTableValuedFunction(tvfName, (args, alias, env) => {
+      const result = queryPragma(baseName, args, env);
+      return toTvfResult(alias, tvfName, result.columns, result.rows);
+    });
+  }
+}
+
+// src/functions/table-valued.ts
 var JSON_TVF_COLUMNS = ["key", "value", "type", "atom", "id", "parent", "fullkey", "path"];
 function jsonTvfResult(alias, defaultName, rows) {
   const table = alias ?? defaultName;
@@ -9206,7 +9777,7 @@ function jsonTvfResult(alias, defaultName, rows) {
     }))
   };
 }
-registry.set("generate_series", (args, alias) => {
+registerTableValuedFunction("generate_series", (args, alias) => {
   if (args.length < 2 || args.length > 3) {
     throw new SqliteError("wrong number of arguments to function generate_series()", "misuse");
   }
@@ -9237,13 +9808,13 @@ registry.set("generate_series", (args, alias) => {
   }
   return { columns: ["value"], rows };
 });
-registry.set("json_each", (args, alias) => {
+registerTableValuedFunction("json_each", (args, alias) => {
   if (args.length < 1 || args.length > 2) {
     throw new SqliteError("wrong number of arguments to function json_each()", "misuse");
   }
   return jsonTvfResult(alias, "json_each", jsonEachRows(args[0], args[1]));
 });
-registry.set("json_tree", (args, alias) => {
+registerTableValuedFunction("json_tree", (args, alias) => {
   if (args.length < 1 || args.length > 2) {
     throw new SqliteError("wrong number of arguments to function json_tree()", "misuse");
   }
@@ -9253,11 +9824,16 @@ function safeInt(value) {
   return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value;
 }
 function evaluateTableFunction(name, args, alias, env, scope, parent) {
-  const fn = registry.get(name.toLowerCase());
+  ensurePragmaTvfsRegistered();
+  const fn = getTableValuedFunction(name);
   if (!fn) throw new SqliteError(`no such table-valued function: ${name}`, "no_such_table");
   const values = args.map((arg) => evalExpr(arg, env.createEvalContext(scope ?? null, parent)));
   return fn(values, alias, env);
 }
+function hasTableValuedFunction(name) {
+  ensurePragmaTvfsRegistered();
+  return hasRegisteredTableValuedFunction(name);
+}
 
 // src/schema/catalog.ts
 function schemaCatalogRows(state) {
@@ -9988,10 +10564,10 @@ function executeSelect2(stmt, env, parent) {
         rows = uniqueRows([...leftRows, ...rightRows]);
         break;
       case "INTERSECT":
-        rows = uniqueRows(leftRows).filter((row) => rightRows.some((other) => rowsEqual(row, other)));
+        rows = uniqueRows(leftRows).filter((row) => rightRows.some((other) => rowsEqual2(row, other)));
         break;
       case "EXCEPT":
-        rows = uniqueRows(leftRows).filter((row) => !rightRows.some((other) => rowsEqual(row, other)));
+        rows = uniqueRows(leftRows).filter((row) => !rightRows.some((other) => rowsEqual2(row, other)));
         break;
     }
     if (stmt.orderBy.length > 0) rows.sort((a, b) => compareCompoundRows(a, b, stmt.orderBy, base.columns));
@@ -10025,7 +10601,7 @@ function executeWith(stmt, env, parent) {
         env.ctes.set(key, valuesToResult(columns, delta));
         const nextResult = executeSelect2(cte.select.compound.select, env, parent);
         const candidates = resultValues(nextResult);
-        const additions = cte.select.compound.op === "UNION ALL" ? candidates : candidates.filter((row) => !accumulated.some((existing) => rowsEqual(existing, row)));
+        const additions = cte.select.compound.op === "UNION ALL" ? candidates : candidates.filter((row) => !accumulated.some((existing) => rowsEqual2(existing, row)));
         if (additions.length === 0) break;
         accumulated = [...accumulated, ...additions];
         delta = additions;
@@ -10327,6 +10903,9 @@ function scanFrom(item, env, parent) {
   if (item.type === "table_func") {
     return evaluateTableFunction(item.name, item.args, item.alias, env).rows;
   }
+  if (item.type === "table" && isPragmaTvfName(item.name) && hasTableValuedFunction(item.name.toLowerCase())) {
+    return evaluateTableFunction(item.name, [], item.alias, env, null, parent).rows;
+  }
   const alias = item.alias ?? item.name;
   const qualified = item.schema ? `${item.schema}.${item.name}` : item.name;
   const db = env.state.databaseForSchema(item.schema, qualified);
@@ -10499,6 +11078,14 @@ function shapeOf(item, env) {
       value: null
     }));
   }
+  if (item.type === "table" && isPragmaTvfName(item.name) && hasTableValuedFunction(item.name.toLowerCase())) {
+    const columns = evaluateTableFunction(item.name, [], item.alias, env).columns;
+    return columns.map((name) => ({
+      table: item.alias ?? item.name,
+      name,
+      value: null
+    }));
+  }
   const alias = item.alias ?? item.name;
   const qualified = item.schema ? `${item.schema}.${item.name}` : item.name;
   const db = env.state.databaseForSchema(item.schema, qualified);
@@ -10568,7 +11155,7 @@ function aggregateValue(expr, rows, env, parent) {
     const ctx = env.createEvalContext(row, parent);
     if (expr.filter && isTruthySql(evalExpr(expr.filter, ctx)) !== true) continue;
     const args = expr.args === "*" ? [] : expr.args.map((arg) => evalExpr(arg, ctx));
-    if (expr.distinct && seen.some((values) => rowsEqual(values, args))) continue;
+    if (expr.distinct && seen.some((values) => rowsEqual2(values, args))) continue;
     seen.push(args);
     accumulator.step(args);
   }
@@ -10579,7 +11166,7 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   const currentCtx = env.createEvalContext(current, parent);
   const partitionKey = spec.partitionBy.map((item) => evalExpr(item, currentCtx));
   const partition = rows.filter(
-    (row) => rowsEqual(
+    (row) => rowsEqual2(
       partitionKey,
       spec.partitionBy.map((item) => evalExpr(item, env.createEvalContext(row, parent)))
     )
@@ -10608,13 +11195,13 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   if (name === "row_number") return index + 1;
   if (name === "rank") {
     let first = index;
-    while (first > 0 && rowsEqual(orderKeys[first], orderKeys[first - 1])) first--;
+    while (first > 0 && rowsEqual2(orderKeys[first], orderKeys[first - 1])) first--;
     return first + 1;
   }
   if (name === "dense_rank") {
-    let rank = 1;
-    for (let i = 1; i <= index; i++) if (!rowsEqual(orderKeys[i], orderKeys[i - 1])) rank++;
-    return rank;
+    let rank2 = 1;
+    for (let i = 1; i <= index; i++) if (!rowsEqual2(orderKeys[i], orderKeys[i - 1])) rank2++;
+    return rank2;
   }
   const evaluated = args.map((arg) => evalExpr(arg, currentCtx));
   if (name === "lag" || name === "lead") {
@@ -10648,7 +11235,7 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   if (name === "cume_dist") {
     if (partition.length === 0) return null;
     let lastPeer = index;
-    while (lastPeer + 1 < partition.length && rowsEqual(orderKeys[lastPeer + 1], orderKeys[index])) {
+    while (lastPeer + 1 < partition.length && rowsEqual2(orderKeys[lastPeer + 1], orderKeys[index])) {
       lastPeer++;
     }
     return (lastPeer + 1) / partition.length;
@@ -10656,7 +11243,7 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   if (name === "percent_rank") {
     if (partition.length <= 1) return 0;
     let first = index;
-    while (first > 0 && rowsEqual(orderKeys[first], orderKeys[first - 1])) first--;
+    while (first > 0 && rowsEqual2(orderKeys[first], orderKeys[first - 1])) first--;
     return first / (partition.length - 1);
   }
   throw new SqliteError(`no such window function: ${expr.func.name}`, "other");
@@ -10681,7 +11268,7 @@ function frameBounds(spec, index, length, ctx, defaultFrameEnd, orderKeys) {
   const isRangeLike = spec.frame.type === "RANGE" || spec.frame.type === "GROUPS";
   let peerFirst = index;
   if (isRangeLike && spec.orderBy.length > 0) {
-    while (peerFirst > 0 && rowsEqual(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
+    while (peerFirst > 0 && rowsEqual2(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
   }
   const bound = (item, isStart) => {
     switch (item.kind) {
@@ -10703,8 +11290,8 @@ function frameBounds(spec, index, length, ctx, defaultFrameEnd, orderKeys) {
 function frameRows(partition, start, end, index, orderKeys, exclude) {
   let peerFirst = index;
   let peerLast = index;
-  while (peerFirst > 0 && rowsEqual(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
-  while (peerLast + 1 < partition.length && rowsEqual(orderKeys[peerLast], orderKeys[peerLast + 1])) peerLast++;
+  while (peerFirst > 0 && rowsEqual2(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
+  while (peerLast + 1 < partition.length && rowsEqual2(orderKeys[peerLast], orderKeys[peerLast + 1])) peerLast++;
   const rows = [];
   for (let i = Math.max(0, start); i <= end && i < partition.length; i++) {
     if (exclude === "current_row" && i === index) continue;
@@ -10930,7 +11517,7 @@ function referencesTable(select, name) {
   };
   return visit(select.from) || (select.compound ? referencesTable(select.compound.select, name) : false);
 }
-function rowsEqual(left, right) {
+function rowsEqual2(left, right) {
   return left.length === right.length && left.every((value, index) => {
     const other = right[index] ?? null;
     return value === null && other === null || value !== null && other !== null && sqlValueEquals(value, other);
@@ -12355,154 +12942,24 @@ function asExplicitRowid(value) {
 // src/executor/pragma.ts
 function executePragma(name, expr, env) {
   const key = name.toLowerCase();
-  switch (key) {
-    case "foreign_keys":
-      return pragmaForeignKeys(expr, env);
-    case "table_info":
-      return pragmaTableInfo(expr, env, false);
-    case "table_xinfo":
-      return pragmaTableInfo(expr, env, true);
-    case "index_list":
-      return pragmaIndexList(expr, env);
-    case "index_info":
-      return pragmaIndexInfo(expr, env);
-    case "foreign_key_list":
-      return pragmaForeignKeyList(expr, env);
-    case "database_list":
-      return pragmaDatabaseList(env);
-    case "user_version":
-      return pragmaIntVersion("user_version", expr, env, "userVersion");
-    case "schema_version":
-      return pragmaIntVersion("schema_version", expr, env, "schemaVersion");
-    default:
-      return emptyResult(0, env.state.lastInsertRowid);
-  }
-}
-function pragmaForeignKeys(expr, env) {
-  if (expr === null) {
-    return valuesToResult(["foreign_keys"], [[env.state.foreignKeysEnabled ? 1 : 0]], 0, env.state.lastInsertRowid);
-  }
-  const value = pragmaValue(expr, env);
-  if (!env.transactions.inTransaction) env.state.foreignKeysEnabled = isTruthySql(value) === true;
-  return emptyResult(0, env.state.lastInsertRowid);
-}
-function pragmaTableInfo(expr, env, xinfo) {
-  const tableName = pragmaTableArg(expr, env);
-  const table = env.state.tables.get(tableName.toLowerCase());
-  if (!table) return emptyResult(0, env.state.lastInsertRowid);
-  const columns = xinfo ? ["cid", "name", "type", "notnull", "dflt_value", "pk", "hidden"] : ["cid", "name", "type", "notnull", "dflt_value", "pk"];
-  const rows = table.columns.map((column, cid) => {
-    const pkIndex = table.columns.filter((c) => c.primaryKey).findIndex((c) => c.name === column.name);
-    const pk = column.primaryKey ? pkIndex >= 0 ? pkIndex + 1 : 1 : 0;
-    const dflt = column.defaultExpr ? defaultLiteral(column.defaultExpr) : null;
-    const base = [cid, column.name, column.typeName ?? "", column.notNull ? 1 : 0, dflt, pk];
-    if (xinfo) {
-      let hidden = 0;
-      if (column.generated?.stored) hidden = 2;
-      else if (column.generated) hidden = 2;
-      if (column.generated && !column.generated.stored) hidden = 2;
-      if (column.generated?.stored) hidden = 3;
-      base.push(hidden);
-    }
-    return base;
-  });
-  return valuesToResult(columns, rows, 0, env.state.lastInsertRowid);
-}
-function defaultLiteral(expr) {
-  if (expr.type === "literal")
-    return typeof expr.value === "string" ? `'${expr.value.replace(/'/g, "''")}'` : expr.value;
-  if (expr.type === "null") return "NULL";
-  return null;
-}
-function pragmaIndexList(expr, env) {
-  const tableName = pragmaTableArg(expr, env);
-  const table = env.state.tables.get(tableName.toLowerCase());
-  if (!table) return emptyResult(0, env.state.lastInsertRowid);
-  const rows = [];
-  let seq = 0;
-  for (const name of table.indexes) {
-    const index = env.state.indexes.get(name.toLowerCase());
-    if (!index) continue;
-    rows.push([seq++, index.name, index.unique ? 1 : 0, "c", 0]);
-  }
-  return valuesToResult(["seq", "name", "unique", "origin", "partial"], rows, 0, env.state.lastInsertRowid);
-}
-function pragmaIndexInfo(expr, env) {
-  const indexName = pragmaTableArg(expr, env);
-  const index = env.state.indexes.get(indexName.toLowerCase());
-  if (!index) return emptyResult(0, env.state.lastInsertRowid);
-  const table = env.state.getTable(index.tableName);
-  const rows = index.columns.map((column, seqno) => {
-    const cid = table.columns.findIndex((c) => c.name.toLowerCase() === column.name.toLowerCase());
-    return [seqno, cid, column.name];
-  });
-  return valuesToResult(["seqno", "cid", "name"], rows, 0, env.state.lastInsertRowid);
-}
-function pragmaForeignKeyList(expr, env) {
-  const tableName = pragmaTableArg(expr, env);
-  const table = env.state.tables.get(tableName.toLowerCase());
-  if (!table) return emptyResult(0, env.state.lastInsertRowid);
-  const rows = [];
-  let id = 0;
-  for (const constraint of table.constraints) {
-    if (constraint.type !== "foreign_key") continue;
-    const refColumns = constraint.refColumns ?? env.state.tables.get(constraint.refTable.toLowerCase())?.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];
-    constraint.columns.forEach((column, seq) => {
-      rows.push([
-        id,
-        seq,
-        constraint.refTable,
-        column,
-        refColumns[seq] ?? null,
-        constraint.onUpdate ?? "NO ACTION",
-        constraint.onDelete ?? "NO ACTION",
-        "NONE"
-      ]);
-    });
-    id++;
-  }
-  return valuesToResult(
-    ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"],
-    rows,
-    0,
-    env.state.lastInsertRowid
-  );
-}
-function pragmaDatabaseList(env) {
-  const rows = [[0, "main", ""]];
-  let seq = 2;
-  for (const [name, attached] of env.state.attached) {
-    const file = attached.filename === ":memory:" ? "" : attached.filename;
-    rows.push([seq++, name, file]);
+  if (key === "foreign_keys" && expr !== null) {
+    const value = evalPragmaSetValue(expr, env);
+    if (!env.transactions.inTransaction) env.state.foreignKeysEnabled = coercePragmaTruthy(value);
+    return emptyResult(0, env.state.lastInsertRowid);
   }
-  return valuesToResult(["seq", "name", "file"], rows, 0, env.state.lastInsertRowid);
-}
-function pragmaIntVersion(label, expr, env, field) {
-  if (expr === null) {
-    return valuesToResult([label], [[env.state[field]]], 0, env.state.lastInsertRowid);
+  if ((key === "user_version" || key === "schema_version") && expr !== null) {
+    const value = evalPragmaSetValue(expr, env);
+    const num2 = coercePragmaInt(value);
+    if (key === "user_version") env.state.userVersion = num2;
+    else env.state.schemaVersion = num2;
+    return emptyResult(0, env.state.lastInsertRowid);
   }
-  const value = pragmaValue(expr, env);
-  const num2 = typeof value === "number" ? Math.trunc(value) : typeof value === "bigint" ? Number(value) : typeof value === "string" ? Number.parseInt(value, 10) : 0;
-  if (field === "userVersion") env.state.userVersion = Number.isFinite(num2) ? num2 : 0;
-  else env.state.schemaVersion = Number.isFinite(num2) ? num2 : 0;
-  return emptyResult(0, env.state.lastInsertRowid);
-}
-function pragmaTableArg(expr, env) {
-  if (!expr) throw new SqliteError("missing pragma argument", "misuse");
-  if (expr.type === "column" && expr.table === null) return expr.name;
-  if (expr.type === "literal" && typeof expr.value === "string") return expr.value;
-  const value = evalExpr(expr, env.createEvalContext());
-  if (typeof value === "string") return value;
-  throw new SqliteError("invalid pragma argument", "misuse");
-}
-function pragmaValue(expr, env) {
-  if (expr.type === "column" && expr.table === null) {
-    const keyword = expr.name.toLowerCase();
-    if (keyword === "on" || keyword === "true" || keyword === "yes") return 1;
-    if (keyword === "off" || keyword === "false" || keyword === "no") return 0;
-    return expr.name;
+  const args = evalPragmaArgs(expr, env);
+  const result = queryPragma(key, args, env);
+  if (result.columns.length === 0 && result.rows.length === 0) {
+    return emptyResult(0, env.state.lastInsertRowid);
   }
-  return evalExpr(expr, env.createEvalContext());
+  return valuesToResult(result.columns, result.rows, 0, env.state.lastInsertRowid);
 }
 
 // src/executor/execute.ts