@zilliz/milvus2-sdk-node 2.2.10 → 2.2.11

package/dist/milvus/grpc/Data.js

@@ -1,30 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -34,54 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Data = void 0;
-var utils_1 = require("../../utils");
-var __1 = require("..");
-var Collection_1 = require("./Collection");
-var Data = /** @class */ (function (_super) {
-    __extends(Data, _super);
-    function Data() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
+const __1 = require("../");
+const Collection_1 = require("./Collection");
+class Data extends Collection_1.Collection {
+    constructor() {
+        super(...arguments);
         // vectorTypes
-        _this.vectorTypes = [__1.DataType.BinaryVector, __1.DataType.FloatVector];
-        return _this;
+        this.vectorTypes = [__1.DataType.BinaryVector, __1.DataType.FloatVector];
     }
     /**
      * Insert data into Milvus.
@@ -91,8 +26,7 @@ var Data = /** @class */ (function (_super) {
      *  | :--- | :-- | :-- |
      *  | collection_name | String | Collection name |
      *  | partition_name(optional)| String | Partition name |
-     *  | fields_data | { [x: string]: any }[] | If the field type is binary, the vector data length needs to be dimension / 8 |
-     *  | hash_keys(optional) | Number[] |  The hash value depends on the primarykey value |
+     *  | fields_data or data | { [x: string]: any }[] | If the field type is binary, the vector data length needs to be dimension / 8 |
      *  | timeout? | number | An optional duration of time in millisecond to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or error occurs. Default is undefined |
   
      *
@@ -117,132 +51,150 @@ var Data = /** @class */ (function (_super) {
      *  });
      * ```
      */
-    Data.prototype.insert = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var collection_name, collectionInfo, fieldsData, params, promise;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        (0, utils_1.checkCollectionName)(data);
-                        if (!data.fields_data ||
-                            !Array.isArray(data.fields_data) ||
-                            !data.fields_data.length) {
-                            throw new Error(__1.ERROR_REASONS.INSERT_CHECK_FILEDS_DATA_IS_REQUIRED);
-                        }
-                        collection_name = data.collection_name;
-                        return [4 /*yield*/, this.describeCollection({
-                                collection_name: collection_name,
-                            })];
-                    case 1:
-                        collectionInfo = _a.sent();
-                        if (collectionInfo.status.error_code !== __1.ErrorCode.SUCCESS) {
-                            throw new Error(collectionInfo.status.reason);
-                        }
-                        fieldsData = new Map(collectionInfo.schema.fields
-                            .filter(function (v) { return !v.is_primary_key || !v.autoID; })
-                            .map(function (v) { return [
-                            v.name,
-                            {
-                                name: v.name,
-                                type: v.data_type,
-                                dim: Number((0, utils_1.findKeyValue)(v.type_params, 'dim')),
-                                value: [],
+    insert(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, __1.checkCollectionName)(data);
+            // ensure fields data available
+            data.fields_data = data.fields_data || data.data;
+            if (!data.fields_data ||
+                !Array.isArray(data.fields_data) ||
+                !data.fields_data.length) {
+                throw new Error(__1.ERROR_REASONS.INSERT_CHECK_FIELD_DATA_IS_REQUIRED);
+            }
+            const { collection_name } = data;
+            const collectionInfo = yield this.describeCollection({
+                collection_name,
+            });
+            if (collectionInfo.status.error_code !== __1.ErrorCode.SUCCESS) {
+                throw new Error(collectionInfo.status.reason);
+            }
+            // Tip: The field data sequence needs to be set same as `collectionInfo.schema.fields`.
+            // If primarykey is set `autoid = true`, you cannot insert the data.
+            const fieldsDataMap = new Map(collectionInfo.schema.fields
+                .filter(v => !v.is_primary_key || !v.autoID)
+                .map(v => [
+                v.name,
+                {
+                    name: v.name,
+                    type: v.data_type,
+                    dim: Number((0, __1.findKeyValue)(v.type_params, 'dim')),
+                    value: [], // value container
+                },
+            ]));
+            // The actual data we pass to Milvus gRPC.
+            const params = Object.assign(Object.assign({}, data), { num_rows: data.fields_data.length });
+            // dynamic field is enabled, create $meta field
+            const isDynamic = collectionInfo.schema.enable_dynamic_field;
+            if (isDynamic) {
+                fieldsDataMap.set(__1.DEFAULT_DYNAMIC_FIELD, {
+                    name: __1.DEFAULT_DYNAMIC_FIELD,
+                    type: 'JSON',
+                    value: [], // value container
+                });
+            }
+            // Loop through each row and set the corresponding field values in the Map.
+            data.fields_data.forEach((v, i) => {
+                // if support dynamic field, all field not in the schema would be grouped to a dynamic field
+                v = isDynamic
+                    ? (0, __1.generateDynamicRow)(v, fieldsDataMap, __1.DEFAULT_DYNAMIC_FIELD)
+                    : v;
+                // get each fieldname in the data object
+                const fieldNames = Object.keys(v);
+                // go through each fieldname and encode or format data
+                fieldNames.forEach(name => {
+                    const target = fieldsDataMap.get(name);
+                    if (!target) {
+                        throw new Error(`${__1.ERROR_REASONS.INSERT_CHECK_WRONG_FIELD} ${i}`);
+                    }
+                    if (__1.DataTypeMap[target.type] === __1.DataType.BinaryVector &&
+                        v[name].length !== target.dim / 8) {
+                        throw new Error(__1.ERROR_REASONS.INSERT_CHECK_WRONG_DIM);
+                    }
+                    // encode data
+                    switch (__1.DataTypeMap[target.type]) {
+                        case __1.DataType.BinaryVector:
+                        case __1.DataType.FloatVector:
+                            for (let val of v[name]) {
+                                target.value.push(val);
+                            }
+                            break;
+                        case __1.DataType.JSON:
+                            // ensure empty string
+                            target.value[i] = Buffer.from(JSON.stringify(v[name] || {}));
+                            break;
+                        default:
+                            target.value[i] = v[name];
+                            break;
+                    }
+                });
+            });
+            // transform data from map to array, milvus grpc params
+            params.fields_data = Array.from(fieldsDataMap.values()).map(v => {
+                // milvus return string for field type, so we define the DataTypeMap to the value we need.
+                // but if milvus change the string, may cause we cant find value.
+                const type = __1.DataTypeMap[v.type];
+                const key = this.vectorTypes.includes(type) ? 'vectors' : 'scalars';
+                let dataKey = 'float_vector';
+                switch (type) {
+                    case __1.DataType.FloatVector:
+                        dataKey = 'float_vector';
+                        break;
+                    case __1.DataType.BinaryVector:
+                        dataKey = 'binary_vector';
+                        break;
+                    case __1.DataType.Double:
+                        dataKey = 'double_data';
+                        break;
+                    case __1.DataType.Float:
+                        dataKey = 'float_data';
+                        break;
+                    case __1.DataType.Int64:
+                        dataKey = 'long_data';
+                        break;
+                    case __1.DataType.Int32:
+                    case __1.DataType.Int16:
+                    case __1.DataType.Int8:
+                        dataKey = 'int_data';
+                        break;
+                    case __1.DataType.Bool:
+                        dataKey = 'bool_data';
+                        break;
+                    case __1.DataType.VarChar:
+                        dataKey = 'string_data';
+                        break;
+                    case __1.DataType.JSON:
+                        dataKey = 'json_data';
+                        break;
+                    default:
+                        throw new Error(`${__1.ERROR_REASONS.INSERT_CHECK_WRONG_DATA_TYPE} "${v.type}."`);
+                }
+                return {
+                    type,
+                    field_name: v.name,
+                    is_dynamic: v.name === __1.DEFAULT_DYNAMIC_FIELD,
+                    [key]: type === __1.DataType.FloatVector
+                        ? {
+                            dim: v.dim,
+                            [dataKey]: {
+                                data: v.value,
                             },
-                        ]; }));
-                        params = __assign(__assign({}, data), { num_rows: data.fields_data.length });
-                        // Loop through each row and set the corresponding field values in the Map.
-                        data.fields_data.forEach(function (v, i) {
-                            var fieldNames = Object.keys(v);
-                            fieldNames.forEach(function (name) {
-                                var target = fieldsData.get(name);
-                                if (!target) {
-                                    throw new Error("".concat(__1.ERROR_REASONS.INSERT_CHECK_WRONG_FIELD, " ").concat(i));
-                                }
-                                var isVector = _this.vectorTypes.includes(__1.DataTypeMap[target.type.toLowerCase()]);
-                                if (__1.DataTypeMap[target.type.toLowerCase()] === __1.DataType.BinaryVector &&
-                                    v[name].length !== target.dim / 8) {
-                                    throw new Error(__1.ERROR_REASONS.INSERT_CHECK_WRONG_DIM);
-                                }
-                                if (isVector) {
-                                    for (var _i = 0, _a = v[name]; _i < _a.length; _i++) {
-                                        var val = _a[_i];
-                                        target.value.push(val);
-                                    }
-                                }
-                                else {
-                                    target.value[i] = v[name];
-                                }
-                            });
-                        });
-                        params.fields_data = Array.from(fieldsData.values()).map(function (v) {
-                            var _a, _b, _c, _d;
-                            // milvus return string for field type, so we define the DataTypeMap to the value we need.
-                            // but if milvus change the string, may casue we cant find value.
-                            var type = __1.DataTypeMap[v.type.toLowerCase()];
-                            var key = _this.vectorTypes.includes(type) ? 'vectors' : 'scalars';
-                            var dataKey = 'float_vector';
-                            switch (type) {
-                                case __1.DataType.FloatVector:
-                                    dataKey = 'float_vector';
-                                    break;
-                                case __1.DataType.BinaryVector:
-                                    dataKey = 'binary_vector';
-                                    break;
-                                case __1.DataType.Double:
-                                    dataKey = 'double_data';
-                                    break;
-                                case __1.DataType.Float:
-                                    dataKey = 'float_data';
-                                    break;
-                                case __1.DataType.Int64:
-                                    dataKey = 'long_data';
-                                    break;
-                                case __1.DataType.Int32:
-                                case __1.DataType.Int16:
-                                case __1.DataType.Int8:
-                                    dataKey = 'int_data';
-                                    break;
-                                case __1.DataType.Bool:
-                                    dataKey = 'bool_data';
-                                    break;
-                                case __1.DataType.VarChar:
-                                    dataKey = 'string_data';
-                                    break;
-                                default:
-                                    throw new Error("".concat(__1.ERROR_REASONS.INSERT_CHECK_WRONG_DATA_TYPE, " \"").concat(v.type, ".\""));
+                        }
+                        : type === __1.DataType.BinaryVector
+                            ? {
+                                dim: v.dim,
+                                [dataKey]: (0, __1.parseBinaryVectorToBytes)(v.value),
                             }
-                            return _a = {
-                                    type: type,
-                                    field_name: v.name
+                            : {
+                                [dataKey]: {
+                                    data: v.value,
                                 },
-                                _a[key] = type === __1.DataType.FloatVector
-                                    ? (_b = {
-                                            dim: v.dim
-                                        },
-                                        _b[dataKey] = {
-                                            data: v.value,
-                                        },
-                                        _b) : type === __1.DataType.BinaryVector
-                                    ? (_c = {
-                                            dim: v.dim
-                                        },
-                                        _c[dataKey] = (0, utils_1.parseBinaryVectorToBytes)(v.value),
-                                        _c) : (_d = {},
-                                    _d[dataKey] = {
-                                        data: v.value,
-                                    },
-                                    _d),
-                                _a;
-                        });
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Insert', params, data.timeout || this.timeout)];
-                    case 2:
-                        promise = _a.sent();
-                        return [2 /*return*/, promise];
-                }
+                            },
+                };
             });
+            const promise = yield (0, __1.promisify)(this.client, 'Insert', params, data.timeout || this.timeout);
+            return promise;
         });
-    };
+    }
     /**
      * Delete entities in Milvus
      *
@@ -251,7 +203,7 @@ var Data = /** @class */ (function (_super) {
      *  | :--- | :-- | :-- |
      *  | collection_name | String | Collection name |
      *  | partition_name(optional)| String | Partition name |
-     *  | expr | String | Boolean expression used to filter attribute. |
+     *  | expr or filter | String | Boolean expression used to filter attribute. |
      *  | timeout? | number | An optional duration of time in millisecond to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or error occurs. Default is undefined |
   
      *
@@ -271,23 +223,62 @@ var Data = /** @class */ (function (_super) {
      *  });
      * ```
      */
-    Data.prototype.deleteEntities = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var promise;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.collection_name || !data.expr) {
-                            throw new Error(__1.ERROR_REASONS.DELETE_PARAMS_CHECK);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Delete', data, data.timeout || this.timeout)];
-                    case 1:
-                        promise = _a.sent();
-                        return [2 /*return*/, promise];
-                }
-            });
+    deleteEntities(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.collection_name) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            // check expr or filter
+            if (!data.filter && !data.expr) {
+                throw new Error(__1.ERROR_REASONS.FILTER_EXPR_REQUIRED);
+            }
+            // filter > expr
+            data.expr = data.filter || data.expr;
+            const promise = yield (0, __1.promisify)(this.client, 'Delete', data, data.timeout || this.timeout);
+            return promise;
+        });
+    }
+    /**
+     * Delete entities in Milvus
+     *
+     * @param data
+     *  | Property | Type | Description |
+     *  | :--- | :-- | :-- |
+     *  | collection_name | String | Collection name |
+     *  | partition_name(optional)| String | Partition name |
+     *  | ids | String[] or Number[] | ids to delete |
+     *  | timeout? | number | An optional duration of time in millisecond to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or error occurs. Default is undefined |
+  
+     *
+     * @returns
+     * | Property | Description |
+     *  | :-- | :-- |
+     *  | status |  { error_code: number, reason: string } |
+     *  | IDs | ID array of the successfully deleted data |
+     *
+     *
+     * #### Example
+     *
+     * ```
+     *  new milvusClient(MILUVS_ADDRESS).deleteEntities({
+     *    collection_name: COLLECTION_NAME,
+     *    expr: 'id in [1,2,3,4]'
+     *  });
+     * ```
+     */
+    delete(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.collection_name) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            if (!data.ids || data.ids.length === 0) {
+                throw new Error(__1.ERROR_REASONS.IDS_REQUIRED);
+            }
+            const pkField = yield this.getPkFieldName(data);
+            const req = Object.assign(Object.assign({}, data), { expr: `${pkField} in [${data.ids.join(',')}]` });
+            return this.deleteEntities(req);
         });
-    };
+    }
     /**
      * Perform vector similarity search.
      *
@@ -295,7 +286,7 @@ var Data = /** @class */ (function (_super) {
      *  | Property | Type | Description |
      *  | :--- | :-- | :-- |
      *  | collection_name | String | Collection name |
-     *  | vectors or vector | Number[][] or Number[] | Original vector to search with |
+     *  | vectors or data or (vector) | Number[][] or Number[] | Original vector to search with |
      *  | partition_names(optional)| String[] | Array of partition names |
      *  | limit(optional) | number | topk alias |
      *  | topk(optional) | number | topk |
@@ -321,137 +312,158 @@ var Data = /** @class */ (function (_super) {
      *  });
      * ```
      */
-    Data.prototype.search = function (data) {
+    search(data) {
         var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function () {
-            var collectionInfo, vectorType_1, defaultOutputFields, dim, anns_field, i, f, type, search_params, searchVectors, round_decimal_1, PlaceholderGroup, placeholderGroupBytes, promise, results_1, _e, topks, scores_1, fields_data, ids, fieldsData_1, idData_1, err_1;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        // params check
-                        (0, utils_1.checkSearchParams)(data);
-                        _f.label = 1;
-                    case 1:
-                        _f.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, this.describeCollection({
-                                collection_name: data.collection_name,
-                            })];
-                    case 2:
-                        collectionInfo = _f.sent();
-                        defaultOutputFields = [];
-                        dim = 0;
-                        anns_field = void 0;
-                        for (i = 0; i < collectionInfo.schema.fields.length; i++) {
-                            f = collectionInfo.schema.fields[i];
-                            type = __1.DataTypeMap[f.data_type.toLowerCase()];
-                            // filter vector field
-                            if (type === __1.DataType.FloatVector || type === __1.DataType.BinaryVector) {
-                                // get dimension
-                                dim = Number((0, utils_1.findKeyValue)(f.type_params, 'dim'));
-                                // correcting dimension if necessary for binary vectors
-                                dim = type === __1.DataType.BinaryVector ? dim / 8 : dim;
-                                // anns field
-                                anns_field = f.name;
-                                // vector type
-                                vectorType_1 = type;
-                            }
-                            else {
-                                // save field name
-                                defaultOutputFields.push(f.name);
-                            }
-                        }
-                        search_params = data.search_params || {
-                            anns_field: anns_field,
-                            topk: data.limit ||
-                                data.topk ||
-                                __1.DEFAULT_TOPK,
-                            offset: data.offset || 0,
-                            metric_type: data.metric_type || __1.DEFAULT_METRIC_TYPE,
-                            params: JSON.stringify(data.params || {}),
-                        };
-                        searchVectors = data.vectors || [
-                            data.vector,
-                        ];
-                        round_decimal_1 = (_b = (_a = data.search_params) === null || _a === void 0 ? void 0 : _a.round_decimal) !== null && _b !== void 0 ? _b : (_c = data.params) === null || _c === void 0 ? void 0 : _c.round_decimal;
-                        PlaceholderGroup = this.milvusProto.lookupType('milvus.proto.common.PlaceholderGroup');
-                        placeholderGroupBytes = PlaceholderGroup.encode(PlaceholderGroup.create({
-                            placeholders: [
-                                {
-                                    tag: '$0',
-                                    type: vectorType_1,
-                                    values: searchVectors.map(function (v) {
-                                        return vectorType_1 === __1.DataType.BinaryVector
-                                            ? (0, utils_1.parseBinaryVectorToBytes)(v)
-                                            : (0, utils_1.parseFloatVectorToBytes)(v);
-                                    }),
-                                },
-                            ],
-                        })).finish();
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Search', {
-                                collection_name: data.collection_name,
-                                partition_names: data.partition_names,
-                                output_fields: data.output_fields || defaultOutputFields,
-                                nq: data.nq || searchVectors.length,
-                                dsl: data.expr || data.filter || '',
-                                dsl_type: __1.DslType.BoolExprV1,
-                                placeholder_group: placeholderGroupBytes,
-                                search_params: (0, utils_1.parseToKeyValue)(search_params),
-                            }, data.timeout || this.timeout)];
-                    case 3:
-                        promise = _f.sent();
-                        results_1 = [];
-                        if (promise.results) {
-                            _e = promise.results, topks = _e.topks, scores_1 = _e.scores, fields_data = _e.fields_data, ids = _e.ids;
-                            fieldsData_1 = fields_data.map(function (item, i) {
-                                // if search result is empty, will cause value is undefined.
-                                var value = item.field ? item[item.field] : undefined;
-                                return {
-                                    type: item.type,
-                                    field_name: item.field_name,
-                                    data: value ? value[value === null || value === void 0 ? void 0 : value.data].data : '',
-                                };
-                            });
-                            idData_1 = ids ? (_d = ids[ids.id_field]) === null || _d === void 0 ? void 0 : _d.data : undefined;
-                            /**
-                             * This code block formats the search results returned by Milvus into row data for easier use.
-                             * Milvus supports multiple queries to search and returns all columns data, so we need to splice the data for each search result using the `topk` variable.
-                             * The `topk` variable is the key we use to splice data for every search result.
-                             * The `scores` array is spliced using the `topk` value, and the resulting scores are formatted to the specified precision using the `formatNumberPrecision` function. The resulting row data is then pushed to the `results` array.
-                             */
-                            topks.forEach(function (v, index) {
-                                var topk = Number(v);
-                                scores_1.splice(0, topk).forEach(function (score, scoreIndex) {
-                                    var i = index === 0 ? scoreIndex : scoreIndex + topk;
-                                    var fixedScore = typeof round_decimal_1 === 'undefined' || round_decimal_1 === -1
-                                        ? score
-                                        : (0, utils_1.formatNumberPrecision)(score, round_decimal_1);
-                                    var result = {
-                                        score: fixedScore,
-                                        id: idData_1 ? idData_1[i] : '',
-                                    };
-                                    fieldsData_1.forEach(function (field) {
-                                        result[field.field_name] = field.data[i];
-                                    });
-                                    results_1.push(result);
-                                });
-                            });
-                        }
-                        return [2 /*return*/, {
-                                status: promise.status,
-                                results: results_1,
-                            }];
-                    case 4:
-                        err_1 = _f.sent();
-                        /* istanbul ignore next */
-                        throw new Error(err_1);
-                    case 5: return [2 /*return*/];
+        return __awaiter(this, void 0, void 0, function* () {
+            // params check
+            (0, __1.checkSearchParams)(data);
+            try {
+                // get collection info
+                const collectionInfo = yield this.describeCollection({
+                    collection_name: data.collection_name,
+                });
+                // get information from collection info
+                let vectorType;
+                let defaultOutputFields = [];
+                let anns_field;
+                for (let i = 0; i < collectionInfo.schema.fields.length; i++) {
+                    const f = collectionInfo.schema.fields[i];
+                    const type = __1.DataTypeMap[f.data_type];
+                    // filter vector field
+                    if (type === __1.DataType.FloatVector || type === __1.DataType.BinaryVector) {
+                        // anns field
+                        anns_field = f.name;
+                        // vector type
+                        vectorType = type;
+                    }
+                    else {
+                        // save field name
+                        defaultOutputFields.push(f.name);
+                    }
                 }
-            });
+                // create search params
+                const search_params = data.search_params || {
+                    anns_field: anns_field,
+                    topk: data.limit ||
+                        data.topk ||
+                        __1.DEFAULT_TOPK,
+                    offset: data.offset || 0,
+                    metric_type: data.metric_type || __1.DEFAULT_METRIC_TYPE,
+                    params: JSON.stringify(data.params || {}),
+                };
+                // create search vectors
+                let searchVectors = data.vectors ||
+                    data.data ||
+                    data.vector;
+                // make sure the searchVectors format is correct
+                if (!Array.isArray(searchVectors[0])) {
+                    searchVectors = [searchVectors];
+                }
+                /**
+                 *  It will decide the score precision.
+                 *  If round_decimal is 3, need return like 3.142
+                 *  And if Milvus return like 3.142, Node will add more number after this like 3.142000047683716.
+                 *  So the score need to slice by round_decimal
+                 */
+                const round_decimal = (_b = (_a = data.search_params) === null || _a === void 0 ? void 0 : _a.round_decimal) !== null && _b !== void 0 ? _b : (_c = data.params) === null || _c === void 0 ? void 0 : _c.round_decimal;
+                // create placeholder_group
+                const PlaceholderGroup = this.milvusProto.lookupType('milvus.proto.common.PlaceholderGroup');
+                // tag $0 is hard code in milvus, when dsltype is expr
+                const placeholderGroupBytes = PlaceholderGroup.encode(PlaceholderGroup.create({
+                    placeholders: [
+                        {
+                            tag: '$0',
+                            type: vectorType,
+                            values: searchVectors.map(v => vectorType === __1.DataType.BinaryVector
+                                ? (0, __1.parseBinaryVectorToBytes)(v)
+                                : (0, __1.parseFloatVectorToBytes)(v)),
+                        },
+                    ],
+                })).finish();
+                const promise = yield (0, __1.promisify)(this.client, 'Search', {
+                    collection_name: data.collection_name,
+                    partition_names: data.partition_names,
+                    output_fields: data.output_fields || defaultOutputFields,
+                    nq: data.nq || searchVectors.length,
+                    dsl: data.expr || data.filter || '',
+                    dsl_type: __1.DslType.BoolExprV1,
+                    placeholder_group: placeholderGroupBytes,
+                    search_params: (0, __1.parseToKeyValue)(search_params),
+                    consistency_level: data.consistency_level,
+                }, data.timeout || this.timeout);
+                // if search failed, return empty with status
+                if (promise.status.error_code !== __1.ErrorCode.SUCCESS) {
+                    return {
+                        status: promise.status,
+                        results: [],
+                    };
+                }
+                // build final results array
+                const results = [];
+                const { topks, scores, fields_data, ids } = promise.results;
+                // build fields data map
+                const fieldsDataMap = (0, __1.getFieldDataMap)(fields_data);
+                // build output name array
+                const output_fields = [
+                    'id',
+                    ...(promise.results.output_fields ||
+                        fields_data.map(f => f.field_name)),
+                ];
+                // vector id support int / str id.
+                const idData = ids ? (_d = ids[ids.id_field]) === null || _d === void 0 ? void 0 : _d.data : undefined;
+                // add id column
+                fieldsDataMap.set('id', idData);
+                // fieldsDataMap.set('score', scores); TODO: fieldDataMap to support formatter
+                /**
+                 * This code block formats the search results returned by Milvus into row data for easier use.
+                 * Milvus supports multiple queries to search and returns all columns data, so we need to splice the data for each search result using the `topk` variable.
+                 * The `topk` variable is the key we use to splice data for every search result.
+                 * The `scores` array is spliced using the `topk` value, and the resulting scores are formatted to the specified precision using the `formatNumberPrecision` function. The resulting row data is then pushed to the `results` array.
+                 */
+                topks.forEach((v, index) => {
+                    const topk = Number(v);
+                    scores.splice(0, topk).forEach((score, scoreIndex) => {
+                        // get correct index
+                        const i = index === 0 ? scoreIndex : scoreIndex + topk;
+                        // fix round_decimal
+                        const fixedScore = typeof round_decimal === 'undefined' || round_decimal === -1
+                            ? score
+                            : (0, __1.formatNumberPrecision)(score, round_decimal);
+                        // init result object
+                        const result = { score: fixedScore };
+                        // build result,
+                        output_fields.forEach(field_name => {
+                            // Check if the field_name exists in the fieldsDataMap
+                            const isFixedSchema = fieldsDataMap.has(field_name);
+                            // Get the data for the field_name from the fieldsDataMap
+                            // If the field_name is not in the fieldsDataMap, use the DEFAULT_DYNAMIC_FIELD
+                            const data = fieldsDataMap.get(isFixedSchema ? field_name : __1.DEFAULT_DYNAMIC_FIELD);
+                            // make data[i] safe
+                            data[i] = data[i] || {};
+                            // extract dynamic info from dynamic field if necessary
+                            result[field_name] = isFixedSchema ? data[i] : data[i][field_name];
+                        });
+                        // init result slot
+                        results[index] = results[index] || [];
+                        // push result data
+                        results[index].push(result);
+                    });
+                });
+                return {
+                    status: promise.status,
+                    // if only searching 1 vector, return the first object of results array
+                    results: searchVectors.length === 1 ? results[0] : results,
+                };
+            }
+            catch (err) {
+                /* istanbul ignore next */
+                throw new Error(err);
+            }
         });
-    };
+    }
     /**
      * Milvus temporarily buffers the newly inserted vectors in the cache. Call `flush()` to persist them to the object storage.
-     * It's async function, so it's will take some times to excute.
+     * It's async function, so it's will take some times to execute.
      * @param data
      *  | Property | Type | Description |
      *  | :--- | :-- | :-- |
@@ -472,25 +484,17 @@ var Data = /** @class */ (function (_super) {
      *  });
      * ```
      */
-    Data.prototype.flush = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data ||
-                            !Array.isArray(data.collection_names) ||
-                            !data.collection_names.length) {
-                            throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Flush', data, data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    flush(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data ||
+                !Array.isArray(data.collection_names) ||
+                !data.collection_names.length) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'Flush', data, data.timeout || this.timeout);
+            return res;
         });
-    };
+    }
     /**
      * It's same function as flush. But flushSync is sync function.
      * So you can ensure it's flushed after function return the result.
@@ -515,43 +519,30 @@ var Data = /** @class */ (function (_super) {
      *  });
      * ```
      */
-    Data.prototype.flushSync = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res, segIDs, isFlushed, flushRes;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data ||
-                            !Array.isArray(data.collection_names) ||
-                            !data.collection_names.length) {
-                            throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Flush', data, data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        segIDs = Object.keys(res.coll_segIDs)
-                            .map(function (v) { return res.coll_segIDs[v].data; })
-                            .reduce(function (pre, cur) { return __spreadArray(__spreadArray([], pre, true), cur, true); }, []);
-                        isFlushed = false;
-                        flushRes = null;
-                        _a.label = 2;
-                    case 2:
-                        if (!!isFlushed) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.getFlushState({ segmentIDs: segIDs })];
-                    case 3:
-                        flushRes = _a.sent();
-                        return [4 /*yield*/, (0, utils_1.sleep)(100)];
-                    case 4:
-                        _a.sent();
-                        isFlushed = flushRes.flushed;
-                        return [3 /*break*/, 2];
-                    case 5: 
-                    // Before Milvus pre-GA will throw error
-                    return [2 /*return*/, flushRes];
-                }
-            });
+    flushSync(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data ||
+                !Array.isArray(data.collection_names) ||
+                !data.collection_names.length) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            // copy flushed collection names
+            const res = yield (0, __1.promisify)(this.client, 'Flush', data, data.timeout || this.timeout);
+            // After flush will return collection segment ids, need use GetPersistentSegmentInfo to check segment flush status.
+            const segIDs = Object.keys(res.coll_segIDs)
+                .map(v => res.coll_segIDs[v].data)
+                .reduce((pre, cur) => [...pre, ...cur], []);
+            let isFlushed = false;
+            let flushRes = null;
+            while (!isFlushed) {
+                flushRes = yield this.getFlushState({ segmentIDs: segIDs });
+                yield (0, __1.sleep)(100);
+                isFlushed = flushRes.flushed;
+            }
+            // Before Milvus pre-GA will throw error
+            return flushRes;
         });
-    };
+    }
     /**
      * Query vector data in Milvus. Current release of Milvus only supports expression as fieldname in [id1,id2,id3]
      *
@@ -559,7 +550,7 @@ var Data = /** @class */ (function (_super) {
      *  | Property | Type  | Description |
      *  | :--- | :-- | :-- |
      *  | collection_name | String | Collection name |
-     *  | expr | String | Scalar field filter expression |
+     *  | expr or filter | String | Scalar field filter expression |
      *  | partitions_names(optional) | String[] | Array of partition names |
      *  | output_fields | String[] | Vector or scalar field to be returned |
      *  | timeout? | number | An optional duration of time in millisecond to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or error occurs. Default is undefined |
@@ -583,77 +574,108 @@ var Data = /** @class */ (function (_super) {
      *  });
      * ```
      */
-    Data.prototype.query = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var limits, offset, promise, results, fieldsData;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        (0, utils_1.checkCollectionName)(data);
-                        if (typeof data.limit === 'number') {
-                            limits = { limit: data.limit };
-                        }
-                        if (typeof data.offset === 'number') {
-                            offset = { offset: data.offset };
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Query', __assign(__assign({}, data), { query_params: (0, utils_1.parseToKeyValue)(__assign(__assign({}, limits), offset)) }), data.timeout || this.timeout)];
-                    case 1:
-                        promise = _a.sent();
-                        results = [];
-                        fieldsData = promise.fields_data.map(function (item, i) {
-                            var _a;
-                            if (item.field === 'vectors') {
-                                var key_1 = item.vectors.data;
-                                var vectorValue = key_1 === 'float_vector'
-                                    ? item.vectors[key_1].data
-                                    : item.vectors[key_1].toJSON().data;
-                                // if binary vector , need use dim / 8 to split vector data
-                                var dim_1 = ((_a = item.vectors) === null || _a === void 0 ? void 0 : _a.data) === 'float_vector'
-                                    ? Number(item.vectors.dim)
-                                    : Number(item.vectors.dim) / 8;
-                                var data_1 = [];
-                                // parse number[] to number[][] by dim
-                                vectorValue.forEach(function (v, i) {
-                                    var index = Math.floor(i / dim_1);
-                                    if (!data_1[index]) {
-                                        data_1[index] = [];
-                                    }
-                                    data_1[index].push(v);
-                                });
-                                return {
-                                    field_name: item.field_name,
-                                    data: data_1,
-                                };
-                            }
-                            var key = item.scalars.data;
-                            var scalarValue = item.scalars[key].data;
-                            return {
-                                field_name: item.field_name,
-                                data: scalarValue,
-                            };
-                        });
-                        // parse column data to [{fieldname:value}]
-                        fieldsData.forEach(function (v) {
-                            v.data.forEach(function (d, i) {
-                                var _a, _b;
-                                if (!results[i]) {
-                                    results[i] = (_a = {},
-                                        _a[v.field_name] = d,
-                                        _a);
-                                }
-                                else {
-                                    results[i] = __assign(__assign({}, results[i]), (_b = {}, _b[v.field_name] = d, _b));
-                                }
-                            });
-                        });
-                        return [2 /*return*/, {
-                                status: promise.status,
-                                data: results,
-                            }];
-                }
+    query(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, __1.checkCollectionName)(data);
+            // Set up limits and offset for the query
+            let limits;
+            let offset;
+            if (typeof data.limit === 'number') {
+                limits = { limit: data.limit };
+            }
+            if (typeof data.offset === 'number') {
+                offset = { offset: data.offset };
+            }
+            // check expr or filter
+            if (!data.filter && !data.expr) {
+                throw new Error(__1.ERROR_REASONS.FILTER_EXPR_REQUIRED);
+            }
+            // filter > expr
+            data.expr = data.filter || data.expr;
+            // Execute the query and get the results
+            const promise = yield (0, __1.promisify)(this.client, 'Query', Object.assign(Object.assign({}, data), { query_params: (0, __1.parseToKeyValue)(Object.assign(Object.assign({}, limits), offset)) }), data.timeout || this.timeout);
+            // compatible with milvus before v2.2.9
+            const output_fields = promise.output_fields || promise.fields_data.map(f => f.field_name);
+            // Initialize an array to hold the query results
+            const results = [];
+            const fieldsDataMap = (0, __1.getFieldDataMap)(promise.fields_data);
+            // For each output field, check if it has a fixed schema or not
+            const fieldData = output_fields.map(field_name => {
+                // Check if the field_name exists in the fieldsDataMap
+                const isFixedSchema = fieldsDataMap.has(field_name);
+                // Get the data for the field_name from the fieldsDataMap
+                // If the field_name is not in the fieldsDataMap, use the DEFAULT_DYNAMIC_FIELD
+                const data = fieldsDataMap.get(isFixedSchema ? field_name : __1.DEFAULT_DYNAMIC_FIELD);
+                // Return an object containing the field_name and its corresponding data
+                // If the schema is fixed, use the data directly
+                // If the schema is not fixed, map the data to extract the field_name values
+                return {
+                    data: isFixedSchema ? data : data.map((d) => d[field_name]),
+                    field_name,
+                };
+            });
+            // parse column data to [{fieldname:value}]
+            fieldData.forEach((v) => {
+                v.data.forEach((d, i) => {
+                    if (!results[i]) {
+                        results[i] = {
+                            [v.field_name]: d,
+                        };
+                    }
+                    else {
+                        results[i] = Object.assign(Object.assign({}, results[i]), { [v.field_name]: d });
+                    }
+                });
             });
+            return {
+                status: promise.status,
+                data: results,
+            };
+        });
+    }
+    /**
+     * get vector data by providing ids in Milvus
+     *
+     * @param data
+     *  | Property | Type  | Description |
+     *  | :--- | :-- | :-- |
+     *  | collection_name | String | Collection name |
+     *  | ids | String[] | ids to get |
+     *  | partitions_names(optional) | String[] | Array of partition names |
+     *  | output_fields | String[] | Vector or scalar field to be returned |
+     *  | timeout? | number | An optional duration of time in millisecond to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or error occurs. Default is undefined |
+  
+     *  | params | {key: value}[] | An optional key pair json array
+     *
+     * @returns
+     * | Property | Description |
+     *  | :-- | :-- |
+     *  | status | { error_code: number,reason:string } |
+     *  | data | Data of all fields that you defined in `output_fields`, {field_name: value}[] |
+     *
+     *
+     * #### Example
+     *
+     * ```
+     *  new milvusClient(MILUVS_ADDRESS).get({
+     *    collection_name: 'my_collection',
+     *    ids: [1,2,3,4,5,6,7,8],
+     *    output_fields: ["age"],
+     *  });
+     * ```
+     */
+    get(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, __1.checkCollectionName)(data);
+            const pkField = yield this.getPkFieldName(data);
+            if (!data.ids || data.ids.length === 0) {
+                throw new Error(__1.ERROR_REASONS.IDS_REQUIRED);
+            }
+            // build query req
+            const req = Object.assign(Object.assign({}, data), { expr: `${pkField} in [${data.ids.join(',')}]` });
+            return this.query(req);
         });
-    };
+    }
     /**
      * @ignore
      * @param data
@@ -661,25 +683,17 @@ var Data = /** @class */ (function (_super) {
      *  | :--- | :-- | :-- |
      *  | request | object | Only allow "system_info" for now |
      */
-    Data.prototype.getMetric = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.request || !data.request.metric_type) {
-                            throw new Error(__1.ERROR_REASONS.GET_METRIC_CHECK_PARAMS);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'GetMetrics', {
-                                request: JSON.stringify(data.request),
-                            }, data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, __assign(__assign({}, res), { response: JSON.parse(res.response) })];
-                }
-            });
+    getMetric(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.request || !data.request.metric_type) {
+                throw new Error(__1.ERROR_REASONS.GET_METRIC_CHECK_PARAMS);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'GetMetrics', {
+                request: JSON.stringify(data.request),
+            }, data.timeout || this.timeout);
+            return Object.assign(Object.assign({}, res), { response: JSON.parse(res.response) });
         });
-    };
+    }
     /**
      * Get flush state by segment ids
      *
@@ -704,23 +718,15 @@ var Data = /** @class */ (function (_super) {
      *   });
      * ```
      */
-    Data.prototype.getFlushState = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.segmentIDs) {
-                            throw new Error(__1.ERROR_REASONS.GET_FLUSH_STATE_CHECK_PARAMS);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'GetFlushState', data, data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    getFlushState(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.segmentIDs) {
+                throw new Error(__1.ERROR_REASONS.GET_FLUSH_STATE_CHECK_PARAMS);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'GetFlushState', data, data.timeout || this.timeout);
+            return res;
         });
-    };
+    }
     /**
      * Do load balancing operation from source query node to destination query node.
      * Only work in cluster milvus.
@@ -737,7 +743,7 @@ var Data = /** @class */ (function (_super) {
      * | Property | Description |
      *  | :--- | :-- |
      *  | status | { error_code: number,reason:string } |
-     *  | infos | segments infomations |
+     *  | infos | segments information |
      *
      *
      * #### Example
@@ -748,23 +754,15 @@ var Data = /** @class */ (function (_super) {
      *   });
      * ```
      */
-    Data.prototype.loadBalance = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.src_nodeID) {
-                            throw new Error(__1.ERROR_REASONS.LOAD_BALANCE_CHECK_PARAMS);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'LoadBalance', data, data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    loadBalance(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.src_nodeID) {
+                throw new Error(__1.ERROR_REASONS.LOAD_BALANCE_CHECK_PARAMS);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'LoadBalance', data, data.timeout || this.timeout);
+            return res;
         });
-    };
+    }
     /**
      * Notifies Proxy to return segments information from query nodes.
      *
@@ -790,23 +788,15 @@ var Data = /** @class */ (function (_super) {
      *    });
      * ```
      */
-    Data.prototype.getQuerySegmentInfo = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.collectionName) {
-                            throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'GetQuerySegmentInfo', data, data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    getQuerySegmentInfo(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.collectionName) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'GetQuerySegmentInfo', data, data.timeout || this.timeout);
+            return res;
         });
-    };
+    }
     /**
      * Import data from files
      *
@@ -834,26 +824,18 @@ var Data = /** @class */ (function (_super) {
      * ```
      */
     /* istanbul ignore next */
-    Data.prototype.bulkInsert = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.collection_name) {
-                            throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
-                        }
-                        if (!data || !data.files) {
-                            throw new Error(__1.ERROR_REASONS.IMPORT_FILE_CHECK);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'Import', __assign(__assign({}, data), { options: data.options || [] }), data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    bulkInsert(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.collection_name) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            if (!data || !data.files) {
+                throw new Error(__1.ERROR_REASONS.IMPORT_FILE_CHECK);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'Import', Object.assign(Object.assign({}, data), { options: data.options || [] }), data.timeout || this.timeout);
+            return res;
         });
-    };
+    }
     /**
      * List import tasks
      *
@@ -884,24 +866,15 @@ var Data = /** @class */ (function (_super) {
      * ```
      */
     /* istanbul ignore next */
-    Data.prototype.listImportTasks = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!data || !data.collection_name) {
-                            throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
-                        }
-                        return [4 /*yield*/, (0, utils_1.promisify)(this.client, 'ListImportTasks', __assign(__assign({}, data), { limit: data.limit || 0 }), data.timeout || this.timeout)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    listImportTasks(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data || !data.collection_name) {
+                throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
+            }
+            const res = yield (0, __1.promisify)(this.client, 'ListImportTasks', Object.assign(Object.assign({}, data), { limit: data.limit || 0 }), data.timeout || this.timeout);
+            return res;
         });
-    };
-    return Data;
-}(Collection_1.Collection));
+    }
+}
 exports.Data = Data;
 //# sourceMappingURL=Data.js.map