@crvouga/sqlite-mem 1.1.1 → 1.1.2

package/README.md

@@ -218,6 +218,8 @@ Goal: drop-in SQL behavior vs SQLite **3.51.0**. Full matrix: [COMPATIBILITY.md]
 - `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`, …), 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
 
 1. **Do not `await`** — the API is sync.

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/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);
@@ -9981,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":
@@ -11445,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);
@@ -11507,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) {
@@ -11515,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":