ydb-qdrant 3.0.0 → 4.1.0

package/README.md

@@ -75,6 +75,8 @@ Optional env:
 # Server
 export PORT=8080
 export LOG_LEVEL=info
+# Collection storage mode (optional; default is multi_table)
+export YDB_QDRANT_COLLECTION_STORAGE_MODE=multi_table   # or one_table
 ```
 
 ## Use as a Node.js library (npm package)
@@ -398,11 +400,13 @@ curl -X POST http://localhost:8080/collections/mycol/points/delete \
 ```
 
 ## Notes
-- One YDB table is created per collection; metadata is tracked in table `qdr__collections`.
-- Each collection table schema: `point_id Utf8` (PK), `embedding String` (binary), `payload JsonDocument`.
+- Storage layout:
+  - **multi_table** (default): one YDB table per collection; metadata is tracked in `qdr__collections`.
+  - **one_table**: a single global table `qdrant_all_points` with `(uid, point_id)` PK, where `uid` encodes tenant+collection.
+- Per‑collection table schema (multi_table): `point_id Utf8` (PK), `embedding String` (binary), `payload JsonDocument`.
 - Vectors are serialized with `Knn::ToBinaryStringFloat`.
 - Search uses a single-phase top‑k over `embedding` with automatic YDB vector index (`emb_idx`) when available; falls back to table scan if missing.
-- **Vector index auto-build**: After ≥100 points upserted + 5s quiet window, a `vector_kmeans_tree` index (levels=1, clusters=128) is built automatically. Incremental updates (<100 points) skip index rebuild.
+- **Vector index auto-build** (multi_table mode only): After ≥100 points upserted + 5s quiet window, a `vector_kmeans_tree` index (levels=1, clusters=128) is built automatically. Incremental updates (<100 points) skip index rebuild. In one_table mode, vector indexes are not supported and all searches use table scans.
 - **Concurrency**: During index rebuilds, YDB may return transient `Aborted`/schema metadata errors. Upserts include bounded retries with backoff to handle this automatically.
 - Filters are not yet modeled; can be added if needed.
 

package/dist/SmokeTest.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { createYdbQdrantClient } from "./package/Api.js";
+import { createYdbQdrantClient } from "./package/api.js";
 async function main() {
     const tenant = process.env.SMOKE_TENANT ?? "smoke";
     const collection = process.env.SMOKE_COLLECTION ?? "demo";

package/dist/config/env.d.ts

@@ -4,3 +4,9 @@ export declare const YDB_DATABASE: string;
 export declare const PORT: number;
 export declare const LOG_LEVEL: string;
 export declare const VECTOR_INDEX_BUILD_ENABLED: boolean;
+export declare enum CollectionStorageMode {
+    MultiTable = "multi_table",
+    OneTable = "one_table"
+}
+export declare const COLLECTION_STORAGE_MODE: CollectionStorageMode;
+export declare function isOneTableMode(mode: CollectionStorageMode): mode is CollectionStorageMode.OneTable;

package/dist/config/env.js

@@ -18,3 +18,20 @@ function parseBooleanEnv(value, defaultValue) {
     return true;
 }
 export const VECTOR_INDEX_BUILD_ENABLED = parseBooleanEnv(process.env.VECTOR_INDEX_BUILD_ENABLED, false);
+export var CollectionStorageMode;
+(function (CollectionStorageMode) {
+    CollectionStorageMode["MultiTable"] = "multi_table";
+    CollectionStorageMode["OneTable"] = "one_table";
+})(CollectionStorageMode || (CollectionStorageMode = {}));
+function resolveCollectionStorageModeEnv() {
+    const explicit = process.env.YDB_QDRANT_COLLECTION_STORAGE_MODE ??
+        process.env.YDB_QDRANT_TABLE_LAYOUT;
+    if (explicit?.trim().toLowerCase() === CollectionStorageMode.OneTable) {
+        return CollectionStorageMode.OneTable;
+    }
+    return CollectionStorageMode.MultiTable;
+}
+export const COLLECTION_STORAGE_MODE = resolveCollectionStorageModeEnv();
+export function isOneTableMode(mode) {
+    return mode === CollectionStorageMode.OneTable;
+}

package/dist/index.js

@@ -1,13 +1,16 @@
 import "dotenv/config";
 import { buildServer } from "./server.js";
-import { PORT } from "./config/env.js";
+import { PORT, COLLECTION_STORAGE_MODE, isOneTableMode, } from "./config/env.js";
 import { logger } from "./logging/logger.js";
 import { readyOrThrow } from "./ydb/client.js";
-import { ensureMetaTable } from "./ydb/schema.js";
+import { ensureMetaTable, ensureGlobalPointsTable } from "./ydb/schema.js";
 async function start() {
     try {
         await readyOrThrow();
         await ensureMetaTable();
+        if (isOneTableMode(COLLECTION_STORAGE_MODE)) {
+            await ensureGlobalPointsTable();
+        }
     }
     catch (err) {
         logger.error({ err }, "YDB not ready; startup continues, requests may fail until configured.");

package/dist/indexing/IndexScheduler.js

@@ -1,8 +1,6 @@
-import { buildVectorIndex } from "../repositories/collectionsRepo.js";
-import { logger } from "../logging/logger.js";
-const QUIET_MS = 10000; // no upserts for 10s => build
-const MIN_POINTS_THRESHOLD = 100; // only rebuild if at least this many points upserted
-const state = {};
+import { GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
+import { state, requestIndexBuildMultiTable, } from "./IndexScheduler.multi-table.js";
+import { requestIndexBuildOneTable } from "./IndexScheduler.one-table.js";
 export function notifyUpsert(tableName, count = 1) {
     const now = Date.now();
     const s = state[tableName] ?? {
@@ -15,52 +13,9 @@ export function notifyUpsert(tableName, count = 1) {
     state[tableName] = s;
 }
 export function requestIndexBuild(tableName, dimension, distance, vectorType, opts) {
-    const s = state[tableName] ?? {
-        lastUpsertMs: 0,
-        pending: false,
-        pointsUpserted: 0,
-    };
-    state[tableName] = s;
-    if (opts?.force) {
-        logger.info({ tableName }, "index build (force) starting");
-        void buildVectorIndex(tableName, dimension, distance, vectorType)
-            .then(() => {
-            logger.info({ tableName }, "index build (force) completed");
-            s.pointsUpserted = 0;
-        })
-            .catch((err) => {
-            logger.error({ err, tableName }, "index build (force) failed");
-        });
-        return;
-    }
-    if (s.pending && s.timer) {
-        // already scheduled; timer will check quiet window
+    if (tableName === GLOBAL_POINTS_TABLE) {
+        requestIndexBuildOneTable(tableName);
         return;
     }
-    s.pending = true;
-    s.timer = setTimeout(function tryBuild() {
-        const since = Date.now() - (state[tableName]?.lastUpsertMs ?? 0);
-        if (since < QUIET_MS) {
-            s.timer = setTimeout(tryBuild, QUIET_MS - since);
-            return;
-        }
-        const pointsCount = state[tableName]?.pointsUpserted ?? 0;
-        if (pointsCount < MIN_POINTS_THRESHOLD) {
-            logger.info({ tableName, pointsCount, threshold: MIN_POINTS_THRESHOLD }, "index build skipped (below threshold)");
-            s.pending = false;
-            s.timer = undefined;
-            return;
-        }
-        logger.info({ tableName, pointsCount }, "index build (scheduled) starting");
-        void buildVectorIndex(tableName, dimension, distance, vectorType)
-            .then(() => {
-            logger.info({ tableName }, "index build (scheduled) completed");
-            state[tableName].pointsUpserted = 0;
-        })
-            .catch((err) => logger.error({ err, tableName }, "index build (scheduled) failed"))
-            .finally(() => {
-            s.pending = false;
-            s.timer = undefined;
-        });
-    }, QUIET_MS);
+    requestIndexBuildMultiTable(tableName, dimension, distance, vectorType, opts);
 }

package/dist/indexing/IndexScheduler.multi-table.d.ts

@@ -0,0 +1,12 @@
+import type { DistanceKind, VectorType } from "../types.js";
+type CollectionKey = string;
+export declare const state: Record<CollectionKey, {
+    lastUpsertMs: number;
+    timer?: NodeJS.Timeout;
+    pending: boolean;
+    pointsUpserted: number;
+}>;
+export declare function requestIndexBuildMultiTable(tableName: string, dimension: number, distance: DistanceKind, vectorType: VectorType, opts?: {
+    force?: boolean;
+}): void;
+export {};

package/dist/indexing/IndexScheduler.multi-table.js

@@ -0,0 +1,54 @@
+import { buildVectorIndex } from "../repositories/collectionsRepo.js";
+import { logger } from "../logging/logger.js";
+const QUIET_MS = 10000;
+const MIN_POINTS_THRESHOLD = 100;
+export const state = {};
+export function requestIndexBuildMultiTable(tableName, dimension, distance, vectorType, opts) {
+    const s = state[tableName] ?? {
+        lastUpsertMs: 0,
+        pending: false,
+        pointsUpserted: 0,
+    };
+    state[tableName] = s;
+    if (opts?.force) {
+        logger.info({ tableName }, "index build (force) starting");
+        void buildVectorIndex(tableName, dimension, distance, vectorType)
+            .then(() => {
+            logger.info({ tableName }, "index build (force) completed");
+            s.pointsUpserted = 0;
+        })
+            .catch((err) => {
+            logger.error({ err, tableName }, "index build (force) failed");
+        });
+        return;
+    }
+    if (s.pending && s.timer) {
+        return;
+    }
+    s.pending = true;
+    s.timer = setTimeout(function tryBuild() {
+        const since = Date.now() - (state[tableName]?.lastUpsertMs ?? 0);
+        if (since < QUIET_MS) {
+            s.timer = setTimeout(tryBuild, QUIET_MS - since);
+            return;
+        }
+        const pointsCount = state[tableName]?.pointsUpserted ?? 0;
+        if (pointsCount < MIN_POINTS_THRESHOLD) {
+            logger.info({ tableName, pointsCount, threshold: MIN_POINTS_THRESHOLD }, "index build skipped (below threshold)");
+            s.pending = false;
+            s.timer = undefined;
+            return;
+        }
+        logger.info({ tableName, pointsCount }, "index build (scheduled) starting");
+        void buildVectorIndex(tableName, dimension, distance, vectorType)
+            .then(() => {
+            logger.info({ tableName }, "index build (scheduled) completed");
+            state[tableName].pointsUpserted = 0;
+        })
+            .catch((err) => logger.error({ err, tableName }, "index build (scheduled) failed"))
+            .finally(() => {
+            s.pending = false;
+            s.timer = undefined;
+        });
+    }, QUIET_MS);
+}

package/dist/indexing/IndexScheduler.one-table.d.ts

@@ -0,0 +1 @@
+export declare function requestIndexBuildOneTable(tableName: string): void;

package/dist/indexing/IndexScheduler.one-table.js

@@ -0,0 +1,4 @@
+import { logger } from "../logging/logger.js";
+export function requestIndexBuildOneTable(tableName) {
+    logger.info({ tableName }, "index build skipped (one_table mode: global vector index not supported)");
+}

package/dist/package/{Api.d.ts → api.d.ts}

@@ -1,6 +1,7 @@
 import type { IAuthService } from "ydb-sdk";
-import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex, upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints } from "../services/QdrantService.js";
-export { QdrantServiceError } from "../services/QdrantService.js";
+import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex } from "../services/CollectionService.js";
+import { upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints } from "../services/PointsService.js";
+export { QdrantServiceError } from "../services/errors.js";
 export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, } from "../types.js";
 type CreateCollectionResult = Awaited<ReturnType<typeof serviceCreateCollection>>;
 type GetCollectionResult = Awaited<ReturnType<typeof serviceGetCollection>>;

package/dist/package/api.js

@@ -0,0 +1,55 @@
+import { readyOrThrow, configureDriver } from "../ydb/client.js";
+import { ensureMetaTable } from "../ydb/schema.js";
+import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex, } from "../services/CollectionService.js";
+import { upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints, } from "../services/PointsService.js";
+export { QdrantServiceError } from "../services/errors.js";
+export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, } from "../types.js";
+function buildTenantClient(resolveTenant) {
+    return {
+        createCollection(collection, body) {
+            return serviceCreateCollection({ tenant: resolveTenant(), collection }, body);
+        },
+        getCollection(collection) {
+            return serviceGetCollection({ tenant: resolveTenant(), collection });
+        },
+        deleteCollection(collection) {
+            return serviceDeleteCollection({ tenant: resolveTenant(), collection });
+        },
+        putCollectionIndex(collection) {
+            return servicePutCollectionIndex({ tenant: resolveTenant(), collection });
+        },
+        upsertPoints(collection, body) {
+            return serviceUpsertPoints({ tenant: resolveTenant(), collection }, body);
+        },
+        searchPoints(collection, body) {
+            return serviceSearchPoints({ tenant: resolveTenant(), collection }, body);
+        },
+        deletePoints(collection, body) {
+            return serviceDeletePoints({ tenant: resolveTenant(), collection }, body);
+        },
+    };
+}
+export async function createYdbQdrantClient(options = {}) {
+    if (options.endpoint !== undefined ||
+        options.database !== undefined ||
+        options.connectionString !== undefined ||
+        options.authService !== undefined) {
+        configureDriver({
+            endpoint: options.endpoint,
+            database: options.database,
+            connectionString: options.connectionString,
+            authService: options.authService,
+        });
+    }
+    await readyOrThrow();
+    await ensureMetaTable();
+    const defaultTenant = options.defaultTenant ?? "default";
+    const baseClient = buildTenantClient(() => defaultTenant);
+    const client = {
+        ...baseClient,
+        forTenant(tenantId) {
+            return buildTenantClient(() => tenantId);
+        },
+    };
+    return client;
+}

package/dist/repositories/collectionsRepo.d.ts

@@ -1,10 +1,11 @@
 import type { DistanceKind, VectorType } from "../types";
-export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string): Promise<void>;
+import { type CollectionStorageMode } from "../config/env.js";
+export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string, layout?: CollectionStorageMode): Promise<void>;
 export declare function getCollectionMeta(metaKey: string): Promise<{
     table: string;
     dimension: number;
     distance: DistanceKind;
     vectorType: VectorType;
 } | null>;
-export declare function deleteCollection(metaKey: string): Promise<void>;
+export declare function deleteCollection(metaKey: string, uid?: string): Promise<void>;
 export declare function buildVectorIndex(tableName: string, dimension: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;

package/dist/repositories/collectionsRepo.js

@@ -1,31 +1,16 @@
-import { Types, TypedValues, withSession, TableDescription, Column, } from "../ydb/client.js";
-export async function createCollection(metaKey, dim, distance, vectorType, tableName) {
-    await withSession(async (s) => {
-        const desc = new TableDescription()
-            .withColumns(new Column("point_id", Types.UTF8), new Column("embedding", Types.BYTES), new Column("payload", Types.JSON_DOCUMENT))
-            .withPrimaryKey("point_id");
-        await s.createTable(tableName, desc);
-    });
-    const upsertMeta = `
-    DECLARE $collection AS Utf8;
-    DECLARE $table AS Utf8;
-    DECLARE $dim AS Uint32;
-    DECLARE $distance AS Utf8;
-    DECLARE $vtype AS Utf8;
-    DECLARE $created AS Timestamp;
-    UPSERT INTO qdr__collections (collection, table_name, vector_dimension, distance, vector_type, created_at)
-    VALUES ($collection, $table, $dim, $distance, $vtype, $created);
-  `;
-    await withSession(async (s) => {
-        await s.executeQuery(upsertMeta, {
-            $collection: TypedValues.utf8(metaKey),
-            $table: TypedValues.utf8(tableName),
-            $dim: TypedValues.uint32(dim),
-            $distance: TypedValues.utf8(distance),
-            $vtype: TypedValues.utf8(vectorType),
-            $created: TypedValues.timestamp(new Date()),
-        });
-    });
+import { TypedValues, withSession } from "../ydb/client.js";
+import { mapDistanceToIndexParam } from "../utils/distance.js";
+import { COLLECTION_STORAGE_MODE, isOneTableMode, } from "../config/env.js";
+import { GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
+import { uidFor } from "../utils/tenant.js";
+import { createCollectionMultiTable, deleteCollectionMultiTable, } from "./collectionsRepo.multi-table.js";
+import { createCollectionOneTable, deleteCollectionOneTable, } from "./collectionsRepo.one-table.js";
+export async function createCollection(metaKey, dim, distance, vectorType, tableName, layout = COLLECTION_STORAGE_MODE) {
+    if (isOneTableMode(layout)) {
+        await createCollectionOneTable(metaKey, dim, distance, vectorType);
+        return;
+    }
+    await createCollectionMultiTable(metaKey, dim, distance, vectorType, tableName);
 }
 export async function getCollectionMeta(metaKey) {
     const qry = `
@@ -49,20 +34,23 @@ export async function getCollectionMeta(metaKey) {
     const vectorType = row.items?.[3]?.textValue ?? "float";
     return { table, dimension, distance, vectorType };
 }
-export async function deleteCollection(metaKey) {
+export async function deleteCollection(metaKey, uid) {
     const meta = await getCollectionMeta(metaKey);
     if (!meta)
         return;
-    await withSession(async (s) => {
-        await s.dropTable(meta.table);
-    });
-    const delMeta = `
-    DECLARE $collection AS Utf8;
-    DELETE FROM qdr__collections WHERE collection = $collection;
-  `;
-    await withSession(async (s) => {
-        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) });
-    });
+    if (meta.table === GLOBAL_POINTS_TABLE) {
+        const effectiveUid = uid ??
+            (() => {
+                const [tenant, collection] = metaKey.split("/", 2);
+                if (!tenant || !collection) {
+                    throw new Error(`deleteCollection: cannot derive uid from malformed metaKey=${metaKey}`);
+                }
+                return uidFor(tenant, collection);
+            })();
+        await deleteCollectionOneTable(metaKey, effectiveUid);
+        return;
+    }
+    await deleteCollectionMultiTable(metaKey, meta.table);
 }
 export async function buildVectorIndex(tableName, dimension, distance, vectorType) {
     const distParam = mapDistanceToIndexParam(distance);
@@ -103,17 +91,3 @@ export async function buildVectorIndex(tableName, dimension, distance, vectorTyp
         await rawSession.api.executeSchemeQuery(createReq);
     });
 }
-function mapDistanceToIndexParam(distance) {
-    switch (distance) {
-        case "Cosine":
-            return "cosine";
-        case "Dot":
-            return "inner_product";
-        case "Euclid":
-            return "euclidean";
-        case "Manhattan":
-            return "manhattan";
-        default:
-            return "cosine";
-    }
-}

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

@@ -0,0 +1,3 @@
+import type { DistanceKind, VectorType } from "../types";
+export declare function createCollectionMultiTable(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string): Promise<void>;
+export declare function deleteCollectionMultiTable(metaKey: string, tableName: string): Promise<void>;

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

@@ -0,0 +1,23 @@
+import { Types, TypedValues, withSession, TableDescription, Column, } from "../ydb/client.js";
+import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
+export async function createCollectionMultiTable(metaKey, dim, distance, vectorType, tableName) {
+    await withSession(async (s) => {
+        const desc = new TableDescription()
+            .withColumns(new Column("point_id", Types.UTF8), new Column("embedding", Types.BYTES), new Column("payload", Types.JSON_DOCUMENT))
+            .withPrimaryKey("point_id");
+        await s.createTable(tableName, desc);
+    });
+    await upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName);
+}
+export async function deleteCollectionMultiTable(metaKey, tableName) {
+    await withSession(async (s) => {
+        await s.dropTable(tableName);
+    });
+    const delMeta = `
+    DECLARE $collection AS Utf8;
+    DELETE FROM qdr__collections WHERE collection = $collection;
+  `;
+    await withSession(async (s) => {
+        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) });
+    });
+}

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

@@ -0,0 +1,3 @@
+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>;

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

@@ -0,0 +1,25 @@
+import { TypedValues, withSession } from "../ydb/client.js";
+import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
+import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
+export async function createCollectionOneTable(metaKey, dim, distance, vectorType) {
+    await upsertCollectionMeta(metaKey, dim, distance, vectorType, GLOBAL_POINTS_TABLE);
+}
+export async function deleteCollectionOneTable(metaKey, uid) {
+    await ensureGlobalPointsTable();
+    const deletePointsYql = `
+    DECLARE $uid AS Utf8;
+    DELETE FROM ${GLOBAL_POINTS_TABLE} WHERE uid = $uid;
+  `;
+    await withSession(async (s) => {
+        await s.executeQuery(deletePointsYql, {
+            $uid: TypedValues.utf8(uid),
+        });
+    });
+    const delMeta = `
+    DECLARE $collection AS Utf8;
+    DELETE FROM qdr__collections WHERE collection = $collection;
+  `;
+    await withSession(async (s) => {
+        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) });
+    });
+}

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

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

package/dist/repositories/collectionsRepo.shared.js

@@ -0,0 +1,23 @@
+import { TypedValues, withSession } from "../ydb/client.js";
+export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName) {
+    const upsertMeta = `
+    DECLARE $collection AS Utf8;
+    DECLARE $table AS Utf8;
+    DECLARE $dim AS Uint32;
+    DECLARE $distance AS Utf8;
+    DECLARE $vtype AS Utf8;
+    DECLARE $created AS Timestamp;
+    UPSERT INTO qdr__collections (collection, table_name, vector_dimension, distance, vector_type, created_at)
+    VALUES ($collection, $table, $dim, $distance, $vtype, $created);
+  `;
+    await withSession(async (s) => {
+        await s.executeQuery(upsertMeta, {
+            $collection: TypedValues.utf8(metaKey),
+            $table: TypedValues.utf8(tableName),
+            $dim: TypedValues.uint32(dim),
+            $distance: TypedValues.utf8(distance),
+            $vtype: TypedValues.utf8(vectorType),
+            $created: TypedValues.timestamp(new Date()),
+        });
+    });
+}

package/dist/repositories/pointsRepo.d.ts

@@ -3,10 +3,10 @@ export declare function upsertPoints(tableName: string, points: Array<{
     id: string | number;
     vector: number[];
     payload?: Record<string, unknown>;
-}>, dimension: number): Promise<number>;
-export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number): Promise<Array<{
+}>, 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): Promise<Array<{
     id: string;
     score: number;
     payload?: Record<string, unknown>;
 }>>;
-export declare function deletePoints(tableName: string, ids: Array<string | number>): Promise<number>;
+export declare function deletePoints(tableName: string, ids: Array<string | number>, uid?: string): Promise<number>;