@undefineds.co/xpod 0.3.25 → 0.3.27

package/dist/storage/quint/SqliteQuintStore.d.ts

@@ -1,67 +1,57 @@
 /**
  * SqliteQuintStore - SQLite implementation of QuintStore using Drizzle ORM
  */
-import { AsyncIterator } from 'asynciterator';
-import type { Term } from '@rdfjs/types';
-import type { Quint, QuintPattern, QuintStoreOptions, QueryOptions, StoreStats, CompoundPattern, CompoundResult } from './types';
+import { BaseQuintStore, type QuintRow, type SqlExecutor } from './BaseQuintStore';
+import type { NewQuintRow } from './schema';
+import type { QuintStoreOptions, StoreStats, QuintPattern, QueryOptions, Quint, TermMatch } from './types';
+import { type PredicateObjectDataType } from './value-types';
+interface SqliteIndexedQuintRow extends NewQuintRow {
+    graph: string;
+    subject: string;
+    predicate: string;
+    object: string;
+    vector: string | null;
+    objectKind: PredicateObjectDataType;
+    objectKey: string | null;
+    objectText: string | null;
+    objectDigest: string | null;
+}
 export interface SqliteQuintStoreOptions extends QuintStoreOptions {
     /** SQLite database file path, use ':memory:' for in-memory database */
     path: string;
 }
-export declare class SqliteQuintStore {
+export declare class SqliteQuintStore extends BaseQuintStore {
     private sqlite;
-    private db;
-    private options;
     private readonly sqliteRuntime;
+    private readonly path;
     constructor(options: SqliteQuintStoreOptions);
-    open(): Promise<void>;
-    close(): Promise<void>;
-    get(pattern: QuintPattern, options?: QueryOptions): Promise<Quint[]>;
-    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): AsyncIterator<Quint>;
-    getByGraphPrefix(prefix: string, options?: QueryOptions): Promise<Quint[]>;
-    count(pattern: QuintPattern): Promise<number>;
-    /**
-     * Compound query - multiple patterns JOINed by a common field
-     * This executes a single SQL query with JOINs, letting SQLite optimize the execution plan
-     */
-    getCompound(compound: CompoundPattern, options?: QueryOptions): Promise<CompoundResult[]>;
-    /**
-     * 批量获取多个 subject 的多个属性
-     *
-     * 用于优化 OPTIONAL 查询：避免每个 OPTIONAL 变成一次 LEFT JOIN
-     *
-     * SQL: SELECT subject, predicate, object FROM quints
-     *      WHERE subject IN (...) AND predicate IN (...)
-     */
-    getAttributes(subjects: string[], predicates: string[], graph?: Term): Promise<Map<string, Map<string, Term[]>>>;
-    /**
-     * Build SQL for compound query with JOINs
-     */
-    private buildCompoundSQL;
-    /**
-     * Build WHERE conditions for a specific table alias
-     */
-    private buildConditionsForAlias;
-    put(quint: Quint): Promise<void>;
-    multiPut(quintList: Quint[]): Promise<void>;
-    updateEmbedding(pattern: QuintPattern, embedding: number[]): Promise<number>;
-    del(pattern: QuintPattern): Promise<number>;
-    multiDel(quintList: Quint[]): Promise<void>;
+    protected createExecutor(): Promise<SqlExecutor>;
+    protected closeExecutor(): Promise<void>;
+    protected openOnce(): Promise<void>;
+    protected buildSelectQuery(pattern: QuintPattern, options?: QueryOptions): {
+        sql: string;
+        params: any[];
+    };
     stats(): Promise<StoreStats>;
+    clear(): Promise<void>;
+    private ensureTypedObjectSchema;
+    private addColumnIfMissing;
+    private createTypedObjectIndexes;
+    private backfillMissingObjectIndexFields;
     private sqliteSpaceStats;
     private estimateDatabaseBytes;
     private collectSpaceObjects;
     private estimateSpaceObjectsFromSchema;
     private estimatePageSize;
-    clear(): Promise<void>;
-    private ensureOpen;
-    private ensureTypedObjectSchema;
-    private addColumnIfMissing;
-    private backfillMissingObjectIndexFields;
-    private buildSelectQuery;
-    private buildWhereClause;
-    private addTermConditions;
-    private serializeOpValue;
+    private objectIndexForSerialized;
+    private objectDigestForIndex;
+    protected resolveObjectDataTypeForPattern(pattern: QuintPattern): PredicateObjectDataType | undefined;
+    protected buildWhereClause(pattern: QuintPattern): {
+        whereClause: string;
+        params: any[];
+    };
+    protected addTermConditions(conditions: string[], params: any[], column: string, match: TermMatch | undefined, isObject: boolean): void;
+    protected addAliasedConditions(conditions: string[], params: any[], alias: string, pattern: QuintPattern): void;
     private addObjectConditions;
     private addObjectExactCondition;
     private addObjectExactValueCondition;
@@ -74,14 +64,13 @@ export declare class SqliteQuintStore {
     private objectPredicateForOperatorValue;
     private objectFieldsForOperatorValue;
     private objectIndexForTerm;
-    private objectIndexForSerialized;
     private objectFieldsForPrefix;
-    private objectDigestForIndex;
     private assertComparableObject;
-    private extractExactPredicate;
-    private resolveObjectDataTypeForPattern;
     private predicateForIndex;
+    put(quint: Quint): Promise<void>;
+    multiPut(quintList: Quint[]): Promise<void>;
     private writeStatementForRow;
-    private quintToRow;
-    private rowToQuint;
+    protected quintToRow(quint: Quint): SqliteIndexedQuintRow;
+    protected rowToQuint(row: QuintRow): Quint;
 }
+export {};