@crvouga/sqlite-mem 1.8.0 → 1.9.0

package/dist/indexes/index.d.ts

@@ -22,8 +22,23 @@ export declare class IndexStore {
     clear(): void;
     clone(): IndexStore;
     freeze(): void;
+    /** Sorted entries for SQLM v3 persistence. */
+    snapshotEntries(): Array<{
+        key: string;
+        rowids: Rowid[];
+        values: SqlValue[];
+    }>;
+    /** Sorted keys + rowids for SQLM v4 (values rebuilt from the table). */
+    snapshotKeys(): Array<{
+        key: string;
+        rowids: Rowid[];
+    }>;
+    rememberKeyValues(key: string, values: readonly SqlValue[]): void;
     get size(): number;
     private orderedKeys;
     private assertMutable;
 }
+/** Hash-join / covering-hash key: NULL components never match. */
 export declare function serializeIndexKey(values: readonly SqlValue[]): string | null;
+/** Index-store key: NULL is a distinct component so composite prefix lookups still hit. */
+export declare function serializeIndexEntry(values: readonly SqlValue[]): string;

package/dist/indexes/keys.d.ts

@@ -0,0 +1,20 @@
+import type { IndexedColumn } from "../ast/nodes.js";
+import type { EvalContext } from "../expressions/context.js";
+import type { IndexInfo } from "../storage/database-state.js";
+import { type Row } from "../storage/row.js";
+import type { Table } from "../storage/table.js";
+import type { Affinity, SqlValue } from "../types/value.js";
+/** Heap cells for evaluating index expressions / partial `WHERE` via `ExecutionEnv`. */
+export declare function heapRowCells(table: Table, row: Row): Array<{
+    table: string;
+    name: string;
+    value: SqlValue;
+    affinity: Affinity;
+    collate: string | null;
+}>;
+/** Indexed-column values for one heap row (expression indexes included when `ctx` is set). */
+export declare function indexKeyValues(columns: readonly IndexedColumn[], row: Row, ctx?: EvalContext | null, table?: Table): SqlValue[];
+/** Rebuild `index.store` from `table` using the same keys as DML maintenance. */
+export declare function rebuildIndexFromTable(index: IndexInfo, table: Table, ctxForRow: (row: Row) => EvalContext): void;
+/** Snapshot / no-`ExecutionEnv` evaluator for index expressions / partial predicates. */
+export declare function tableRowEvalContext(table: Table, row: Row): EvalContext;

package/dist/serialization/codec.d.ts

@@ -10,7 +10,7 @@ export interface SnapshotRuntime {
 export interface DecodedSnapshot {
     /** Restored catalog and table data. */
     state: DatabaseState;
-    /** Present for v2 snapshots; `null` for v1 (schema/rows only). */
+    /** Present for v2+ snapshots; `null` for v1 (schema/rows only). */
     runtime: SnapshotRuntime | null;
 }
 /**
@@ -18,7 +18,7 @@ export interface DecodedSnapshot {
  *
  * Prefer {@link Database.snapshot} unless you are serializing engine state directly.
  */
-export declare function encodeDatabaseState(state: DatabaseState, runtime: SnapshotRuntime): Uint8Array;
+export declare function encodeDatabaseState(state: DatabaseState, runtime: SnapshotRuntime, formatVersion?: number): Uint8Array;
 /**
  * Decode a blob from {@link encodeDatabaseState} / {@link Database.snapshot}.
  *

package/dist/storage/row.d.ts

@@ -1,10 +1,13 @@
 import type { SqlValue } from "../types/value.js";
 export type Rowid = number | bigint;
+/** Heap row: `values[i]` is `table.columns[i]`. */
 export interface Row {
     rowid: Rowid;
-    values: Map<string, SqlValue>;
+    values: SqlValue[];
 }
-export type RowValues = Map<string, SqlValue> | ReadonlyMap<string, SqlValue> | Record<string, SqlValue>;
+export type NamedRowValues = Map<string, SqlValue> | ReadonlyMap<string, SqlValue> | Record<string, SqlValue>;
+export type RowValues = NamedRowValues | readonly SqlValue[];
 export declare function normalizeColumnName(name: string): string;
-export declare function rowValues(values: RowValues): Map<string, SqlValue>;
+export declare function rowValues(values: NamedRowValues): Map<string, SqlValue>;
 export declare function cloneRow(row: Row): Row;
+export declare function isValueArray(values: RowValues): values is readonly SqlValue[];

package/dist/storage/table.d.ts

@@ -55,7 +55,16 @@ export declare class Table {
     /** Cached maximum rowid. `undefined` means recompute after deleting the maximum. */
     private maximumRowid;
     frozen: boolean;
+    /** nameLower → column index; rebuilt after ALTER. */
+    private colIndex;
     constructor(name: string, columns: ColumnInfo[], options?: TableOptions);
+    rebuildColIndex(): void;
+    columnOffset(nameLower: string): number | undefined;
+    hasColumn(nameLower: string): boolean;
+    cell(row: Row, nameLower: string): SqlValue;
+    setCell(row: Row, nameLower: string, value: SqlValue): void;
+    namedValues(row: Row): Map<string, SqlValue>;
+    rowFromNamed(values: Map<string, SqlValue>, rowid?: Rowid): Row;
     integerPkColumn(): ColumnInfo | undefined;
     get(rowid: Rowid): Row | undefined;
     getByKey(value: SqlValue): Row | undefined;
@@ -82,6 +91,7 @@ export declare class Table {
     private assertMutable;
     /** Rebuild clustered storage after snapshot decode or bulk load. */
     rebuildClusteredRows(): void;
+    private cellsFromInput;
     private prepareValues;
     private column;
     private validate;

package/dist/types/value.d.ts

@@ -72,7 +72,6 @@ export declare function sqlValueEquals(a: SqlValue, b: SqlValue): boolean;
  * Returns -1, 0, 1, or null if either side is NULL (SQL NULL).
  */
 export declare function compareSql(a: SqlValue, b: SqlValue): number | null;
-/** UTF-8 encode `s` (SQLite TEXT → BLOB). */
 export declare function utf8Encode(s: string): Uint8Array;
 /** UTF-8 decode `b` (SQLite BLOB → TEXT). */
 export declare function utf8Decode(b: Uint8Array): string;