@undefineds.co/xpod 0.3.14 → 0.3.16

package/dist/storage/quint/SqliteQuintStore.js

@@ -4,6 +4,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
@@ -13,7 +14,11 @@ const schema_1 = require("./schema");
 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 {
     constructor(options) {
         this.sqlite = null;
@@ -47,20 +52,34 @@ class SqliteQuintStore {
         // 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,
-        PRIMARY KEY (graph, subject, predicate, object)
+        vector TEXT
       );
-
-      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);
+    `);
+        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);
     `);
     }
     async close() {
@@ -75,29 +94,8 @@ class SqliteQuintStore {
     // ============================================
     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 !== undefined) {
-            query = query.limit(options.limit);
-        }
-        if (options?.offset !== undefined) {
-            // SQLite requires LIMIT when using OFFSET
-            if (options?.limit === undefined) {
-                query = query.limit(SQLITE_UNBOUNDED_LIMIT);
-            }
-            query = query.offset(options.offset);
-        }
-        const rows = await query;
+        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) {
@@ -117,13 +115,9 @@ class SqliteQuintStore {
     }
     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;
+        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
@@ -284,137 +278,12 @@ class SqliteQuintStore {
      */
     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;
-            }
-            if (isObject) {
-                if ((0, serialization_1.isSerializedObjectValue)(value)) {
-                    return value;
-                }
-                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 (isObject && ops.$strStartsWith !== undefined) {
-                    const lexical = this.objectLexicalSql(fullColumn);
-                    conditions.push(`${lexical} >= ?`);
-                    conditions.push(`${lexical} < ?`);
-                    params.push(ops.$strStartsWith);
-                    params.push(ops.$strStartsWith + '\uffff');
-                }
-                if (isObject && ops.$strEndsWith !== undefined) {
-                    conditions.push(`${this.objectLexicalSql(fullColumn)} LIKE ?`);
-                    params.push(`%${ops.$strEndsWith}`);
-                }
-                if (isObject && ops.$strContains !== undefined) {
-                    conditions.push(`${this.objectLexicalSql(fullColumn)} LIKE ?`);
-                    params.push(`%${ops.$strContains}%`);
-                }
-                if (isObject && ops.$strRegex !== undefined) {
-                    conditions.push(`${this.objectLexicalSql(fullColumn)} GLOB ?`);
-                    params.push(ops.$strRegex.replace(/\.\*/g, '*').replace(/\./g, '?'));
-                }
-                if (isObject && ops.$language !== undefined) {
-                    conditions.push(`lower(${fullColumn}) LIKE ?`);
-                    params.push(ops.$language === '*' ? '%"@%' : `%"@${ops.$language.toLowerCase()}`);
-                }
-                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);
+        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;
     }
     // ============================================
@@ -423,43 +292,26 @@ class SqliteQuintStore {
     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 },
-        });
+        const statement = this.writeStatementForRow(row);
+        this.sqlite.prepare(statement.sql).run(...statement.params);
     }
     async multiPut(quintList) {
         this.ensureOpen();
         if (quintList.length === 0)
             return;
-        const rows = quintList.map(q => this.quintToRow(q));
+        const rows = quintList.map(q => this.writeStatementForRow(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();
+                this.sqlite.prepare(row.sql).run(...row.params);
             }
         })();
     }
     async updateEmbedding(pattern, embedding) {
         this.ensureOpen();
-        const conditions = this.buildConditions(pattern);
+        const { whereClause, params } = this.buildWhereClause(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));
+        const result = this.sqlite.prepare(`UPDATE quints SET vector = ?${whereClause}`).run(vectorJson, ...params);
         return result.changes;
     }
     // ============================================
@@ -467,13 +319,8 @@ class SqliteQuintStore {
     // ============================================
     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));
+        const { whereClause, params } = this.buildWhereClause(pattern);
+        const result = this.sqlite.prepare(`DELETE FROM quints${whereClause}`).run(...params);
         return result.changes;
     }
     async multiDel(quintList) {
@@ -486,9 +333,13 @@ class SqliteQuintStore {
                 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();
+                this.sqlite.prepare(`
+          DELETE FROM quints
+          WHERE graph = ?
+            AND subject = ?
+            AND predicate = ?
+            AND object = ?
+        `).run(g, s, p, o);
             }
         })();
     }
@@ -608,142 +459,524 @@ class SqliteQuintStore {
             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';
+    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}`);
+        }
+    }
+    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);
+        }
+    }
+    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 fpValue;
+                    return 'object_key';
                 }
-                return value;
+                return field;
+            }).join(', ');
+            query += ` ORDER BY ${orderCols}`;
+            if (options.reverse) {
+                query += ' DESC';
             }
-            if (isObject && !(0, serialization_1.isSerializedObjectValue)(value)) {
-                return `"${value}"`;
+        }
+        if (options?.limit !== undefined) {
+            query += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        if (options?.offset !== undefined) {
+            if (options.limit === undefined) {
+                query += ' LIMIT ?';
+                params.push(SQLITE_UNBOUNDED_LIMIT);
             }
-            return value;
+            query += ' OFFSET ?';
+            params.push(options.offset);
+        }
+        return { sql: query, params };
+    }
+    buildWhereClause(pattern) {
+        const conditions = [];
+        const params = [];
+        const predicate = this.extractExactPredicate(pattern.predicate);
+        this.addTermConditions(conditions, params, 'graph', pattern.graph, false);
+        this.addTermConditions(conditions, params, 'subject', pattern.subject, false);
+        this.addTermConditions(conditions, params, 'predicate', pattern.predicate, false);
+        if (pattern.object) {
+            this.addObjectConditions(conditions, params, undefined, pattern.object, predicate);
+        }
+        return {
+            whereClause: conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '',
+            params,
         };
-        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 (isObject && ops.$strStartsWith !== undefined) {
-                    const lexical = drizzle_orm_1.sql.raw(this.objectLexicalSql('object'));
-                    conditions.push((0, drizzle_orm_1.sql) `${lexical} >= ${ops.$strStartsWith}`);
-                    conditions.push((0, drizzle_orm_1.sql) `${lexical} < ${ops.$strStartsWith + '\uffff'}`);
-                }
-                if (isObject && ops.$strEndsWith !== undefined) {
-                    conditions.push((0, drizzle_orm_1.sql) `${drizzle_orm_1.sql.raw(this.objectLexicalSql('object'))} LIKE ${`%${ops.$strEndsWith}`}`);
-                }
-                if (isObject && ops.$strContains !== undefined) {
-                    conditions.push((0, drizzle_orm_1.sql) `${drizzle_orm_1.sql.raw(this.objectLexicalSql('object'))} LIKE ${`%${ops.$strContains}%`}`);
+    }
+    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`);
+        }
+    }
+    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);
                 }
-                if (isObject && ops.$strRegex !== undefined) {
-                    conditions.push((0, drizzle_orm_1.sql) `${drizzle_orm_1.sql.raw(this.objectLexicalSql('object'))} GLOB ${ops.$strRegex.replace(/\.\*/g, '*').replace(/\./g, '?')}`);
+                const fpValue = `N${serialization_1.SEP}${(0, serialization_1.fpEncode)(value)}`;
+                if (filterOp === '$gt' || filterOp === '$lte') {
+                    return fpValue + serialization_1.SEP + '\uffff';
                 }
-                if (isObject && ops.$language !== undefined) {
-                    conditions.push(ops.$language === '*'
-                        ? (0, drizzle_orm_1.sql) `lower(${column}) LIKE ${`%"@%`}`
-                        : (0, drizzle_orm_1.sql) `lower(${column}) LIKE ${`%"@${ops.$language.toLowerCase()}`}`);
+                return fpValue;
+            }
+            return value;
+        }
+        if (isObject && !(0, serialization_1.isSerializedObjectValue)(value)) {
+            return `"${value}"`;
+        }
+        return value;
+    }
+    addObjectConditions(conditions, params, alias, match, predicate) {
+        const column = (name) => alias ? `${alias}.${name}` : name;
+        if (typeof match === 'object' && 'termType' in match) {
+            this.addObjectExactCondition(conditions, params, column, match, predicate);
+            return;
+        }
+        const ops = match;
+        if (ops.$eq !== undefined) {
+            this.addObjectExactValueCondition(conditions, params, column, ops.$eq, '$eq', predicate);
+        }
+        if (ops.$ne !== undefined) {
+            this.addObjectExactValueCondition(conditions, params, column, ops.$ne, '$ne', predicate);
+        }
+        if (ops.$gt !== undefined) {
+            this.addObjectComparableCondition(conditions, params, column, '>', ops.$gt, '$gt', predicate);
+        }
+        if (ops.$gte !== undefined) {
+            this.addObjectComparableCondition(conditions, params, column, '>=', ops.$gte, '$gte', predicate);
+        }
+        if (ops.$lt !== undefined) {
+            this.addObjectComparableCondition(conditions, params, column, '<', ops.$lt, '$lt', predicate);
+        }
+        if (ops.$lte !== undefined) {
+            this.addObjectComparableCondition(conditions, params, column, '<=', ops.$lte, '$lte', predicate);
+        }
+        if (ops.$in !== undefined && ops.$in.length > 0) {
+            const predicates = ops.$in.map((value) => this.objectPredicateForOperatorValue(value, '$in', predicate));
+            const placeholders = predicates.map((item) => {
+                if (item.fields.objectKey === null) {
+                    return `(${column('object_kind')} = ? AND ${column('object_digest')} = ? AND ${column('object')} = ?)`;
                 }
-                if (ops.$isNull === true) {
-                    conditions.push((0, drizzle_orm_1.isNull)(column));
+                return `(${column('object_kind')} = ? AND ${column('object_key')} = ?)`;
+            }).join(' OR ');
+            conditions.push(`(${placeholders})`);
+            for (const item of predicates) {
+                if (item.fields.objectKey === null) {
+                    params.push(item.fields.objectKind, this.objectDigestForIndex(item.serialized, item.fields), item.serialized);
                 }
-                if (ops.$isNull === false) {
-                    conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                else {
+                    params.push(item.fields.objectKind, item.fields.objectKey);
                 }
             }
-        };
-        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;
+        }
+        if (ops.$notIn !== undefined && ops.$notIn.length > 0) {
+            for (const value of ops.$notIn) {
+                conditions.push(`${column('object')} != ?`);
+                params.push(this.objectPredicateForOperatorValue(value, '$notIn', predicate).serialized);
+            }
+        }
+        if (ops.$startsWith !== undefined) {
+            const fields = this.objectFieldsForPrefix(ops.$startsWith, predicate);
+            this.assertComparableObject(fields, '$startsWith');
+            conditions.push(`${column('object_kind')} = ?`);
+            params.push(fields.objectKind);
+            conditions.push(`${column('object_key')} >= ? AND ${column('object_key')} < ?`);
+            params.push(ops.$startsWith, ops.$startsWith + '\uffff');
+        }
+        if (ops.$endsWith !== undefined) {
+            this.addObjectTextCondition(conditions, params, column, 'LIKE', `%${ops.$endsWith}`, predicate);
+        }
+        if (ops.$contains !== undefined) {
+            this.addObjectTextCondition(conditions, params, column, 'LIKE', `%${ops.$contains}%`, predicate);
+        }
+        if (ops.$regex !== undefined) {
+            this.addObjectTextCondition(conditions, params, column, 'GLOB', ops.$regex.replace(/\.\*/g, '*').replace(/\./g, '?'), predicate);
+        }
+        if (ops.$strStartsWith !== undefined) {
+            this.addObjectLexicalStringCondition(conditions, params, column, 'startsWith', ops.$strStartsWith);
+        }
+        if (ops.$strEndsWith !== undefined) {
+            this.addObjectLexicalStringCondition(conditions, params, column, 'endsWith', ops.$strEndsWith);
+        }
+        if (ops.$strContains !== undefined) {
+            this.addObjectLexicalStringCondition(conditions, params, column, 'contains', ops.$strContains);
+        }
+        if (ops.$strRegex !== undefined) {
+            this.addObjectLexicalStringCondition(conditions, params, column, 'regex', ops.$strRegex);
+        }
+        if (ops.$language !== undefined) {
+            this.addObjectLanguageCondition(conditions, params, column, ops.$language);
+        }
+        if (ops.$isNull === true) {
+            conditions.push(`${column('object')} IS NULL`);
+        }
+        if (ops.$isNull === false) {
+            conditions.push(`${column('object')} IS NOT NULL`);
+        }
+    }
+    addObjectExactCondition(conditions, params, column, object, predicate) {
+        const serialized = (0, serialization_1.serializeObject)(object);
+        const fields = this.objectIndexForTerm(this.predicateForIndex(predicate), object);
+        this.addObjectExactSerializedCondition(conditions, params, column, serialized, fields);
+    }
+    addObjectExactValueCondition(conditions, params, column, value, op, predicate) {
+        const item = this.objectPredicateForOperatorValue(value, op, predicate);
+        if (op === '$ne') {
+            conditions.push(`${column('object')} != ?`);
+            params.push(item.serialized);
+            return;
+        }
+        this.addObjectExactSerializedCondition(conditions, params, column, item.serialized, item.fields);
+    }
+    addObjectExactSerializedCondition(conditions, params, column, serialized, fields) {
+        if (fields.objectKey !== null) {
+            conditions.push(`${column('object_kind')} = ?`);
+            params.push(fields.objectKind);
+            conditions.push(`${column('object_key')} = ?`);
+            params.push(fields.objectKey);
+            return;
+        }
+        conditions.push(`${column('object_kind')} = ?`);
+        params.push(fields.objectKind);
+        conditions.push(`${column('object_digest')} = ?`);
+        params.push(this.objectDigestForIndex(serialized, fields));
+        conditions.push(`${column('object')} = ?`);
+        params.push(serialized);
+    }
+    addObjectComparableCondition(conditions, params, column, sqlOperator, value, op, predicate) {
+        const item = this.objectPredicateForOperatorValue(value, op, predicate);
+        this.assertComparableObject(item.fields, op);
+        conditions.push(`${column('object_kind')} = ?`);
+        params.push(item.fields.objectKind);
+        conditions.push(`${column('object_key')} ${sqlOperator} ?`);
+        params.push(item.serialized);
+    }
+    addObjectTextCondition(conditions, params, column, sqlOperator, value, predicate) {
+        const declaredType = (0, value_types_1.getPredicateObjectDataType)(predicate, this.options.predicateObjectDataTypes);
+        if (declaredType) {
+            if (!['text', 'longText', 'literal'].includes(declaredType)) {
+                throw new Error(`Object text search is not supported for ${declaredType}`);
+            }
+            conditions.push(`${column('object_kind')} = ?`);
+            params.push(declaredType);
+        }
+        conditions.push(`${column('object_text')} ${sqlOperator} ?`);
+        params.push(value);
+    }
+    addObjectLexicalStringCondition(conditions, params, column, op, value) {
+        const lexical = this.objectLexicalSql(column);
+        if (op === 'startsWith') {
+            conditions.push(`(${lexical} >= ? AND ${lexical} < ?)`);
+            params.push(value, value + '\uffff');
+            return;
+        }
+        if (op === 'endsWith') {
+            conditions.push(`${lexical} LIKE ?`);
+            params.push(`%${value}`);
+            return;
+        }
+        if (op === 'contains') {
+            conditions.push(`${lexical} LIKE ?`);
+            params.push(`%${value}%`);
+            return;
+        }
+        conditions.push(`${lexical} GLOB ?`);
+        params.push(value.replace(/\.\*/g, '*').replace(/\./g, '?'));
+    }
+    addObjectLanguageCondition(conditions, params, column, lang) {
+        const languageLiteralKinds = `${column('object_kind')} IN ('text', 'longText', 'literal')`;
+        if (lang === '*') {
+            conditions.push(`(${languageLiteralKinds} AND lower(${column('object')}) LIKE ?)`);
+            params.push('%"@%');
+            return;
+        }
+        conditions.push(`(${languageLiteralKinds} AND (lower(${column('object')}) LIKE ? OR lower(${column('object')}) LIKE ?))`);
+        params.push(`%"@${lang.toLowerCase()}`, `%"@${lang.toLowerCase()}-%`);
     }
     objectLexicalSql(column) {
+        const object = column('object');
         return `CASE
-      WHEN ${column} LIKE '"%"@%' THEN substr(${column}, 2, instr(substr(${column}, 2), '"') - 1)
-      WHEN ${column} LIKE '"%"^^%' THEN substr(${column}, 2, instr(substr(${column}, 2), '"') - 1)
-      WHEN ${column} LIKE '"%"' THEN substr(${column}, 2, length(${column}) - 2)
-      WHEN ${column} LIKE 'N${serialization_1.SEP}%' THEN substr(${column}, length('N${serialization_1.SEP}') + instr(substr(${column}, length('N${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + instr(substr(${column}, length('N${serialization_1.SEP}') + instr(substr(${column}, length('N${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + 1)
-      WHEN ${column} LIKE 'D${serialization_1.SEP}%' THEN substr(${column}, length('D${serialization_1.SEP}') + instr(substr(${column}, length('D${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + 1)
-      ELSE ${column}
+      WHEN ${column('object_text')} IS NOT NULL THEN ${column('object_text')}
+      WHEN ${column('object_kind')} IN ('iri', 'blankNode') THEN ${column('object_key')}
+      WHEN ${column('object_kind')} = 'numeric' THEN substr(${object}, length('N${serialization_1.SEP}') + instr(substr(${object}, length('N${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + instr(substr(${object}, length('N${serialization_1.SEP}') + instr(substr(${object}, length('N${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + 1)
+      WHEN ${column('object_kind')} = 'dateTime' THEN substr(${object}, length('D${serialization_1.SEP}') + instr(substr(${object}, length('D${serialization_1.SEP}') + 1), '${serialization_1.SEP}') + 1)
+      ELSE NULL
     END`;
     }
+    objectPredicateForOperatorValue(value, op, predicate) {
+        const serialized = this.serializeOpValue(value, true, op);
+        return {
+            serialized,
+            fields: this.objectFieldsForOperatorValue(value, serialized, op, predicate),
+        };
+    }
+    objectFieldsForOperatorValue(value, serialized, op, predicate) {
+        const declaredType = (0, value_types_1.getPredicateObjectDataType)(predicate, this.options.predicateObjectDataTypes);
+        if (declaredType) {
+            if (declaredType === 'longText') {
+                return { objectKind: 'longText', objectKey: null, objectText: String(value) };
+            }
+            return { objectKind: declaredType, objectKey: serialized, objectText: null };
+        }
+        if (typeof value === 'number' && !['$eq', '$ne', '$in', '$notIn'].includes(op)) {
+            return { objectKind: 'numeric', objectKey: serialized, objectText: null };
+        }
+        if (!['$eq', '$ne', '$in', '$notIn'].includes(op)) {
+            if ((0, serialization_1.isSerializedNumericLiteral)(serialized)) {
+                return { objectKind: 'numeric', objectKey: serialized, objectText: null };
+            }
+            if ((0, serialization_1.isSerializedDateTimeLiteral)(serialized)) {
+                return { objectKind: 'dateTime', objectKey: serialized, objectText: null };
+            }
+        }
+        return this.objectIndexForSerialized(predicate, serialized);
+    }
+    objectIndexForTerm(predicate, object) {
+        return (0, value_types_1.objectIndexFieldsFromTerm)(object, {
+            predicate,
+            predicateObjectDataTypes: this.options.predicateObjectDataTypes,
+            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) {
+            if (declaredType === 'longText') {
+                return { objectKind: 'longText', objectKey: null, objectText: prefix };
+            }
+            return { objectKind: declaredType, objectKey: prefix, objectText: null };
+        }
+        if ((0, serialization_1.isSerializedNumericLiteral)(prefix)) {
+            return { objectKind: 'numeric', objectKey: prefix, objectText: null };
+        }
+        if ((0, serialization_1.isSerializedDateTimeLiteral)(prefix)) {
+            return { objectKind: 'dateTime', objectKey: prefix, objectText: null };
+        }
+        if (prefix.startsWith('"')) {
+            return { objectKind: 'text', objectKey: prefix, objectText: null };
+        }
+        if (prefix.startsWith('_:')) {
+            return { objectKind: 'blankNode', objectKey: prefix, objectText: null };
+        }
+        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;
+    }
+    writeStatementForRow(row) {
+        const params = [
+            row.objectKind,
+            row.objectKey,
+            row.objectText,
+            row.objectDigest,
+            row.graph,
+            row.subject,
+            row.predicate,
+            row.object,
+            row.vector,
+        ];
+        if (row.objectKey !== null) {
+            return {
+                sql: `
+          INSERT INTO quints (
+            object_kind, object_key, object_text, object_digest,
+            graph, subject, predicate, object, vector
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT (graph, subject, predicate, object_kind, object_key)
+            WHERE object_key IS NOT NULL
+          DO UPDATE SET
+            vector = excluded.vector,
+            object_text = excluded.object_text,
+            object_digest = excluded.object_digest
+          WHERE quints.object = excluded.object
+        `,
+                params,
+            };
+        }
+        return {
+            sql: `
+        INSERT INTO quints (
+          object_kind, object_key, object_text, object_digest,
+          graph, subject, predicate, object, vector
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT (graph, subject, predicate, object_kind, object_digest)
+          WHERE object_digest IS NOT NULL
+        DO UPDATE SET
+          vector = excluded.vector,
+          object_text = excluded.object_text
+        WHERE quints.object = excluded.object
+      `,
+            params,
+        };
+    }
     quintToRow(quint) {
+        const predicate = (0, serialization_1.termToId)(quint.predicate);
+        const object = (0, serialization_1.serializeObject)(quint.object);
+        const objectIndex = this.objectIndexForTerm(predicate, quint.object);
         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),
+            predicate,
+            object,
             vector: quint.vector ? JSON.stringify(quint.vector) : null,
+            objectKind: objectIndex.objectKind,
+            objectKey: objectIndex.objectKey,
+            objectText: objectIndex.objectText,
+            objectDigest: this.objectDigestForIndex(object, objectIndex),
         };
     }
     rowToQuint(row) {