@crvouga/sqlite-mem 1.1.0 → 1.1.1

package/README.md

@@ -216,7 +216,7 @@ Goal: drop-in SQL behavior vs SQLite **3.51.0**. Full matrix: [COMPATIBILITY.md]
 - FTS3/4/5 — largely implemented; shadow-table change counters intentionally diverge; some edges partial
 - `EXPLAIN` / `EXPLAIN QUERY PLAN` — stub shapes, not real bytecode
 - `INDEXED BY` / `NOT INDEXED` — parsed and discarded
-- Unknown statement `PRAGMA` succeeds with an empty result (SQLite-like). All oracle-exposed `pragma_*` eponymous TVFs are supported (`SELECT * FROM pragma_table_info('t')`, bare `FROM pragma_database_list`, …). Storage/journal getters return bun `:memory:`-compatible defaults.
+- Unknown statement `PRAGMA` succeeds with an empty result (SQLite-like). All oracle-exposed `pragma_*` eponymous TVFs are supported (`SELECT * FROM pragma_table_info('t')`, bare `FROM pragma_database_list`, …), including **correlated** args such as `FROM table_list AS tl, pragma_table_info(tl.name) AS p` (Kysely SQLite introspector). Storage/journal getters return bun `:memory:`-compatible defaults.
 
 ## Common pitfalls
 

package/dist/executor/pragma-engine.d.ts

@@ -13,6 +13,12 @@ export declare const PRAGMA_TVF_NAMES: readonly ["analysis_limit", "application_
 /** Full pragma name list for `pragma_pragma_list` (includes names without TVFs). */
 export declare const PRAGMA_LIST_NAMES: string[];
 export declare function isPragmaTvfName(name: string): boolean;
+/**
+ * Column names for a pragma_* TVF without evaluating arguments.
+ * Used by SELECT shape analysis so correlated args (e.g. `tl.name`) are not
+ * resolved before the outer row is bound.
+ */
+export declare function pragmaTvfColumns(name: string): string[] | null;
 /**
  * Query a pragma by name with optional SQL values (TVF args or evaluated statement args).
  * Read-only — writers stay in {@link executePragma}.

package/dist/functions/table-valued.d.ts

@@ -3,6 +3,11 @@ import type { ExecutionEnv, ScopeRow } from "../executor/env.js";
 import { registerTableValuedFunction, type TableValuedResult } from "./table-valued-registry.js";
 export type { TableValuedResult };
 export { registerTableValuedFunction };
+/**
+ * Known output columns for a TVF without evaluating arguments.
+ * Prefer this for FROM-item shape analysis when args may be correlated.
+ */
+export declare function tableValuedColumns(name: string): string[] | null;
 export declare function evaluateTableFunction(name: string, args: Expr[], alias: string | null, env: ExecutionEnv, scope?: ScopeRow | null, parent?: import("../expressions/context.js").EvalContext): TableValuedResult;
 export declare function listTableValuedFunctions(): string[];
 export declare function hasTableValuedFunction(name: string): boolean;

package/dist/index.js

@@ -9400,6 +9400,56 @@ function isPragmaTvfName(name) {
   }
   return false;
 }
+function pragmaTvfColumns(name) {
+  const key = normalizePragmaKey(name);
+  switch (key) {
+    case "foreign_keys":
+      return ["foreign_keys"];
+    case "user_version":
+      return ["user_version"];
+    case "schema_version":
+      return ["schema_version"];
+    case "table_info":
+      return ["cid", "name", "type", "notnull", "dflt_value", "pk"];
+    case "table_xinfo":
+      return ["cid", "name", "type", "notnull", "dflt_value", "pk", "hidden"];
+    case "index_list":
+      return ["seq", "name", "unique", "origin", "partial"];
+    case "index_info":
+      return ["seqno", "cid", "name"];
+    case "index_xinfo":
+      return ["seqno", "cid", "name", "desc", "coll", "key"];
+    case "foreign_key_list":
+      return ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"];
+    case "foreign_key_check":
+      return ["table", "rowid", "parent", "fkid"];
+    case "database_list":
+      return ["seq", "name", "file"];
+    case "table_list":
+      return ["schema", "name", "type", "ncol", "wr", "strict"];
+    case "collation_list":
+      return ["seq", "name"];
+    case "compile_options":
+      return ["compile_options"];
+    case "function_list":
+      return ["name", "builtin", "type", "enc", "narg", "flags"];
+    case "module_list":
+    case "pragma_list":
+      return ["name"];
+    case "integrity_check":
+    case "quick_check":
+      return [key];
+    case "optimize":
+      return ["optimize"];
+    case "page_count":
+      return ["page_count"];
+    default: {
+      const storage = STORAGE_DEFAULTS[key];
+      if (storage) return [storage.column];
+      return null;
+    }
+  }
+}
 function normalizePragmaKey(name) {
   const lower = name.toLowerCase();
   if (PRAGMA_TVF_NAMES.includes(lower)) return lower;
@@ -9823,6 +9873,13 @@ registerTableValuedFunction("json_tree", (args, alias) => {
 function safeInt(value) {
   return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value;
 }
+function tableValuedColumns(name) {
+  ensurePragmaTvfsRegistered();
+  const lower = name.toLowerCase();
+  if (lower === "generate_series") return ["value"];
+  if (lower === "json_each" || lower === "json_tree") return [...JSON_TVF_COLUMNS];
+  return pragmaTvfColumns(name);
+}
 function evaluateTableFunction(name, args, alias, env, scope, parent) {
   ensurePragmaTvfsRegistered();
   const fn = getTableValuedFunction(name);
@@ -11071,7 +11128,8 @@ function shapeOf(item, env) {
   if (item.type === "subquery")
     return resultColumnNames(item.select.columns).map((name) => ({ table: item.alias, name, value: null }));
   if (item.type === "table_func") {
-    const columns = item.name.toLowerCase() === "generate_series" ? ["value"] : item.name.toLowerCase() === "json_each" || item.name.toLowerCase() === "json_tree" ? ["key", "value", "type", "atom", "id", "parent", "fullkey", "path"] : evaluateTableFunction(item.name, item.args, item.alias, env).columns;
+    const known = tableValuedColumns(item.name);
+    const columns = known ?? evaluateTableFunction(item.name, item.args, item.alias, env).columns;
     return columns.map((name) => ({
       table: item.alias ?? item.name,
       name,
@@ -11079,7 +11137,7 @@ function shapeOf(item, env) {
     }));
   }
   if (item.type === "table" && isPragmaTvfName(item.name) && hasTableValuedFunction(item.name.toLowerCase())) {
-    const columns = evaluateTableFunction(item.name, [], item.alias, env).columns;
+    const columns = tableValuedColumns(item.name) ?? evaluateTableFunction(item.name, [], item.alias, env).columns;
     return columns.map((name) => ({
       table: item.alias ?? item.name,
       name,