@zilliz/milvus2-sdk-node 2.3.5 → 2.4.1

package/dist/milvus/grpc/Data.js

@@ -15,31 +15,29 @@ const Collection_1 = require("./Collection");
 class Data extends Collection_1.Collection {
     constructor() {
         super(...arguments);
-        // vectorTypes
-        this.vectorTypes = [__1.DataType.BinaryVector, __1.DataType.FloatVector];
+        // alias
+        this.hybridSearch = this.search;
         /**
-         * list indexed segments
+         * List indexed segments.
          *
-         * @param data
-         *  | Property | Type | Description |
-         *  | :-- | :-- | :-- |
-         *  | collection_name | string | the name of the collection |
-         *  | index_name | string | the name of the collection's index |
-         *  | timeout? | number | An optional duration of time in milliseconds to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or an error occurs. Default is undefined |
+         * @param {ListIndexedSegmentReq} data - The request parameters.
+         * @param {string} data.collection_name - The name of the collection.
+         * @param {string} data.index_name - The name of the collection's index.
+         * @param {number} [data.timeout] - An optional duration of time in milliseconds to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or an error occurs. Default is undefined.
          *
-         * @returns
-         *  | Property | Description |
-         *  | :-- | :-- |
-         *  | status | status |
-         *  | segmentIDs | segment IDs |
+         * @returns {Promise<ListIndexedSegmentResponse>} The result of the operation.
+         * @returns {string} status.error_code - The error code of the operation.
+         * @returns {string} status.reason - The reason for the error, if any.
+         * @returns {number[]} segmentIDs - Segment IDs.
          *
          * @throws {Error} if `collection_name` property is not present in `data`
          *
-         * #### Example
-         *
+         * @example
          * ```
-         *  new milvusClient(MILUVS_ADDRESS).getPkFieldName({
+         *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+         *  const indexedSegments = await milvusClient.listIndexedSegment({
          *    collection_name: 'my_collection',
+         *    index_name: 'my_index',
          *  });
          * ```
          */
@@ -50,7 +48,7 @@ class Data extends Collection_1.Collection {
         //     throw new Error(ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
         //   }
         //   const res = await promisify(
-        //     this.client,
+        //     this.channelPool,
         //     'ListIndexedSegment',
         //     data,
         //     data.timeout || this.timeout
@@ -58,28 +56,26 @@ class Data extends Collection_1.Collection {
         //   return res;
         // }
         /**
-         * describe segment index data
+         * Describe segment index data.
          *
-         * @param data
-         *  | Property | Type | Description |
-         *  | :-- | :-- | :-- |
-         *  | collection_name | string | the name of the collection |
-         *  | segmentsIDs | number[] | the name of the collection's index |
-         *  | timeout? | number | An optional duration of time in milliseconds to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or an error occurs. Default is undefined |
+         * @param {DescribeSegmentIndexDataReq} data - The request parameters.
+         * @param {string} data.collection_name - The name of the collection.
+         * @param {number[]} data.segmentsIDs - The segment IDs.
+         * @param {number} [data.timeout] - An optional duration of time in milliseconds to allow for the RPC. If it is set to undefined, the client keeps waiting until the server responds or an error occurs. Default is undefined.
          *
-         * @returns
-         *  | Property | Description |
-         *  | :-- | :-- |
-         *  | status | status |
-         *  | segmentIDs | segment IDs |
+         * @returns {Promise<DescribeSegmentIndexDataResponse>} The result of the operation.
+         * @returns {string} status.error_code - The error code of the operation.
+         * @returns {string} status.reason - The reason for the error, if any.
+         * @returns {number[]} segmentIDs - Segment IDs.
          *
          * @throws {Error} if `collection_name` property is not present in `data`
          *
-         * #### Example
-         *
+         * @example
          * ```
-         *  new milvusClient(MILUVS_ADDRESS).getPkFieldName({
+         *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+         *  const segmentIndexData = await milvusClient.describeSegmentIndexData({
          *    collection_name: 'my_collection',
+         *    segmentsIDs: [1,2,3,4],
          *  });
          * ```
          */
@@ -90,7 +86,7 @@ class Data extends Collection_1.Collection {
         //     throw new Error(ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
         //   }
         //   const res = await promisify(
-        //     this.client,
+        //     this.channelPool,
         //     'DescribeSegmentIndexData',
         //     data,
         //     data.timeout || this.timeout
@@ -115,31 +111,27 @@ class Data extends Collection_1.Collection {
         });
     }
     /**
-     * Insert/upsert data into Milvus.
-     *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_name | String | Collection name |
-     *  | partition_name(optional)| String | Partition name |
-     *  | 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 |
-  
-     *
-     * @returns
-     * | Property | Description |
-     *  | :-- | :-- |
-     *  | status | { error_code: number, reason: string } |
-     *  | succ_index |  Index array of the successfully inserted data |
-     *  | err_index | Index array of the unsuccessfully inserted data |
-     *  | IDs | ID array of the successfully inserted data |
-     *
-     *
-     * #### Example
-     *
+     * Insert or upsert data into a Milvus collection.
+     *
+     * @param {InsertReq} data - The request parameters.
+     * @param {string} data.collection_name - The name of the collection.
+     * @param {string} [data.partition_name] - The name of the partition (optional).
+     * @param {{ [x: string]: any }[]} data.data - The data to be inserted. If the field type is binary, the vector data length needs to be dimension / 8.
+     * @param {InsertTransformers} data.transformers - The transformers for bf16 or f16 data, it accept an f32 array, it should output f16 or bf16 bytes (optional)
+     * @param {number} [data.timeout] - An optional duration of time in milliseconds 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 {Promise<MutationResult>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {number[]} succ_index - Index array of the successfully inserted data.
+     * @returns {number[]} err_index - Index array of the unsuccessfully inserted data.
+     * @returns {number[]} IDs - ID array of the successfully inserted data.
+     *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).insert({
-     *    collection_name: COLLECTION_NAME,
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const resStatus = await milvusClient.insert({
+     *    collection_name: 'my_collection',
      *    fields_data: [{
      *      vector_field: [1,2,2,4],
      *      scalar_field: 1
@@ -213,7 +205,7 @@ class Data extends Collection_1.Collection {
                             field.data = field.data.concat((0, __1.buildFieldData)(rowData, field));
                             break;
                         default:
-                            field.data[rowIndex] = (0, __1.buildFieldData)(rowData, field);
+                            field.data[rowIndex] = (0, __1.buildFieldData)(rowData, field, data.transformers);
                             break;
                     }
                 });
@@ -225,78 +217,105 @@ class Data extends Collection_1.Collection {
                 // 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[field.type];
-                const key = this.vectorTypes.includes(type) ? 'vectors' : 'scalars';
+                const key = __1.VectorDataTypes.includes(type) ? 'vectors' : 'scalars';
                 const dataKey = (0, __1.getDataKey)(type);
                 const elementType = __1.DataTypeMap[field.elementType];
                 const elementTypeKey = (0, __1.getDataKey)(elementType);
-                return {
-                    type,
-                    field_name: field.name,
-                    is_dynamic: field.name === __1.DEFAULT_DYNAMIC_FIELD,
-                    [key]: type === __1.DataType.FloatVector
-                        ? {
+                // build key value
+                let keyValue;
+                switch (type) {
+                    case __1.DataType.FloatVector:
+                        keyValue = {
                             dim: field.dim,
                             [dataKey]: {
                                 data: field.data,
                             },
-                        }
-                        : type === __1.DataType.BinaryVector
-                            ? {
-                                dim: field.dim,
-                                [dataKey]: (0, __1.parseBinaryVectorToBytes)(field.data),
-                            }
-                            : type === __1.DataType.Array
-                                ? {
-                                    [dataKey]: {
-                                        data: field.data.map(d => {
-                                            return {
-                                                [elementTypeKey]: {
-                                                    type: elementType,
-                                                    data: d,
-                                                },
-                                            };
-                                        }),
-                                        element_type: elementType,
-                                    },
-                                }
-                                : {
-                                    [dataKey]: {
-                                        data: field.data,
-                                    },
-                                },
+                        };
+                        break;
+                    case __1.DataType.BFloat16Vector:
+                    case __1.DataType.Float16Vector:
+                        keyValue = {
+                            dim: field.dim,
+                            [dataKey]: Buffer.concat(field.data),
+                        };
+                        break;
+                    case __1.DataType.BinaryVector:
+                        keyValue = {
+                            dim: field.dim,
+                            [dataKey]: (0, __1.f32ArrayToBinaryBytes)(field.data),
+                        };
+                        break;
+                    case __1.DataType.SparseFloatVector:
+                        const dim = (0, __1.getSparseDim)(field.data);
+                        keyValue = {
+                            dim,
+                            [dataKey]: {
+                                dim,
+                                contents: (0, __1.sparseRowsToBytes)(field.data),
+                            },
+                        };
+                        break;
+                    case __1.DataType.Array:
+                        keyValue = {
+                            [dataKey]: {
+                                data: field.data.map(d => {
+                                    return {
+                                        [elementTypeKey]: {
+                                            type: elementType,
+                                            data: d,
+                                        },
+                                    };
+                                }),
+                                element_type: elementType,
+                            },
+                        };
+                        break;
+                    default:
+                        keyValue = {
+                            [dataKey]: {
+                                data: field.data,
+                            },
+                        };
+                        break;
+                }
+                return {
+                    type,
+                    field_name: field.name,
+                    is_dynamic: field.name === __1.DEFAULT_DYNAMIC_FIELD,
+                    [key]: keyValue,
                 };
             });
             // if timeout is not defined, set timeout to 0
             const timeout = typeof data.timeout === 'undefined' ? 0 : data.timeout;
+            // delete data
+            try {
+                delete params.data;
+            }
+            catch (e) { }
             // execute Insert
-            const promise = yield (0, __1.promisify)(this.client, upsert ? 'Upsert' : 'Insert', params, timeout);
+            const promise = yield (0, __1.promisify)(this.channelPool, upsert ? 'Upsert' : 'Insert', params, timeout);
             return promise;
         });
     }
     /**
-     * Delete entities in Milvus
+     * Delete entities in a Milvus collection.
      *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_name | String | Collection name |
-     *  | partition_name(optional)| String | Partition name |
-     *  | 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 |
-  
-     *
-     * @returns
-     * | Property | Description |
-     *  | :-- | :-- |
-     *  | status |  { error_code: number, reason: string } |
-     *  | IDs | ID array of the successfully deleted data |
+     * @param {DeleteEntitiesReq} data - The request parameters.
+     * @param {string} data.collection_name - The name of the collection.
+     * @param {string} [data.partition_name] - The name of the partition (optional).
+     * @param {string} data.expr - Boolean expression used to filter entities for deletion.
+     * @param {number} [data.timeout] - An optional duration of time in milliseconds 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 {Promise<MutationResult>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {number[]} IDs - ID array of the successfully deleted data.
      *
-     * #### Example
-     *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).deleteEntities({
-     *    collection_name: COLLECTION_NAME,
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const resStatus = await milvusClient.deleteEntities({
+     *    collection_name: 'my_collection',
      *    expr: 'id in [1,2,3,4]'
      *  });
      * ```
@@ -312,35 +331,40 @@ class Data extends Collection_1.Collection {
             }
             // filter > expr
             data.expr = data.filter || data.expr;
-            const promise = yield (0, __1.promisify)(this.client, 'Delete', data, data.timeout || this.timeout);
+            const promise = yield (0, __1.promisify)(this.channelPool, '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
+     * Delete entities in a Milvus collection.
+     *
+     * @param {DeleteReq} data - The request parameters.
+     * @param {string} data.collection_name - The name of the collection.
+     * @param {string} [data.partition_name] - The name of the partition (optional).
+     * @param {(string[] | number[])} [data.ids] - IDs of the entities to delete.
+     * @param {string} [data.filter] - Filter expression, takes precedence over ids.
+     * @param {string} [data.expr] - equals to data.filter.
+     * @param {number} [data.timeout] - Optional duration of time in milliseconds to allow for the RPC. If undefined, the client keeps waiting until the server responds or an error occurs. Default is undefined.
+     *
+     * @returns {Promise<MutationResult>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {number[]} IDs - Array of IDs of the successfully deleted entities.
+     *
+     * @example
+     * ```
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const resStatus = await milvusClient.delete({
+     *    collection_name: 'my_collection',
+     *    filter: 'id in [1,2,3,4]'
+     *  });
+     * ```
      *
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).deleteEntities({
-     *    collection_name: COLLECTION_NAME,
-     *    expr: 'id in [1,2,3,4]'
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const resStatus = await milvusClient.delete({
+     *    collection_name: 'my_collection',
+     *    ids: [1,2,3,4]
      *  });
      * ```
      */
@@ -349,229 +373,104 @@ class Data extends Collection_1.Collection {
             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 pkFieldType = yield this.getPkFieldType(data);
+            let expr = '';
             // generate expr by different type of pk
-            const expr = __1.DataTypeMap[pkFieldType] === __1.DataType.VarChar
-                ? `${pkField} in ["${data.ids.join('","')}"]`
-                : `${pkField} in [${data.ids.join(',')}]`;
+            if (data.ids) {
+                expr =
+                    __1.DataTypeMap[pkFieldType] === __1.DataType.VarChar
+                        ? `${pkField} in ["${data.ids.join('","')}"]`
+                        : `${pkField} in [${data.ids.join(',')}]`;
+            }
+            // if filter exist use filter;
+            if (data.filter) {
+                expr = data.filter;
+            }
             const req = Object.assign(Object.assign({}, data), { expr });
             return this.deleteEntities(req);
         });
     }
     /**
-     * Perform vector similarity search.
-     *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_name | String | Collection name |
-     *  | 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 |
-     *  | offset(optional) | number | offset |
-     *  | filter(optional) | String | Scalar field filter expression |
-     *  | expr(optional) | String | filter alias |
-     *  | output_fields(optional) | String[] | Support scalar field |
-     *  | metric_type(optional) | String | similarity metric |
-     *  | params(optional) | key value object | search params |
-     *
-     * @returns
-     * | Property | Description |
-     *  | :-- | :-- |
-     *  | status | { error_code: number, reason: string } |∂
-     *  | results | {score:number,id:string}[]; |
-     *
-     * #### Example
-     *
+     * Perform vector similarity search in a Milvus collection.
+     *
+     * @param {SearchReq | SearchSimpleReq} data - The request parameters.
+     * @param {string} data.collection_name - The name of the collection.
+     * @param {Number[]} data.vector - Original vector to search with.
+     * @param {string[]} [data.partition_names] - Array of partition names (optional).
+     * @param {number} [data.topk] - Topk (optional).
+     * @param {number} [data.limit] - Alias for topk (optional).
+     * @param {number} [data.offset] - Offset (optional).
+     * @param {string} [data.filter] - Scalar field filter expression (optional).
+     * @param {string[]} [data.output_fields] - Support scalar field (optional).
+     * @param {object} [data.params] - Search params (optional).
+     * @param {OutputTransformers} data.transformers - The transformers for bf16 or f16 data, it accept bytes or sparse dic vector, it can ouput f32 array or other format(optional)
+     * @param {number} [data.timeout] - An optional duration of time in milliseconds 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 {Promise<SearchResults>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {{score:number,id:string, [outputfield]: value}[]} results - Array of search results.
+     *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).search({
-     *   collection_name: COLLECTION_NAME,
-     *   vector: [1, 2, 3, 4],
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const searchResults = await milvusClient.search({
+     *    collection_name: 'my_collection',
+     *    vector: [1, 2, 3, 4],
      *  });
      * ```
      */
     search(data) {
-        var _a, _b, _c, _d;
         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,
-                    cache: true,
-                });
-                // 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 || '',
-                    params: JSON.stringify(data.params || {}),
-                    ignore_growing: data.ignore_growing || false,
-                };
-                // 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: typeof data.consistency_level === 'undefined'
-                        ? __1.ConsistencyLevelEnum.Bounded
-                        : data.consistency_level,
-                }, data.timeout || this.timeout);
-                // if search failed
-                // if nothing returned
-                // return empty with status
-                if (promise.status.error_code !== __1.ErrorCode.SUCCESS ||
-                    promise.results.scores.length === 0) {
-                    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.buildFieldDataMap)(fields_data);
-                // build output name array
-                const output_fields = [
-                    'id',
-                    ...(!!((_d = promise.results.output_fields) === null || _d === void 0 ? void 0 : _d.length)
-                        ? promise.results.output_fields
-                        : fields_data.map(f => f.field_name)),
-                ];
-                // vector id support int / str id.
-                const idData = ids ? ids[ids.id_field].data : {};
-                // 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 * index;
-                        // 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 dynamic data[i] safe
-                            data[i] = isFixedSchema ? 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);
-                    });
-                });
+            // get collection info
+            const collectionInfo = yield this.describeCollection({
+                collection_name: data.collection_name,
+                cache: true,
+            });
+            // build search params
+            const { request, nq, round_decimal, isHybridSearch } = (0, __1.buildSearchRequest)(data, collectionInfo, this.milvusProto);
+            // execute search
+            const originSearchResult = yield (0, __1.promisify)(this.channelPool, isHybridSearch ? 'HybridSearch' : 'Search', request, data.timeout || this.timeout);
+            // if search failed
+            // if nothing returned
+            // return empty with status
+            if (originSearchResult.status.error_code !== __1.ErrorCode.SUCCESS ||
+                originSearchResult.results.scores.length === 0) {
                 return {
-                    status: promise.status,
-                    // if only searching 1 vector, return the first object of results array
-                    results: searchVectors.length === 1 ? results[0] || [] : results,
+                    status: originSearchResult.status,
+                    results: [],
                 };
             }
-            catch (err) {
-                /* istanbul ignore next */
-                throw new Error(err);
-            }
+            // build final results array
+            const results = (0, __1.formatSearchResult)(originSearchResult, {
+                round_decimal,
+                transformers: data.transformers,
+            });
+            return {
+                status: originSearchResult.status,
+                // nq === 1, return the first object of results array
+                results: nq === 1 ? results[0] || [] : results,
+            };
         });
     }
     /**
-     * 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 execute.
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_names | String[] | Array of collection names |
-     *  | 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 |
-  
+     * Flushes the newly inserted vectors that are temporarily buffered in the cache to the object storage.
+     * This is an asynchronous function and may take some time to execute deponds on your data size.
      *
-     * @returns
-     * | Property | Description |
-     *  | :-- | :-- |
-     *  | status | { error_code: number, reason: string } |
+     * @param {FlushReq} data - The request parameters.
+     * @param {string[]} data.collection_names - Array of collection names.
+     * @param {number} [data.timeout] - An optional duration of time in milliseconds 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.
      *
-     * #### Example
+     * @returns {Promise<FlushResult>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
      *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).flush({
-     *     collection_names: ['my_collection'],
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const flushStatus = await milvusClient.flush({
+     *    collection_names: ['my_collection'],
      *  });
      * ```
      */
@@ -582,31 +481,27 @@ class Data extends Collection_1.Collection {
                 !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);
+            const res = yield (0, __1.promisify)(this.channelPool, '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.
+     * This function is similar to the `flush` function, but it is synchronous.
+     * This ensures that the flush operation is completed before the function returns.
      *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_names | String[] | Array of collection names |
-     *  | 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 |
-  
+     * @param {FlushReq} data - The request parameters.
+     * @param {string[]} data.collection_names - Array of collection names.
+     * @param {number} [data.timeout] - An optional duration of time in milliseconds 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 } |
-     *
-     * #### Example
+     * @returns {Promise<GetFlushStateResponse>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
      *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).flushSync({
-     *     collection_names: ['my_collection'],
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const flushSyncStatus = await milvusClient.flushSync({
+     *    collection_names: ['my_collection'],
      *  });
      * ```
      */
@@ -618,7 +513,7 @@ class Data extends Collection_1.Collection {
                 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);
+            const res = yield (0, __1.promisify)(this.channelPool, '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)
@@ -635,32 +530,30 @@ class Data extends Collection_1.Collection {
         });
     }
     /**
-     * Query vector data in Milvus. Current release of Milvus only supports expression as fieldname in [id1,id2,id3]
-     *
-     * @param data
-     *  | Property | Type  | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_name | String | Collection name |
-     *  | 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 |
-  
-     *  | 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
-     *
+     * Query vector data in Milvus. Current release of Milvus only supports expression as fieldname in [id1,id2,id3].
+     *
+     * @param {QueryReq} data - The request parameters.
+     * @param {string} data.collection_name - Collection name.
+     * @param {string[]} [data.ids] - IDs to get.
+     * @param {string} [data.expr] - Scalar field filter expression.
+     * @param {string} [data.filter] - Equals to data.expr.
+     * @param {string[]} [data.partitions_names] - Array of partition names (optional).
+     * @param {string[]} data.output_fields - Vector or scalar field to be returned.
+     * @param {number} [data.timeout] - 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.
+     * @param {{key: value}[]} [data.params] - An optional key pair json array of search parameters.
+     * @param {OutputTransformers} data.transformers - The transformers for bf16 or f16 data, it accept bytes or sparse dic vector, it can ouput f32 array or other format(optional)
+     *
+     * @returns {Promise<QueryResults>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {{field_name: value}[]} data - Data of all fields that you defined in `output_fields`.
+     *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).query({
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const queryResults = await milvusClient.query({
      *    collection_name: 'my_collection',
-     *    expr: "age in [1,2,3,4,5,6,7,8]",
+     *    filter: "age in [1,2,3,4,5,6,7,8]",
      *    output_fields: ["age"],
      *  });
      * ```
@@ -677,13 +570,25 @@ class Data extends Collection_1.Collection {
             if (typeof data.offset === 'number') {
                 offset = { offset: data.offset };
             }
-            // filter > expr or empty
-            data.expr = data.filter || data.expr || '';
+            // id in expression
+            let primaryKeyInIdsExpression = '';
+            // if we have ids
+            if (data.ids && data.ids.length > 0) {
+                const pkField = yield this.getPkFieldName(data);
+                const pkFieldType = yield this.getPkFieldType(data);
+                // generate expr by different type of pk
+                primaryKeyInIdsExpression =
+                    __1.DataTypeMap[pkFieldType] === __1.DataType.VarChar
+                        ? `${pkField} in ["${data.ids.join('","')}"]`
+                        : `${pkField} in [${data.ids.join(',')}]`;
+            }
+            // filter > expr or empty > ids
+            data.expr = data.filter || data.expr || primaryKeyInIdsExpression;
             // 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);
+            const promise = yield (0, __1.promisify)(this.channelPool, 'Query', Object.assign(Object.assign({}, data), { query_params: (0, __1.parseToKeyValue)(Object.assign(Object.assign({}, limits), offset)) }), data.timeout || this.timeout);
             // always get output_fields from fields_data
             const output_fields = promise.fields_data.map(f => f.field_name);
-            const fieldsDataMap = (0, __1.buildFieldDataMap)(promise.fields_data);
+            const fieldsDataMap = (0, __1.buildFieldDataMap)(promise.fields_data, data.transformers);
             // For each output field, check if it has a fixed schema or not
             const fieldDataContainer = output_fields.map(field_name => {
                 // Check if the field_name exists in the fieldsDataMap
@@ -718,6 +623,7 @@ class Data extends Collection_1.Collection {
         return __awaiter(this, void 0, void 0, function* () {
             const queryResult = yield this.query({
                 collection_name: data.collection_name,
+                expr: data.expr || '',
                 output_fields: [__1.DEFAULT_COUNT_QUERY_STRING],
             });
             return {
@@ -727,51 +633,34 @@ class Data extends Collection_1.Collection {
         });
     }
     /**
-     * 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
-     *
+     * Retrieve vector data by providing IDs in Milvus.
+     *
+     * @param {GetReq} data - The request parameters.
+     * @param {string} data.collection_name - Collection name.
+     * @param {string[]} data.ids - IDs to get.
+     * @param {string[]} [data.partitions_names] - Array of partition names (optional).
+     * @param {string[]} data.output_fields - Vector or scalar field to be returned.
+     * @param {number} [data.timeout] - 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.
+     * @param {{key: value}[]} [data.params] - An optional key pair json array.
+     *
+     * @returns {Promise<QueryResults>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {{field_name: value}[]} data - Data of all fields that you defined in `output_fields`.
+     *
+     * @example
      * ```
-     *  new milvusClient(MILUVS_ADDRESS).get({
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const getResults = await milvusClient.get({
      *    collection_name: 'my_collection',
-     *    ids: [1,2,3,4,5,6,7,8],
+     *    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);
-            }
-            const pkFieldType = yield this.getPkFieldType(data);
-            // generate expr by different type of pk
-            const expr = __1.DataTypeMap[pkFieldType] === __1.DataType.VarChar
-                ? `${pkField} in ["${data.ids.join('","')}"]`
-                : `${pkField} in [${data.ids.join(',')}]`;
-            // build query req
-            const req = Object.assign(Object.assign({}, data), { expr });
-            return this.query(req);
+            return this.query(data);
         });
     }
     /**
@@ -786,34 +675,30 @@ class Data extends Collection_1.Collection {
             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', {
+            const res = yield (0, __1.promisify)(this.channelPool, '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
+     * Get the flush state of specified segment IDs in Milvus.
      *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | segmentIDs | Array | The segment ids |
-     *  | 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 |
+     * @param {GetFlushStateReq} data - The request parameters.
+     * @param {number[]} data.segmentIDs - The segment IDs.
+     * @param {number} [data.timeout] - 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 } |
-     *  | flushed | segments flushed or not |
-     *
-     *
-     * #### Example
+     * @returns {Promise<GetFlushStateResponse>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {boolean[]} flushed - Array indicating whether each segment is flushed or not.
      *
+     * @example
      * ```
-     *   const res = await milvusClient.getFlushState({
-     *    segmentIDs: segIds,
-     *   });
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const flushState = await milvusClient.getFlushState({
+     *    segmentIDs: [1,2,3,4],
+     *  });
      * ```
      */
     getFlushState(data) {
@@ -821,35 +706,31 @@ class Data extends Collection_1.Collection {
             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);
+            const res = yield (0, __1.promisify)(this.channelPool, '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.
+     * Perform a load balancing operation from a source query node to destination query nodes.
+     * This function only works in a Milvus cluster.
      *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | src_nodeID | number | The source query node id to balance. |
-     *  | dst_nodeIDs | number[] | The destination query node ids to balance.(optional) |
-     *  | sealed_segmentIDs | number[] | Sealed segment ids to balance.(optional) |
-     *  | 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 } |
-     *  | infos | segments information |
+     * @param {LoadBalanceReq} data - The request parameters.
+     * @param {number} data.src_nodeID - The source query node id to balance.
+     * @param {number[]} [data.dst_nodeIDs] - The destination query node ids to balance (optional).
+     * @param {number[]} [data.sealed_segmentIDs] - Sealed segment ids to balance (optional).
+     * @param {number} [data.timeout] - 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 {Promise<ResStatus>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {SegmentInfo[]} infos - Information about the segments.
      *
-     * #### Example
-     *
+     * @example
      * ```
-     *   const res = await loadBalance({
-     *      src_nodeID: 31,
-     *   });
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const loadBalanceStatus = await milvusClient.loadBalance({
+     *    src_nodeID: 31,
+     *  });
      * ```
      */
     loadBalance(data) {
@@ -857,33 +738,28 @@ class Data extends Collection_1.Collection {
             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);
+            const res = yield (0, __1.promisify)(this.channelPool, 'LoadBalance', data, data.timeout || this.timeout);
             return res;
         });
     }
     /**
      * Notifies Proxy to return segments information from query nodes.
      *
-     * @param data
-     *  | Property | Type  | Description |
-     *  | :--- | :-- | :-- |
-     *  | collectionName | String | The name of the collection to get segments info. |
-     *  | 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 } |
-     *  | infos | QuerySegmentInfo is the growing segments's information in query cluster. |
+     * @param {GetQuerySegmentInfoReq} data - The request parameters.
+     * @param {string} data.collectionName - The name of the collection to get segments info.
+     * @param {number} [data.timeout] - 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 {Promise<GetQuerySegmentInfoResponse>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {QuerySegmentInfo[]} infos - The growing segments' information in query cluster.
      *
-     * #### Example
-     *
+     * @example
      * ```
-     *   const res = await getQuerySegmentInfo({
-     *      collectionName: COLLECTION,
-     *    });
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const querySegmentInfo = await milvusClient.getQuerySegmentInfo({
+     *    collectionName: 'my_collection',
+     *  });
      * ```
      */
     getQuerySegmentInfo(data) {
@@ -891,33 +767,28 @@ class Data extends Collection_1.Collection {
             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);
+            const res = yield (0, __1.promisify)(this.channelPool, 'GetQuerySegmentInfo', data, data.timeout || this.timeout);
             return res;
         });
     }
-    /**data
+    /**
      * Notifies Proxy to return segments information from data nodes.
      *
-     * @param data
-     *  | Property | Type  | Description |
-     *  | :--- | :-- | :-- |
-     *  | collectionName | String | The name of the collection to get segments info. |
-     *  | 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 |
+     * @param {GetPersistentSegmentInfoReq} data - The request parameters.
+     * @param {string} data.collectionName - The name of the collection to get segments info.
+     * @param {number} [data.timeout] - 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 {Promise<GetPersistentSegmentInfoResponse>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {PersistentSegmentInfo[]} infos - The growing segments' information in data cluster.
      *
-     * @returns
-     * | Property | Description |
-     *  | :--- | :-- |
-     *  | status | { error_code: number,reason:string } |
-     *  | infos | getPersistentSegmentInfo is the growing segments's information in query cluster. |
-     *
-     *
-     * #### Example
-     *
+     * @example
      * ```
-     *   const res = await getPersistentSegmentInfo({
-     *      collectionName: COLLECTION,
-     *    });
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const persistentSegmentInfo = await milvusClient.getPersistentSegmentInfo({
+     *    collectionName: 'my_collection',
+     *  });
      * ```
      */
     getPersistentSegmentInfo(data) {
@@ -925,34 +796,30 @@ class Data extends Collection_1.Collection {
             if (!data || !data.collectionName) {
                 throw new Error(__1.ERROR_REASONS.COLLECTION_NAME_IS_REQUIRED);
             }
-            const res = yield (0, __1.promisify)(this.client, 'GetPersistentSegmentInfo', data, data.timeout || this.timeout);
+            const res = yield (0, __1.promisify)(this.channelPool, 'GetPersistentSegmentInfo', data, data.timeout || this.timeout);
             return res;
         });
     }
     /**
-     * Import data from files
+     * Import data from files.
      *
-     * @param data
-     *  | Property | Type | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_name | String | The name of the collection |
-     *  | files | string[] | File path array |
-     *
-     *
-     * @returns
-     * | Property | Description |
-     *  | :--- | :-- |
-     *  | status | { error_code: number,reason:string } |
-     *  | tasks | taskId array |
+     * @param {ImportReq} data - The request parameters.
+     * @param {string} data.collection_name - The name of the collection.
+     * @param {string[]} data.files - Array of file paths.
+     * @param {number} [data.timeout] - 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 {Promise<ImportResponse>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {string[]} tasks - Array of task IDs.
      *
-     * #### Example
-     *
+     * @example
      * ```
-     *   const res = await bulkInsert({
-     *      collection_name: COLLECTION,
-     *      files: [`path-to-data-file.json`]
-     *    });
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const importResponse = await milvusClient.bulkInsert({
+     *    collection_name: 'my_collection',
+     *    files: ['path-to-data-file.json'],
+     *  });
      * ```
      */
     /* istanbul ignore next */
@@ -964,37 +831,33 @@ class Data extends Collection_1.Collection {
             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);
+            const res = yield (0, __1.promisify)(this.channelPool, 'Import', Object.assign(Object.assign({}, data), { options: data.options || [] }), data.timeout || this.timeout);
             return res;
         });
     }
     /**
-     * List import tasks
-     *
-     * @param data
-     *  | Property | Type  | Description |
-     *  | :--- | :-- | :-- |
-     *  | collection_name | String | The name of the collection |
-     *  | limit | number | optional, maximum number of tasks returned, list all tasks if the value is 0 |
-     *
-     *
-     * @returns
-     * | Property | Description |
-     *  | :--- | :-- |
-     *  | status | { error_code: number,reason:string } |
-     *  | state | import state |
-     *  | row_count | how many rows to import|
-     *  | id_list| id lists |
-     *  | collection_id | collection to be imported to |
-     *  | tasks | taskId array  |
-     *
-     *
-     * #### Example
-     *
+     * List import tasks.
+     *
+     * @param {ListImportTasksReq} data - The request parameters.
+     * @param {string} data.collection_name - The name of the collection.
+     * @param {number} [data.limit] - Optional, maximum number of tasks returned, list all tasks if the value is 0.
+     * @param {number} [data.timeout] - 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 {Promise<ListImportTasksResponse>} The result of the operation.
+     * @returns {string} status.error_code - The error code of the operation.
+     * @returns {string} status.reason - The reason for the error, if any.
+     * @returns {string} state - Import state.
+     * @returns {number} row_count - How many rows to import.
+     * @returns {string[]} id_list - ID lists.
+     * @returns {string} collection_id - Collection to be imported to.
+     * @returns {string[]} tasks - TaskId array.
+     *
+     * @example
      * ```
-     *   const res = await listImportTasks({
-     *      collection_name: COLLECTION
-     *    });
+     *  const milvusClient = new milvusClient(MILUVS_ADDRESS);
+     *  const listImportTasksResponse = await milvusClient.listImportTasks({
+     *    collection_name: 'my_collection',
+     *  });
      * ```
      */
     /* istanbul ignore next */
@@ -1003,7 +866,7 @@ class Data extends Collection_1.Collection {
             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);
+            const res = yield (0, __1.promisify)(this.channelPool, 'ListImportTasks', Object.assign(Object.assign({}, data), { limit: data.limit || 0 }), data.timeout || this.timeout);
             return res;
         });
     }