flatsql 2.0.2 → 3.0.0

package/wasm/ps.d.ts

@@ -0,0 +1,21 @@
+// Types for wasm/ps.js (the partition store artifact, flatsql-ps-threads.wasm).
+
+export const FLATSQL_PS_THREADS_FILE: 'flatsql-ps-threads.wasm';
+
+/** URL of the packaged flatsql-ps-threads.wasm. */
+export function getFlatSQLPsThreadsURL(): URL;
+
+export interface LoadFlatSQLPsThreadsOptions {
+  url?: string | URL;
+  path?: string;
+  /** false skips the integrity.json check. */
+  verify?: boolean;
+  /** SHA-256 (hex) provider outside Node; back it with WASM or native crypto. Browser WebCrypto is intentionally not used. */
+  computeSHA256?: (bytes: Uint8Array) => string | Promise<string>;
+}
+
+/** The artifact's bytes, checked against integrity.json (Node, or with computeSHA256). */
+export function loadFlatSQLPsThreads(options?: LoadFlatSQLPsThreadsOptions): Promise<Uint8Array>;
+
+/** The artifact's sha256 (hex) from the packaged integrity.json, or null. */
+export function flatsqlPsThreadsSha256(): Promise<string | null>;

package/wasm/ps.js

@@ -0,0 +1,75 @@
+// The partition store artifact, flatsql-ps-threads.wasm (docs/PARTITION-STORE-WASM.md).
+//
+// A wasm32-wasip1-threads reactor: hosts instantiate it once per writer or
+// reader instance over a shared env.memory, provide WASI preview1,
+// wasi.thread-spawn and the seven env.flatsql_io_* imports, and drive it
+// through the flatsql_ps_* C ABI (cpp/include/flatsql/ps/flatsql_ps.h).
+// Node: flatsql/ps/node-host. Go/WasmEdge: the SDN host. Browsers: sdn-js.
+
+const PS_THREADS_URL = new URL('./flatsql-ps-threads.wasm', import.meta.url);
+
+/** File name of the artifact next to this module. */
+export const FLATSQL_PS_THREADS_FILE = 'flatsql-ps-threads.wasm';
+
+/** URL of the packaged flatsql-ps-threads.wasm. */
+export function getFlatSQLPsThreadsURL() {
+  return PS_THREADS_URL;
+}
+
+/**
+ * The artifact's bytes, checked against wasm/integrity.json: in Node with
+ * node:crypto, elsewhere with `computeSHA256` (bytes -> hex), which the caller
+ * backs with WASM or native crypto (browser WebCrypto is intentionally not
+ * used, as in wasm/index.js). A mismatch throws.
+ *
+ * @param {{ url?: string | URL, path?: string, verify?: boolean,
+ *   computeSHA256?: (bytes: Uint8Array) => string | Promise<string> }} [options]
+ * @returns {Promise<Uint8Array>}
+ */
+export async function loadFlatSQLPsThreads(options = {}) {
+  let bytes;
+  const url = options.url ? new URL(options.url, import.meta.url) : PS_THREADS_URL;
+  if (options.path || url.protocol === 'file:') {
+    const [{ readFile }, { fileURLToPath }] = await Promise.all([import('node:fs/promises'), import('node:url')]);
+    bytes = new Uint8Array(await readFile(options.path ?? fileURLToPath(url)));
+  } else {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`Failed to load ${FLATSQL_PS_THREADS_FILE}: ${response.status}`);
+    bytes = new Uint8Array(await response.arrayBuffer());
+  }
+  if (options.verify === false || options.url || options.path) return bytes;
+  const hash = options.computeSHA256 ?? (await nodeSha256());
+  if (!hash) return bytes;
+  const expected = await flatsqlPsThreadsSha256();
+  if (!expected) throw new Error(`integrity.json has no sha256 for ${FLATSQL_PS_THREADS_FILE}`);
+  const actual = await hash(bytes);
+  if (actual !== expected) {
+    throw new Error(`${FLATSQL_PS_THREADS_FILE}: sha256 ${actual} does not match integrity.json (${expected})`);
+  }
+  return bytes;
+}
+
+/** The artifact's sha256 (hex) from the packaged integrity.json, or null. */
+export async function flatsqlPsThreadsSha256() {
+  const integrityUrl = new URL('./integrity.json', import.meta.url);
+  let text;
+  try {
+    if (integrityUrl.protocol === 'file:') {
+      const [{ readFile }, { fileURLToPath }] = await Promise.all([import('node:fs/promises'), import('node:url')]);
+      text = await readFile(fileURLToPath(integrityUrl), 'utf8');
+    } else {
+      const response = await fetch(integrityUrl);
+      if (!response.ok) return null;
+      text = await response.text();
+    }
+  } catch {
+    return null;
+  }
+  return JSON.parse(text)?.files?.[FLATSQL_PS_THREADS_FILE]?.sha256 ?? null;
+}
+
+async function nodeSha256() {
+  if (!globalThis.process?.versions?.node) return null;
+  const { createHash } = await import('node:crypto');
+  return (bytes) => createHash('sha256').update(bytes).digest('hex');
+}

package/dist/artifacts/builder.d.ts

@@ -1,31 +0,0 @@
-import { type DatabaseSchema } from '../schema/index.js';
-import { type ArtifactFieldExtractor } from './demo-extractors.js';
-import type { ArtifactBuilderOptions, ArtifactIngestOptions, ArtifactQueryParams, ArtifactQuerySpec, ArtifactIngestResult, ArtifactQueryResult } from './types.js';
-export declare class FlatSQLArtifactBuilder {
-    private readonly schema;
-    private readonly db;
-    private readonly beginTransactionSql;
-    private readonly tableByName;
-    private readonly fileIdToTable;
-    private readonly extractors;
-    private readonly queryCache;
-    private readonly queryResultCache;
-    private sequence;
-    static fromSchema(source: string, options: ArtifactBuilderOptions): FlatSQLArtifactBuilder;
-    constructor(schema: DatabaseSchema, options: ArtifactBuilderOptions);
-    registerFileId(fileId: string, tableName: string): void;
-    setFieldExtractor(tableName: string, extractor: ArtifactFieldExtractor): void;
-    enableDemoExtractors(): void;
-    ingestBuffers(buffers: Uint8Array[], options?: ArtifactIngestOptions): ArtifactIngestResult;
-    query(sql: string, params?: ArtifactQueryParams): ArtifactQueryResult;
-    queryMany(queries: readonly ArtifactQuerySpec[]): ArtifactQueryResult[];
-    close(): void;
-    private createIndexTables;
-    private indexTableName;
-    private recordTableName;
-    private coveringIndexName;
-    private createCoveringIndexes;
-    private dropCoveringIndexes;
-    private createIngestPlan;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/artifacts/builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/artifacts/builder.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAIL,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EAEpB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAyYpB,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAe;IAClC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6C;IACxE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAItB;IACL,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA0C;IAC3E,OAAO,CAAC,QAAQ,CAAK;IAErB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,sBAAsB;gBAW9E,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,sBAAsB;IAcnE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAIvD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,sBAAsB,GAAG,IAAI;IAI7E,oBAAoB,IAAI,IAAI;IAM5B,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,OAAO,GAAE,qBAA0B,GAAG,oBAAoB;IA6C/F,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,mBAAmB;IAyCrE,SAAS,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,GAAG,mBAAmB,EAAE;IAIvE,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,gBAAgB;CAyCzB"}

package/dist/artifacts/builder.js

@@ -1,514 +0,0 @@
-import { availableParallelism } from 'node:os';
-import { DatabaseSync } from 'node:sqlite';
-import { parseSchema, SQLColumnType, } from '../schema/index.js';
-import { createArtifactFieldAppender, createArtifactFieldValueReader, demoExtractors, } from './demo-extractors.js';
-function toSqliteType(column) {
-    switch (column.sqlType) {
-        case SQLColumnType.INTEGER:
-            return 'INTEGER';
-        case SQLColumnType.REAL:
-            return 'REAL';
-        case SQLColumnType.TEXT:
-            return 'TEXT';
-        case SQLColumnType.BLOB:
-            return 'BLOB';
-        default:
-            return 'BLOB';
-    }
-}
-const decoder = new TextDecoder();
-const INSERT_BATCH_SIZE = 64;
-const DEFAULT_PAGE_SIZE = 32768;
-const DEFAULT_MMAP_SIZE = 268435456;
-const DEFAULT_CACHE_SIZE = -131072;
-const DEFAULT_THREAD_COUNT = Math.min(4, Math.max(2, availableParallelism()));
-const MAX_QUERY_STATEMENT_CACHE_ENTRIES = 256;
-const MAX_QUERY_RESULT_CACHE_ENTRIES = 1024;
-const MAX_QUERY_RESULT_CACHE_ROWS = 1000;
-const schemaCache = new Map();
-const VOLATILE_QUERY_PATTERNS = [
-    /\bRANDOM\s*\(/i,
-    /\bCHANGES\s*\(/i,
-    /\bTOTAL_CHANGES\s*\(/i,
-    /\bLAST_INSERT_ROWID\s*\(/i,
-    /\bCURRENT_(TIME|DATE|TIMESTAMP)\b/i,
-    /\bDATE\s*\(/i,
-    /\bTIME\s*\(/i,
-    /\bDATETIME\s*\(/i,
-    /\bJULIANDAY\s*\(/i,
-    /\bUNIXEPOCH\s*\(/i,
-    /\bSTRFTIME\s*\(/i,
-];
-function isCacheableQuerySql(sql) {
-    const trimmed = sql.trimStart();
-    if (trimmed.length === 0) {
-        return false;
-    }
-    const upper = trimmed.toUpperCase();
-    if (upper.startsWith('SELECT') || upper.startsWith('WITH')) {
-        return true;
-    }
-    return upper.startsWith('PRAGMA') && !trimmed.includes('=');
-}
-function isResultCacheableQuerySql(sql) {
-    return isCacheableQuerySql(sql) && !VOLATILE_QUERY_PATTERNS.some((pattern) => pattern.test(sql));
-}
-function normalizeRow(row, columns) {
-    return columns.map((column) => row[column]);
-}
-function cloneQueryResult(result) {
-    return {
-        columns: [...result.columns],
-        rows: result.rows.map((row) => [...row]),
-        rowCount: result.rowCount,
-    };
-}
-function encodeCacheValue(value) {
-    if (value === null) {
-        return { type: 'null' };
-    }
-    switch (typeof value) {
-        case 'string':
-            return { type: 'string', value };
-        case 'number':
-            return { type: 'number', value: Object.is(value, -0) ? '-0' : String(value) };
-        case 'bigint':
-            return { type: 'bigint', value: value.toString() };
-        case 'boolean':
-            return { type: 'boolean', value };
-        case 'undefined':
-            return { type: 'undefined' };
-        default:
-            return null;
-    }
-}
-function buildResultCacheKey(sql, params) {
-    if (!isResultCacheableQuerySql(sql)) {
-        return null;
-    }
-    if (params === undefined) {
-        return sql;
-    }
-    if (Array.isArray(params)) {
-        const encoded = params.map(encodeCacheValue);
-        if (encoded.some((value) => value === null)) {
-            return null;
-        }
-        return JSON.stringify({ sql, params: { type: 'array', values: encoded } });
-    }
-    const prototype = Object.getPrototypeOf(params);
-    if (prototype !== Object.prototype && prototype !== null) {
-        return null;
-    }
-    const namedParams = params;
-    const encodedEntries = [];
-    const keys = Object.keys(namedParams).sort();
-    for (const key of keys) {
-        const encodedValue = encodeCacheValue(namedParams[key]);
-        if (encodedValue === null) {
-            return null;
-        }
-        encodedEntries.push({ key, value: encodedValue });
-    }
-    return JSON.stringify({ sql, params: { type: 'object', entries: encodedEntries } });
-}
-function getCachedResult(cache, key) {
-    const cached = cache.get(key);
-    if (!cached) {
-        return undefined;
-    }
-    cache.delete(key);
-    cache.set(key, cached);
-    return cached;
-}
-function setCachedResult(cache, key, result) {
-    if (result.rowCount > MAX_QUERY_RESULT_CACHE_ROWS) {
-        cache.delete(key);
-        return;
-    }
-    cache.set(key, cloneQueryResult(result));
-    while (cache.size > MAX_QUERY_RESULT_CACHE_ENTRIES) {
-        const oldest = cache.keys().next().value;
-        if (oldest === undefined) {
-            break;
-        }
-        cache.delete(oldest);
-    }
-}
-function getCachedStatement(cache, key) {
-    const cached = cache.get(key);
-    if (!cached) {
-        return undefined;
-    }
-    cache.delete(key);
-    cache.set(key, cached);
-    return cached;
-}
-function setCachedStatement(cache, key, value) {
-    cache.set(key, value);
-    while (cache.size > MAX_QUERY_STATEMENT_CACHE_ENTRIES) {
-        const oldest = cache.keys().next().value;
-        if (oldest === undefined) {
-            break;
-        }
-        cache.delete(oldest);
-    }
-}
-function executeStatementAll(statement, params) {
-    if (params === undefined) {
-        return statement.all();
-    }
-    if (Array.isArray(params)) {
-        switch (params.length) {
-            case 0:
-                return statement.all();
-            case 1:
-                return statement.all(params[0]);
-            case 2:
-                return statement.all(params[0], params[1]);
-            case 3:
-                return statement.all(params[0], params[1], params[2]);
-            case 4:
-                return statement.all(params[0], params[1], params[2], params[3]);
-            default:
-                return statement.all(...params);
-        }
-    }
-    return statement.all(params);
-}
-function readFileId(data) {
-    if (data.length < 8) {
-        throw new Error('FlatBuffer payload is too short to contain a file identifier');
-    }
-    return decoder.decode(data.subarray(4, 8));
-}
-function readFileIdCode(data) {
-    if (data.length < 8) {
-        throw new Error('FlatBuffer payload is too short to contain a file identifier');
-    }
-    return (data[4] |
-        (data[5] << 8) |
-        (data[6] << 16) |
-        (data[7] << 24)) >>> 0;
-}
-function encodeFileId(fileId) {
-    if (fileId.length !== 4) {
-        throw new Error('FlatBuffer file identifiers must be four characters');
-    }
-    return (fileId.charCodeAt(0) |
-        (fileId.charCodeAt(1) << 8) |
-        (fileId.charCodeAt(2) << 16) |
-        (fileId.charCodeAt(3) << 24)) >>> 0;
-}
-function withTransaction(db, beginSql, operation) {
-    let started = false;
-    try {
-        db.exec(beginSql);
-        started = true;
-        const result = operation();
-        db.exec('COMMIT');
-        started = false;
-        return result;
-    }
-    catch (error) {
-        if (started) {
-            db.exec('ROLLBACK');
-        }
-        throw error;
-    }
-}
-function readPragmaText(db, name) {
-    const statement = db.prepare(`PRAGMA ${name}`);
-    const row = statement.get();
-    const value = row ? Object.values(row)[0] : undefined;
-    return typeof value === 'string' ? value.toLowerCase() : String(value ?? '').toLowerCase();
-}
-function applyPerformanceProfile(db, profile) {
-    db.exec(`PRAGMA page_size = ${DEFAULT_PAGE_SIZE}`);
-    db.exec(`PRAGMA threads = ${DEFAULT_THREAD_COUNT}`);
-    db.exec(`PRAGMA mmap_size = ${DEFAULT_MMAP_SIZE}`);
-    if (profile === 'safe') {
-        db.exec('PRAGMA journal_mode = DELETE');
-        db.exec('PRAGMA synchronous = FULL');
-        return 'BEGIN IMMEDIATE';
-    }
-    db.exec('PRAGMA journal_mode = OFF');
-    if (readPragmaText(db, 'journal_mode') !== 'off') {
-        db.exec('PRAGMA journal_mode = MEMORY');
-    }
-    db.exec('PRAGMA synchronous = OFF');
-    db.exec('PRAGMA locking_mode = EXCLUSIVE');
-    db.exec('PRAGMA temp_store = MEMORY');
-    db.exec(`PRAGMA cache_size = ${DEFAULT_CACHE_SIZE}`);
-    return 'BEGIN EXCLUSIVE';
-}
-function createArgumentAppender(fieldCount) {
-    switch (fieldCount) {
-        case 1:
-            return (pendingArgs, fieldValues, recordOffset, recordLength, sequence) => pendingArgs.push(fieldValues[0], recordOffset, recordLength, sequence);
-        case 2:
-            return (pendingArgs, fieldValues, recordOffset, recordLength, sequence) => pendingArgs.push(fieldValues[0], fieldValues[1], recordOffset, recordLength, sequence);
-        case 3:
-            return (pendingArgs, fieldValues, recordOffset, recordLength, sequence) => pendingArgs.push(fieldValues[0], fieldValues[1], fieldValues[2], recordOffset, recordLength, sequence);
-        case 4:
-            return (pendingArgs, fieldValues, recordOffset, recordLength, sequence) => pendingArgs.push(fieldValues[0], fieldValues[1], fieldValues[2], fieldValues[3], recordOffset, recordLength, sequence);
-        default:
-            return (pendingArgs, fieldValues, recordOffset, recordLength, sequence) => {
-                for (let index = 0; index < fieldValues.length; index += 1) {
-                    pendingArgs.push(fieldValues[index]);
-                }
-                pendingArgs.push(recordOffset, recordLength, sequence);
-            };
-    }
-}
-function buildInsertSql(recordTableName, fieldNames, rowCount) {
-    const columnNames = [...fieldNames.map((fieldName) => `"${fieldName}"`), 'data_offset', 'data_length', 'sequence'].join(', ');
-    const valueTuple = `(${Array.from({ length: fieldNames.length + 3 }, () => '?').join(', ')})`;
-    return `INSERT INTO "${recordTableName}" (${columnNames}) VALUES ${Array.from({ length: rowCount }, () => valueTuple).join(', ')}`;
-}
-function createBatchedRowWriter(db, recordTableName, fieldNames) {
-    const fullStatement = db.prepare(buildInsertSql(recordTableName, fieldNames, INSERT_BATCH_SIZE));
-    const partialStatements = new Map();
-    const appendArgs = createArgumentAppender(fieldNames.length);
-    let pendingArgs = [];
-    let pendingRowCount = 0;
-    function statementFor(rowCount) {
-        if (rowCount === INSERT_BATCH_SIZE) {
-            return fullStatement;
-        }
-        let statement = partialStatements.get(rowCount);
-        if (!statement) {
-            statement = db.prepare(buildInsertSql(recordTableName, fieldNames, rowCount));
-            partialStatements.set(rowCount, statement);
-        }
-        return statement;
-    }
-    function flushRows() {
-        if (pendingRowCount === 0) {
-            return;
-        }
-        statementFor(pendingRowCount).run(...pendingArgs);
-        pendingArgs = [];
-        pendingRowCount = 0;
-    }
-    return {
-        writeRow(fieldValues, recordOffset, recordLength, sequence) {
-            appendArgs(pendingArgs, fieldValues, recordOffset, recordLength, sequence);
-            pendingRowCount += 1;
-            if (pendingRowCount === INSERT_BATCH_SIZE) {
-                flushRows();
-            }
-        },
-        writeCompiledRow(appendFieldValues, data, recordOffset, recordLength, sequence) {
-            appendFieldValues(pendingArgs, data);
-            pendingArgs.push(recordOffset, recordLength, sequence);
-            pendingRowCount += 1;
-            if (pendingRowCount === INSERT_BATCH_SIZE) {
-                flushRows();
-            }
-        },
-        flushRows,
-    };
-}
-export class FlatSQLArtifactBuilder {
-    schema;
-    db;
-    beginTransactionSql;
-    tableByName = new Map();
-    fileIdToTable = new Map();
-    extractors = new Map();
-    queryCache = new Map();
-    queryResultCache = new Map();
-    sequence = 1;
-    static fromSchema(source, options) {
-        const schemaName = options.name ?? 'artifact';
-        const cacheKey = `${schemaName}\u0000${source}`;
-        let schema = schemaCache.get(cacheKey);
-        if (!schema) {
-            schema = parseSchema(source, schemaName);
-            schemaCache.set(cacheKey, schema);
-        }
-        return new FlatSQLArtifactBuilder(schema, options);
-    }
-    constructor(schema, options) {
-        if (!options.sqlitePath) {
-            throw new Error('Artifact builder requires sqlitePath');
-        }
-        this.schema = schema;
-        this.db = new DatabaseSync(options.sqlitePath);
-        this.beginTransactionSql = applyPerformanceProfile(this.db, options.performanceProfile ?? 'fast');
-        for (const table of schema.tables) {
-            this.tableByName.set(table.name, table);
-        }
-        this.createIndexTables();
-    }
-    registerFileId(fileId, tableName) {
-        this.fileIdToTable.set(encodeFileId(fileId), tableName);
-    }
-    setFieldExtractor(tableName, extractor) {
-        this.extractors.set(tableName, extractor);
-    }
-    enableDemoExtractors() {
-        for (const [tableName, extractor] of Object.entries(demoExtractors)) {
-            this.extractors.set(tableName, extractor);
-        }
-    }
-    ingestBuffers(buffers, options = {}) {
-        let currentOffset = options.startOffset ?? 0;
-        const plan = this.createIngestPlan();
-        this.queryCache.clear();
-        this.queryResultCache.clear();
-        withTransaction(this.db, this.beginTransactionSql, () => {
-            for (let index = 0; index < buffers.length; index++) {
-                const buffer = buffers[index];
-                const fileIdCode = readFileIdCode(buffer);
-                const tableName = this.fileIdToTable.get(fileIdCode);
-                if (!tableName) {
-                    const fileId = readFileId(buffer);
-                    throw new Error(`No table registered for file identifier ${fileId}`);
-                }
-                const tablePlan = plan.tablePlans.get(tableName);
-                if (!tablePlan) {
-                    throw new Error(`Table ${tableName} is not present in the parsed schema`);
-                }
-                if (!plan.touchedTables.has(tableName)) {
-                    this.dropCoveringIndexes(tablePlan.table);
-                    plan.touchedTables.add(tableName);
-                }
-                const recordOffset = options.offsets?.[index] ?? currentOffset;
-                tablePlan.writeRecord(buffer, recordOffset, buffer.length, this.sequence);
-                this.sequence += 1;
-                currentOffset = recordOffset + buffer.length;
-            }
-            for (const tableName of plan.touchedTables) {
-                const tablePlan = plan.tablePlans.get(tableName);
-                if (tablePlan) {
-                    tablePlan.flushRows();
-                    this.createCoveringIndexes(tablePlan.table);
-                }
-            }
-        });
-        return { recordCount: buffers.length };
-    }
-    query(sql, params) {
-        const resultCacheKey = buildResultCacheKey(sql, params);
-        const cachedResult = resultCacheKey ? getCachedResult(this.queryResultCache, resultCacheKey) : undefined;
-        if (cachedResult) {
-            return cloneQueryResult(cachedResult);
-        }
-        const cacheable = isCacheableQuerySql(sql);
-        let cached = cacheable ? getCachedStatement(this.queryCache, sql) : undefined;
-        if (!cached) {
-            const statement = this.db.prepare(sql);
-            const arrayMode = typeof statement.setReturnArrays === 'function';
-            if (arrayMode) {
-                statement.setReturnArrays(true);
-            }
-            const columns = statement.columns().map((column) => column.name);
-            cached = { statement, columns, arrayMode };
-            if (cacheable) {
-                setCachedStatement(this.queryCache, sql, cached);
-            }
-        }
-        const rawRows = executeStatementAll(cached.statement, params);
-        const rows = cached.arrayMode
-            ? rawRows
-            : rawRows.map((row) => normalizeRow(row, cached.columns));
-        const result = {
-            columns: [...cached.columns],
-            rows,
-            rowCount: rows.length,
-        };
-        if (resultCacheKey) {
-            setCachedResult(this.queryResultCache, resultCacheKey, result);
-        }
-        return resultCacheKey ? cloneQueryResult(result) : result;
-    }
-    queryMany(queries) {
-        return queries.map(({ sql, params }) => this.query(sql, params));
-    }
-    close() {
-        this.queryCache.clear();
-        this.queryResultCache.clear();
-        this.db.close();
-    }
-    createIndexTables() {
-        for (const table of this.schema.tables) {
-            const indexedColumns = table.columns.filter((column) => column.isIndexed && !column.name.startsWith('_'));
-            if (indexedColumns.length === 0) {
-                continue;
-            }
-            const columnDefinitions = indexedColumns
-                .map((column) => `"${column.name}" ${toSqliteType(column)} NOT NULL`)
-                .join(',\n            ');
-            this.db.exec(`CREATE TABLE IF NOT EXISTS "${this.recordTableName(table.name)}" (
-            ${columnDefinitions},
-            data_offset INTEGER NOT NULL,
-            data_length INTEGER NOT NULL,
-            sequence INTEGER NOT NULL
-          )`);
-            for (const column of indexedColumns) {
-                this.db.exec(`CREATE VIEW IF NOT EXISTS "${this.indexTableName(table.name, column.name)}" AS
-           SELECT "${column.name}" AS key, data_offset, data_length, sequence
-           FROM "${this.recordTableName(table.name)}"`);
-            }
-        }
-    }
-    indexTableName(tableName, columnName) {
-        return `_idx_${tableName}_${columnName}`;
-    }
-    recordTableName(tableName) {
-        return `_rows_${tableName}`;
-    }
-    coveringIndexName(tableName, columnName) {
-        return `_cov_${tableName}_${columnName}`;
-    }
-    createCoveringIndexes(table) {
-        for (const column of table.columns) {
-            if (!column.isIndexed || column.name.startsWith('_')) {
-                continue;
-            }
-            this.db.exec(`CREATE INDEX "${this.coveringIndexName(table.name, column.name)}"
-         ON "${this.recordTableName(table.name)}" ("${column.name}", sequence, data_offset, data_length)`);
-        }
-    }
-    dropCoveringIndexes(table) {
-        for (const column of table.columns) {
-            if (!column.isIndexed || column.name.startsWith('_')) {
-                continue;
-            }
-            this.db.exec(`DROP INDEX IF EXISTS "${this.coveringIndexName(table.name, column.name)}"`);
-        }
-    }
-    createIngestPlan() {
-        const tablePlans = new Map();
-        for (const [tableName, table] of this.tableByName.entries()) {
-            const extractor = this.extractors.get(tableName);
-            if (!extractor) {
-                continue;
-            }
-            const fieldNames = table.columns
-                .filter((column) => column.isIndexed && !column.name.startsWith('_'))
-                .map((column) => column.name);
-            if (fieldNames.length === 0) {
-                continue;
-            }
-            const recordTableName = this.recordTableName(table.name);
-            const rowWriter = createBatchedRowWriter(this.db, recordTableName, fieldNames);
-            const compiledAppender = createArtifactFieldAppender(extractor, fieldNames);
-            const extractRowValues = compiledAppender ? null : createArtifactFieldValueReader(extractor, fieldNames);
-            tablePlans.set(tableName, {
-                table,
-                writeRecord: compiledAppender
-                    ? (data, recordOffset, recordLength, sequence) => rowWriter.writeCompiledRow(compiledAppender, data, recordOffset, recordLength, sequence)
-                    : (data, recordOffset, recordLength, sequence) => rowWriter.writeRow(extractRowValues(data), recordOffset, recordLength, sequence),
-                flushRows: rowWriter.flushRows,
-            });
-        }
-        return {
-            tablePlans,
-            touchedTables: new Set(),
-        };
-    }
-}
-//# sourceMappingURL=builder.js.map