@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/storage/quint/SqliteQuintStore.js

@@ -0,0 +1,630 @@
+"use strict";
+/**
+ * SqliteQuintStore - SQLite implementation of QuintStore using Drizzle ORM
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteQuintStore = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const better_sqlite3_2 = require("drizzle-orm/better-sqlite3");
+const drizzle_orm_1 = require("drizzle-orm");
+const asynciterator_1 = require("asynciterator");
+const n3_1 = require("n3");
+const schema_1 = require("./schema");
+const serialization_1 = require("./serialization");
+const types_1 = require("./types");
+class SqliteQuintStore {
+    constructor(options) {
+        this.sqlite = null;
+        this.db = null;
+        // 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)
+        if (dbPath !== ':memory:') {
+            const dir = (0, node_path_1.dirname)(dbPath);
+            if (!(0, node_fs_1.existsSync)(dir)) {
+                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+            }
+        }
+        this.sqlite = new better_sqlite3_1.default(dbPath);
+        this.db = (0, better_sqlite3_2.drizzle)(this.sqlite);
+        // Create table and indexes
+        this.sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS quints (
+        graph TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        predicate TEXT NOT NULL,
+        object TEXT NOT NULL,
+        vector TEXT,
+        PRIMARY KEY (graph, subject, predicate, object)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_spog ON quints (subject, predicate, object, graph);
+      CREATE INDEX IF NOT EXISTS idx_ogsp ON quints (object, graph, subject, predicate);
+      CREATE INDEX IF NOT EXISTS idx_gspo ON quints (graph, subject, predicate, object);
+      CREATE INDEX IF NOT EXISTS idx_sopg ON quints (subject, object, predicate, graph);
+      CREATE INDEX IF NOT EXISTS idx_pogs ON quints (predicate, object, graph, subject);
+      CREATE INDEX IF NOT EXISTS idx_gpos ON quints (graph, predicate, object, subject);
+    `);
+    }
+    async close() {
+        if (this.sqlite) {
+            this.sqlite.close();
+            this.sqlite = null;
+            this.db = null;
+        }
+    }
+    // ============================================
+    // Query Operations
+    // ============================================
+    async get(pattern, options) {
+        this.ensureOpen();
+        const conditions = this.buildConditions(pattern);
+        let query = this.db.select().from(schema_1.quints);
+        if (conditions.length > 0) {
+            query = query.where((0, drizzle_orm_1.and)(...conditions));
+        }
+        // ORDER BY 支持
+        if (options?.order && options.order.length > 0) {
+            // 使用 sql 模板构建 ORDER BY
+            const orderCol = options.order[0]; // 目前只支持单列排序
+            const direction = options.reverse ? 'DESC' : 'ASC';
+            query = query.orderBy(drizzle_orm_1.sql.raw(`${orderCol} ${direction}`));
+        }
+        if (options?.limit) {
+            query = query.limit(options.limit);
+        }
+        if (options?.offset) {
+            // SQLite requires LIMIT when using OFFSET
+            if (!options?.limit) {
+                query = query.limit(-1); // -1 means no limit in SQLite
+            }
+            query = query.offset(options.offset);
+        }
+        const rows = await query;
+        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 conditions = this.buildConditions(pattern);
+        let query = this.db.select({ count: (0, drizzle_orm_1.sql) `count(*)` }).from(schema_1.quints);
+        if (conditions.length > 0) {
+            query = query.where((0, drizzle_orm_1.and)(...conditions));
+        }
+        const result = await query;
+        return result[0]?.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, []);
+            }
+            // 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');
+        }
+        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`;
+            }
+        }
+        // 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 ?`;
+            params.push(options.limit);
+        }
+        if (options?.offset) {
+            if (!options?.limit) {
+                sql += ` LIMIT -1`;
+            }
+            sql += ` OFFSET ?`;
+            params.push(options.offset);
+        }
+        return { sql, params };
+    }
+    /**
+     * Build WHERE conditions for a specific table alias
+     */
+    buildConditionsForAlias(pattern, alias, params) {
+        const conditions = [];
+        /**
+         * Serialize operator value for comparison
+         * - Term: use serializeObject/termToId
+         * - number: for exact match ($eq, $ne, $in, $notIn) use full serialization
+         *           for range comparison ($gt, $gte, $lt, $lte) use fpstring
+         * - string: assume already serialized or use as-is
+         */
+        const serializeOpValue = (value, isObject, filterOp) => {
+            if (typeof value === 'object' && 'termType' in value) {
+                // It's a Term - use full serialization
+                return isObject ? (0, serialization_1.serializeObject)(value) : (0, serialization_1.termToId)(value);
+            }
+            if (typeof value === 'number') {
+                if (isObject) {
+                    // For exact match operations, use full serialization (includes datatype and original value)
+                    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);
+                    }
+                    // For range comparisons, use fpstring
+                    const fpValue = `N${serialization_1.SEP}${(0, serialization_1.fpEncode)(value)}`;
+                    // $gt and $lte need max suffix to compare correctly
+                    if (filterOp === '$gt' || filterOp === '$lte') {
+                        return fpValue + serialization_1.SEP + '\uffff';
+                    }
+                    // $lt and $gte use prefix only
+                    return fpValue;
+                }
+                return value;
+            }
+            // String value
+            if (isObject) {
+                // Already serialized (starts with N\0 or D\0 or ")
+                if (value.startsWith('N\u0000') || value.startsWith('D\u0000') || value.startsWith('"')) {
+                    return value;
+                }
+                // Plain string - wrap as xsd:string literal
+                return `"${value}"`;
+            }
+            return value;
+        };
+        const addCondition = (column, match, isObject = false) => {
+            if (!match)
+                return;
+            const fullColumn = `${alias}.${column}`;
+            if ((0, types_1.isTerm)(match)) {
+                conditions.push(`${fullColumn} = ?`);
+                params.push(isObject ? (0, serialization_1.serializeObject)(match) : (0, serialization_1.termToId)(match));
+            }
+            else {
+                const ops = match;
+                if (ops.$eq !== undefined) {
+                    conditions.push(`${fullColumn} = ?`);
+                    params.push(serializeOpValue(ops.$eq, isObject, '$eq'));
+                }
+                if (ops.$ne !== undefined) {
+                    conditions.push(`${fullColumn} != ?`);
+                    params.push(serializeOpValue(ops.$ne, isObject, '$ne'));
+                }
+                if (ops.$gt !== undefined) {
+                    conditions.push(`${fullColumn} > ?`);
+                    params.push(serializeOpValue(ops.$gt, isObject, '$gt'));
+                }
+                if (ops.$gte !== undefined) {
+                    conditions.push(`${fullColumn} >= ?`);
+                    params.push(serializeOpValue(ops.$gte, isObject, '$gte'));
+                }
+                if (ops.$lt !== undefined) {
+                    conditions.push(`${fullColumn} < ?`);
+                    params.push(serializeOpValue(ops.$lt, isObject, '$lt'));
+                }
+                if (ops.$lte !== undefined) {
+                    conditions.push(`${fullColumn} <= ?`);
+                    params.push(serializeOpValue(ops.$lte, isObject, '$lte'));
+                }
+                if (ops.$in !== undefined && ops.$in.length > 0) {
+                    const placeholders = ops.$in.map(() => '?').join(', ');
+                    conditions.push(`${fullColumn} IN (${placeholders})`);
+                    params.push(...ops.$in.map(v => serializeOpValue(v, isObject, '$in')));
+                }
+                if (ops.$notIn !== undefined && ops.$notIn.length > 0) {
+                    const placeholders = ops.$notIn.map(() => '?').join(', ');
+                    conditions.push(`${fullColumn} NOT IN (${placeholders})`);
+                    params.push(...ops.$notIn.map(v => serializeOpValue(v, isObject, '$notIn')));
+                }
+                if (ops.$startsWith !== undefined) {
+                    conditions.push(`${fullColumn} >= ?`);
+                    conditions.push(`${fullColumn} < ?`);
+                    params.push(ops.$startsWith);
+                    params.push(ops.$startsWith + '\uffff');
+                }
+                if (ops.$endsWith !== undefined) {
+                    conditions.push(`${fullColumn} LIKE ?`);
+                    params.push(`%${ops.$endsWith}`);
+                }
+                if (ops.$contains !== undefined) {
+                    conditions.push(`${fullColumn} LIKE ?`);
+                    params.push(`%${ops.$contains}%`);
+                }
+                if (ops.$isNull === true) {
+                    conditions.push(`${fullColumn} IS NULL`);
+                }
+                if (ops.$isNull === false) {
+                    conditions.push(`${fullColumn} IS NOT NULL`);
+                }
+            }
+        };
+        addCondition('graph', pattern.graph);
+        addCondition('subject', pattern.subject);
+        addCondition('predicate', pattern.predicate);
+        addCondition('object', pattern.object, true);
+        return conditions;
+    }
+    // ============================================
+    // Write Operations
+    // ============================================
+    async put(quint) {
+        this.ensureOpen();
+        const row = this.quintToRow(quint);
+        await this.db.insert(schema_1.quints)
+            .values(row)
+            .onConflictDoUpdate({
+            target: [schema_1.quints.graph, schema_1.quints.subject, schema_1.quints.predicate, schema_1.quints.object],
+            set: { vector: row.vector },
+        });
+    }
+    async multiPut(quintList) {
+        this.ensureOpen();
+        if (quintList.length === 0)
+            return;
+        const rows = quintList.map(q => this.quintToRow(q));
+        // Use transaction for batch insert
+        this.sqlite.transaction(() => {
+            for (const row of rows) {
+                this.db.insert(schema_1.quints)
+                    .values(row)
+                    .onConflictDoUpdate({
+                    target: [schema_1.quints.graph, schema_1.quints.subject, schema_1.quints.predicate, schema_1.quints.object],
+                    set: { vector: row.vector },
+                })
+                    .run();
+            }
+        })();
+    }
+    async updateEmbedding(pattern, embedding) {
+        this.ensureOpen();
+        const conditions = this.buildConditions(pattern);
+        const vectorJson = JSON.stringify(embedding);
+        if (conditions.length === 0) {
+            const result = await this.db.update(schema_1.quints)
+                .set({ vector: vectorJson });
+            return result.changes;
+        }
+        const result = await this.db.update(schema_1.quints)
+            .set({ vector: vectorJson })
+            .where((0, drizzle_orm_1.and)(...conditions));
+        return result.changes;
+    }
+    // ============================================
+    // Delete Operations
+    // ============================================
+    async del(pattern) {
+        this.ensureOpen();
+        const conditions = this.buildConditions(pattern);
+        if (conditions.length === 0) {
+            // Delete all - dangerous!
+            const result = await this.db.delete(schema_1.quints);
+            return result.changes;
+        }
+        const result = await this.db.delete(schema_1.quints).where((0, drizzle_orm_1.and)(...conditions));
+        return result.changes;
+    }
+    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.db.delete(schema_1.quints)
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.quints.graph, g), (0, drizzle_orm_1.eq)(schema_1.quints.subject, s), (0, drizzle_orm_1.eq)(schema_1.quints.predicate, p), (0, drizzle_orm_1.eq)(schema_1.quints.object, o)))
+                    .run();
+            }
+        })();
+    }
+    // ============================================
+    // 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,
+        };
+    }
+    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.');
+        }
+    }
+    buildConditions(pattern) {
+        const conditions = [];
+        /**
+         * Serialize operator value for comparison
+         * - Term: use serializeObject/termToId
+         * - number: for exact match ($eq, $ne, $in, $notIn) use full serialization
+         *           for range comparison ($gt, $gte, $lt, $lte) use fpstring
+         * - string: assume already serialized or use as-is
+         */
+        const 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) {
+                    // For exact match operations, use full serialization (includes datatype and original value)
+                    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);
+                    }
+                    // For range comparisons, use fpstring
+                    const fpValue = `N${serialization_1.SEP}${(0, serialization_1.fpEncode)(value)}`;
+                    // $gt and $lte need max suffix
+                    if (filterOp === '$gt' || filterOp === '$lte') {
+                        return fpValue + serialization_1.SEP + '\uffff';
+                    }
+                    return fpValue;
+                }
+                return value;
+            }
+            // String - already serialized or plain string
+            if (isObject && !value.startsWith('N\u0000') && !value.startsWith('D\u0000') && !value.startsWith('"')) {
+                return `"${value}"`;
+            }
+            return value;
+        };
+        const addTermConditions = (column, match, isObject = false) => {
+            if (!match)
+                return;
+            if ((0, types_1.isTerm)(match)) {
+                // Exact Term match
+                conditions.push((0, drizzle_orm_1.eq)(column, isObject ? (0, serialization_1.serializeObject)(match) : (0, serialization_1.termToId)(match)));
+            }
+            else {
+                // Operator match
+                const ops = match;
+                if (ops.$eq !== undefined) {
+                    conditions.push((0, drizzle_orm_1.eq)(column, serializeOpValue(ops.$eq, isObject, '$eq')));
+                }
+                if (ops.$ne !== undefined) {
+                    conditions.push((0, drizzle_orm_1.ne)(column, serializeOpValue(ops.$ne, isObject, '$ne')));
+                }
+                if (ops.$gt !== undefined) {
+                    conditions.push((0, drizzle_orm_1.gt)(column, serializeOpValue(ops.$gt, isObject, '$gt')));
+                }
+                if (ops.$gte !== undefined) {
+                    conditions.push((0, drizzle_orm_1.gte)(column, serializeOpValue(ops.$gte, isObject, '$gte')));
+                }
+                if (ops.$lt !== undefined) {
+                    conditions.push((0, drizzle_orm_1.lt)(column, serializeOpValue(ops.$lt, isObject, '$lt')));
+                }
+                if (ops.$lte !== undefined) {
+                    conditions.push((0, drizzle_orm_1.lte)(column, serializeOpValue(ops.$lte, isObject, '$lte')));
+                }
+                if (ops.$in !== undefined && ops.$in.length > 0) {
+                    const serializedValues = ops.$in.map(v => serializeOpValue(v, isObject, '$in'));
+                    conditions.push((0, drizzle_orm_1.inArray)(column, serializedValues));
+                }
+                if (ops.$notIn !== undefined && ops.$notIn.length > 0) {
+                    const serializedValues = ops.$notIn.map(v => serializeOpValue(v, isObject, '$notIn'));
+                    conditions.push((0, drizzle_orm_1.notInArray)(column, serializedValues));
+                }
+                if (ops.$startsWith !== undefined) {
+                    // Use range query for prefix matching (index-friendly)
+                    conditions.push((0, drizzle_orm_1.gte)(column, ops.$startsWith));
+                    conditions.push((0, drizzle_orm_1.lt)(column, ops.$startsWith + '\uffff'));
+                }
+                if (ops.$endsWith !== undefined) {
+                    conditions.push((0, drizzle_orm_1.like)(column, `%${ops.$endsWith}`));
+                }
+                if (ops.$contains !== undefined) {
+                    conditions.push((0, drizzle_orm_1.like)(column, `%${ops.$contains}%`));
+                }
+                if (ops.$regex !== undefined) {
+                    // SQLite uses GLOB as regex approximation
+                    conditions.push((0, drizzle_orm_1.sql) `${column} GLOB ${ops.$regex.replace(/\.\*/g, '*').replace(/\./g, '?')}`);
+                }
+                if (ops.$isNull === true) {
+                    conditions.push((0, drizzle_orm_1.isNull)(column));
+                }
+                if (ops.$isNull === false) {
+                    conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                }
+            }
+        };
+        addTermConditions(schema_1.quints.graph, pattern.graph);
+        addTermConditions(schema_1.quints.subject, pattern.subject);
+        addTermConditions(schema_1.quints.predicate, pattern.predicate);
+        addTermConditions(schema_1.quints.object, pattern.object, true);
+        return conditions;
+    }
+    quintToRow(quint) {
+        return {
+            graph: (0, serialization_1.termToId)(quint.graph),
+            subject: (0, serialization_1.termToId)(quint.subject),
+            predicate: (0, serialization_1.termToId)(quint.predicate),
+            object: (0, serialization_1.serializeObject)(quint.object),
+            vector: quint.vector ? JSON.stringify(quint.vector) : null,
+        };
+    }
+    rowToQuint(row) {
+        const quad = (0, serialization_1.rowToQuad)(row);
+        const quint = quad;
+        if (row.vector) {
+            quint.vector = (0, serialization_1.parseVector)(row.vector);
+        }
+        return quint;
+    }
+}
+exports.SqliteQuintStore = SqliteQuintStore;
+//# sourceMappingURL=SqliteQuintStore.js.map