@crvouga/sqlite-mem 1.1.0 → 1.1.2

package/README.md

@@ -216,7 +216,9 @@ 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.
+
+**Also supported (oracle-parity):** boolean literals **`TRUE` / `FALSE`** (any case → integers `1` / `0`) and **`IS [NOT] TRUE` / `IS [NOT] FALSE`** (SQLite truthiness, including NULL). A column named `true`/`false` shadows the literal.
 
 ## Common pitfalls
 

package/dist/ast/nodes.d.ts

@@ -2,7 +2,7 @@ import type { SqlValue } from "../types/value.js";
 export type BinaryOp = "+" | "-" | "*" | "/" | "%" | "||" | "=" | "==" | "!=" | "<>" | "<" | "<=" | ">" | ">=" | "AND" | "OR" | "IS" | "IS NOT" | "IS DISTINCT FROM" | "IS NOT DISTINCT FROM" | "LIKE" | "NOT LIKE" | "GLOB" | "NOT GLOB" | "IN" | "NOT IN" | "MATCH" | "->" | "->>" | "&" | "|" | "<<" | ">>";
 export type UnaryOp = "+" | "-" | "~" | "NOT";
 /** Parsed SQL expression AST (literals, operators, functions, subqueries, …). */
-export type Expr = LiteralExpr | NullExpr | ColumnRefExpr | UnaryExpr | BinaryExpr | BetweenExpr | InExpr | LikeExpr | FunctionExpr | AggregateExpr | WindowExpr | CaseExpr | CastExpr | ExistsExpr | SubqueryExpr | ParameterExpr | RowExpr | CollateExpr;
+export type Expr = LiteralExpr | NullExpr | ColumnRefExpr | UnaryExpr | BinaryExpr | BetweenExpr | InExpr | LikeExpr | IsBoolExpr | FunctionExpr | AggregateExpr | WindowExpr | CaseExpr | CastExpr | ExistsExpr | SubqueryExpr | ParameterExpr | RowExpr | CollateExpr;
 export interface LiteralExpr {
     type: "literal";
     value: SqlValue;
@@ -28,6 +28,14 @@ export interface BinaryExpr {
     left: Expr;
     right: Expr;
 }
+/** `expr IS [NOT] TRUE` / `expr IS [NOT] FALSE` (truthiness, not equality to 1/0). */
+export interface IsBoolExpr {
+    type: "is_bool";
+    expr: Expr;
+    not: boolean;
+    /** `true` for TRUE, `false` for FALSE. */
+    sense: boolean;
+}
 export interface BetweenExpr {
     type: "between";
     not: boolean;

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

@@ -91,6 +91,7 @@ var KEYWORDS = {
   FOREIGN: "FOREIGN",
   FROM: "FROM",
   FULL: "FULL",
+  FALSE: "FALSE",
   GENERATED: "GENERATED",
   GLOB: "GLOB",
   GROUP: "GROUP",
@@ -165,6 +166,7 @@ var KEYWORDS = {
   TO: "TO",
   TRANSACTION: "TRANSACTION",
   TRIGGER: "TRIGGER",
+  TRUE: "TRUE",
   UNBOUNDED: "UNBOUNDED",
   UNION: "UNION",
   UNIQUE: "UNIQUE",
@@ -519,6 +521,7 @@ var IDENT_KEYWORDS = /* @__PURE__ */ new Set([
   "FOREIGN",
   "FROM",
   "FULL",
+  "FALSE",
   "GENERATED",
   "GLOB",
   "GROUP",
@@ -593,6 +596,7 @@ var IDENT_KEYWORDS = /* @__PURE__ */ new Set([
   "TO",
   "TRANSACTION",
   "TRIGGER",
+  "TRUE",
   "UNBOUNDED",
   "UNION",
   "UNIQUE",
@@ -1939,6 +1943,14 @@ var Parser = class {
           continue;
         }
         const not = this.match("NOT");
+        if (this.match("TRUE")) {
+          left = { type: "is_bool", expr: left, not, sense: true };
+          continue;
+        }
+        if (this.match("FALSE")) {
+          left = { type: "is_bool", expr: left, not, sense: false };
+          continue;
+        }
         const right2 = this.parseIsRhs();
         left = { type: "binary", op: not ? "IS NOT" : "IS", left, right: right2 };
         continue;
@@ -5527,6 +5539,8 @@ function explicitCollation(expr) {
     case "unary":
     case "cast":
       return explicitCollation(expr.expr);
+    case "is_bool":
+      return explicitCollation(expr.expr);
     case "binary":
       return explicitCollation(expr.left) ?? explicitCollation(expr.right);
     case "between":
@@ -5557,6 +5571,8 @@ function inheritedCollation(expr, ctx) {
     case "unary":
     case "cast":
       return inheritedCollation(expr.expr, ctx);
+    case "is_bool":
+      return inheritedCollation(expr.expr, ctx);
     default:
       return null;
   }
@@ -5602,6 +5618,13 @@ function evalExpr(expr, ctx) {
       if (expr.op === "-") return asNumber(-numberValue(value));
       return ~integerValue(value);
     }
+    case "is_bool": {
+      const truth = isTruthySql(evalExpr(expr.expr, ctx));
+      if (!expr.not && expr.sense) return booleanValue(truth === true);
+      if (!expr.not && !expr.sense) return booleanValue(truth === false);
+      if (expr.not && expr.sense) return booleanValue(truth !== true);
+      return booleanValue(truth !== false);
+    }
     case "binary":
       return evalBinary(expr.op, expr.left, expr.right, ctx);
     case "between": {
@@ -9038,8 +9061,13 @@ var ExecutionEnv = class {
           if (table === null) return !cell.hiddenByUsing;
           return (cell.tableLower ?? cell.table?.toLowerCase()) === tableKey;
         });
-        if (matches.length === 0)
+        if (matches.length === 0) {
+          if (table === null) {
+            if (key === "true") return 1;
+            if (key === "false") return 0;
+          }
           throw new SqliteError(`no such column: ${table ? `${table}.` : ""}${name}`, "no_such_column");
+        }
         if (matches.length > 1 && table === null) throw new SqliteError(`ambiguous column name: ${name}`, "other");
         return matches[0].value;
       },
@@ -9052,8 +9080,10 @@ var ExecutionEnv = class {
           if (table === null) return !cell2.hiddenByUsing;
           return (cell2.tableLower ?? cell2.table?.toLowerCase()) === tableKey;
         });
-        if (matches.length === 0)
+        if (matches.length === 0) {
+          if (table === null && (key === "true" || key === "false")) return "integer";
           throw new SqliteError(`no such column: ${table ? `${table}.` : ""}${name}`, "no_such_column");
+        }
         if (matches.length > 1 && table === null) throw new SqliteError(`ambiguous column name: ${name}`, "other");
         const cell = matches[0];
         return cell.affinity === "REAL" && typeof cell.value === "number" ? "real" : storageClassOf(cell.value);
@@ -9400,6 +9430,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 +9903,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);
@@ -9924,6 +10011,8 @@ function exprEquals(left, right) {
       return right.type === "column" && (left.table ?? "").toLowerCase() === (right.table ?? "").toLowerCase() && left.name.toLowerCase() === right.name.toLowerCase();
     case "unary":
       return right.type === "unary" && left.op === right.op && exprEquals(left.expr, right.expr);
+    case "is_bool":
+      return right.type === "is_bool" && left.not === right.not && left.sense === right.sense && exprEquals(left.expr, right.expr);
     case "binary":
       return right.type === "binary" && left.op === right.op && exprEquals(left.left, right.left) && exprEquals(left.right, right.right);
     case "function":
@@ -11071,7 +11160,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 +11169,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,
@@ -11387,6 +11477,9 @@ function validateProjectedColumns(stmt, sample, env, parent) {
       case "unary":
         recurse(expr.expr);
         break;
+      case "is_bool":
+        recurse(expr.expr);
+        break;
       case "binary":
         recurse(expr.left);
         recurse(expr.right);
@@ -11449,6 +11542,10 @@ function expressionName(expr) {
   if (expr.type === "binary") {
     return `${expressionName(expr.left)} ${expr.op} ${expressionName(expr.right)}`;
   }
+  if (expr.type === "is_bool") {
+    const sense = expr.sense ? "TRUE" : "FALSE";
+    return `${expressionName(expr.expr)} IS${expr.not ? " NOT" : ""} ${sense}`;
+  }
   return expr.type;
 }
 function replaceSpecial(expr, evaluate) {
@@ -11457,6 +11554,8 @@ function replaceSpecial(expr, evaluate) {
   switch (expr.type) {
     case "unary":
       return { ...expr, expr: recurse(expr.expr) };
+    case "is_bool":
+      return { ...expr, expr: recurse(expr.expr) };
     case "binary":
       return { ...expr, left: recurse(expr.left), right: recurse(expr.right) };
     case "between":