ydb-qdrant 4.0.0 → 4.1.1

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. Columns: `uid Utf8`, `point_id Utf8`, `embedding String` (binary float), `embedding_bit String` (bit‑quantized), `payload JsonDocument`.
+- 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; searches use a two‑phase approximate+exact flow over `qdrant_all_points` (bit‑quantized candidates via `embedding_bit` using the corresponding distance function, then exact re‑ranking over `embedding`). Note: For Dot metric, Phase 1 uses CosineDistance as a proxy since there is no direct distance equivalent for inner product on bit vectors.
 - **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/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/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,32 +1,16 @@
-import { Types, TypedValues, withSession, TableDescription, Column, } from "../ydb/client.js";
+import { TypedValues, withSession } from "../ydb/client.js";
 import { mapDistanceToIndexParam } from "../utils/distance.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 { 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 = `
@@ -50,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);

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>;

package/dist/repositories/pointsRepo.js

@@ -1,133 +1,20 @@
-import { TypedValues, withSession } from "../ydb/client.js";
-import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
-import { logger } from "../logging/logger.js";
-import { notifyUpsert } from "../indexing/IndexScheduler.js";
-import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
-import { mapDistanceToKnnFn } from "../utils/distance.js";
-import { withRetry, isTransientYdbError } from "../utils/retry.js";
-export async function upsertPoints(tableName, points, dimension) {
-    let upserted = 0;
-    await withSession(async (s) => {
-        for (const p of points) {
-            const id = String(p.id);
-            if (p.vector.length !== dimension) {
-                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
-            }
-            const ddl = `
-        DECLARE $id AS Utf8;
-        DECLARE $vec AS List<Float>;
-        DECLARE $payload AS JsonDocument;
-        UPSERT INTO ${tableName} (point_id, embedding, payload)
-        VALUES (
-          $id,
-          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
-          $payload
-        );
-      `;
-            const params = {
-                $id: TypedValues.utf8(id),
-                $vec: buildVectorParam(p.vector),
-                $payload: buildJsonOrEmpty(p.payload),
-            };
-            await withRetry(() => s.executeQuery(ddl, params), {
-                isTransient: isTransientYdbError,
-                context: { tableName, id },
-            });
-            upserted += 1;
-        }
-    });
-    notifyUpsert(tableName, upserted);
-    return upserted;
-}
-// Removed legacy index backfill helper
-export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension) {
-    if (queryVector.length !== dimension) {
-        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
-    }
-    const { fn, order } = mapDistanceToKnnFn(distance);
-    // Single-phase search over embedding using vector index if present
-    const qf = buildVectorParam(queryVector);
-    const params = {
-        $qf: qf,
-        $k2: TypedValues.uint32(top),
-    };
-    const buildQuery = (useIndex) => `
-    DECLARE $qf AS List<Float>;
-    DECLARE $k2 AS Uint32;
-    $qbinf = Knn::ToBinaryStringFloat($qf);
-    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-    FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
-    ORDER BY score ${order}
-    LIMIT $k2;
-  `;
-    let rs;
-    if (VECTOR_INDEX_BUILD_ENABLED) {
-        try {
-            // Try with vector index first
-            rs = await withSession(async (s) => {
-                return await s.executeQuery(buildQuery(true), params);
-            });
-            logger.info({ tableName }, "vector index found; using index for search");
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            const indexUnavailable = /not found|does not exist|no such index|no global index|is not ready to use/i.test(msg);
-            if (indexUnavailable) {
-                logger.info({ tableName }, "vector index not available (missing or building); falling back to table scan");
-                rs = await withSession(async (s) => {
-                    return await s.executeQuery(buildQuery(false), params);
-                });
-            }
-            else {
-                throw e;
-            }
-        }
+import { upsertPointsMultiTable, searchPointsMultiTable, deletePointsMultiTable, } from "./pointsRepo.multi-table.js";
+import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, } from "./pointsRepo.one-table.js";
+export async function upsertPoints(tableName, points, dimension, uid) {
+    if (uid) {
+        return await upsertPointsOneTable(tableName, points, dimension, uid);
     }
-    else {
-        // Vector index usage disabled: always use table scan
-        rs = await withSession(async (s) => {
-            return await s.executeQuery(buildQuery(false), params);
-        });
+    return await upsertPointsMultiTable(tableName, points, dimension);
+}
+export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid) {
+    if (uid) {
+        return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid);
     }
-    const rowset = rs.resultSets?.[0];
-    const rows = (rowset?.rows ?? []);
-    return rows.map((row) => {
-        const id = row.items?.[0]?.textValue;
-        if (typeof id !== "string") {
-            throw new Error("point_id is missing in YDB search result");
-        }
-        let payload;
-        let scoreIdx = 1;
-        if (withPayload) {
-            const payloadText = row.items?.[1]?.textValue;
-            if (payloadText) {
-                try {
-                    payload = JSON.parse(payloadText);
-                }
-                catch {
-                    payload = undefined;
-                }
-            }
-            scoreIdx = 2;
-        }
-        const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
-        return { id, score, ...(payload ? { payload } : {}) };
-    });
+    return await searchPointsMultiTable(tableName, queryVector, top, withPayload, distance, dimension);
 }
-export async function deletePoints(tableName, ids) {
-    let deleted = 0;
-    await withSession(async (s) => {
-        for (const id of ids) {
-            const yql = `
-        DECLARE $id AS Utf8;
-        DELETE FROM ${tableName} WHERE point_id = $id;
-      `;
-            const params = {
-                $id: TypedValues.utf8(String(id)),
-            };
-            await s.executeQuery(yql, params);
-            deleted += 1;
-        }
-    });
-    return deleted;
+export async function deletePoints(tableName, ids, uid) {
+    if (uid) {
+        return await deletePointsOneTable(tableName, ids, uid);
+    }
+    return await deletePointsMultiTable(tableName, ids);
 }

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

@@ -0,0 +1,12 @@
+import type { DistanceKind } from "../types";
+export declare function upsertPointsMultiTable(tableName: string, points: Array<{
+    id: string | number;
+    vector: number[];
+    payload?: Record<string, unknown>;
+}>, dimension: number): Promise<number>;
+export declare function searchPointsMultiTable(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number): Promise<Array<{
+    id: string;
+    score: number;
+    payload?: Record<string, unknown>;
+}>>;
+export declare function deletePointsMultiTable(tableName: string, ids: Array<string | number>): Promise<number>;

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

@@ -0,0 +1,129 @@
+import { TypedValues, withSession } from "../ydb/client.js";
+import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
+import { logger } from "../logging/logger.js";
+import { notifyUpsert } from "../indexing/IndexScheduler.js";
+import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
+import { mapDistanceToKnnFn } from "../utils/distance.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+export async function upsertPointsMultiTable(tableName, points, dimension) {
+    let upserted = 0;
+    await withSession(async (s) => {
+        for (const p of points) {
+            const id = String(p.id);
+            if (p.vector.length !== dimension) {
+                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
+            }
+            const ddl = `
+        DECLARE $id AS Utf8;
+        DECLARE $vec AS List<Float>;
+        DECLARE $payload AS JsonDocument;
+        UPSERT INTO ${tableName} (point_id, embedding, payload)
+        VALUES (
+          $id,
+          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
+          $payload
+        );
+      `;
+            const params = {
+                $id: TypedValues.utf8(id),
+                $vec: buildVectorParam(p.vector),
+                $payload: buildJsonOrEmpty(p.payload),
+            };
+            await withRetry(() => s.executeQuery(ddl, params), {
+                isTransient: isTransientYdbError,
+                context: { tableName, id },
+            });
+            upserted += 1;
+        }
+    });
+    notifyUpsert(tableName, upserted);
+    return upserted;
+}
+export async function searchPointsMultiTable(tableName, queryVector, top, withPayload, distance, dimension) {
+    if (queryVector.length !== dimension) {
+        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
+    }
+    const { fn, order } = mapDistanceToKnnFn(distance);
+    const qf = buildVectorParam(queryVector);
+    const params = {
+        $qf: qf,
+        $k2: TypedValues.uint32(top),
+    };
+    const buildQuery = (useIndex) => `
+    DECLARE $qf AS List<Float>;
+    DECLARE $k2 AS Uint32;
+    $qbinf = Knn::ToBinaryStringFloat($qf);
+    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+    FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
+    ORDER BY score ${order}
+    LIMIT $k2;
+  `;
+    let rs;
+    if (VECTOR_INDEX_BUILD_ENABLED) {
+        try {
+            rs = await withSession(async (s) => {
+                return await s.executeQuery(buildQuery(true), params);
+            });
+            logger.info({ tableName }, "vector index found; using index for search");
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            const indexUnavailable = /not found|does not exist|no such index|no global index|is not ready to use/i.test(msg);
+            if (indexUnavailable) {
+                logger.info({ tableName }, "vector index not available (missing or building); falling back to table scan");
+                rs = await withSession(async (s) => {
+                    return await s.executeQuery(buildQuery(false), params);
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    else {
+        rs = await withSession(async (s) => {
+            return await s.executeQuery(buildQuery(false), params);
+        });
+    }
+    const rowset = rs.resultSets?.[0];
+    const rows = (rowset?.rows ?? []);
+    return rows.map((row) => {
+        const id = row.items?.[0]?.textValue;
+        if (typeof id !== "string") {
+            throw new Error("point_id is missing in YDB search result");
+        }
+        let payload;
+        let scoreIdx = 1;
+        if (withPayload) {
+            const payloadText = row.items?.[1]?.textValue;
+            if (payloadText) {
+                try {
+                    payload = JSON.parse(payloadText);
+                }
+                catch {
+                    payload = undefined;
+                }
+            }
+            scoreIdx = 2;
+        }
+        const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
+        return { id, score, ...(payload ? { payload } : {}) };
+    });
+}
+export async function deletePointsMultiTable(tableName, ids) {
+    let deleted = 0;
+    await withSession(async (s) => {
+        for (const id of ids) {
+            const yql = `
+        DECLARE $id AS Utf8;
+        DELETE FROM ${tableName} WHERE point_id = $id;
+      `;
+            const params = {
+                $id: TypedValues.utf8(String(id)),
+            };
+            await s.executeQuery(yql, params);
+            deleted += 1;
+        }
+    });
+    return deleted;
+}

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

@@ -0,0 +1,12 @@
+import type { DistanceKind } from "../types";
+export declare function upsertPointsOneTable(tableName: string, points: Array<{
+    id: string | number;
+    vector: number[];
+    payload?: Record<string, unknown>;
+}>, dimension: number, uid: string): Promise<number>;
+export declare function searchPointsOneTable(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 deletePointsOneTable(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;

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

@@ -0,0 +1,145 @@
+import { TypedValues, Types, withSession } from "../ydb/client.js";
+import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
+import { notifyUpsert } from "../indexing/IndexScheduler.js";
+import { mapDistanceToKnnFn, mapDistanceToBitKnnFn, } from "../utils/distance.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+export async function upsertPointsOneTable(tableName, points, dimension, uid) {
+    let upserted = 0;
+    await withSession(async (s) => {
+        for (const p of points) {
+            const id = String(p.id);
+            if (p.vector.length !== dimension) {
+                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
+            }
+            const ddl = `
+        DECLARE $uid AS Utf8;
+        DECLARE $id AS Utf8;
+        DECLARE $vec AS List<Float>;
+        DECLARE $payload AS JsonDocument;
+        UPSERT INTO ${tableName} (uid, point_id, embedding, embedding_bit, payload)
+        VALUES (
+          $uid,
+          $id,
+          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
+          Untag(Knn::ToBinaryStringBit($vec), "BitVector"),
+          $payload
+        );
+      `;
+            const params = {
+                $uid: TypedValues.utf8(uid),
+                $id: TypedValues.utf8(id),
+                $vec: buildVectorParam(p.vector),
+                $payload: buildJsonOrEmpty(p.payload),
+            };
+            await withRetry(() => s.executeQuery(ddl, params), {
+                isTransient: isTransientYdbError,
+                context: { tableName, id },
+            });
+            upserted += 1;
+        }
+    });
+    notifyUpsert(tableName, upserted);
+    return upserted;
+}
+export async function searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid) {
+    if (queryVector.length !== dimension) {
+        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
+    }
+    const { fn, order } = mapDistanceToKnnFn(distance);
+    const { fn: bitFn, order: bitOrder } = mapDistanceToBitKnnFn(distance);
+    const qf = buildVectorParam(queryVector);
+    const candidateLimit = top * 10;
+    const results = await withSession(async (s) => {
+        // Phase 1: approximate candidate selection using embedding_bit
+        const phase1Query = `
+      DECLARE $qf AS List<Float>;
+      DECLARE $k AS Uint32;
+      DECLARE $uid AS Utf8;
+      $qbin_bit = Knn::ToBinaryStringBit($qf);
+      SELECT point_id
+      FROM ${tableName}
+      WHERE uid = $uid AND embedding_bit IS NOT NULL
+      ORDER BY ${bitFn}(embedding_bit, $qbin_bit) ${bitOrder}
+      LIMIT $k;
+    `;
+        const phase1Params = {
+            $qf: qf,
+            $k: TypedValues.uint32(candidateLimit),
+            $uid: TypedValues.utf8(uid),
+        };
+        const rs1 = await s.executeQuery(phase1Query, phase1Params);
+        const rowset1 = rs1.resultSets?.[0];
+        const rows1 = (rowset1?.rows ?? []);
+        const candidateIds = rows1
+            .map((row) => row.items?.[0]?.textValue)
+            .filter((id) => typeof id === "string");
+        if (candidateIds.length === 0) {
+            return [];
+        }
+        // Phase 2: exact re-ranking on full-precision embedding for candidates only
+        const phase2Query = `
+      DECLARE $qf AS List<Float>;
+      DECLARE $k AS Uint32;
+      DECLARE $uid AS Utf8;
+      DECLARE $ids AS List<Utf8>;
+      $qbinf = Knn::ToBinaryStringFloat($qf);
+      SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+      FROM ${tableName}
+      WHERE uid = $uid AND point_id IN $ids
+      ORDER BY score ${order}
+      LIMIT $k;
+    `;
+        const idsParam = TypedValues.list(Types.UTF8, candidateIds);
+        const phase2Params = {
+            $qf: qf,
+            $k: TypedValues.uint32(top),
+            $uid: TypedValues.utf8(uid),
+            $ids: idsParam,
+        };
+        const rs2 = await s.executeQuery(phase2Query, phase2Params);
+        const rowset2 = rs2.resultSets?.[0];
+        const rows2 = (rowset2?.rows ?? []);
+        return rows2.map((row) => {
+            const id = row.items?.[0]?.textValue;
+            if (typeof id !== "string") {
+                throw new Error("point_id is missing in YDB search result");
+            }
+            let payload;
+            let scoreIdx = 1;
+            if (withPayload) {
+                const payloadText = row.items?.[1]?.textValue;
+                if (payloadText) {
+                    try {
+                        payload = JSON.parse(payloadText);
+                    }
+                    catch {
+                        payload = undefined;
+                    }
+                }
+                scoreIdx = 2;
+            }
+            const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
+            return { id, score, ...(payload ? { payload } : {}) };
+        });
+    });
+    return results;
+}
+export async function deletePointsOneTable(tableName, ids, uid) {
+    let deleted = 0;
+    await withSession(async (s) => {
+        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 s.executeQuery(yql, params);
+            deleted += 1;
+        }
+    });
+    return deleted;
+}

package/dist/services/CollectionService.d.ts

@@ -9,6 +9,12 @@ export interface NormalizedCollectionContext {
     metaKey: string;
 }
 export declare function normalizeCollectionContext(input: CollectionContextInput): NormalizedCollectionContext;
+export declare function resolvePointsTableAndUid(ctx: NormalizedCollectionContext, meta: {
+    table: string;
+}): Promise<{
+    tableName: string;
+    uid: string | undefined;
+}>;
 export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
     acknowledged: boolean;
 }>;

package/dist/services/CollectionService.js

@@ -1,13 +1,20 @@
-import { sanitizeCollectionName, sanitizeTenantId, metaKeyFor, tableNameFor, } from "../utils/tenant.js";
 import { CreateCollectionReq } from "../types.js";
-import { ensureMetaTable } from "../ydb/schema.js";
+import { ensureMetaTable, GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
 import { createCollection as repoCreateCollection, deleteCollection as repoDeleteCollection, getCollectionMeta, } from "../repositories/collectionsRepo.js";
 import { QdrantServiceError } from "./errors.js";
+import { normalizeCollectionContextShared, tableNameFor, } from "./CollectionService.shared.js";
+import { resolvePointsTableAndUidOneTable } from "./CollectionService.one-table.js";
 export function normalizeCollectionContext(input) {
-    const tenant = sanitizeTenantId(input.tenant);
-    const collection = sanitizeCollectionName(input.collection);
-    const metaKey = metaKeyFor(tenant, collection);
-    return { tenant, collection, metaKey };
+    return normalizeCollectionContextShared(input.tenant, input.collection);
+}
+export async function resolvePointsTableAndUid(ctx, meta) {
+    if (meta?.table === GLOBAL_POINTS_TABLE) {
+        return await resolvePointsTableAndUidOneTable(ctx);
+    }
+    return {
+        tableName: meta.table,
+        uid: undefined,
+    };
 }
 export async function putCollectionIndex(ctx) {
     await ensureMetaTable();

package/dist/services/CollectionService.multi-table.d.ts

@@ -0,0 +1,5 @@
+import { type NormalizedCollectionContextLike } from "./CollectionService.shared.js";
+export declare function resolvePointsTableAndUidMultiTable(ctx: NormalizedCollectionContextLike): {
+    tableName: string;
+    uid: string | undefined;
+};

package/dist/services/CollectionService.multi-table.js

@@ -0,0 +1,7 @@
+import { tableNameFor, } from "./CollectionService.shared.js";
+export function resolvePointsTableAndUidMultiTable(ctx) {
+    return {
+        tableName: tableNameFor(ctx.tenant, ctx.collection),
+        uid: undefined,
+    };
+}

package/dist/services/CollectionService.one-table.d.ts

@@ -0,0 +1,5 @@
+import { type NormalizedCollectionContextLike } from "./CollectionService.shared.js";
+export declare function resolvePointsTableAndUidOneTable(ctx: NormalizedCollectionContextLike): Promise<{
+    tableName: string;
+    uid: string | undefined;
+}>;

package/dist/services/CollectionService.one-table.js

@@ -0,0 +1,9 @@
+import { uidFor, } from "./CollectionService.shared.js";
+import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
+export async function resolvePointsTableAndUidOneTable(ctx) {
+    await ensureGlobalPointsTable();
+    return {
+        tableName: GLOBAL_POINTS_TABLE,
+        uid: uidFor(ctx.tenant, ctx.collection),
+    };
+}

package/dist/services/CollectionService.shared.d.ts

@@ -0,0 +1,11 @@
+export interface NormalizedCollectionContextLike {
+    tenant: string;
+    collection: string;
+}
+export declare function tableNameFor(tenantId: string, collection: string): string;
+export declare function uidFor(tenantId: string, collection: string): string;
+export declare function normalizeCollectionContextShared(tenant: string | undefined, collection: string): {
+    tenant: string;
+    collection: string;
+    metaKey: string;
+};

package/dist/services/CollectionService.shared.js

@@ -0,0 +1,17 @@
+import { sanitizeCollectionName, sanitizeTenantId, metaKeyFor, tableNameFor as tableNameForInternal, uidFor as uidForInternal, } from "../utils/tenant.js";
+export function tableNameFor(tenantId, collection) {
+    return tableNameForInternal(tenantId, collection);
+}
+export function uidFor(tenantId, collection) {
+    return uidForInternal(tenantId, collection);
+}
+export function normalizeCollectionContextShared(tenant, collection) {
+    const normalizedTenant = sanitizeTenantId(tenant);
+    const normalizedCollection = sanitizeCollectionName(collection);
+    const metaKey = metaKeyFor(normalizedTenant, normalizedCollection);
+    return {
+        tenant: normalizedTenant,
+        collection: normalizedCollection,
+        metaKey,
+    };
+}

package/dist/services/PointsService.js

@@ -6,7 +6,7 @@ import { requestIndexBuild } from "../indexing/IndexScheduler.js";
 import { logger } from "../logging/logger.js";
 import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
 import { QdrantServiceError } from "./errors.js";
-import { normalizeCollectionContext, } from "./CollectionService.js";
+import { normalizeCollectionContext, resolvePointsTableAndUid, } from "./CollectionService.js";
 import { normalizeSearchBodyForSearch, normalizeSearchBodyForQuery, } from "../utils/normalization.js";
 let loggedIndexBuildDisabled = false;
 export async function upsertPoints(ctx, body) {
@@ -26,12 +26,13 @@ export async function upsertPoints(ctx, body) {
             error: parsed.error.flatten(),
         });
     }
-    const upserted = await repoUpsertPoints(meta.table, parsed.data.points, meta.dimension);
+    const { tableName, uid } = await resolvePointsTableAndUid(normalized, meta);
+    const upserted = await repoUpsertPoints(tableName, parsed.data.points, meta.dimension, uid);
     if (VECTOR_INDEX_BUILD_ENABLED) {
-        requestIndexBuild(meta.table, meta.dimension, meta.distance, meta.vectorType);
+        requestIndexBuild(tableName, meta.dimension, meta.distance, meta.vectorType);
     }
     else if (!loggedIndexBuildDisabled) {
-        logger.info({ table: meta.table }, "vector index building disabled by env; skipping automatic emb_idx rebuilds");
+        logger.info({ table: tableName }, "vector index building disabled by env; skipping automatic emb_idx rebuilds");
         loggedIndexBuildDisabled = true;
     }
     return { upserted };
@@ -68,6 +69,7 @@ async function executeSearch(ctx, normalizedSearch, source) {
             error: parsed.error.flatten(),
         });
     }
+    const { tableName, uid } = await resolvePointsTableAndUid(normalized, meta);
     logger.info({
         tenant: normalized.tenant,
         collection: normalized.collection,
@@ -77,7 +79,7 @@ async function executeSearch(ctx, normalizedSearch, source) {
         distance: meta.distance,
         vectorType: meta.vectorType,
     }, `${source}: executing`);
-    const hits = await repoSearchPoints(meta.table, parsed.data.vector, parsed.data.top, parsed.data.with_payload, meta.distance, meta.dimension);
+    const hits = await repoSearchPoints(tableName, parsed.data.vector, parsed.data.top, parsed.data.with_payload, meta.distance, meta.dimension, uid);
     const threshold = normalizedSearch.scoreThreshold;
     const filtered = threshold === undefined
         ? hits
@@ -120,6 +122,7 @@ export async function deletePoints(ctx, body) {
             error: parsed.error.flatten(),
         });
     }
-    const deleted = await repoDeletePoints(meta.table, parsed.data.points);
+    const { tableName, uid } = await resolvePointsTableAndUid(normalized, meta);
+    const deleted = await repoDeletePoints(tableName, parsed.data.points, uid);
     return { deleted };
 }

package/dist/utils/distance.d.ts

@@ -4,3 +4,14 @@ export declare function mapDistanceToKnnFn(distance: DistanceKind): {
     order: "ASC" | "DESC";
 };
 export declare function mapDistanceToIndexParam(distance: DistanceKind): string;
+/**
+ * Maps a user-specified distance metric to a YDB Knn distance function
+ * suitable for bit-quantized vectors (Phase 1 approximate candidate selection).
+ * Always returns a distance function (lower is better, ASC ordering).
+ * For Dot, falls back to CosineDistance as a proxy since there is no
+ * direct distance equivalent for inner product.
+ */
+export declare function mapDistanceToBitKnnFn(distance: DistanceKind): {
+    fn: string;
+    order: "ASC";
+};

package/dist/utils/distance.js

@@ -26,3 +26,25 @@ export function mapDistanceToIndexParam(distance) {
             return "cosine";
     }
 }
+/**
+ * Maps a user-specified distance metric to a YDB Knn distance function
+ * suitable for bit-quantized vectors (Phase 1 approximate candidate selection).
+ * Always returns a distance function (lower is better, ASC ordering).
+ * For Dot, falls back to CosineDistance as a proxy since there is no
+ * direct distance equivalent for inner product.
+ */
+export function mapDistanceToBitKnnFn(distance) {
+    switch (distance) {
+        case "Cosine":
+            return { fn: "Knn::CosineDistance", order: "ASC" };
+        case "Dot":
+            // No direct distance equivalent; use Cosine as proxy
+            return { fn: "Knn::CosineDistance", order: "ASC" };
+        case "Euclid":
+            return { fn: "Knn::EuclideanDistance", order: "ASC" };
+        case "Manhattan":
+            return { fn: "Knn::ManhattanDistance", order: "ASC" };
+        default:
+            return { fn: "Knn::CosineDistance", order: "ASC" };
+    }
+}

package/dist/utils/tenant.d.ts

@@ -2,3 +2,4 @@ export declare function sanitizeCollectionName(name: string): string;
 export declare function sanitizeTenantId(tenantId: string | undefined): string;
 export declare function tableNameFor(tenantId: string, collection: string): string;
 export declare function metaKeyFor(tenantId: string, collection: string): string;
+export declare function uidFor(tenantId: string, collectionName: string): string;

package/dist/utils/tenant.js

@@ -15,3 +15,6 @@ export function tableNameFor(tenantId, collection) {
 export function metaKeyFor(tenantId, collection) {
     return `${sanitizeTenantId(tenantId)}/${sanitizeCollectionName(collection)}`;
 }
+export function uidFor(tenantId, collectionName) {
+    return tableNameFor(tenantId, collectionName);
+}

package/dist/ydb/schema.d.ts

@@ -1 +1,3 @@
+export declare const GLOBAL_POINTS_TABLE = "qdrant_all_points";
 export declare function ensureMetaTable(): Promise<void>;
+export declare function ensureGlobalPointsTable(): Promise<void>;

package/dist/ydb/schema.js

@@ -1,5 +1,7 @@
 import { withSession, TableDescription, Column, Types } from "./client.js";
 import { logger } from "../logging/logger.js";
+export const GLOBAL_POINTS_TABLE = "qdrant_all_points";
+let globalPointsTableReady = false;
 export async function ensureMetaTable() {
     try {
         await withSession(async (s) => {
@@ -22,3 +24,68 @@ export async function ensureMetaTable() {
         logger.debug({ err }, "ensureMetaTable: ignored");
     }
 }
+export async function ensureGlobalPointsTable() {
+    if (globalPointsTableReady) {
+        return;
+    }
+    try {
+        await withSession(async (s) => {
+            let tableDescription = null;
+            try {
+                tableDescription = await s.describeTable(GLOBAL_POINTS_TABLE);
+            }
+            catch {
+                // Table doesn't exist, create it with all columns
+                const desc = new TableDescription()
+                    .withColumns(new Column("uid", Types.UTF8), new Column("point_id", Types.UTF8), new Column("embedding", Types.BYTES), new Column("embedding_bit", Types.BYTES), new Column("payload", Types.JSON_DOCUMENT))
+                    .withPrimaryKeys("uid", "point_id");
+                await s.createTable(GLOBAL_POINTS_TABLE, desc);
+                globalPointsTableReady = true;
+                logger.info(`created global points table ${GLOBAL_POINTS_TABLE}`);
+                return;
+            }
+            // Table exists, check if embedding_bit column is present
+            const columns = tableDescription.columns ?? [];
+            const hasEmbeddingBit = columns.some((col) => col.name === "embedding_bit");
+            let needsBackfill = false;
+            if (!hasEmbeddingBit) {
+                // Add the missing embedding_bit column
+                const alterDdl = `
+          ALTER TABLE ${GLOBAL_POINTS_TABLE}
+          ADD COLUMN embedding_bit String;
+        `;
+                await s.executeQuery(alterDdl);
+                logger.info(`added embedding_bit column to existing table ${GLOBAL_POINTS_TABLE}`);
+                needsBackfill = true;
+            }
+            else {
+                // Column exists; check if any legacy rows still have NULL embedding_bit
+                const checkNullsDdl = `
+          SELECT 1 AS has_null
+          FROM ${GLOBAL_POINTS_TABLE}
+          WHERE embedding_bit IS NULL
+          LIMIT 1;
+        `;
+                const checkRes = await s.executeQuery(checkNullsDdl);
+                const hasNullRows = checkRes.resultSets?.[0]?.rows &&
+                    checkRes.resultSets[0].rows.length > 0;
+                needsBackfill = Boolean(hasNullRows);
+            }
+            if (needsBackfill) {
+                // Backfill existing rows: convert embedding to bit representation
+                const backfillDdl = `
+          UPDATE ${GLOBAL_POINTS_TABLE}
+          SET embedding_bit = Untag(Knn::ToBinaryStringBit(Knn::FloatFromBinaryString(embedding)), "BitVector")
+          WHERE embedding_bit IS NULL;
+        `;
+                await s.executeQuery(backfillDdl);
+                logger.info(`backfilled embedding_bit column from embedding in ${GLOBAL_POINTS_TABLE}`);
+            }
+            // Mark table ready only after schema (and any required backfill) succeed
+            globalPointsTableReady = true;
+        });
+    }
+    catch (err) {
+        logger.debug({ err }, "ensureGlobalPointsTable: ignored");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-qdrant",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "main": "dist/package/api.js",
   "types": "dist/package/api.d.ts",
   "exports": {