@undefineds.co/xpod 0.3.25 → 0.3.26

package/dist/storage/quint/SqliteQuintStore.js

@@ -7,363 +7,206 @@ exports.SqliteQuintStore = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const drizzle_orm_1 = require("drizzle-orm");
-const asynciterator_1 = require("asynciterator");
-const n3_1 = require("n3");
-const schema_1 = require("./schema");
+const BaseQuintStore_1 = require("./BaseQuintStore");
 const serialization_1 = require("./serialization");
 const SqliteRuntime_1 = require("../SqliteRuntime");
-const types_1 = require("./types");
 const value_types_1 = require("./value-types");
 const SQLITE_UNBOUNDED_LIMIT = Number.MAX_SAFE_INTEGER;
 function digestObject(value) {
     return (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
 }
-class SqliteQuintStore {
+class SqliteExecutor {
+    constructor(db) {
+        this.db = db;
+    }
+    async query(sqlText, params) {
+        return this.db.prepare(sqlText).all(...(params ?? []));
+    }
+    async execute(sqlText, params) {
+        return this.db.prepare(sqlText).run(...(params ?? [])).changes;
+    }
+    async executeInTransaction(statements) {
+        this.db.transaction(() => {
+            for (const statement of statements) {
+                this.db.prepare(statement.sql).run(...(statement.params ?? []));
+            }
+        })();
+    }
+    async exec(sqlText) {
+        this.db.exec(sqlText);
+    }
+}
+class SqliteQuintStore extends BaseQuintStore_1.BaseQuintStore {
     constructor(options) {
+        const path = options.path.startsWith('sqlite:') ? options.path.slice(7) : options.path;
+        super(options);
         this.sqlite = null;
-        this.db = null;
         this.sqliteRuntime = (0, SqliteRuntime_1.getSqliteRuntime)();
-        // Handle sqlite: prefix
-        let path = options.path;
-        if (path.startsWith('sqlite:')) {
-            path = path.slice(7);
-        }
-        this.options = { ...options, path };
-    }
-    // ============================================
-    // Lifecycle
-    // ============================================
-    async open() {
-        // Idempotent: if already open, do nothing
-        if (this.sqlite) {
-            return;
-        }
-        const dbPath = this.options.path;
-        // Ensure directory exists (unless it's in-memory)
+        this.path = path;
+    }
+    async createExecutor() {
+        const dbPath = this.path;
         if (dbPath !== ':memory:') {
             const dir = (0, node_path_1.dirname)(dbPath);
-            if (!(0, node_fs_1.existsSync)(dir)) {
+            if (dir && !(0, node_fs_1.existsSync)(dir)) {
                 (0, node_fs_1.mkdirSync)(dir, { recursive: true });
             }
         }
         this.sqlite = this.sqliteRuntime.openDatabase(dbPath);
-        this.db = this.sqliteRuntime.createDrizzleDatabase(this.sqlite);
-        // Create table and indexes
-        this.sqlite.exec(`
-      CREATE TABLE IF NOT EXISTS quints (
-        object_kind TEXT,
-        object_key TEXT,
-        object_text TEXT,
-        object_digest TEXT,
-        graph TEXT NOT NULL,
-        subject TEXT NOT NULL,
-        predicate TEXT NOT NULL,
-        object TEXT NOT NULL,
-        vector TEXT
-      );
-    `);
-        this.ensureTypedObjectSchema();
-        this.sqlite.exec(`
-      CREATE INDEX IF NOT EXISTS idx_quints_graph ON quints (graph);
-      CREATE INDEX IF NOT EXISTS idx_quints_subject ON quints (subject);
-      CREATE INDEX IF NOT EXISTS idx_quints_predicate ON quints (predicate);
-      CREATE INDEX IF NOT EXISTS idx_quints_object_key ON quints (object_kind, object_key);
-      CREATE INDEX IF NOT EXISTS idx_quints_predicate_object_key ON quints (predicate, object_kind, object_key);
-      CREATE INDEX IF NOT EXISTS idx_quints_predicate_object_digest ON quints (predicate, object_kind, object_digest);
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_quints_gspo_key
-        ON quints (graph, subject, predicate, object_kind, object_key)
-        WHERE object_key IS NOT NULL;
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_quints_gspo_digest
-        ON quints (graph, subject, predicate, object_kind, object_digest)
-        WHERE object_digest IS NOT NULL;
-      CREATE INDEX IF NOT EXISTS idx_quints_gsp ON quints (graph, subject, predicate);
-      CREATE INDEX IF NOT EXISTS idx_quints_sp ON quints (subject, predicate);
-      CREATE INDEX IF NOT EXISTS idx_quints_gp ON quints (graph, predicate);
-    `);
+        return new SqliteExecutor(this.sqlite);
     }
-    async close() {
+    async closeExecutor() {
         if (this.sqlite) {
             this.sqlite.close();
             this.sqlite = null;
-            this.db = null;
         }
     }
-    // ============================================
-    // Query Operations
-    // ============================================
-    async get(pattern, options) {
-        this.ensureOpen();
-        const { sql: query, params } = this.buildSelectQuery(pattern, options);
-        const rows = this.sqlite.prepare(query).all(...params);
-        return rows.map((row) => this.rowToQuint(row));
-    }
-    match(subject, predicate, object, graph) {
-        const pattern = {};
-        if (subject)
-            pattern.subject = subject;
-        if (predicate)
-            pattern.predicate = predicate;
-        if (object)
-            pattern.object = object;
-        if (graph)
-            pattern.graph = graph;
-        return (0, asynciterator_1.wrap)(this.get(pattern));
-    }
-    async getByGraphPrefix(prefix, options) {
-        return this.get({ graph: { $startsWith: prefix } }, options);
-    }
-    async count(pattern) {
-        this.ensureOpen();
-        const { whereClause, params } = this.buildWhereClause(pattern);
-        const result = this.sqlite.prepare(`SELECT COUNT(*) AS count FROM quints${whereClause}`).get(...params);
-        return Number(result?.count ?? 0);
-    }
-    /**
-     * Compound query - multiple patterns JOINed by a common field
-     * This executes a single SQL query with JOINs, letting SQLite optimize the execution plan
-     */
-    async getCompound(compound, options) {
-        this.ensureOpen();
-        const { patterns, joinOn, select } = compound;
-        if (patterns.length === 0) {
-            return [];
-        }
-        if (patterns.length === 1) {
-            // Single pattern, fall back to regular get
-            const quads = await this.get(patterns[0], options);
-            return quads.map(q => ({
-                joinValue: (0, serialization_1.termToId)(q[joinOn]),
-                bindings: {},
-                quads: [q],
-            }));
-        }
-        // Build JOIN SQL
-        const { sql: sqlQuery, params } = this.buildCompoundSQL(compound, options);
-        if (this.options.debug) {
-            console.log('[SqliteQuintStore] Compound SQL:', sqlQuery);
-            console.log('[SqliteQuintStore] Params:', params);
-        }
-        // Execute raw SQL
-        const stmt = this.sqlite.prepare(sqlQuery);
-        const rows = stmt.all(...params);
-        // Convert rows to CompoundResult
-        return rows.map(row => {
-            const bindings = {};
-            // Extract bindings based on select config or default naming
-            if (select) {
-                for (const s of select) {
-                    bindings[s.alias] = row[s.alias];
-                }
-            }
-            else {
-                // Default: include all fields from all patterns
-                for (const key of Object.keys(row)) {
-                    if (key !== 'join_value') {
-                        bindings[key] = row[key];
-                    }
-                }
-            }
-            return {
-                joinValue: row.join_value,
-                bindings,
-            };
-        });
-    }
-    /**
-     * 批量获取多个 subject 的多个属性
-     *
-     * 用于优化 OPTIONAL 查询：避免每个 OPTIONAL 变成一次 LEFT JOIN
-     *
-     * SQL: SELECT subject, predicate, object FROM quints
-     *      WHERE subject IN (...) AND predicate IN (...)
-     */
-    async getAttributes(subjects, predicates, graph) {
-        this.ensureOpen();
-        if (subjects.length === 0 || predicates.length === 0) {
-            return new Map();
-        }
-        // Build SQL with IN clauses
-        const params = [];
-        let sql = `SELECT subject, predicate, object FROM quints WHERE subject IN (${subjects.map(() => '?').join(', ')}) AND predicate IN (${predicates.map(() => '?').join(', ')})`;
-        params.push(...subjects);
-        params.push(...predicates);
-        // Add graph filter if specified
-        if (graph && graph.termType !== 'DefaultGraph') {
-            sql += ` AND graph = ?`;
-            params.push((0, serialization_1.termToId)(graph));
-        }
-        if (this.options.debug) {
-            console.log('[SqliteQuintStore] getAttributes SQL:', sql);
-            console.log('[SqliteQuintStore] Params:', params.length, 'subjects:', subjects.length, 'predicates:', predicates.length);
-        }
-        const stmt = this.sqlite.prepare(sql);
-        const rows = stmt.all(...params);
-        // Build result map: subject -> predicate -> object[]
-        const result = new Map();
-        for (const row of rows) {
-            if (!result.has(row.subject)) {
-                result.set(row.subject, new Map());
-            }
-            const predicateMap = result.get(row.subject);
-            if (!predicateMap.has(row.predicate)) {
-                predicateMap.set(row.predicate, []);
+    async openOnce() {
+        const executor = await this.createExecutor();
+        this.executor = executor;
+        try {
+            await executor.exec(`
+        CREATE TABLE IF NOT EXISTS quints (
+          object_kind TEXT,
+          object_key TEXT,
+          object_text TEXT,
+          object_digest TEXT,
+          graph TEXT NOT NULL,
+          subject TEXT NOT NULL,
+          predicate TEXT NOT NULL,
+          object TEXT NOT NULL,
+          vector TEXT
+        );
+      `);
+            await this.ensureTypedObjectSchema();
+            await this.createTypedObjectIndexes();
+            this.opened = true;
+        }
+        catch (error) {
+            await this.closeExecutor().catch(() => { });
+            if (this.executor === executor) {
+                this.executor = null;
             }
-            // Deserialize object back to Term
-            const objectTerm = (0, serialization_1.deserializeObject)(row.object);
-            predicateMap.get(row.predicate).push(objectTerm);
-        }
-        if (this.options.debug) {
-            console.log('[SqliteQuintStore] getAttributes returned', result.size, 'subjects');
+            this.opened = false;
+            throw error;
         }
-        return result;
     }
-    /**
-     * Build SQL for compound query with JOINs
-     */
-    buildCompoundSQL(compound, options) {
-        const { patterns, joinOn, select } = compound;
-        const params = [];
-        // Map joinOn to column name
-        const joinColumn = joinOn; // 'subject' | 'predicate' | 'object' | 'graph'
-        // Build SELECT clause
-        let selectClause = `q0.${joinColumn} as join_value`;
-        if (select) {
-            for (const s of select) {
-                selectClause += `, q${s.pattern}.${s.field} as ${s.alias}`;
-            }
-        }
-        else {
-            // Default: select object from each pattern as p0_object, p1_object, etc.
-            for (let i = 0; i < patterns.length; i++) {
-                selectClause += `, q${i}.object as p${i}_object`;
-                selectClause += `, q${i}.predicate as p${i}_predicate`;
+    buildSelectQuery(pattern, options) {
+        const { whereClause, params } = this.buildWhereClause(pattern);
+        let sqlText = `SELECT * FROM quints${whereClause}`;
+        if (options?.order && options.order.length > 0) {
+            const orderCols = options.order.map(field => {
+                if (field === 'object') {
+                    const objectType = this.resolveObjectDataTypeForPattern(pattern);
+                    if (objectType === 'longText') {
+                        throw new Error('ORDER BY object is not supported for longText predicates');
+                    }
+                    return 'object_key';
+                }
+                return field;
+            }).join(', ');
+            sqlText += ` ORDER BY ${orderCols}`;
+            if (options.reverse) {
+                sqlText += ' DESC';
             }
         }
-        // Build FROM clause with JOINs
-        let fromClause = 'quints q0';
-        for (let i = 1; i < patterns.length; i++) {
-            fromClause += ` JOIN quints q${i} ON q0.${joinColumn} = q${i}.${joinColumn}`;
-            // Also join on graph to ensure same graph
-            fromClause += ` AND q0.graph = q${i}.graph`;
-        }
-        // Build WHERE clause
-        const whereParts = [];
-        for (let i = 0; i < patterns.length; i++) {
-            const pattern = patterns[i];
-            const alias = `q${i}`;
-            const conditions = this.buildConditionsForAlias(pattern, alias, params);
-            whereParts.push(...conditions);
-        }
-        let sql = `SELECT ${selectClause} FROM ${fromClause}`;
-        if (whereParts.length > 0) {
-            sql += ` WHERE ${whereParts.join(' AND ')}`;
-        }
-        // Add LIMIT/OFFSET
-        if (options?.limit) {
-            sql += ` LIMIT ?`;
+        if (options?.limit !== undefined) {
+            sqlText += ` LIMIT ?`;
             params.push(options.limit);
         }
-        if (options?.offset) {
-            if (!options?.limit) {
-                sql += ` LIMIT -1`;
+        if (options?.offset !== undefined) {
+            if (options.limit === undefined) {
+                sqlText += ` LIMIT ?`;
+                params.push(SQLITE_UNBOUNDED_LIMIT);
             }
-            sql += ` OFFSET ?`;
+            sqlText += ` OFFSET ?`;
             params.push(options.offset);
         }
-        return { sql, params };
+        return { sql: sqlText, params };
     }
-    /**
-     * Build WHERE conditions for a specific table alias
-     */
-    buildConditionsForAlias(pattern, alias, params) {
-        const conditions = [];
-        this.addTermConditions(conditions, params, `${alias}.graph`, pattern.graph, false);
-        this.addTermConditions(conditions, params, `${alias}.subject`, pattern.subject, false);
-        this.addTermConditions(conditions, params, `${alias}.predicate`, pattern.predicate, false);
-        if (pattern.object) {
-            this.addObjectConditions(conditions, params, alias, pattern.object, this.extractExactPredicate(pattern.predicate));
-        }
-        return conditions;
+    async stats() {
+        const stats = await super.stats();
+        return {
+            totalCount: Number(stats.totalCount),
+            vectorCount: Number(stats.vectorCount),
+            graphCount: Number(stats.graphCount),
+            ...this.sqliteSpaceStats(),
+        };
     }
-    // ============================================
-    // Write Operations
-    // ============================================
-    async put(quint) {
+    async clear() {
         this.ensureOpen();
-        const row = this.quintToRow(quint);
-        const statement = this.writeStatementForRow(row);
-        this.sqlite.prepare(statement.sql).run(...statement.params);
+        await this.executor.execute('DELETE FROM quints');
     }
-    async multiPut(quintList) {
-        this.ensureOpen();
-        if (quintList.length === 0)
-            return;
-        const rows = quintList.map(q => this.writeStatementForRow(this.quintToRow(q)));
-        // Use transaction for batch insert
-        this.sqlite.transaction(() => {
-            for (const row of rows) {
-                this.sqlite.prepare(row.sql).run(...row.params);
-            }
-        })();
+    async ensureTypedObjectSchema() {
+        await this.addColumnIfMissing('object_kind', 'TEXT');
+        await this.addColumnIfMissing('object_key', 'TEXT');
+        await this.addColumnIfMissing('object_text', 'TEXT');
+        await this.addColumnIfMissing('object_digest', 'TEXT');
+        for (const indexName of ['idx_spog', 'idx_ogsp', 'idx_gspo', 'idx_sopg', 'idx_pogs', 'idx_gpos']) {
+            await this.executor.exec(`DROP INDEX IF EXISTS ${indexName}`);
+        }
+        await this.backfillMissingObjectIndexFields();
+        await this.executor.exec(`
+      UPDATE quints
+      SET object_kind = 'text'
+      WHERE object_kind = 'shortText'
+    `);
     }
-    async updateEmbedding(pattern, embedding) {
-        this.ensureOpen();
-        const { whereClause, params } = this.buildWhereClause(pattern);
-        const vectorJson = JSON.stringify(embedding);
-        const result = this.sqlite.prepare(`UPDATE quints SET vector = ?${whereClause}`).run(vectorJson, ...params);
-        return result.changes;
-    }
-    // ============================================
-    // Delete Operations
-    // ============================================
-    async del(pattern) {
-        this.ensureOpen();
-        const { whereClause, params } = this.buildWhereClause(pattern);
-        const result = this.sqlite.prepare(`DELETE FROM quints${whereClause}`).run(...params);
-        return result.changes;
+    async addColumnIfMissing(name, definition) {
+        const columns = new Set(this.sqlite.prepare('PRAGMA table_info(quints)').all().map(row => row.name));
+        if (!columns.has(name)) {
+            await this.executor.exec(`ALTER TABLE quints ADD COLUMN ${name} ${definition}`);
+        }
     }
-    async multiDel(quintList) {
-        this.ensureOpen();
-        if (quintList.length === 0)
-            return;
-        this.sqlite.transaction(() => {
-            for (const quint of quintList) {
-                const g = (0, serialization_1.termToId)(quint.graph);
-                const s = (0, serialization_1.termToId)(quint.subject);
-                const p = (0, serialization_1.termToId)(quint.predicate);
-                const o = (0, serialization_1.serializeObject)(quint.object);
-                this.sqlite.prepare(`
-          DELETE FROM quints
-          WHERE graph = ?
-            AND subject = ?
-            AND predicate = ?
-            AND object = ?
-        `).run(g, s, p, o);
-            }
-        })();
+    async createTypedObjectIndexes() {
+        await this.executor.exec(`
+      CREATE INDEX IF NOT EXISTS idx_quints_graph ON quints (graph);
+      CREATE INDEX IF NOT EXISTS idx_quints_subject ON quints (subject);
+      CREATE INDEX IF NOT EXISTS idx_quints_predicate ON quints (predicate);
+      CREATE INDEX IF NOT EXISTS idx_quints_object_key ON quints (object_kind, object_key);
+      CREATE INDEX IF NOT EXISTS idx_quints_predicate_object_key ON quints (predicate, object_kind, object_key);
+      CREATE INDEX IF NOT EXISTS idx_quints_predicate_object_digest ON quints (predicate, object_kind, object_digest);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_quints_gspo_key
+        ON quints (graph, subject, predicate, object_kind, object_key)
+        WHERE object_key IS NOT NULL;
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_quints_gspo_digest
+        ON quints (graph, subject, predicate, object_kind, object_digest)
+        WHERE object_digest IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS idx_quints_gsp ON quints (graph, subject, predicate);
+      CREATE INDEX IF NOT EXISTS idx_quints_sp ON quints (subject, predicate);
+      CREATE INDEX IF NOT EXISTS idx_quints_gp ON quints (graph, predicate);
+    `);
     }
-    // ============================================
-    // Management
-    // ============================================
-    async stats() {
-        this.ensureOpen();
-        const totalResult = await this.db
-            .select({ count: (0, drizzle_orm_1.sql) `count(*)` })
-            .from(schema_1.quints);
-        const vectorResult = await this.db
-            .select({ count: (0, drizzle_orm_1.sql) `count(*)` })
-            .from(schema_1.quints)
-            .where((0, drizzle_orm_1.sql) `${schema_1.quints.vector} IS NOT NULL`);
-        const graphResult = await this.db
-            .select({ count: (0, drizzle_orm_1.sql) `COUNT(DISTINCT ${schema_1.quints.graph})` })
-            .from(schema_1.quints);
-        return {
-            totalCount: totalResult[0]?.count ?? 0,
-            vectorCount: vectorResult[0]?.count ?? 0,
-            graphCount: graphResult[0]?.count ?? 0,
-            ...this.sqliteSpaceStats(),
-        };
+    async backfillMissingObjectIndexFields() {
+        const rows = await this.executor.query(`
+      SELECT graph, subject, predicate, object
+      FROM quints
+      WHERE object_kind IS NULL
+         OR (object_key IS NULL AND object_digest IS NULL)
+    `);
+        for (const row of rows) {
+            const objectIndex = this.objectIndexForSerialized(row.predicate, row.object);
+            await this.executor.execute(`
+        UPDATE quints
+        SET object_kind = ?,
+            object_key = ?,
+            object_text = ?,
+            object_digest = ?
+        WHERE graph = ?
+          AND subject = ?
+          AND predicate = ?
+          AND object = ?
+      `, [
+                objectIndex.objectKind,
+                objectIndex.objectKey,
+                objectIndex.objectText,
+                this.objectDigestForIndex(row.object, objectIndex),
+                row.graph,
+                row.subject,
+                row.predicate,
+                row.object,
+            ]);
+        }
     }
     sqliteSpaceStats() {
         const spaceObjects = this.collectSpaceObjects();
@@ -447,94 +290,25 @@ class SqliteQuintStore {
             return 4096;
         }
     }
-    async clear() {
-        this.ensureOpen();
-        await this.db.delete(schema_1.quints);
-    }
-    // ============================================
-    // Private Helpers
-    // ============================================
-    ensureOpen() {
-        if (!this.db) {
-            throw new Error('Store not open. Call open() first.');
-        }
-    }
-    ensureTypedObjectSchema() {
-        this.addColumnIfMissing('object_kind', 'TEXT');
-        this.addColumnIfMissing('object_key', 'TEXT');
-        this.addColumnIfMissing('object_text', 'TEXT');
-        this.addColumnIfMissing('object_digest', 'TEXT');
-        for (const indexName of ['idx_spog', 'idx_ogsp', 'idx_gspo', 'idx_sopg', 'idx_pogs', 'idx_gpos']) {
-            this.sqlite.exec(`DROP INDEX IF EXISTS ${indexName}`);
-        }
-        this.backfillMissingObjectIndexFields();
-        this.sqlite.prepare(`
-      UPDATE quints
-      SET object_kind = 'text'
-      WHERE object_kind = 'shortText'
-    `).run();
-    }
-    addColumnIfMissing(name, definition) {
-        const columns = new Set(this.sqlite.prepare('PRAGMA table_info(quints)').all().map(row => row.name));
-        if (!columns.has(name)) {
-            this.sqlite.exec(`ALTER TABLE quints ADD COLUMN ${name} ${definition}`);
-        }
+    objectIndexForSerialized(predicate, object) {
+        return (0, value_types_1.objectIndexFieldsFromSerialized)(object, {
+            predicate,
+            predicateObjectDataTypes: this.options.predicateObjectDataTypes,
+            textMaxBytes: this.options.textMaxBytes,
+        });
     }
-    backfillMissingObjectIndexFields() {
-        const rows = this.sqlite.prepare(`
-      SELECT graph, subject, predicate, object
-      FROM quints
-      WHERE object_kind IS NULL
-         OR (object_key IS NULL AND object_digest IS NULL)
-    `).all();
-        const update = this.sqlite.prepare(`
-      UPDATE quints
-      SET object_kind = ?,
-          object_key = ?,
-          object_text = ?,
-          object_digest = ?
-      WHERE graph = ?
-        AND subject = ?
-        AND predicate = ?
-        AND object = ?
-    `);
-        for (const row of rows) {
-            const objectIndex = this.objectIndexForSerialized(row.predicate, row.object);
-            update.run(objectIndex.objectKind, objectIndex.objectKey, objectIndex.objectText, this.objectDigestForIndex(row.object, objectIndex), row.graph, row.subject, row.predicate, row.object);
-        }
+    objectDigestForIndex(serialized, fields) {
+        return fields.objectKey === null ? digestObject(serialized) : null;
     }
-    buildSelectQuery(pattern, options) {
-        const { whereClause, params } = this.buildWhereClause(pattern);
-        let query = `SELECT * FROM quints${whereClause}`;
-        if (options?.order && options.order.length > 0) {
-            const orderCols = options.order.map(field => {
-                if (field === 'object') {
-                    const objectType = this.resolveObjectDataTypeForPattern(pattern);
-                    if (objectType === 'longText') {
-                        throw new Error('ORDER BY object is not supported for longText predicates');
-                    }
-                    return 'object_key';
-                }
-                return field;
-            }).join(', ');
-            query += ` ORDER BY ${orderCols}`;
-            if (options.reverse) {
-                query += ' DESC';
-            }
-        }
-        if (options?.limit !== undefined) {
-            query += ' LIMIT ?';
-            params.push(options.limit);
+    resolveObjectDataTypeForPattern(pattern) {
+        const predicate = this.extractExactPredicate(pattern.predicate);
+        if (predicate) {
+            return (0, value_types_1.getPredicateObjectDataType)(predicate, this.options.predicateObjectDataTypes);
         }
-        if (options?.offset !== undefined) {
-            if (options.limit === undefined) {
-                query += ' LIMIT ?';
-                params.push(SQLITE_UNBOUNDED_LIMIT);
-            }
-            query += ' OFFSET ?';
-            params.push(options.offset);
+        if (pattern.object && typeof pattern.object === 'object' && 'termType' in pattern.object) {
+            return this.objectIndexForTerm(predicate, pattern.object).objectKind;
         }
-        return { sql: query, params };
+        return undefined;
     }
     buildWhereClause(pattern) {
         const conditions = [];
@@ -552,93 +326,15 @@ class SqliteQuintStore {
         };
     }
     addTermConditions(conditions, params, column, match, isObject) {
-        if (!match)
-            return;
-        if ((0, types_1.isTerm)(match)) {
-            conditions.push(`${column} = ?`);
-            params.push(isObject ? (0, serialization_1.serializeObject)(match) : (0, serialization_1.termToId)(match));
-            return;
-        }
-        const ops = match;
-        if (ops.$eq !== undefined) {
-            conditions.push(`${column} = ?`);
-            params.push(this.serializeOpValue(ops.$eq, isObject, '$eq'));
-        }
-        if (ops.$ne !== undefined) {
-            conditions.push(`${column} != ?`);
-            params.push(this.serializeOpValue(ops.$ne, isObject, '$ne'));
-        }
-        if (ops.$gt !== undefined) {
-            conditions.push(`${column} > ?`);
-            params.push(this.serializeOpValue(ops.$gt, isObject, '$gt'));
-        }
-        if (ops.$gte !== undefined) {
-            conditions.push(`${column} >= ?`);
-            params.push(this.serializeOpValue(ops.$gte, isObject, '$gte'));
-        }
-        if (ops.$lt !== undefined) {
-            conditions.push(`${column} < ?`);
-            params.push(this.serializeOpValue(ops.$lt, isObject, '$lt'));
-        }
-        if (ops.$lte !== undefined) {
-            conditions.push(`${column} <= ?`);
-            params.push(this.serializeOpValue(ops.$lte, isObject, '$lte'));
-        }
-        if (ops.$in !== undefined && ops.$in.length > 0) {
-            const placeholders = ops.$in.map(() => '?').join(', ');
-            conditions.push(`${column} IN (${placeholders})`);
-            params.push(...ops.$in.map(v => this.serializeOpValue(v, isObject, '$in')));
-        }
-        if (ops.$notIn !== undefined && ops.$notIn.length > 0) {
-            const placeholders = ops.$notIn.map(() => '?').join(', ');
-            conditions.push(`${column} NOT IN (${placeholders})`);
-            params.push(...ops.$notIn.map(v => this.serializeOpValue(v, isObject, '$notIn')));
-        }
-        if (ops.$startsWith !== undefined) {
-            conditions.push(`${column} >= ? AND ${column} < ?`);
-            params.push(ops.$startsWith, ops.$startsWith + '\uffff');
-        }
-        if (ops.$endsWith !== undefined) {
-            conditions.push(`${column} LIKE ?`);
-            params.push(`%${ops.$endsWith}`);
-        }
-        if (ops.$contains !== undefined) {
-            conditions.push(`${column} LIKE ?`);
-            params.push(`%${ops.$contains}%`);
-        }
-        if (ops.$regex !== undefined) {
-            conditions.push(`${column} GLOB ?`);
-            params.push(ops.$regex.replace(/\.\*/g, '*').replace(/\./g, '?'));
-        }
-        if (ops.$isNull === true) {
-            conditions.push(`${column} IS NULL`);
-        }
-        if (ops.$isNull === false) {
-            conditions.push(`${column} IS NOT NULL`);
-        }
+        this.addConditions(conditions, params, column, match, isObject);
     }
-    serializeOpValue(value, isObject, filterOp) {
-        if (typeof value === 'object' && 'termType' in value) {
-            return isObject ? (0, serialization_1.serializeObject)(value) : (0, serialization_1.termToId)(value);
-        }
-        if (typeof value === 'number') {
-            if (isObject) {
-                if (filterOp === '$eq' || filterOp === '$ne' || filterOp === '$in' || filterOp === '$notIn') {
-                    const lit = n3_1.DataFactory.literal(String(value), n3_1.DataFactory.namedNode('http://www.w3.org/2001/XMLSchema#integer'));
-                    return (0, serialization_1.serializeObject)(lit);
-                }
-                const fpValue = `N${serialization_1.SEP}${(0, serialization_1.fpEncode)(value)}`;
-                if (filterOp === '$gt' || filterOp === '$lte') {
-                    return fpValue + serialization_1.SEP + '\uffff';
-                }
-                return fpValue;
-            }
-            return value;
-        }
-        if (isObject && !(0, serialization_1.isSerializedObjectValue)(value)) {
-            return `"${value}"`;
+    addAliasedConditions(conditions, params, alias, pattern) {
+        this.addTermConditions(conditions, params, `${alias}.graph`, pattern.graph, false);
+        this.addTermConditions(conditions, params, `${alias}.subject`, pattern.subject, false);
+        this.addTermConditions(conditions, params, `${alias}.predicate`, pattern.predicate, false);
+        if (pattern.object) {
+            this.addObjectConditions(conditions, params, alias, pattern.object, this.extractExactPredicate(pattern.predicate));
         }
-        return value;
     }
     addObjectConditions(conditions, params, alias, match, predicate) {
         const column = (name) => alias ? `${alias}.${name}` : name;
@@ -843,7 +539,7 @@ class SqliteQuintStore {
                 return { objectKind: 'dateTime', objectKey: serialized, objectText: null };
             }
         }
-        return this.objectIndexForSerialized(predicate, serialized);
+        return this.objectIndexForSerialized(predicate ?? '', serialized);
     }
     objectIndexForTerm(predicate, object) {
         return (0, value_types_1.objectIndexFieldsFromTerm)(object, {
@@ -852,13 +548,6 @@ class SqliteQuintStore {
             textMaxBytes: this.options.textMaxBytes,
         });
     }
-    objectIndexForSerialized(predicate, object) {
-        return (0, value_types_1.objectIndexFieldsFromSerialized)(object, {
-            predicate,
-            predicateObjectDataTypes: this.options.predicateObjectDataTypes,
-            textMaxBytes: this.options.textMaxBytes,
-        });
-    }
     objectFieldsForPrefix(prefix, predicate) {
         const declaredType = (0, value_types_1.getPredicateObjectDataType)(predicate, this.options.predicateObjectDataTypes);
         if (declaredType) {
@@ -881,40 +570,28 @@ class SqliteQuintStore {
         }
         return { objectKind: 'iri', objectKey: prefix, objectText: null };
     }
-    objectDigestForIndex(serialized, fields) {
-        return fields.objectKey === null ? digestObject(serialized) : null;
-    }
     assertComparableObject(fields, op) {
         if (fields.objectKey !== null && fields.objectKind !== 'longText') {
             return;
         }
         throw new Error(`Object ${op} is not supported for ${fields.objectKind}; declare/use a comparable data type instead of longText`);
     }
-    extractExactPredicate(match) {
-        if (!match)
-            return undefined;
-        if (typeof match === 'object' && 'termType' in match) {
-            return (0, serialization_1.termToId)(match);
-        }
-        const ops = match;
-        if (ops.$eq !== undefined) {
-            return String(this.serializeOpValue(ops.$eq, false, '$eq'));
-        }
-        return undefined;
-    }
-    resolveObjectDataTypeForPattern(pattern) {
-        const predicate = this.extractExactPredicate(pattern.predicate);
-        if (predicate) {
-            return (0, value_types_1.getPredicateObjectDataType)(predicate, this.options.predicateObjectDataTypes);
-        }
-        if (pattern.object && typeof pattern.object === 'object' && 'termType' in pattern.object) {
-            return this.objectIndexForTerm(predicate, pattern.object).objectKind;
-        }
-        return undefined;
-    }
     predicateForIndex(predicate) {
         return predicate;
     }
+    async put(quint) {
+        this.ensureOpen();
+        const row = this.quintToRow(quint);
+        const statement = this.writeStatementForRow(row);
+        await this.executor.execute(statement.sql, statement.params);
+    }
+    async multiPut(quintList) {
+        this.ensureOpen();
+        if (quintList.length === 0)
+            return;
+        const statements = quintList.map(quint => this.writeStatementForRow(this.quintToRow(quint)));
+        await this.executor.executeInTransaction(statements);
+    }
     writeStatementForRow(row) {
         const params = [
             row.objectKind,