ydb-qdrant 8.1.0 → 9.0.3

package/dist/repositories/collectionsRepo.one-table.d.ts

@@ -1,3 +1,4 @@
-import type { DistanceKind, VectorType } from "../types";
-export declare function createCollectionOneTable(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;
-export declare function deleteCollectionOneTable(metaKey: string, uid: string): Promise<void>;
+import type { DistanceKind, VectorType } from "../qdrant/QdrantRestTypes.js";
+export declare function createCollectionOneTable(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, userUid?: string): Promise<void>;
+export declare function deleteAllPointsForCollectionOneTable(collection: string): Promise<void>;
+export declare function deleteCollectionOneTable(metaKey: string, collection: string): Promise<void>;

package/dist/repositories/collectionsRepo.one-table.js

@@ -1,36 +1,24 @@
 import { TypedValues, Types, withSession, withQuerySession, createExecuteQuerySettings, } from "../ydb/client.js";
-import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
+import { GLOBAL_POINTS_TABLE, POINTS_BY_FILE_LOOKUP_TABLE, ensureGlobalPointsTable, ensurePointsByFileTable, } from "../ydb/schema.js";
 import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
 import { withRetry, isTransientYdbError } from "../utils/retry.js";
+import { isOutOfBufferMemoryYdbError } from "../utils/ydbErrors.js";
+import { logger } from "../logging/logger.js";
 const DELETE_COLLECTION_BATCH_SIZE = 10000;
-function isOutOfBufferMemoryYdbError(error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (/Out of buffer memory/i.test(msg)) {
-        return true;
-    }
-    if (typeof error === "object" && error !== null) {
-        const issues = error.issues;
-        if (issues !== undefined) {
-            const issuesText = typeof issues === "string" ? issues : JSON.stringify(issues);
-            return /Out of buffer memory/i.test(issuesText);
-        }
-    }
-    return false;
-}
-async function deletePointsForUidInChunks(s, uid) {
+async function deletePointsForCollectionInChunks(s, collection) {
     const selectYql = `
-    DECLARE $uid AS Utf8;
+    DECLARE $collection AS Utf8;
     DECLARE $limit AS Uint32;
     SELECT point_id
     FROM ${GLOBAL_POINTS_TABLE}
-    WHERE uid = $uid
+    WHERE collection = $collection
     LIMIT $limit;
   `;
     const deleteBatchYql = `
-    DECLARE $uid AS Utf8;
+    DECLARE $collection AS Utf8;
     DECLARE $ids AS List<Utf8>;
     DELETE FROM ${GLOBAL_POINTS_TABLE}
-    WHERE uid = $uid AND point_id IN $ids;
+    WHERE collection = $collection AND point_id IN $ids;
   `;
     // Best‑effort loop: stop when there are no more rows for this uid.
     // Each iteration only touches a limited number of rows to avoid
@@ -40,7 +28,7 @@ async function deletePointsForUidInChunks(s, uid) {
     const settings = createExecuteQuerySettings();
     while (iterations++ < MAX_ITERATIONS) {
         const rs = (await s.executeQuery(selectYql, {
-            $uid: TypedValues.utf8(uid),
+            $collection: TypedValues.utf8(collection),
             $limit: TypedValues.uint32(DELETE_COLLECTION_BATCH_SIZE),
         }, undefined, settings));
         const rowset = rs.resultSets?.[0];
@@ -53,20 +41,76 @@ async function deletePointsForUidInChunks(s, uid) {
         }
         const idsValue = TypedValues.list(Types.UTF8, ids);
         await s.executeQuery(deleteBatchYql, {
-            $uid: TypedValues.utf8(uid),
+            $collection: TypedValues.utf8(collection),
             $ids: idsValue,
         }, undefined, settings);
     }
 }
-export async function createCollectionOneTable(metaKey, dim, distance, vectorType) {
-    await upsertCollectionMeta(metaKey, dim, distance, vectorType, GLOBAL_POINTS_TABLE);
+async function deleteLookupRowsForCollectionInChunks(s, collection) {
+    const selectYql = `
+    DECLARE $collection AS Utf8;
+    DECLARE $limit AS Uint32;
+    SELECT file_path, point_id
+    FROM ${POINTS_BY_FILE_LOOKUP_TABLE}
+    WHERE collection = $collection
+    LIMIT $limit;
+  `;
+    const deleteBatchYql = `
+    DECLARE $rows AS List<Struct<
+        collection: Utf8,
+        file_path: Utf8,
+        point_id: Utf8
+    >>;
+
+    DELETE FROM ${POINTS_BY_FILE_LOOKUP_TABLE} ON
+    SELECT collection, file_path, point_id FROM AS_TABLE($rows);
+  `;
+    let iterations = 0;
+    const MAX_ITERATIONS = 10000;
+    const settings = createExecuteQuerySettings();
+    const rowType = Types.struct({
+        collection: Types.UTF8,
+        file_path: Types.UTF8,
+        point_id: Types.UTF8,
+    });
+    while (iterations++ < MAX_ITERATIONS) {
+        const rs = (await s.executeQuery(selectYql, {
+            $collection: TypedValues.utf8(collection),
+            $limit: TypedValues.uint32(DELETE_COLLECTION_BATCH_SIZE),
+        }, undefined, settings));
+        const rowset = rs.resultSets?.[0];
+        const rows = rowset?.rows ?? [];
+        const lookupRows = rows
+            .map((row) => ({
+            collection,
+            file_path: row.items?.[0]?.textValue,
+            point_id: row.items?.[1]?.textValue,
+        }))
+            .filter((row) => typeof row.file_path === "string" &&
+            typeof row.point_id === "string");
+        if (lookupRows.length === 0) {
+            break;
+        }
+        await s.executeQuery(deleteBatchYql, {
+            $rows: TypedValues.list(rowType, lookupRows),
+        }, undefined, settings);
+    }
+}
+export async function createCollectionOneTable(metaKey, dim, distance, vectorType, userUid) {
+    await upsertCollectionMeta(metaKey, dim, distance, vectorType, GLOBAL_POINTS_TABLE, userUid);
 }
-export async function deleteCollectionOneTable(metaKey, uid) {
+export async function deleteAllPointsForCollectionOneTable(collection) {
     await ensureGlobalPointsTable();
+    await ensurePointsByFileTable();
     const batchDeletePointsYql = `
-    DECLARE $uid AS Utf8;
+    DECLARE $collection AS Utf8;
     BATCH DELETE FROM ${GLOBAL_POINTS_TABLE}
-    WHERE uid = $uid;
+    WHERE collection = $collection;
+  `;
+    const batchDeleteLookupYql = `
+    DECLARE $collection AS Utf8;
+    BATCH DELETE FROM ${POINTS_BY_FILE_LOOKUP_TABLE}
+    WHERE collection = $collection;
   `;
     await withRetry(async () => {
         try {
@@ -74,7 +118,26 @@ export async function deleteCollectionOneTable(metaKey, uid) {
                 await qs.execute({
                     text: batchDeletePointsYql,
                     parameters: {
-                        $uid: TypedValues.utf8(uid),
+                        $collection: TypedValues.utf8(collection),
+                    },
+                });
+            });
+        }
+        catch (err) {
+            if (!isOutOfBufferMemoryYdbError(err)) {
+                throw err;
+            }
+            logger.warn({ tableName: GLOBAL_POINTS_TABLE, collection }, "BATCH DELETE hit out-of-buffer-memory, falling back to chunked deletion");
+            await withSession(async (s) => {
+                await deletePointsForCollectionInChunks(s, collection);
+            });
+        }
+        try {
+            await withQuerySession(async (qs) => {
+                await qs.execute({
+                    text: batchDeleteLookupYql,
+                    parameters: {
+                        $collection: TypedValues.utf8(collection),
                     },
                 });
             });
@@ -83,23 +146,23 @@ export async function deleteCollectionOneTable(metaKey, uid) {
             if (!isOutOfBufferMemoryYdbError(err)) {
                 throw err;
             }
-            // BATCH DELETE already deletes in chunks per partition, but if YDB
-            // still reports an out-of-buffer-memory condition, fall back to
-            // per-uid chunked deletion strategy to complete the deletion.
+            logger.warn({ tableName: POINTS_BY_FILE_LOOKUP_TABLE, collection }, "BATCH DELETE hit out-of-buffer-memory, falling back to chunked deletion");
             await withSession(async (s) => {
-                await deletePointsForUidInChunks(s, uid);
+                await deleteLookupRowsForCollectionInChunks(s, collection);
             });
         }
     }, {
         isTransient: isTransientYdbError,
         context: {
-            operation: "deleteCollectionOneTable",
+            operation: "deleteAllPointsForCollectionOneTable",
             tableName: GLOBAL_POINTS_TABLE,
-            metaKey,
-            uid,
-            mode: "batch_delete",
+            collection,
+            mode: "batch_delete_with_lookup_cleanup",
         },
     });
+}
+export async function deleteCollectionOneTable(metaKey, collection) {
+    await deleteAllPointsForCollectionOneTable(collection);
     const delMeta = `
     DECLARE $collection AS Utf8;
     DELETE FROM qdr__collections WHERE collection = $collection;

package/dist/repositories/collectionsRepo.shared.d.ts

@@ -1,2 +1,2 @@
-import type { DistanceKind, VectorType } from "../types";
-export declare function upsertCollectionMeta(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string): Promise<void>;
+import type { DistanceKind, VectorType } from "../qdrant/QdrantRestTypes.js";
+export declare function upsertCollectionMeta(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string, userUid?: string): Promise<void>;

package/dist/repositories/collectionsRepo.shared.js

@@ -1,6 +1,6 @@
 import { UPSERT_OPERATION_TIMEOUT_MS } from "../config/env.js";
-import { TypedValues, withSession, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
-export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName) {
+import { TypedValues, Types, withSession, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
+export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName, userUid) {
     const now = new Date();
     const upsertMeta = `
     DECLARE $collection AS Utf8;
@@ -10,9 +10,13 @@ export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, t
     DECLARE $vtype AS Utf8;
     DECLARE $created AS Timestamp;
     DECLARE $last_accessed AS Timestamp;
-    UPSERT INTO qdr__collections (collection, table_name, vector_dimension, distance, vector_type, created_at, last_accessed_at)
-    VALUES ($collection, $table, $dim, $distance, $vtype, $created, $last_accessed);
+    DECLARE $user_uid AS Optional<Utf8>;
+    UPSERT INTO qdr__collections (collection, table_name, vector_dimension, distance, vector_type, created_at, last_accessed_at, user_uid)
+    VALUES ($collection, $table, $dim, $distance, $vtype, $created, $last_accessed, $user_uid);
   `;
+    const userUidValue = userUid && userUid.trim().length > 0
+        ? TypedValues.optional(TypedValues.utf8(userUid))
+        : TypedValues.optionalNull(Types.UTF8);
     await withSession(async (s) => {
         const settings = createExecuteQuerySettingsWithTimeout({
             keepInCache: true,
@@ -27,6 +31,7 @@ export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, t
             $vtype: TypedValues.utf8(vectorType),
             $created: TypedValues.timestamp(now),
             $last_accessed: TypedValues.timestamp(now),
+            $user_uid: userUidValue,
         }, undefined, settings);
     });
 }

package/dist/repositories/pointsRepo.d.ts

@@ -1,6 +1,8 @@
-import type { DistanceKind, UpsertPoint } from "../types.js";
-import type { YdbQdrantScoredPoint } from "../qdrant/QdrantRestTypes.js";
-export declare function upsertPoints(tableName: string, points: UpsertPoint[], dimension: number, uid: string): Promise<number>;
-export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string, filterPaths?: Array<Array<string>>): Promise<YdbQdrantScoredPoint[]>;
+import type { UpsertPoint } from "../qdrant/Requests.js";
+import type { DistanceKind, YdbQdrantScoredPoint } from "../qdrant/QdrantRestTypes.js";
+import type { RetrievedPoint } from "./pointsRepo.one-table/Retrieve.js";
+export declare function upsertPoints(tableName: string, points: UpsertPoint[], dimension: number, uid: string, apiKey: string): Promise<number>;
+export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string, apiKey: string, filterPaths?: Array<Array<string>>): Promise<YdbQdrantScoredPoint[]>;
 export declare function deletePoints(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;
 export declare function deletePointsByPathSegments(tableName: string, uid: string, paths: Array<Array<string>>): Promise<number>;
+export declare function retrievePointsByIds(tableName: string, ids: Array<string | number>, uid: string, apiKey: string, withPayload: boolean): Promise<RetrievedPoint[]>;

package/dist/repositories/pointsRepo.js

@@ -1,11 +1,9 @@
-import { SEARCH_MODE, OVERFETCH_MULTIPLIER, } from "../config/env.js";
-import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, deletePointsByPathSegmentsOneTable, } from "./pointsRepo.one-table.js";
-export async function upsertPoints(tableName, points, dimension, uid) {
-    return await upsertPointsOneTable(tableName, points, dimension, uid);
+import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, deletePointsByPathSegmentsOneTable, retrievePointsByIdsOneTable, } from "./pointsRepo.one-table.js";
+export async function upsertPoints(tableName, points, dimension, uid, apiKey) {
+    return await upsertPointsOneTable(tableName, points, dimension, uid, apiKey);
 }
-export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid, filterPaths) {
-    const mode = SEARCH_MODE;
-    return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, OVERFETCH_MULTIPLIER, filterPaths);
+export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid, apiKey, filterPaths) {
+    return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, apiKey, filterPaths);
 }
 export async function deletePoints(tableName, ids, uid) {
     return await deletePointsOneTable(tableName, ids, uid);
@@ -13,3 +11,6 @@ export async function deletePoints(tableName, ids, uid) {
 export async function deletePointsByPathSegments(tableName, uid, paths) {
     return await deletePointsByPathSegmentsOneTable(tableName, uid, paths);
 }
+export async function retrievePointsByIds(tableName, ids, uid, apiKey, withPayload) {
+    return await retrievePointsByIdsOneTable(tableName, ids, uid, apiKey, withPayload);
+}

package/dist/repositories/pointsRepo.one-table/Delete.d.ts

@@ -1,2 +1,2 @@
-export declare function deletePointsOneTable(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;
-export declare function deletePointsByPathSegmentsOneTable(tableName: string, uid: string, paths: Array<Array<string>>): Promise<number>;
+export declare function deletePointsOneTable(tableName: string, ids: Array<string | number>, collection: string): Promise<number>;
+export declare function deletePointsByPathSegmentsOneTable(tableName: string, collection: string, paths: Array<Array<string>>): Promise<number>;

package/dist/repositories/pointsRepo.one-table/Delete.js

@@ -1,29 +1,56 @@
-import { TypedValues, withSession, createExecuteQuerySettings, } from "../../ydb/client.js";
-import { withRetry, isTransientYdbError } from "../../utils/retry.js";
-import { buildPathSegmentsWhereClause } from "./PathSegmentsFilter.js";
-const DELETE_FILTER_SELECT_BATCH_SIZE = 1000;
-export async function deletePointsOneTable(tableName, ids, uid) {
-    let deleted = 0;
+import { TypedValues, Types, withSession, createExecuteQuerySettings, } from "../../ydb/client.js";
+import { withRetry, isTransientYdbError, isTransientYdbErrorInAcquiredSession, } from "../../utils/retry.js";
+import { DELETE_FILTER_SELECT_BATCH_SIZE } from "../../config/env.js";
+import { buildExactPathSegmentsFilter } from "./PathSegmentsFilter.js";
+import { pathSegmentsToPrefix } from "../../utils/pathPrefix.js";
+import { POINTS_BY_FILE_LOOKUP_TABLE, ensurePointsByFileTable, } from "../../ydb/schema.js";
+const DELETE_FILTER_PATHS_CHUNK_SIZE = 250;
+const DELETE_FILTER_PATHS_CHUNK_CONCURRENCY = 3;
+// Delete is idempotent in our usage (DELETE by PK / DELETE by selected keys),
+// so it is safe to use stronger retries for transient YDB states like Aborted/Undetermined.
+// Keep backoff capped to avoid multi-minute request tails during outages.
+const DELETE_BY_ID_RETRY_MAX_RETRIES = 10;
+const DELETE_BY_ID_RETRY_BASE_DELAY_MS = 250;
+const DELETE_BY_ID_RETRY_MAX_BACKOFF_MS = 1500;
+const DELETE_BY_FILTER_RETRY_MAX_RETRIES = 12;
+const DELETE_BY_FILTER_RETRY_BASE_DELAY_MS = 300;
+const DELETE_BY_FILTER_RETRY_MAX_BACKOFF_MS = 2000;
+export async function deletePointsOneTable(tableName, ids, collection) {
+    if (ids.length === 0) {
+        return 0;
+    }
+    const yql = `
+        DECLARE $collection AS Utf8;
+        DECLARE $ids AS List<Utf8>;
+
+        DELETE FROM ${tableName}
+        WHERE collection = $collection AND point_id IN $ids;
+
+        $lookup_rows = (
+          SELECT collection, file_path, point_id
+          FROM ${POINTS_BY_FILE_LOOKUP_TABLE}
+          WHERE collection = $collection AND point_id IN $ids
+        );
+
+        DELETE FROM ${POINTS_BY_FILE_LOOKUP_TABLE} ON
+        SELECT collection, file_path, point_id FROM $lookup_rows;
+    `;
+    const stringIds = ids.map((id) => String(id));
+    await ensurePointsByFileTable();
     await withSession(async (s) => {
         const settings = createExecuteQuerySettings();
-        for (const id of ids) {
-            const yql = `
-        DECLARE $uid AS Utf8;
-        DECLARE $id AS Utf8;
-        DELETE FROM ${tableName} WHERE uid = $uid AND point_id = $id;
-      `;
-            const params = {
-                $uid: TypedValues.utf8(uid),
-                $id: TypedValues.utf8(String(id)),
-            };
-            await withRetry(() => s.executeQuery(yql, params, undefined, settings), {
-                isTransient: isTransientYdbError,
-                context: { tableName, uid, pointId: String(id) },
-            });
-            deleted += 1;
-        }
+        await withRetry(() => s.executeQuery(yql, {
+            $collection: TypedValues.utf8(collection),
+            $ids: TypedValues.list(Types.UTF8, stringIds),
+        }, undefined, settings), {
+            isTransient: isTransientYdbErrorInAcquiredSession,
+            maxRetries: DELETE_BY_ID_RETRY_MAX_RETRIES,
+            baseDelayMs: DELETE_BY_ID_RETRY_BASE_DELAY_MS,
+            maxBackoffMs: DELETE_BY_ID_RETRY_MAX_BACKOFF_MS,
+            context: { tableName, collection, idCount: ids.length },
+        });
     });
-    return deleted;
+    return ids.length;
 }
 const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
 function bigintToSafeNumberOrNull(value) {
@@ -105,62 +132,132 @@ function readDeletedCountFromResult(rs) {
     }
     return 0;
 }
-export async function deletePointsByPathSegmentsOneTable(tableName, uid, paths) {
-    if (paths.length === 0) {
-        return 0;
-    }
-    const { whereSql, params: whereParams } = buildPathSegmentsWhereClause(paths);
-    const whereParamDeclarations = Object.keys(whereParams)
-        .sort()
-        .map((key) => `DECLARE ${key} AS Utf8;`)
-        .join("\n    ");
+async function deletePointsByPathSegmentsChunked(tableName, collection, whereSql, whereParamDeclarations, whereParams, batchLimit) {
     const deleteBatchYql = `
-    DECLARE $uid AS Utf8;
+    DECLARE $collection AS Utf8;
     DECLARE $limit AS Uint32;
     ${whereParamDeclarations}
 
     $to_delete = (
-      SELECT uid, point_id
-      FROM ${tableName}
-      WHERE uid = $uid AND ${whereSql}
+      SELECT collection, file_path, point_id
+      FROM ${POINTS_BY_FILE_LOOKUP_TABLE}
+      WHERE collection = $collection AND ${whereSql}
       LIMIT $limit
     );
 
     DELETE FROM ${tableName} ON
-    SELECT uid, point_id FROM $to_delete;
+    SELECT collection, point_id FROM $to_delete;
+
+    DELETE FROM ${POINTS_BY_FILE_LOOKUP_TABLE} ON
+    SELECT collection, file_path, point_id FROM $to_delete;
 
     SELECT CAST(COUNT(*) AS Uint32) AS deleted FROM $to_delete;
   `;
+    const settings = createExecuteQuerySettings();
     let deleted = 0;
-    await withSession(async (s) => {
-        const settings = createExecuteQuerySettings();
-        // Best-effort loop: stop when there are no more matching rows.
-        // Use limited batches to avoid per-operation buffer limits.
-        while (true) {
-            const rs = (await withRetry(() => s.executeQuery(deleteBatchYql, {
+    while (true) {
+        const rs = await withSession(async (s) => {
+            return await withRetry(() => s.executeQuery(deleteBatchYql, {
                 ...whereParams,
-                $uid: TypedValues.utf8(uid),
-                $limit: TypedValues.uint32(DELETE_FILTER_SELECT_BATCH_SIZE),
+                $collection: TypedValues.utf8(collection),
+                $limit: TypedValues.uint32(batchLimit),
             }, undefined, settings), {
-                isTransient: isTransientYdbError,
+                isTransient: isTransientYdbErrorInAcquiredSession,
+                maxRetries: DELETE_BY_FILTER_RETRY_MAX_RETRIES,
+                baseDelayMs: DELETE_BY_FILTER_RETRY_BASE_DELAY_MS,
+                maxBackoffMs: DELETE_BY_FILTER_RETRY_MAX_BACKOFF_MS,
                 context: {
                     tableName,
-                    uid,
-                    filterPathsCount: paths.length,
-                    batchLimit: DELETE_FILTER_SELECT_BATCH_SIZE,
+                    collection,
+                    filterParamsCount: Object.keys(whereParams).length,
+                    batchLimit,
                 },
-            }));
-            const batchDeleted = readDeletedCountFromResult(rs);
-            if (!Number.isSafeInteger(batchDeleted) ||
-                batchDeleted < 0 ||
-                batchDeleted > DELETE_FILTER_SELECT_BATCH_SIZE) {
-                throw new Error(`Unexpected deleted count from YDB: ${String(batchDeleted)}. Expected an integer in [0, ${DELETE_FILTER_SELECT_BATCH_SIZE}].`);
-            }
-            if (batchDeleted <= 0) {
-                break;
-            }
-            deleted += batchDeleted;
+            });
+        });
+        const batchDeleted = readDeletedCountFromResult(rs);
+        if (!Number.isSafeInteger(batchDeleted) ||
+            batchDeleted < 0 ||
+            batchDeleted > batchLimit) {
+            throw new Error(`Unexpected deleted count from YDB: ${String(batchDeleted)}. Expected an integer in [0, ${batchLimit}].`);
+        }
+        if (batchDeleted <= 0) {
+            break;
         }
+        deleted += batchDeleted;
+    }
+    return deleted;
+}
+function dedupePathSegmentsPaths(paths) {
+    const seenPrefixes = new Set();
+    const uniquePaths = [];
+    for (const pathSegments of paths) {
+        const prefix = pathSegmentsToPrefix(pathSegments);
+        if (seenPrefixes.has(prefix)) {
+            continue;
+        }
+        seenPrefixes.add(prefix);
+        uniquePaths.push(pathSegments);
+    }
+    return uniquePaths;
+}
+async function deletePointsByPathSegmentsChunkWithRetry(tableName, collection, chunk, totalInputPathsCount, chunkCount) {
+    const filter = buildExactPathSegmentsFilter(chunk.chunkPaths, "file_path");
+    if (!filter) {
+        return 0;
+    }
+    const { whereSql, whereParamDeclarations, whereParams } = filter;
+    return await withRetry(async () => {
+        return await deletePointsByPathSegmentsChunked(tableName, collection, whereSql, whereParamDeclarations, whereParams, DELETE_FILTER_SELECT_BATCH_SIZE);
+    }, {
+        isTransient: isTransientYdbError,
+        maxRetries: DELETE_BY_FILTER_RETRY_MAX_RETRIES,
+        baseDelayMs: DELETE_BY_FILTER_RETRY_BASE_DELAY_MS,
+        maxBackoffMs: DELETE_BY_FILTER_RETRY_MAX_BACKOFF_MS,
+        context: {
+            operation: "deletePointsByPathSegmentsOneTable",
+            tableName,
+            collection,
+            filterPathsCount: totalInputPathsCount,
+            chunkPathsCount: chunk.chunkPaths.length,
+            chunkIndex: chunk.chunkIndex,
+            chunkCount,
+            concurrency: DELETE_FILTER_PATHS_CHUNK_CONCURRENCY,
+            mode: "points_by_file_lookup_delete",
+        },
     });
+}
+export async function deletePointsByPathSegmentsOneTable(tableName, collection, paths) {
+    if (paths.length === 0) {
+        return 0;
+    }
+    await ensurePointsByFileTable();
+    const uniquePaths = dedupePathSegmentsPaths(paths);
+    const chunks = [];
+    for (let chunkStart = 0; chunkStart < uniquePaths.length; chunkStart += DELETE_FILTER_PATHS_CHUNK_SIZE) {
+        chunks.push({
+            chunkIndex: Math.floor(chunkStart / DELETE_FILTER_PATHS_CHUNK_SIZE) + 1,
+            chunkPaths: uniquePaths.slice(chunkStart, chunkStart + DELETE_FILTER_PATHS_CHUNK_SIZE),
+        });
+    }
+    const chunkCount = chunks.length;
+    let deleted = 0;
+    for (let batchStart = 0; batchStart < chunkCount; batchStart += DELETE_FILTER_PATHS_CHUNK_CONCURRENCY) {
+        const chunkBatch = chunks.slice(batchStart, batchStart + DELETE_FILTER_PATHS_CHUNK_CONCURRENCY);
+        const batchResults = await Promise.allSettled(chunkBatch.map((chunk) => deletePointsByPathSegmentsChunkWithRetry(tableName, collection, chunk, uniquePaths.length, chunkCount)));
+        let firstError;
+        for (const result of batchResults) {
+            if (result.status === "fulfilled") {
+                deleted += result.value;
+                continue;
+            }
+            firstError ??=
+                result.reason instanceof Error
+                    ? result.reason
+                    : new Error(String(result.reason));
+        }
+        if (firstError !== undefined) {
+            throw firstError;
+        }
+    }
     return deleted;
 }

package/dist/repositories/pointsRepo.one-table/PathSegmentsFilter.d.ts

@@ -2,13 +2,15 @@ import type { Ydb } from "ydb-sdk";
 type QueryParams = {
     [key: string]: Ydb.ITypedValue;
 };
+type BuiltPathSegmentsFilter = {
+    whereSql: string;
+    whereParamDeclarations: string;
+    whereParams: QueryParams;
+};
 export declare function buildPathSegmentsWhereClause(paths: Array<Array<string>>): {
     whereSql: string;
     params: QueryParams;
 };
-export declare function buildPathSegmentsFilter(paths: Array<Array<string>> | undefined): {
-    whereSql: string;
-    whereParamDeclarations: string;
-    whereParams: QueryParams;
-} | undefined;
+export declare function buildPrefixPathSegmentsFilter(paths: Array<Array<string>> | undefined, columnName?: string): BuiltPathSegmentsFilter | undefined;
+export declare function buildExactPathSegmentsFilter(paths: Array<Array<string>> | undefined, columnName?: string): BuiltPathSegmentsFilter | undefined;
 export {};

package/dist/repositories/pointsRepo.one-table/PathSegmentsFilter.js

@@ -1,33 +1,64 @@
 import { TypedValues } from "../../ydb/client.js";
-export function buildPathSegmentsWhereClause(paths) {
+import { pathSegmentsToPrefix } from "../../utils/pathPrefix.js";
+function buildPrefixPathSegmentsWhereClauseForColumn(paths, columnName) {
     const params = {};
     const orGroups = [];
     for (let pIdx = 0; pIdx < paths.length; pIdx += 1) {
         const segs = paths[pIdx];
         if (segs.length === 0) {
-            throw new Error("delete-by-filter: empty path segments");
+            throw new Error("pathSegments filter: empty path segments");
         }
-        const andParts = [];
-        for (let sIdx = 0; sIdx < segs.length; sIdx += 1) {
-            const paramName = `$p${pIdx}_${sIdx}`;
-            // payload is JsonDocument; JSON_VALUE supports JsonPath access.
-            andParts.push(`JSON_VALUE(payload, '$.pathSegments."${sIdx}"') = ${paramName}`);
-            params[paramName] = TypedValues.utf8(segs[sIdx]);
+        const prefix = pathSegmentsToPrefix(segs);
+        const exactParam = `$ppfx${pIdx}`;
+        const descendantParam = `$ppfxd${pIdx}`;
+        params[exactParam] = TypedValues.utf8(prefix);
+        params[descendantParam] = TypedValues.utf8(`${prefix}/`);
+        orGroups.push(`(${columnName} = ${exactParam} OR StartsWith(${columnName}, ${descendantParam}))`);
+    }
+    return {
+        whereSql: orGroups.length === 1 ? orGroups[0] : `(${orGroups.join(" OR ")})`,
+        params,
+    };
+}
+function buildExactPathSegmentsWhereClauseForColumn(paths, columnName) {
+    const params = {};
+    const orGroups = [];
+    for (let pIdx = 0; pIdx < paths.length; pIdx += 1) {
+        const segs = paths[pIdx];
+        if (segs.length === 0) {
+            throw new Error("pathSegments filter: empty path segments");
         }
-        orGroups.push(`(${andParts.join(" AND ")})`);
+        const prefix = pathSegmentsToPrefix(segs);
+        const exactParam = `$ppfx${pIdx}`;
+        params[exactParam] = TypedValues.utf8(prefix);
+        orGroups.push(`${columnName} = ${exactParam}`);
     }
     return {
         whereSql: orGroups.length === 1 ? orGroups[0] : `(${orGroups.join(" OR ")})`,
         params,
     };
 }
-export function buildPathSegmentsFilter(paths) {
-    if (!paths || paths.length === 0)
-        return undefined;
-    const { whereSql, params: whereParams } = buildPathSegmentsWhereClause(paths);
+function buildPathSegmentsFilterFromWhereClause(whereSql, whereParams) {
     const whereParamDeclarations = Object.keys(whereParams)
         .sort()
         .map((key) => `DECLARE ${key} AS Utf8;`)
         .join("\n        ");
     return { whereSql, whereParamDeclarations, whereParams };
 }
+export function buildPathSegmentsWhereClause(paths) {
+    return buildPrefixPathSegmentsWhereClauseForColumn(paths, "path_prefix");
+}
+export function buildPrefixPathSegmentsFilter(paths, columnName = "path_prefix") {
+    if (!paths || paths.length === 0) {
+        return undefined;
+    }
+    const { whereSql, params: whereParams } = buildPrefixPathSegmentsWhereClauseForColumn(paths, columnName);
+    return buildPathSegmentsFilterFromWhereClause(whereSql, whereParams);
+}
+export function buildExactPathSegmentsFilter(paths, columnName = "file_path") {
+    if (!paths || paths.length === 0) {
+        return undefined;
+    }
+    const { whereSql, params: whereParams } = buildExactPathSegmentsWhereClauseForColumn(paths, columnName);
+    return buildPathSegmentsFilterFromWhereClause(whereSql, whereParams);
+}

package/dist/repositories/pointsRepo.one-table/Retrieve.d.ts

@@ -0,0 +1,6 @@
+import type { Payload } from "../../qdrant/QdrantRestTypes.js";
+export interface RetrievedPoint {
+    id: string;
+    payload: Payload | null;
+}
+export declare function retrievePointsByIdsOneTable(tableName: string, ids: Array<string | number>, uid: string, apiKey: string, withPayload: boolean): Promise<RetrievedPoint[]>;