@undefineds.co/xpod 0.2.43 → 0.2.45

package/dist/storage/quint/PgQuintStore.js

@@ -12,7 +12,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PgQuintStore = void 0;
 const pglite_1 = require("@electric-sql/pglite");
+const node_crypto_1 = require("node:crypto");
 const BaseQuintStore_1 = require("./BaseQuintStore");
+const serialization_1 = require("./serialization");
+const value_types_1 = require("./value-types");
 const PostgresPoolManager_1 = require("../database/PostgresPoolManager");
 /**
  * PostgreSQL 兼容的分隔符
@@ -31,6 +34,9 @@ function toPgSafe(str) {
 function fromPgSafe(str) {
     return str.replace(new RegExp(PG_SEP, 'g'), '\u0000');
 }
+function digestObject(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(toPgSafe(value)).digest('hex');
+}
 /**
  * PGLite 执行器
  */
@@ -157,6 +163,7 @@ class PgQuintStore extends BaseQuintStore_1.BaseQuintStore {
         super(options);
         this.pglite = null;
         this.pgPool = null; // pg.Pool
+        this.sharedPoolConfig = null;
         this.pgOptions = {
             driver: 'pglite', // 默认使用 PGLite
             ...options,
@@ -167,17 +174,19 @@ class PgQuintStore extends BaseQuintStore_1.BaseQuintStore {
             // 使用共享的连接池（如果提供），避免死锁
             if (this.pgOptions.pool) {
                 this.pgPool = this.pgOptions.pool;
+                this.sharedPoolConfig = null;
                 return new PgExecutor(this.pgPool);
             }
             // 使用共享连接池管理器，避免多个组件创建独立连接池
-            this.pgPool = (0, PostgresPoolManager_1.getSharedPool)({
+            this.sharedPoolConfig = {
                 connectionString: this.pgOptions.connectionString,
                 host: this.pgOptions.host,
                 port: this.pgOptions.port,
                 database: this.pgOptions.database,
                 user: this.pgOptions.user,
                 password: this.pgOptions.password,
-            });
+            };
+            this.pgPool = (0, PostgresPoolManager_1.getSharedPool)(this.sharedPoolConfig);
             return new PgExecutor(this.pgPool);
         }
         else {
@@ -193,8 +202,14 @@ class PgQuintStore extends BaseQuintStore_1.BaseQuintStore {
             this.pglite = null;
         }
         if (this.pgPool) {
-            await this.pgPool.end();
+            if (this.sharedPoolConfig) {
+                (0, PostgresPoolManager_1.releaseSharedPool)(this.sharedPoolConfig);
+            }
+            else {
+                await this.pgPool.end();
+            }
             this.pgPool = null;
+            this.sharedPoolConfig = null;
         }
     }
     /**
@@ -208,43 +223,45 @@ class PgQuintStore extends BaseQuintStore_1.BaseQuintStore {
         // PostgreSQL 建表语法
         await this.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,
-        PRIMARY KEY (graph, subject, predicate, object)
+        vector TEXT
       )
     `);
+        await this.ensureTypedObjectSchema();
         const indexes = [
-            '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)',
+            '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)',
         ];
         for (const indexSql of indexes) {
             await this.executor.exec(indexSql);
         }
     }
     /**
-     * 重写 put 方法，使用 PostgreSQL 的 ON CONFLICT
+     * 重写 put 方法，避免长文本对象进入 PostgreSQL btree 唯一键
      */
     async put(quint) {
         this.ensureOpen();
-        const row = this.quintToRow(quint);
-        // PostgreSQL UPSERT 语法
-        const sql = `
-      INSERT INTO quints (graph, subject, predicate, object, vector) 
-      VALUES ($1, $2, $3, $4, $5)
-      ON CONFLICT (graph, subject, predicate, object) 
-      DO UPDATE SET vector = EXCLUDED.vector
-    `;
-        await this.executor.execute(sql, [row.graph, row.subject, row.predicate, row.object, row.vector]);
+        const row = this.quintToPgRow(quint);
+        await this.executor.executeInTransaction(this.writeStatementsForRow(row));
     }
     /**
-     * 重写 multiPut 方法，使用 PostgreSQL 的 ON CONFLICT
+     * 重写 multiPut 方法，使用同一事务保持批量写入幂等
      */
     async multiPut(quintList) {
         console.log(`[PgQuintStore.multiPut] Starting: ${quintList.length} quints`);
@@ -253,22 +270,651 @@ class PgQuintStore extends BaseQuintStore_1.BaseQuintStore {
             console.log(`[PgQuintStore.multiPut] Empty list, skipping`);
             return;
         }
+        const statements = quintList.flatMap(quint => {
+            const row = this.quintToPgRow(quint);
+            return this.writeStatementsForRow(row);
+        });
+        console.log(`[PgQuintStore.multiPut] Executing ${statements.length} statements in transaction`);
+        const start = Date.now();
+        await this.executor.executeInTransaction(statements);
+        console.log(`[PgQuintStore.multiPut] Completed in ${Date.now() - start}ms`);
+    }
+    async multiDel(quintList) {
+        this.ensureOpen();
+        if (quintList.length === 0)
+            return;
         const statements = quintList.map(quint => {
-            const row = this.quintToRow(quint);
+            const row = this.quintToPgRow(quint);
             return {
                 sql: `
-          INSERT INTO quints (graph, subject, predicate, object, vector) 
-          VALUES ($1, $2, $3, $4, $5)
-          ON CONFLICT (graph, subject, predicate, object) 
-          DO UPDATE SET vector = EXCLUDED.vector
+          DELETE FROM quints
+          WHERE graph = $1
+            AND subject = $2
+            AND predicate = $3
+            AND object = $4
         `,
-                params: [row.graph, row.subject, row.predicate, row.object, row.vector],
+                params: [row.graph, row.subject, row.predicate, row.object],
             };
         });
-        console.log(`[PgQuintStore.multiPut] Executing ${statements.length} statements in transaction`);
-        const start = Date.now();
         await this.executor.executeInTransaction(statements);
-        console.log(`[PgQuintStore.multiPut] Completed in ${Date.now() - start}ms`);
+    }
+    async getAttributes(subjects, predicates, graph) {
+        this.ensureOpen();
+        if (subjects.length === 0 || predicates.length === 0) {
+            return new Map();
+        }
+        const subjectPlaceholders = subjects.map(() => '?').join(', ');
+        const predicatePlaceholders = predicates.map(() => '?').join(', ');
+        let sql = `
+      SELECT subject, predicate, object
+      FROM quints
+      WHERE subject IN (${subjectPlaceholders})
+        AND predicate IN (${predicatePlaceholders})
+    `;
+        const params = [...subjects, ...predicates];
+        if (graph && graph.termType !== 'DefaultGraph') {
+            const graphValue = (0, serialization_1.termToId)(graph);
+            sql += ` AND graph = ?`;
+            params.push(graphValue);
+        }
+        const rows = await this.executor.query(sql, params);
+        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, []);
+            }
+            predicateMap.get(row.predicate).push(this.deserializeObject(row.object));
+        }
+        return result;
+    }
+    buildWhereClause(pattern) {
+        const conditions = [];
+        const params = [];
+        const predicate = this.extractExactPredicate(pattern.predicate);
+        this.addPgCondition(conditions, params, 'graph', pattern.graph);
+        this.addPgCondition(conditions, params, 'subject', pattern.subject);
+        this.addPgCondition(conditions, params, 'predicate', pattern.predicate);
+        if (pattern.object) {
+            this.addObjectConditions(conditions, params, undefined, pattern.object, predicate);
+        }
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        return { whereClause, params };
+    }
+    addPgCondition(conditions, params, column, match) {
+        if (!match)
+            return;
+        if (typeof match === 'object' && 'termType' in match) {
+            const value = (0, serialization_1.termToId)(match);
+            conditions.push(`${column} = ?`);
+            params.push(value);
+            return;
+        }
+        const ops = match;
+        if (ops.$eq !== undefined) {
+            const value = this.serializeOpValue(ops.$eq, false, '$eq');
+            conditions.push(`${column} = ?`);
+            params.push(String(value));
+            return;
+        }
+        super.addConditions(conditions, params, column, match, false);
+    }
+    addAliasedConditions(conditions, params, alias, pattern) {
+        this.addAliasedPgCondition(conditions, params, alias, 'graph', pattern.graph, false);
+        this.addAliasedPgCondition(conditions, params, alias, 'subject', pattern.subject, false);
+        this.addAliasedPgCondition(conditions, params, alias, 'predicate', pattern.predicate, false);
+        this.addAliasedObjectConditions(conditions, params, alias, pattern);
+    }
+    buildCompoundQuery(compound, options) {
+        const { patterns, joinOn, select } = compound;
+        const params = [];
+        let selectClause = `q0.${joinOn} as join_value`;
+        if (select) {
+            for (const s of select) {
+                selectClause += `, q${s.pattern}.${s.field} as ${s.alias}`;
+            }
+        }
+        else {
+            for (let i = 0; i < patterns.length; i++) {
+                selectClause += `, q${i}.object as p${i}_object`;
+                selectClause += `, q${i}.predicate as p${i}_predicate`;
+            }
+        }
+        let fromClause = 'quints q0';
+        for (let i = 1; i < patterns.length; i++) {
+            fromClause += ` JOIN quints q${i} ON q0.${joinOn} = q${i}.${joinOn}`;
+            fromClause += ` AND q0.graph = q${i}.graph`;
+        }
+        const whereParts = [];
+        for (let i = 0; i < patterns.length; i++) {
+            const pattern = patterns[i];
+            const alias = `q${i}`;
+            this.addAliasedConditions(whereParts, params, alias, pattern);
+        }
+        let sql = `SELECT ${selectClause} FROM ${fromClause}`;
+        if (whereParts.length > 0) {
+            sql += ` WHERE ${whereParts.join(' AND ')}`;
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ?`;
+            params.push(options.limit);
+        }
+        if (options?.offset) {
+            sql += ` OFFSET ?`;
+            params.push(options.offset);
+        }
+        return { sql, params };
+    }
+    buildSelectQuery(pattern, options) {
+        const { whereClause, params } = this.buildWhereClause(pattern);
+        let sql = `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(', ');
+            sql += ` ORDER BY ${orderCols}`;
+            if (options.reverse) {
+                sql += ' DESC';
+            }
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ?`;
+            params.push(options.limit);
+        }
+        if (options?.offset) {
+            sql += ` OFFSET ?`;
+            params.push(options.offset);
+        }
+        return { sql, params };
+    }
+    async count(pattern) {
+        const count = await super.count(pattern);
+        return Number(count);
+    }
+    async stats() {
+        const stats = await super.stats();
+        return {
+            totalCount: Number(stats.totalCount),
+            vectorCount: Number(stats.vectorCount),
+            graphCount: Number(stats.graphCount),
+        };
+    }
+    async ensureTypedObjectSchema() {
+        const statements = [
+            'ALTER TABLE quints ADD COLUMN IF NOT EXISTS object_kind TEXT',
+            'ALTER TABLE quints ADD COLUMN IF NOT EXISTS object_key TEXT',
+            'ALTER TABLE quints ADD COLUMN IF NOT EXISTS object_text TEXT',
+            'ALTER TABLE quints ADD COLUMN IF NOT EXISTS object_digest TEXT',
+        ];
+        for (const statement of statements) {
+            await this.executor.exec(statement);
+        }
+        // The old Postgres schema indexed complete RDF terms. Long literals can
+        // exceed the btree tuple size and surface as 500s while creating containers.
+        const obsoleteIndexes = [
+            'idx_spog',
+            'idx_ogsp',
+            'idx_gspo',
+            'idx_sopg',
+            'idx_pogs',
+            'idx_gpos',
+            'idx_pg_spog',
+            'idx_pg_ogsp',
+            'idx_pg_gspo',
+            'idx_pg_sopg',
+            'idx_pg_pogs',
+            'idx_pg_gpos',
+            'idx_pg_graph_prefix',
+            'idx_quints_predicate_object_text',
+            'idx_quints_quint_hash',
+            'idx_quints_graph_hash',
+            'idx_quints_subject_hash',
+            'idx_quints_predicate_hash',
+            'idx_quints_object_hash',
+            'idx_quints_gsp_hash',
+            'idx_quints_sp_hash',
+            'idx_quints_gp_hash',
+        ];
+        for (const indexName of obsoleteIndexes) {
+            await this.executor.exec(`DROP INDEX IF EXISTS ${indexName}`);
+        }
+        await this.executor.exec('ALTER TABLE quints DROP CONSTRAINT IF EXISTS quints_pkey');
+        const obsoleteColumns = [
+            'quint_hash',
+            'graph_hash',
+            'subject_hash',
+            'predicate_hash',
+            'object_hash',
+        ];
+        for (const columnName of obsoleteColumns) {
+            await this.executor.exec(`ALTER TABLE quints DROP COLUMN IF EXISTS ${columnName}`);
+        }
+        await this.backfillMissingObjectIndexFields();
+        await this.executor.exec(`
+      UPDATE quints
+      SET object_kind = 'text'
+      WHERE object_kind = 'shortText'
+    `);
+    }
+    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 = $1,
+            object_key = $2,
+            object_text = $3,
+            object_digest = $4
+        WHERE graph = $5
+          AND subject = $6
+          AND predicate = $7
+          AND object = $8
+      `, [
+                objectIndex.objectKind,
+                objectIndex.objectKey,
+                objectIndex.objectText,
+                this.objectDigestForIndex(row.object, objectIndex),
+                row.graph,
+                row.subject,
+                row.predicate,
+                row.object,
+            ]);
+        }
+    }
+    quintToPgRow(quint) {
+        const row = this.quintToRow(quint);
+        const objectIndex = this.objectIndexForTerm(row.predicate, quint.object);
+        return {
+            ...row,
+            objectKind: objectIndex.objectKind,
+            objectKey: objectIndex.objectKey,
+            objectText: objectIndex.objectText,
+            objectDigest: this.objectDigestForIndex(row.object, objectIndex),
+        };
+    }
+    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,
+        });
+    }
+    objectDigestForIndex(serialized, fields) {
+        return fields.objectKey === null ? digestObject(serialized) : null;
+    }
+    writeStatementsForRow(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 ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+          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 ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+        ON CONFLICT (graph, subject, predicate, object_kind, object_digest)
+          WHERE object_digest IS NOT NULL
+        DO UPDATE SET
+          object = CASE WHEN quints.object = EXCLUDED.object THEN EXCLUDED.object ELSE NULL END,
+          vector = EXCLUDED.vector,
+          object_text = EXCLUDED.object_text
+      `,
+                params,
+            }];
+    }
+    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')} = ?)`;
+                }
+                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);
+                }
+                else {
+                    params.push(item.fields.objectKind, item.fields.objectKey);
+                }
+            }
+        }
+        if (ops.$notIn !== undefined && ops.$notIn.length > 0) {
+            const values = ops.$notIn.map((value) => this.objectPredicateForOperatorValue(value, '$notIn', predicate).serialized);
+            for (const value of values) {
+                conditions.push(`${column('object')} != ?`);
+                params.push(value);
+            }
+        }
+        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) {
+            const pattern = ops.$regex.replace(/\.\*/g, '%').replace(/\./g, '_');
+            this.addObjectTextCondition(conditions, params, column, 'LIKE', pattern, 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.objectFieldsForTerm(object, predicate);
+        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(`RIGHT(${lexical}, LENGTH(?)) = ?`);
+            params.push(value, value);
+            return;
+        }
+        if (op === 'contains') {
+            conditions.push(`POSITION(? IN ${lexical}) > 0`);
+            params.push(value);
+            return;
+        }
+        conditions.push(`${lexical} ~ ?`);
+        params.push(value);
+    }
+    objectLexicalSql(column) {
+        return `CASE
+      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 split_part(${column('object')}, '${PG_SEP}', 4)
+      WHEN ${column('object_kind')} = 'dateTime' THEN split_part(${column('object')}, '${PG_SEP}', 3)
+      ELSE NULL
+    END`;
+    }
+    addObjectLanguageCondition(conditions, params, column, lang) {
+        const languageLiteralKinds = `${column('object_kind')} IN ('text', 'longText', 'literal')`;
+        if (lang === '*') {
+            conditions.push(`(${languageLiteralKinds} AND ${column('object')} ~ ?)`);
+            params.push('"@[A-Za-z]+(-[A-Za-z0-9]+)*$');
+            return;
+        }
+        const suffix = `"@${lang.toLowerCase()}`;
+        conditions.push(`(${languageLiteralKinds} AND (RIGHT(LOWER(${column('object')}), LENGTH(?)) = ? OR LOWER(${column('object')}) LIKE ?))`);
+        params.push(suffix, suffix, `%"@${lang.toLowerCase()}-%`);
+    }
+    objectPredicateForOperatorValue(value, op, predicate) {
+        const serialized = this.serializeOpValue(value, true, op);
+        return {
+            serialized,
+            fields: this.objectFieldsForSerialized(serialized, predicate),
+        };
+    }
+    objectFieldsForTerm(object, predicate) {
+        return (0, value_types_1.objectIndexFieldsFromTerm)(object, {
+            predicate,
+            predicateObjectDataTypes: this.options.predicateObjectDataTypes,
+            textMaxBytes: this.options.textMaxBytes,
+        });
+    }
+    objectFieldsForSerialized(serialized, predicate) {
+        return (0, value_types_1.objectIndexFieldsFromSerialized)(serialized, {
+            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 };
+    }
+    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`);
+    }
+    addAliasedObjectConditions(conditions, params, alias, pattern) {
+        if (!pattern.object)
+            return;
+        this.addObjectConditions(conditions, params, alias, pattern.object, this.extractExactPredicate(pattern.predicate));
+    }
+    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.objectFieldsForTerm(pattern.object, predicate).objectKind;
+        }
+        return undefined;
+    }
+    addAliasedPgCondition(conditions, params, alias, column, match, isObject) {
+        if (!match)
+            return;
+        if (isObject) {
+            this.addObjectConditions(conditions, params, alias, match, undefined);
+            return;
+        }
+        if (typeof match === 'object' && 'termType' in match) {
+            const value = (0, serialization_1.termToId)(match);
+            conditions.push(`${alias}.${column} = ?`);
+            params.push(value);
+            return;
+        }
+        if (match.$eq !== undefined) {
+            const value = this.serializeOpValue(match.$eq, false, '$eq');
+            conditions.push(`${alias}.${column} = ?`);
+            params.push(value);
+            return;
+        }
+        this.addFallbackAliasedCondition(conditions, params, alias, column, match, isObject);
+    }
+    addFallbackAliasedCondition(conditions, params, alias, column, match, isObject) {
+        if (isObject) {
+            this.addObjectConditions(conditions, params, alias, match, undefined);
+            return;
+        }
+        if (match.$gt !== undefined) {
+            conditions.push(`${alias}.${column} > ?`);
+            params.push(this.serializeOpValue(match.$gt, false, '$gt'));
+        }
+        if (match.$gte !== undefined) {
+            conditions.push(`${alias}.${column} >= ?`);
+            params.push(this.serializeOpValue(match.$gte, false, '$gte'));
+        }
+        if (match.$lt !== undefined) {
+            conditions.push(`${alias}.${column} < ?`);
+            params.push(this.serializeOpValue(match.$lt, false, '$lt'));
+        }
+        if (match.$lte !== undefined) {
+            conditions.push(`${alias}.${column} <= ?`);
+            params.push(this.serializeOpValue(match.$lte, false, '$lte'));
+        }
+        if (match.$in !== undefined && match.$in.length > 0) {
+            const placeholders = match.$in.map(() => '?').join(', ');
+            conditions.push(`${alias}.${column} IN (${placeholders})`);
+            params.push(...match.$in.map((value) => this.serializeOpValue(value, false, '$in')));
+        }
     }
 }
 exports.PgQuintStore = PgQuintStore;