ydb-qdrant 7.0.1 → 8.1.1

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

@@ -1,53 +1,107 @@
-import { withSession } from "../../ydb/client.js";
-import { buildPathSegmentsWhereClause } from "./PathSegmentsFilter.js";
-import { Uint32, Utf8 } from "@ydbjs/value/primitive";
+import { TypedValues, withSession, createExecuteQuerySettings, } from "../../ydb/client.js";
 import { withRetry, isTransientYdbError } from "../../utils/retry.js";
-import { UPSERT_OPERATION_TIMEOUT_MS } from "../../config/env.js";
-import { attachQueryDiagnostics } from "../../ydb/QueryDiagnostics.js";
+import { buildPathSegmentsWhereClause } from "./PathSegmentsFilter.js";
 const DELETE_FILTER_SELECT_BATCH_SIZE = 1000;
 export async function deletePointsOneTable(tableName, ids, uid) {
     let deleted = 0;
-    await withSession(async (sql, signal) => {
+    await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
         for (const id of ids) {
-            await withRetry(async () => {
-                await attachQueryDiagnostics(sql `
-            DELETE FROM ${sql.identifier(tableName)}
-            WHERE uid = $uid AND point_id = $id;
-          `, {
-                    operation: "deletePointsOneTable",
-                    tableName,
-                    uid,
-                    pointId: String(id),
-                })
-                    .parameter("uid", new Utf8(uid))
-                    .parameter("id", new Utf8(String(id)))
-                    .idempotent(true)
-                    .timeout(UPSERT_OPERATION_TIMEOUT_MS)
-                    .signal(signal);
-            }, {
+            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: {
-                    operation: "deletePointsOneTable",
-                    tableName,
-                    uid,
-                    pointId: String(id),
-                },
+                context: { tableName, uid, pointId: String(id) },
             });
             deleted += 1;
         }
     });
     return deleted;
 }
-function toCount(value) {
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+function bigintToSafeNumberOrNull(value) {
+    if (value > MAX_SAFE_BIGINT || value < -MAX_SAFE_BIGINT) {
+        return null;
+    }
+    return Number(value);
+}
+function longLikeToBigInt(value) {
+    const low = BigInt(value.low >>> 0);
+    const high = BigInt(value.high >>> 0);
+    let n = low + (high << 32n);
+    // If this is a signed Long-like and the sign bit is set, interpret as a negative 64-bit integer.
+    const isUnsigned = value.unsigned === true;
+    const signBitSet = (value.high & 0x8000_0000) !== 0;
+    if (!isUnsigned && signBitSet) {
+        n -= 1n << 64n;
+    }
+    return n;
+}
+function toNumber(value) {
     if (typeof value === "number" && Number.isFinite(value))
         return value;
     if (typeof value === "bigint") {
-        const n = Number(value);
-        return Number.isFinite(n) ? n : 0;
+        return bigintToSafeNumberOrNull(value);
     }
     if (typeof value === "string") {
+        // Prefer exact parsing for integer strings to avoid silent precision loss.
+        if (/^-?\d+$/.test(value.trim())) {
+            try {
+                const b = BigInt(value.trim());
+                return bigintToSafeNumberOrNull(b);
+            }
+            catch {
+                return null;
+            }
+        }
         const n = Number(value);
-        return Number.isFinite(n) ? n : 0;
+        return Number.isFinite(n) ? n : null;
+    }
+    if (value && typeof value === "object") {
+        // ydb-sdk may return Uint64/Int64 as protobufjs Long-like objects:
+        // { low: number, high: number, unsigned?: boolean }
+        const v = value;
+        if (typeof v.low === "number" && typeof v.high === "number") {
+            const b = longLikeToBigInt({
+                low: v.low,
+                high: v.high,
+                unsigned: v.unsigned === true,
+            });
+            return bigintToSafeNumberOrNull(b);
+        }
+    }
+    return null;
+}
+function readDeletedCountFromResult(rs) {
+    const sets = rs.resultSets ?? [];
+    for (let i = sets.length - 1; i >= 0; i -= 1) {
+        const rowset = sets[i];
+        const rows = rowset?.rows ?? [];
+        const cell = rows[0]?.items?.[0];
+        if (!cell)
+            continue;
+        const candidates = [
+            cell.uint64Value,
+            cell.int64Value,
+            cell.uint32Value,
+            cell.int32Value,
+            cell.textValue,
+        ];
+        for (const c of candidates) {
+            const n = toNumber(c);
+            if (n !== null)
+                return n;
+        }
+        // We got a result cell but couldn't parse any of its known numeric representations.
+        // Returning 0 here would silently stop the delete loop, so fail loud.
+        throw new Error("Unable to parse deleted count from YDB result.");
     }
     return 0;
 }
@@ -56,51 +110,52 @@ export async function deletePointsByPathSegmentsOneTable(tableName, uid, paths)
         return 0;
     }
     const { whereSql, params: whereParams } = buildPathSegmentsWhereClause(paths);
+    const whereParamDeclarations = Object.keys(whereParams)
+        .sort()
+        .map((key) => `DECLARE ${key} AS Utf8;`)
+        .join("\n    ");
+    const deleteBatchYql = `
+    DECLARE $uid AS Utf8;
+    DECLARE $limit AS Uint32;
+    ${whereParamDeclarations}
+
+    $to_delete = (
+      SELECT uid, point_id
+      FROM ${tableName}
+      WHERE uid = $uid AND ${whereSql}
+      LIMIT $limit
+    );
+
+    DELETE FROM ${tableName} ON
+    SELECT uid, point_id FROM $to_delete;
+
+    SELECT CAST(COUNT(*) AS Uint32) AS deleted FROM $to_delete;
+  `;
     let deleted = 0;
-    await withSession(async (sql, signal) => {
+    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 [rows] = await withRetry(async () => {
-                let q = attachQueryDiagnostics(sql `
-            $to_delete = (
-              SELECT uid, point_id
-              FROM ${sql.identifier(tableName)}
-              WHERE uid = $uid AND ${sql.unsafe(whereSql)}
-              LIMIT $limit
-            );
-
-            DELETE FROM ${sql.identifier(tableName)} ON
-            SELECT uid, point_id FROM $to_delete;
-
-            SELECT COUNT(*) AS deleted FROM $to_delete;
-          `, {
-                    operation: "deletePointsByPathSegmentsOneTable",
-                    tableName,
-                    uid,
-                    batchLimit: DELETE_FILTER_SELECT_BATCH_SIZE,
-                    pathsCount: paths.length,
-                })
-                    .idempotent(true)
-                    .timeout(UPSERT_OPERATION_TIMEOUT_MS)
-                    .signal(signal)
-                    .parameter("uid", new Utf8(uid))
-                    .parameter("limit", new Uint32(DELETE_FILTER_SELECT_BATCH_SIZE));
-                for (const [key, value] of Object.entries(whereParams)) {
-                    q = q.parameter(key, value);
-                }
-                return await q;
-            }, {
+            const rs = (await withRetry(() => s.executeQuery(deleteBatchYql, {
+                ...whereParams,
+                $uid: TypedValues.utf8(uid),
+                $limit: TypedValues.uint32(DELETE_FILTER_SELECT_BATCH_SIZE),
+            }, undefined, settings), {
                 isTransient: isTransientYdbError,
                 context: {
-                    operation: "deletePointsByPathSegmentsOneTable",
                     tableName,
                     uid,
+                    filterPathsCount: paths.length,
                     batchLimit: DELETE_FILTER_SELECT_BATCH_SIZE,
-                    pathsCount: paths.length,
                 },
-            });
-            const batchDeleted = toCount(rows[0]?.deleted);
+            }));
+            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;
             }

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

@@ -1,11 +1,14 @@
-import type { Value } from "@ydbjs/value";
-type QueryParams = Record<string, Value>;
+import type { Ydb } from "ydb-sdk";
+type QueryParams = {
+    [key: string]: Ydb.ITypedValue;
+};
 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 {};

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

@@ -1,4 +1,4 @@
-import { Utf8 } from "@ydbjs/value/primitive";
+import { TypedValues } from "../../ydb/client.js";
 export function buildPathSegmentsWhereClause(paths) {
     const params = {};
     const orGroups = [];
@@ -11,11 +11,8 @@ export function buildPathSegmentsWhereClause(paths) {
         for (let sIdx = 0; sIdx < segs.length; sIdx += 1) {
             const paramName = `$p${pIdx}_${sIdx}`;
             // payload is JsonDocument; JSON_VALUE supports JsonPath access.
-            // Security: path segment values are always bound as parameters (see `params[paramName]`)
-            // and MUST NOT be interpolated into `whereSql`. The only dynamic part in the SQL text
-            // below is the numeric segment index (sIdx) and the internal parameter name.
             andParts.push(`JSON_VALUE(payload, '$.pathSegments."${sIdx}"') = ${paramName}`);
-            params[paramName] = new Utf8(segs[sIdx]);
+            params[paramName] = TypedValues.utf8(segs[sIdx]);
         }
         orGroups.push(`(${andParts.join(" AND ")})`);
     }
@@ -28,5 +25,9 @@ export function buildPathSegmentsFilter(paths) {
     if (!paths || paths.length === 0)
         return undefined;
     const { whereSql, params: whereParams } = buildPathSegmentsWhereClause(paths);
-    return { whereSql, whereParams };
+    const whereParamDeclarations = Object.keys(whereParams)
+        .sort()
+        .map((key) => `DECLARE ${key} AS Utf8;`)
+        .join("\n        ");
+    return { whereSql, whereParamDeclarations, whereParams };
 }

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

@@ -0,0 +1,4 @@
+import type { DistanceKind } from "../../types.js";
+import { SearchMode } from "../../config/env.js";
+import type { YdbQdrantScoredPoint } from "../../qdrant/QdrantRestTypes.js";
+export declare function searchPointsOneTable(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string, mode: SearchMode | undefined, overfetchMultiplier: number, filterPaths?: Array<Array<string>>): Promise<YdbQdrantScoredPoint[]>;

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

@@ -0,0 +1,208 @@
+import { Types, TypedValues, withSession, createExecuteQuerySettingsWithTimeout, } from "../../ydb/client.js";
+import { buildVectorBinaryParams } from "../../ydb/helpers.js";
+import { mapDistanceToKnnFn, mapDistanceToBitKnnFn, } from "../../utils/distance.js";
+import { logger } from "../../logging/logger.js";
+import { SearchMode, SEARCH_OPERATION_TIMEOUT_MS } from "../../config/env.js";
+import { buildPathSegmentsFilter } from "./PathSegmentsFilter.js";
+function assertVectorDimension(vector, dimension, messagePrefix = "Vector dimension mismatch") {
+    if (vector.length !== dimension) {
+        throw new Error(`${messagePrefix}: got ${vector.length}, expected ${dimension}`);
+    }
+}
+function typedBytesOrFallback(value) {
+    const typedValuesCompat = TypedValues;
+    if (typeof typedValuesCompat.bytes === "function") {
+        return typedValuesCompat.bytes(value);
+    }
+    if (typeof typedValuesCompat.fromNative === "function") {
+        return typedValuesCompat.fromNative(Types.BYTES, value);
+    }
+    throw new Error("ydb-sdk does not support constructing BYTES typed parameters (TypedValues.bytes/fromNative missing); cannot execute vector search");
+}
+function parseSearchRows(rows, withPayload) {
+    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 } : {}) };
+    });
+}
+function buildExactSearchQueryAndParams(args) {
+    const { fn, order } = mapDistanceToKnnFn(args.distance);
+    const filter = buildPathSegmentsFilter(args.filterPaths);
+    const filterWhere = filter ? ` AND ${filter.whereSql}` : "";
+    const binaries = buildVectorBinaryParams(args.queryVector);
+    const yql = `
+        DECLARE $qbinf AS String;
+        DECLARE $k AS Uint32;
+        DECLARE $uid AS Utf8;
+        ${filter?.whereParamDeclarations ?? ""}
+        SELECT point_id, ${args.withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+        FROM ${args.tableName}
+        WHERE uid = $uid${filterWhere}
+        ORDER BY score ${order}
+        LIMIT $k;
+      `;
+    const params = {
+        ...(filter?.whereParams ?? {}),
+        $qbinf: typedBytesOrFallback(binaries.float),
+        $k: TypedValues.uint32(args.top),
+        $uid: TypedValues.utf8(args.uid),
+    };
+    return { yql, params, modeLog: "one_table_exact_client_side_serialization" };
+}
+function buildApproxSearchQueryAndParams(args) {
+    const { fn, order } = mapDistanceToKnnFn(args.distance);
+    const { fn: bitFn, order: bitOrder } = mapDistanceToBitKnnFn(args.distance);
+    const safeTop = args.top > 0 ? args.top : 1;
+    const rawCandidateLimit = safeTop * args.overfetchMultiplier;
+    const candidateLimit = Math.max(safeTop, rawCandidateLimit);
+    const filter = buildPathSegmentsFilter(args.filterPaths);
+    const filterWhere = filter ? ` AND ${filter.whereSql}` : "";
+    const binaries = buildVectorBinaryParams(args.queryVector);
+    const yql = `
+        DECLARE $qbin_bit AS String;
+        DECLARE $qbinf AS String;
+        DECLARE $candidateLimit AS Uint32;
+        DECLARE $safeTop AS Uint32;
+        DECLARE $uid AS Utf8;
+        ${filter?.whereParamDeclarations ?? ""}
+
+        $candidates = (
+          SELECT point_id
+          FROM ${args.tableName}
+          WHERE uid = $uid AND embedding_quantized IS NOT NULL
+            ${filterWhere}
+          ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
+          LIMIT $candidateLimit
+        );
+
+        SELECT point_id, ${args.withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+        FROM ${args.tableName}
+        WHERE uid = $uid
+          AND point_id IN $candidates
+          ${filterWhere}
+        ORDER BY score ${order}
+        LIMIT $safeTop;
+      `;
+    const params = {
+        ...(filter?.whereParams ?? {}),
+        $qbin_bit: typedBytesOrFallback(binaries.bit),
+        $qbinf: typedBytesOrFallback(binaries.float),
+        $candidateLimit: TypedValues.uint32(candidateLimit),
+        $safeTop: TypedValues.uint32(safeTop),
+        $uid: TypedValues.utf8(args.uid),
+    };
+    return {
+        yql,
+        params,
+        safeTop,
+        candidateLimit,
+        modeLog: "one_table_approximate_client_side_serialization",
+    };
+}
+async function searchPointsOneTableExact(tableName, queryVector, top, withPayload, distance, dimension, uid, filterPaths) {
+    assertVectorDimension(queryVector, dimension);
+    const results = await withSession(async (s) => {
+        const { yql, params, modeLog } = buildExactSearchQueryAndParams({
+            tableName,
+            queryVector,
+            top,
+            withPayload,
+            distance,
+            uid,
+            filterPaths,
+        });
+        if (logger.isLevelEnabled("debug")) {
+            logger.debug({
+                tableName,
+                distance,
+                top,
+                withPayload,
+                mode: modeLog,
+                yql,
+                params: {
+                    uid,
+                    top,
+                    vectorLength: queryVector.length,
+                    vectorPreview: queryVector.slice(0, 3),
+                },
+            }, "one_table search (exact): executing YQL");
+        }
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
+        });
+        const rs = await s.executeQuery(yql, params, undefined, settings);
+        const rowset = rs.resultSets?.[0];
+        const rows = (rowset?.rows ?? []);
+        return parseSearchRows(rows, withPayload);
+    });
+    return results;
+}
+async function searchPointsOneTableApproximate(tableName, queryVector, top, withPayload, distance, dimension, uid, overfetchMultiplier, filterPaths) {
+    assertVectorDimension(queryVector, dimension);
+    const results = await withSession(async (s) => {
+        const { yql, params, safeTop, candidateLimit, modeLog } = buildApproxSearchQueryAndParams({
+            tableName,
+            queryVector,
+            top,
+            withPayload,
+            distance,
+            uid,
+            overfetchMultiplier,
+            filterPaths,
+        });
+        if (logger.isLevelEnabled("debug")) {
+            logger.debug({
+                tableName,
+                distance,
+                top,
+                safeTop,
+                candidateLimit,
+                mode: modeLog,
+                yql,
+                params: {
+                    uid,
+                    safeTop,
+                    candidateLimit,
+                    vectorLength: queryVector.length,
+                    vectorPreview: queryVector.slice(0, 3),
+                },
+            }, "one_table search (approximate): executing YQL");
+        }
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
+        });
+        const rs = await s.executeQuery(yql, params, undefined, settings);
+        const rowset = rs.resultSets?.[0];
+        const rows = (rowset?.rows ?? []);
+        return parseSearchRows(rows, withPayload);
+    });
+    return results;
+}
+export async function searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, overfetchMultiplier, filterPaths) {
+    if (mode === SearchMode.Exact) {
+        return await searchPointsOneTableExact(tableName, queryVector, top, withPayload, distance, dimension, uid, filterPaths);
+    }
+    return await searchPointsOneTableApproximate(tableName, queryVector, top, withPayload, distance, dimension, uid, overfetchMultiplier, filterPaths);
+}

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

@@ -1,2 +1,2 @@
-import type { QdrantPointStructDense } from "../../qdrant/QdrantTypes.js";
-export declare function upsertPointsOneTable(tableName: string, points: QdrantPointStructDense[], dimension: number, uid: string): Promise<number>;
+import type { UpsertPoint } from "../../types.js";
+export declare function upsertPointsOneTable(tableName: string, points: UpsertPoint[], dimension: number, uid: string): Promise<number>;

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

@@ -1,13 +1,9 @@
-import { getAbortErrorCause, isTimeoutAbortError } from "../../ydb/client.js";
+import { TypedValues, Types, withSession, Ydb as YdbRuntime, createBulkUpsertSettingsWithTimeout, } from "../../ydb/client.js";
 import { buildVectorBinaryParams } from "../../ydb/helpers.js";
+import { withRetry, isTransientYdbError } from "../../utils/retry.js";
 import { UPSERT_BATCH_SIZE } from "../../ydb/schema.js";
 import { UPSERT_OPERATION_TIMEOUT_MS } from "../../config/env.js";
 import { logger } from "../../logging/logger.js";
-import { withRetry, isTransientYdbError } from "../../utils/retry.js";
-import { bulkUpsertRowsOnce } from "../../ydb/bulkUpsert.js";
-import { Bytes, JsonDocument, Utf8 } from "@ydbjs/value/primitive";
-import { List } from "@ydbjs/value/list";
-import { Struct } from "@ydbjs/value/struct";
 function assertPointVectorsDimension(args) {
     for (const p of args.points) {
         const id = String(p.id);
@@ -26,75 +22,64 @@ function assertPointVectorsDimension(args) {
         }
     }
 }
-function buildUpsertQueryAndParams(args) {
-    const rows = args.batch.map((p) => {
+function buildBulkUpsertRowsValue(args) {
+    const rowType = Types.struct({
+        uid: Types.UTF8,
+        point_id: Types.UTF8,
+        embedding: Types.BYTES,
+        embedding_quantized: Types.BYTES,
+        payload: Types.JSON_DOCUMENT,
+    });
+    return TypedValues.list(rowType, args.batch.map((p) => {
         const binaries = buildVectorBinaryParams(p.vector);
         return {
-            uid: new Utf8(args.uid),
-            point_id: new Utf8(String(p.id)),
-            embedding: new Bytes(binaries.float),
-            embedding_quantized: new Bytes(binaries.bit),
-            payload: new JsonDocument(JSON.stringify(p.payload ?? {})),
+            uid: args.uid,
+            point_id: String(p.id),
+            embedding: binaries.float,
+            embedding_quantized: binaries.bit,
+            payload: JSON.stringify(p.payload ?? {}),
         };
-    });
-    const rowsValue = new List(...rows.map((row) => new Struct({
-        uid: row.uid,
-        point_id: row.point_id,
-        embedding: row.embedding,
-        embedding_quantized: row.embedding_quantized,
-        payload: row.payload,
-    })));
-    return {
-        rowsValue,
-    };
+    }));
 }
 export async function upsertPointsOneTable(tableName, points, dimension, uid) {
+    if (!tableName) {
+        throw new Error("bulkUpsert: tableName is empty");
+    }
     assertPointVectorsDimension({ tableName, uid, points, dimension });
     let upserted = 0;
-    for (let i = 0; i < points.length; i += UPSERT_BATCH_SIZE) {
-        const batch = points.slice(i, i + UPSERT_BATCH_SIZE);
-        const { rowsValue } = buildUpsertQueryAndParams({
-            tableName,
-            uid,
-            batch,
+    await withSession(async (s) => {
+        const bulkSettings = createBulkUpsertSettingsWithTimeout({
+            timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
         });
-        await withRetry(async () => {
-            const startedAtMs = Date.now();
-            try {
-                await bulkUpsertRowsOnce({
+        for (let i = 0; i < points.length; i += UPSERT_BATCH_SIZE) {
+            const batch = points.slice(i, i + UPSERT_BATCH_SIZE);
+            const rowsValue = buildBulkUpsertRowsValue({
+                uid,
+                batch,
+            });
+            if (logger.isLevelEnabled("debug")) {
+                logger.debug({
                     tableName,
-                    rowsValue,
-                    timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
-                });
+                    mode: "one_table_bulk_upsert_client_side_serialization",
+                    batchSize: batch.length,
+                    params: {
+                        rows: batch.map((p) => ({
+                            uid,
+                            point_id: String(p.id),
+                            vectorLength: p.vector.length,
+                            vectorPreview: p.vector.slice(0, 3),
+                            payload: p.payload ?? {},
+                        })),
+                    },
+                }, "one_table upsert: executing BulkUpsert");
             }
-            catch (err) {
-                const durationMs = Date.now() - startedAtMs;
-                if (err instanceof Error && err.name === "AbortError") {
-                    logger.warn({
-                        tableName,
-                        uid,
-                        batchStart: i,
-                        batchSize: batch.length,
-                        timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
-                        durationMs,
-                        err,
-                        errCause: getAbortErrorCause(err),
-                        isTimeout: isTimeoutAbortError(err),
-                    }, "upsertPointsOneTable: BulkUpsert aborted");
-                }
-                throw err;
-            }
-        }, {
-            isTransient: isTransientYdbError,
-            context: {
-                operation: "upsertPointsOneTable",
-                tableName,
-                uid,
-                batchStart: i,
-                batchSize: batch.length,
-            },
-        });
-        upserted += batch.length;
-    }
+            const typedRows = YdbRuntime.TypedValue.create(rowsValue);
+            await withRetry(() => s.bulkUpsert(tableName, typedRows, bulkSettings), {
+                isTransient: isTransientYdbError,
+                context: { tableName, batchSize: batch.length, mode: "bulkUpsert" },
+            });
+            upserted += batch.length;
+        }
+    });
     return upserted;
 }

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

@@ -1,3 +1,3 @@
-export { searchPointsOneTable } from "./pointsRepo.one-table/Search/index.js";
+export { searchPointsOneTable } from "./pointsRepo.one-table/Search.js";
 export { upsertPointsOneTable } from "./pointsRepo.one-table/Upsert.js";
 export { deletePointsOneTable, deletePointsByPathSegmentsOneTable, } from "./pointsRepo.one-table/Delete.js";

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

@@ -1,3 +1,3 @@
-export { searchPointsOneTable } from "./pointsRepo.one-table/Search/index.js";
+export { searchPointsOneTable } from "./pointsRepo.one-table/Search.js";
 export { upsertPointsOneTable } from "./pointsRepo.one-table/Upsert.js";
 export { deletePointsOneTable, deletePointsByPathSegmentsOneTable, } from "./pointsRepo.one-table/Delete.js";