@tablestore/tablestore-agent-cli 0.1.3 → 0.1.4

package/dist/dashboard-runtime/node_modules/tablestore/lib/protocol/encoder.js

@@ -1,1593 +0,0 @@
-var TableStore = require('../core');
-
-var BaseProto = require('./tablestore_compiled_proto.js');
-var tsProtos = BaseProto.main.proto;
-var tsFilterProtos = BaseProto.filter.proto;
-var tsSearchProtos = BaseProto.search.proto;
-
-
-const COLUMN_CONDITION_TYPE_MAP = {
-    COMPOSITE_COLUMN_CONDITION: tsFilterProtos.FT_COMPOSITE_COLUMN_VALUE,
-    SINGLE_COLUMN_CONDITION: tsFilterProtos.FT_SINGLE_COLUMN_VALUE,
-};
-
-TableStore.encoder = {
-    encode: function (operation, params) {
-        return tsMap[operation](params);
-    },
-
-    encodeCreateTable: function (params) {
-        if (!params.reservedThroughput || !params.tableOptions) {
-            throw new Error('reservedThroughput and tableOptions are required');
-        }
-
-        var properties = {};
-
-        var primaryKey = [];
-        TableStore.util.arrayEach(params.tableMeta.primaryKey, function(pk) {
-            primaryKey.push({
-                name: pk.name,
-                type: TableStore.PrimaryKeyType[pk.type] || pk.type,
-                option: TableStore.PrimaryKeyOption[pk.option] || pk.option
-            });
-        });
-
-        properties.tableMeta = {
-            tableName: params.tableMeta.tableName,
-            primaryKey: primaryKey
-        };
-
-        properties.reservedThroughput = {
-            capacityUnit: params.reservedThroughput.capacityUnit
-        };
-
-        if (Object.prototype.toString.call(params.tableMeta.definedColumn) === '[object Array]') {
-            properties.tableMeta.definedColumn = params.tableMeta.definedColumn;
-        }
-
-        if (params.tableOptions) {
-            properties.tableOptions = {
-                timeToLive: params.tableOptions.timeToLive,
-                maxVersions: params.tableOptions.maxVersions,
-                allowUpdate: params.tableOptions.allowUpdate
-            };
-            if (params.tableOptions.maxTimeDeviation) {
-                properties.tableOptions.deviationCellVersionInSec =
-                    params.tableOptions.maxTimeDeviation
-            }
-        }
-        if (params.streamSpecification) {
-            properties.streamSpec = {
-                enableStream: params.streamSpecification.enableStream,
-                expirationTime: params.streamSpecification.expirationTime
-            }
-        }
-        if (Object.prototype.toString.call(params.indexMetas) === '[object Array]') {
-            var indexMetas = [];
-            TableStore.util.arrayEach(params.indexMetas, function(meta) {
-                indexMetas.push({
-                    name: meta.name,
-                    primaryKey: meta.primaryKey,
-                    definedColumn: meta.definedColumn,
-                    indexUpdateMode: meta.indexUpdateMode || TableStore.IndexUpdateMode.IUM_ASYNC_INDEX,//默认增量
-                    indexType: meta.indexType || TableStore.IndexType.IT_GLOBAL_INDEX,//IT_GLOBAL_INDEX
-                });
-            });
-            properties.indexMetas = indexMetas;
-        }
-
-        var request = tsProtos.CreateTableRequest.create(properties);
-
-        return request;
-    },
-    encodeListTable: function () {
-        var request = tsProtos.ListTableRequest.create();
-        return request;
-    },
-    encodeDeleteTable: function (params) {
-        var properties = {
-            tableName: params.tableName
-        };
-
-        var request = tsProtos.DeleteTableRequest.create(properties);
-
-        return request;
-    },
-    encodeUpdateTable: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            tableOptions: {
-                timeToLive: params.tableOptions.timeToLive,
-                maxVersions: params.tableOptions.maxVersions,
-                allowUpdate: params.tableOptions.allowUpdate,
-                deviationCellVersionInSec: params.tableOptions.maxTimeDeviation
-            }
-        };
-
-        if (params.reservedThroughput) {
-            properties.reservedThroughput =  {
-                capacityUnit: params.reservedThroughput.capacityUnit
-            };
-        }
-
-        if (params.streamSpecification) {
-            properties.streamSpec = {
-                enableStream: params.streamSpecification.enableStream,
-                expirationTime: params.streamSpecification.expirationTime
-            }
-        }
-
-        var request = tsProtos.UpdateTableRequest.create(properties);
-
-        return request;
-    },
-    encodeDescribeTable: function (params) {
-        var properties = {
-            tableName: params.tableName
-        };
-        var request = tsProtos.DescribeTableRequest.create(properties);
-        return request;
-    },
-
-    encodeGetRow: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            primaryKey: TableStore.PlainBufferBuilder.serializePrimaryKey(params.primaryKey),
-            attributeColumns: params.attributeColumns
-        };
-
-        if (params.maxVersions) {
-            properties.maxVersions = params.maxVersions;
-        } else {
-            properties.maxVersions = 1;
-        }
-
-        if (params.columnFilter) {
-            var filterProperties = {};
-            TableStore.encoder._makeColumnCondition(filterProperties, params.columnFilter);
-
-            var pbFilter = tsFilterProtos.Filter.create(filterProperties)
-            var filterWriter = tsFilterProtos.Filter.encode(pbFilter);
-
-            properties.filter = filterWriter.finish();
-        }
-
-        if (params.timeRange) {
-            properties.timeRange = {
-                startTime: params.timeRange.startTime,
-                endTime: params.timeRange.endTime,
-                specificTime: params.timeRange.specificTime
-            };
-        }
-
-        if (params.startColumn) {
-            properties.startColumn = params.startColumn;
-        }
-        if (params.endColumn) {
-            properties.endColumn = params.endColumn;
-        }
-
-        if (params.columnsToGet) {
-            properties.columnsToGet = params.columnsToGet
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-
-        if (params.maxVersions) {
-            properties.maxVersions = params.maxVersions;
-        } else {
-            properties.maxVersions = 1;
-        }
-
-        var request = tsProtos.GetRowRequest.create(properties);
-
-        return request;
-    },
-    encodePutRow: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            row: TableStore.PlainBufferBuilder.serializeForPutRow(params.primaryKey, params.attributeColumns)
-        };
-
-        if (params.condition === undefined || params.condition === null) {
-            properties.condtion = new TableStore.Condition(TableStore.RowExistenceExpectation.IGNORE, null);
-        }
-        properties.condition = {};
-        TableStore.encoder._makeCondition(properties.condition, params.condition);
-
-        if (params.returnContent && params.returnContent.returnType) {
-            properties.returnContent = {
-                returnType: params.returnContent.returnType
-            };
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-        var request = tsProtos.PutRowRequest.create(properties);
-        return request;
-    },
-    encodeUpdateRow: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            rowChange: TableStore.PlainBufferBuilder.serializeForUpdateRow(params.primaryKey, params.updateOfAttributeColumns)
-        };
-
-        if (params.condition === undefined || params.condition === null) {
-            params.condtion = new TableStore.Condition(TableStore.RowExistenceExpectation.IGNORE, null);
-        }
-        properties.condition = {};
-        TableStore.encoder._makeCondition(properties.condition, params.condition);
-
-        if (params.returnContent && params.returnContent.returnType) {
-            properties.returnContent = {
-                returnType: params.returnContent.returnType,
-                returnColumnNames: params.returnContent.returnColumns
-            };
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-        var request = tsProtos.UpdateRowRequest.create(properties);
-
-        return request;
-    },
-    encodeDeleteRow: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            primaryKey: TableStore.PlainBufferBuilder.serializeForDeleteRow(params.primaryKey)
-        };
-
-        if (params.condition === undefined || params.condition === null) {
-            params.condtion = new TableStore.Condition(TableStore.RowExistenceExpectation.IGNORE, null);
-        }
-        properties.condition = {};
-        TableStore.encoder._makeCondition(properties.condition, params.condition);
-
-        if (params.returnContent && params.returnContent.returnType) {
-            properties.returnContent = {
-                returnType: params.returnContent.returnType
-            };
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-        var request = tsProtos.DeleteRowRequest.create(properties);
-
-        return request;
-    },
-    encodeGetRange: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            inclusiveStartPrimaryKey: TableStore.PlainBufferBuilder.serializePrimaryKey(params.inclusiveStartPrimaryKey),
-            exclusiveEndPrimaryKey: TableStore.PlainBufferBuilder.serializePrimaryKey(params.exclusiveEndPrimaryKey),
-            direction: tsProtos.Direction[params.direction]
-        };
-
-        if (params.maxVersions) {
-            properties.maxVersions = params.maxVersions;
-        } else {
-            properties.maxVersions = 1;
-        }
-
-        if (params.columnFilter) {
-            var filterProperties = {};
-            TableStore.encoder._makeColumnCondition(filterProperties, params.columnFilter);
-
-            var pbFilter = tsFilterProtos.Filter.create(filterProperties);
-            var filterWriter = tsFilterProtos.Filter.encode(pbFilter);
-
-            properties.filter = filterWriter.finish();
-        }
-
-        if (params.limit) {
-            properties.limit = params.limit;
-        }
-
-        if (params.timeRange) {
-            properties.timeRange = {
-                startTime: params.timeRange.startTime,
-                endTime: params.timeRange.endTime,
-                specificTime: params.timeRange.specificTime
-            };
-        }
-
-        if (params.startColumn) {
-            properties.startColumn = params.startColumn;
-        }
-        if (params.endColumn) {
-            properties.endColumn = params.endColumn;
-        }
-
-        if (params.columnsToGet) {
-            properties.columnsToGet = params.columnsToGet
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-        var request = tsProtos.GetRangeRequest.create(properties);
-
-        return request;
-    },
-    encodeBatchGetRow: function (params) {
-        if (params.tables === undefined || params.tables === null) {
-            throw new Error('params.tables is not correct');
-        }
-
-        var properties = {
-            tables: []
-        };
-
-        for (var i = 0; i < params.tables.length; i++) {
-            var item = {
-                tableName: params.tables[i].tableName,
-                primaryKey: [],
-            };
-
-            for (var pk in params.tables[i].primaryKey) {
-                item.primaryKey.push(TableStore.PlainBufferBuilder.serializePrimaryKey(params.tables[i].primaryKey[pk]));
-            }
-
-            if (params.tables[i].columnFilter) {
-                var filterProperties = {};
-                TableStore.encoder._makeColumnCondition(filterProperties, params.tables[i].columnFilter);
-
-                var pbFilter = tsFilterProtos.Filter.create(filterProperties);
-                var filterWriter = tsFilterProtos.Filter.encode(pbFilter);
-
-                item.filter = filterWriter.finish();
-            }
-
-            if (params.tables[i].maxVersions) {
-                item.maxVersions = params.tables[i].maxVersions;
-            } else {
-                item.maxVersions = 1;
-            }
-
-            if (params.tables[i].timeRange) {
-                item.timeRange = {
-                    startTime: params.tables[i].timeRange.startTime,
-                    endTime: params.tables[i].timeRange.endTime,
-                    specificTime: params.tables[i].timeRange.specificTime
-                };
-            }
-
-            if (params.tables[i].startColumn) {
-                item.startColumn = params.tables[i].startColumn;
-            }
-            if (params.tables[i].endColumn) {
-                item.endColumn = params.tables[i].endColumn;
-            }
-
-            if (params.tables[i].columnsToGet) {
-                item.columnsToGet = params.tables[i].columnsToGet
-            }
-
-            properties.tables.push(item);
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-        var request = tsProtos.BatchGetRowRequest.create(properties);
-
-        return request;
-    },
-    encodeBatchWriteRow: function (params) {
-        if (params.tables === undefined || params.tables === null || params.tables.length <= 0) {
-            throw new Error('params.tables is not correct');
-        }
-
-        var properties = {
-            tables: []
-        };
-
-        for (var i = 0; i < params.tables.length; i++) {
-            var item = {
-                tableName: params.tables[i].tableName,
-                rows: []
-            };
-
-            for (var attr in params.tables[i].rows) {
-                var row = {};
-                var batchWriteType = params.tables[i].rows[attr].type;
-                row.type = ~["PUT", "UPDATE", "DELETE"].indexOf(batchWriteType) ? TableStore.BatchWriteType[batchWriteType] : batchWriteType;
-                switch (batchWriteType) {
-                    case 'PUT':
-                        row.rowChange = TableStore.PlainBufferBuilder.serializeForPutRow(
-                            params.tables[i].rows[attr].primaryKey, params.tables[i].rows[attr].attributeColumns);
-                        break;
-                    case 'UPDATE':
-                        row.rowChange = TableStore.PlainBufferBuilder.serializeForUpdateRow(
-                            params.tables[i].rows[attr].primaryKey, params.tables[i].rows[attr].attributeColumns);
-                        break;
-                    case 'DELETE':
-                        row.rowChange = TableStore.PlainBufferBuilder.serializeForDeleteRow(
-                            params.tables[i].rows[attr].primaryKey, params.tables[i].rows[attr].attributeColumns);
-                        break;
-                    default:
-                        throw new Error('batchwriterow type is error:' + params.tables[i].rows[attr].type);
-                }
-
-                if (params.tables[i].rows[attr].condition) {
-                    row.condition = {};
-                    TableStore.encoder._makeCondition(row.condition, params.tables[i].rows[attr].condition);
-                }
-
-                if (params.tables[i].rows[attr].returnContent &&
-                    params.tables[i].rows[attr].returnContent.returnType) {
-                    row.returnContent = { returnType: params.tables[i].rows[attr].returnContent.returnType };
-
-                    if (params.tables[i].rows[attr].returnContent.returnColumns) {
-                        row.returnContent.returnColumnNames = params.tables[i].rows[attr].returnContent.returnColumns;
-
-                    }
-                }
-
-                item.rows.push(row);
-            }
-
-            properties.tables.push(item);
-        }
-
-        if (params.transactionId) {
-            properties.transactionId = params.transactionId
-        }
-
-        var request = tsProtos.BatchWriteRowRequest.create(properties);
-
-        return request;
-    },
-    _makeColumnCondition: function (proto, column_condition) {
-        if (column_condition === null) {
-            return;
-        }
-
-        if (!column_condition instanceof TableStore.ColumnCondition) {
-            throw new Error("column condition should be an instance of ColumnCondition");
-        }
-
-        proto.type = column_condition.getType();
-        if (proto.type === null) {
-            throw new Error("column_condition_type should be one of TableStore.ColumnConditionType");
-        }
-
-        // condition
-        if (column_condition instanceof TableStore.CompositeCondition) {
-            proto.filter = TableStore.encoder._makeCompositeCondition(column_condition);
-        } else if (column_condition instanceof TableStore.SingleColumnCondition) {
-            proto.filter = TableStore.encoder._makeSingleColumnCondition(column_condition);
-        } else if (column_condition instanceof TableStore.ColumnPaginationFilter) {
-            proto.filter = TableStore.encoder._makeColumnPaginationFilter(column_condition);
-        } else {
-            throw new Error("expect CompositeCondition, RelationCondition, ColumnPaginationFilter but not ");
-        }
-    },
-    _makeCompositeCondition: function (condition) {
-        if (condition.combinator === undefined || condition.combinator === null) {
-            throw new Error("LogicalOperator should be one of TableStore.LogicalOperator");
-        }
-        var subFilters = [];
-        for (sub in condition.sub_conditions) {
-            var subFilter = {};
-            TableStore.encoder._makeColumnCondition(subFilter, condition.sub_conditions[sub]);
-            subFilters.push(subFilter);
-        }
-
-        var properties = {
-            combinator: condition.combinator,
-            subFilters: subFilters
-        };
-
-        var proto = tsFilterProtos.CompositeColumnValueFilter.create(properties);
-        var writer = tsFilterProtos.CompositeColumnValueFilter.encode(proto);
-
-        return writer.finish();
-    },
-
-    _makeSingleColumnCondition: function (condition) {
-        if (condition.comparator === null) {
-            throw new Error("ComparatorType should be one of [%s], not %s");
-        }
-
-        var properties = {
-            comparator: condition.comparator,
-            columnName: condition.columnName,
-            columnValue: TableStore.PlainBufferBuilder.serializeColumnValue(condition.columnValue),
-            filterIfMissing: !condition.passIfMissing,
-            latestVersionOnly: condition.latestVersionOnly
-        };
-
-        var proto = tsFilterProtos.SingleColumnValueFilter.create(properties);
-        var writer = tsFilterProtos.SingleColumnValueFilter.encode(proto);
-        return writer.finish();
-    },
-    _makeColumnPaginationFilter: function (condition) {
-        var properties = {
-            offset: condition.offset,
-            limit: condition.limit
-        };
-
-        var proto = tsFilterProtos.ColumnPaginationFilter.create(properties);
-        var writer = tsFilterProtos.ColumnPaginationFilter.encode(proto);
-        return writer.finish();
-    },
-    _makeCondition: function (proto, condition) {
-        if (!condition instanceof TableStore.Condition) {
-            throw new Error("condition should be an instance of TableStore.Condition");
-        }
-
-        proto.rowExistence = condition.rowExistenceExpectation;
-        if (proto.rowExistence === undefined || proto.rowExistence === null) {
-            throw new Error("rowExistenceExpectation should be one of TableStore.RowExistenceExpectation");
-        }
-
-        if (condition.columnCondition != null) {
-            var properties = {};
-            TableStore.encoder._makeColumnCondition(properties, condition.columnCondition);
-            var pbFilter = tsFilterProtos.Filter.create(properties);
-            var filterWriter = tsFilterProtos.Filter.encode(pbFilter);
-            
-            proto.columnCondition = filterWriter.finish();
-        }
-    },
-    encodeListSearchIndex: function (params) {
-        var request = tsSearchProtos.ListSearchIndexRequest.create({
-            tableName: params.tableName
-        });
-        return request;
-    },
-    encodeDescribeSearchIndex: function (params) {
-        var request = tsSearchProtos.DescribeSearchIndexRequest.create({
-            tableName: params.tableName,
-            indexName: params.indexName
-        });
-        return request;
-    },
-    encodeUpdateSearchIndex: function (params) {
-        return tsSearchProtos.UpdateSearchIndexRequest.create({
-            tableName: params.tableName,
-            indexName: params.indexName,
-            timeToLive: params.timeToLive,
-        });
-    },
-    encodeCreateSearchIndex: function (params) {
-        const properties = {
-            tableName: params.tableName,
-            indexName: params.indexName,
-            sourceIndexName: params.sourceIndexName,
-            timeToLive: params.timeToLive,
-            schema: TableStore.encoder._makeIndexSchema(params.schema)
-        };
-
-        var request = tsSearchProtos.CreateSearchIndexRequest.create(properties);
-
-        return request;
-    },
-    _makeIndexSchema: function(schema) {
-        var properties = {
-            fieldSchemas: TableStore.encoder._makeFieldSchemaArray(schema.fieldSchemas),
-            indexSetting: TableStore.encoder._makeIndexSetting(schema.indexSetting)
-        };
-        if (schema.indexSort) {
-            properties.indexSort = TableStore.encoder._makeSort(schema.indexSort);
-        }
-        var indexSchema = tsSearchProtos.IndexSchema.create(properties);
-
-        return indexSchema;
-    },
-    _makeSingleWordAnalyzerParameter: function(aParameter) {
-        const properties = {
-            caseSensitive: aParameter.caseSensitive,
-            delimitWord: aParameter.delimitWord,
-        };
-        return tsSearchProtos.SingleWordAnalyzerParameter.encode(properties).finish();
-    },
-    _makeSplitAnalyzerParameter: function(aParameter) {
-        const properties = {
-            delimiter: aParameter.delimiter,
-        };
-        return tsSearchProtos.SplitAnalyzerParameter.encode(properties).finish();
-    },
-    _makeFuzzyAnalyzerParameter: function(aParameter) {
-        const properties = {
-            minChars: aParameter.minChars,
-            maxChars: aParameter.maxChars,
-        };
-        return tsSearchProtos.FuzzyAnalyzerParameter.encode(properties).finish();
-    },
-    _makeAnalyzerParameter: function(schema) {
-        if (schema.analyzer) {
-            if (schema.analyzer === "single_word") {
-                return  TableStore.encoder._makeSingleWordAnalyzerParameter(schema.analyzerParameter);
-            }
-            if (schema.analyzer === "split") {
-                return  TableStore.encoder._makeSplitAnalyzerParameter(schema.analyzerParameter);
-            }
-            if (schema.analyzer === "fuzzy") {
-                return  TableStore.encoder._makeFuzzyAnalyzerParameter(schema.analyzerParameter);
-            }
-        }
-        return null
-    },
-    _makeFieldSchemaArray: function(fieldSchemaArray) {
-        if (!fieldSchemaArray) return null;
-
-        var fieldSchemas = [];
-        TableStore.util.arrayEach(fieldSchemaArray, function(fieldSchema) {
-            fieldSchemas.push(TableStore.encoder._makeFieldSchema(fieldSchema));
-        });
-        return fieldSchemas;
-    },
-    _makeFieldSchema: function(aFieldSchema) {
-        const properties = {
-            fieldName: aFieldSchema.fieldName,
-            fieldType: aFieldSchema.fieldType,
-            indexOptions: aFieldSchema.indexOptions || null,
-            enableHighlighting: aFieldSchema.enableHighlighting || null,
-            analyzer: aFieldSchema.analyzer || null,
-            index: aFieldSchema.index || null,
-            docValues: aFieldSchema.enableSortAndAgg || null,
-            store: aFieldSchema.store || null,
-            isArray: aFieldSchema.isAnArray || null,
-            fieldSchemas: TableStore.encoder._makeFieldSchemaArray(aFieldSchema.fieldSchemas),
-            analyzerParameter: TableStore.encoder._makeAnalyzerParameter(aFieldSchema),
-            isVirtualField: aFieldSchema.isVirtualField || null,
-            sourceFieldNames: aFieldSchema.sourceFieldNames || null,
-            dateFormats: aFieldSchema.dateFormats || null,
-            vectorOptions: aFieldSchema.vectorOptions || null,
-        };
-
-        return tsSearchProtos.FieldSchema.create(properties);
-    },
-    _makeIndexSetting: function(aIndexSetting) {
-        var properties = {
-            numberOfShards: 1,
-            routingFields: aIndexSetting && aIndexSetting.routingFields || null,
-            routingPartitionSize: aIndexSetting && aIndexSetting.routingPartitionSize || null
-        };
-
-        var indexSetting = tsSearchProtos.IndexSetting.create(properties);
-
-        return indexSetting;
-    },
-    encodeDeleteSearchIndex: function (params) {
-        var properties = {
-            tableName: params.tableName,
-            indexName: params.indexName
-        };
-        var request = tsSearchProtos.DeleteSearchIndexRequest.create(properties);
-
-        return request;
-    },
-    encodeSearch: function (params) {
-        const properties = {
-            tableName: params.tableName,
-            indexName: params.indexName,
-            searchQuery: TableStore.encoder._makeSearchQuery(params.searchQuery),
-            columnsToGet: TableStore.encoder._makeColumnToGet(params.columnToGet),
-            timeoutMs: params.timeoutMs || 10000
-        };
-
-        if (Object.prototype.toString.call(params.routingValues) === '[object Array]') {
-            properties.routingValues = TableStore.encoder._makeRoutingValues(params.routingValues);
-        }
-
-        return tsSearchProtos.SearchRequest.create(properties);
-    },
-    encodeComputeSplits: function (params) {
-        let properties = {
-            tableName: params.tableName,
-        };
-        if (params.searchIndexSplitsOptions) {
-            properties.searchIndexSplitsOptions = {
-                indexName: params.searchIndexSplitsOptions.indexName,
-            }
-        }
-        return tsSearchProtos.ComputeSplitsRequest.create(properties);
-    },
-    encodeParallelScan: function (params) {
-        let properties = {
-            tableName: params.tableName,
-            indexName: params.indexName,
-            columnsToGet: TableStore.encoder._makeColumnToGet(params.columnToGet),
-            sessionId: params.sessionId,
-            scanQuery: TableStore.encoder._makeScanQuery(params.scanQuery),
-            timeoutMs: params.timeoutMs || 20000
-        };
-        return tsSearchProtos.ParallelScanRequest.create(properties);
-    },
-    _makeScanQuery(aScanQuery) {
-        let properties = {
-            query: TableStore.encoder._makeQuery(aScanQuery.query),
-            limit: aScanQuery.limit,
-            aliveTime: aScanQuery.aliveTime,
-            token: aScanQuery.token,
-            currentParallelId: aScanQuery.currentParallelId,
-            maxParallel: aScanQuery.maxParallel,
-        };
-        return tsSearchProtos.ScanQuery.create(properties);
-    },
-    _makeSearchQuery(aSearchQuery) {
-        var properties = {
-            offset: aSearchQuery.offset,
-            limit: aSearchQuery.limit,
-            query: TableStore.encoder._makeQuery(aSearchQuery.query),
-            getTotalCount: aSearchQuery.getTotalCount || false
-        };
-
-        if (aSearchQuery.token) {
-            properties.token = aSearchQuery.token;
-        }
-        if (aSearchQuery.sort) {
-            properties.sort = TableStore.encoder._makeSort(aSearchQuery.sort);
-        }
-        if (aSearchQuery.aggs) {
-            properties.aggs = TableStore.encoder._makeAggregations(aSearchQuery.aggs)
-        }
-        if (aSearchQuery.groupBys) {
-            properties.groupBys = TableStore.encoder._makeGroupBys(aSearchQuery.groupBys)
-        }
-        if(aSearchQuery.highlight) {
-            properties.highlight = TableStore.encoder._makeHighlight(aSearchQuery.highlight);
-        }
-        if (aSearchQuery.collapse) {
-            properties.collapse = TableStore.encoder._makeCollapse(aSearchQuery.collapse)
-        }
-        var searchQuery = tsSearchProtos.SearchQuery.create(properties);
-        var writer = tsSearchProtos.SearchQuery.encode(searchQuery);
-
-        return writer.finish();
-    },
-    _makeQuery(aQuery) {
-        var query = TableStore.encoder._constrctQueryParam(aQuery.queryType, aQuery.query);
-        var writer = Object.getPrototypeOf(query).constructor.encode(query);
-
-        var properties = {
-            type: aQuery.queryType,
-            query: writer.finish()
-        };
-
-        var query = tsSearchProtos.Query.create(properties);
-
-        return query;
-    },
-    _makeCollapse(aCollapse) {
-        const properties = {};
-        if (aCollapse.fieldName) {
-            properties.fieldName = aCollapse.fieldName;
-        }
-        return tsSearchProtos.Collapse.create(properties);
-    },
-    _makeAggregations(aggs) {
-        let aggArray = [];
-        for (let agg of aggs.aggs) {
-            aggArray.push(TableStore.encoder._makeAggregation(agg));
-        }
-        return {aggs: aggArray};
-    },
-    _makeAggregation(agg) {
-        const aggBody = TableStore.encoder._constructAggregationParam(agg.type, agg.body);
-        const writer = Object.getPrototypeOf(aggBody).constructor.encode(aggBody);
-        const properties = {
-            name: agg.name,
-            type: agg.type,
-            body: writer.finish(),
-        };
-        return tsSearchProtos.Aggregation.create(properties);
-    },
-    _constructAggregationParam(aggType, agg) {
-        switch (aggType) {
-            case TableStore.AggregationType.AGG_AVG: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                };
-                if (agg.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(agg.missing, "agg.missing");
-                }
-                return tsSearchProtos.AvgAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_MAX: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                };
-                if (agg.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(agg.missing, "agg.missing");
-                }
-                return tsSearchProtos.MaxAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_MIN: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                };
-                if (agg.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(agg.missing, "agg.missing");
-                }
-                return tsSearchProtos.MinAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_SUM: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                };
-                if (agg.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(agg.missing, "agg.missing");
-                }
-                return tsSearchProtos.SumAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_COUNT: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                };
-                return tsSearchProtos.CountAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_DISTINCT_COUNT: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                };
-                if (agg.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(agg.missing, "agg.missing");
-                }
-                return tsSearchProtos.DistinctCountAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_TOP_ROWS: {
-                const properties = {
-                    limit: agg.limit,
-                };
-                if (agg.sort) {
-                    properties.sort = TableStore.encoder._makeSort(agg.sort);
-                }
-                return tsSearchProtos.TopRowsAggregation.create(properties);
-            }
-            case TableStore.AggregationType.AGG_PERCENTILES: {
-                const properties = {
-                    fieldName: agg.fieldName,
-                    percentiles: agg.percentiles,
-                };
-                if (agg.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(agg.missing, "agg.missing");
-                }
-                return tsSearchProtos.PercentilesAggregation.create(properties);
-            }
-            default:
-                throw new Error("not exist AggregationType: " + aggType);
-        }
-    },
-    _makeGroupBys(group_bys) {
-        let groupByArray = [];
-        for (let groupBy of group_bys.groupBys) {
-            groupByArray.push(TableStore.encoder._makeGroupBy(groupBy));
-        }
-        return {groupBys: groupByArray};
-    },
-    _makeGroupBy(groupBy) {
-        const groupByBody = TableStore.encoder._constructGroupByParam(groupBy.type, groupBy.body);
-        const writer = Object.getPrototypeOf(groupByBody).constructor.encode(groupByBody);
-        const properties = {
-            name: groupBy.name,
-            type: groupBy.type,
-            body: writer.finish(),
-        };
-        return tsSearchProtos.GroupBy.create(properties);
-    },
-    _constructGroupByParam(groupByType, groupBy) {
-        switch (groupByType) {
-            case TableStore.GroupByType.GROUP_BY_FIELD: {
-                let properties = {
-                    fieldName: groupBy.fieldName,
-                    size: groupBy.size,
-                    minDocCount: groupBy.minDocCount,
-                };
-                if (groupBy.sort) {
-                    properties.sort = TableStore.encoder._makeGroupBySort(groupBy.sort);
-                }
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByField.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_RANGE: {
-                const properties = {
-                    fieldName: groupBy.fieldName,
-                    ranges: TableStore.encoder._makeRange(groupBy.ranges),
-                };
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByRange.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_FILTER: {
-                const properties = {
-                    filters: [],
-                };
-                TableStore.util.arrayEach(groupBy.filters, function (f) {
-                    let q = TableStore.encoder._makeQuery(f)
-                    properties.filters.push(q);
-                });
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByFilter.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_GEO_DISTANCE: {
-                const properties = {
-                    fieldName: groupBy.fieldName,
-                    ranges: TableStore.encoder._makeRange(groupBy.ranges),
-                    origin: tsSearchProtos.GeoPoint.create(groupBy.origin),
-                };
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByGeoDistance.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_HISTOGRAM: {
-                const properties = {
-                    fieldName: groupBy.fieldName,
-                    minDocCount: groupBy.minDocCount,
-                };
-                if (groupBy.sort) {
-                    properties.sort = TableStore.encoder._makeGroupBySort(groupBy.sort);
-                }
-                if (groupBy.fieldRange) {
-                    properties.fieldRange = TableStore.encoder._makeFieldRange(groupBy.fieldRange);
-                }
-                if (groupBy.interval) {
-                    properties.interval = TableStore.PlainBufferBuilder.serializeSearchValue(groupBy.interval, "groupBy.interval");
-                }
-                if (groupBy.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(groupBy.missing, "groupByHistogram.missing");
-                }
-                if (groupBy.offset) {
-                    properties.offset = TableStore.PlainBufferBuilder.serializeSearchValue(groupBy.offset, "groupByHistogram.offset");
-                }
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy)
-                return tsSearchProtos.GroupByHistogram.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_DATE_HISTOGRAM: {
-                const properties = {
-                    fieldName: groupBy.fieldName,
-                    minDocCount: groupBy.minDocCount,
-                };
-                if (groupBy.sort) {
-                    properties.sort = TableStore.encoder._makeGroupBySort(groupBy.sort);
-                }
-                if (groupBy.fieldRange) {
-                    properties.fieldRange = TableStore.encoder._makeFieldRange(groupBy.fieldRange);
-                }
-                if (groupBy.interval) {
-                    properties.interval = TableStore.encoder._makeDateTimeValue(groupBy.interval);
-                }
-                if (groupBy.missing) {
-                    properties.missing = TableStore.PlainBufferBuilder.serializeSearchValue(groupBy.missing, "groupByDateHistogram.missing");
-                }
-                if (groupBy.offset) {
-                    properties.offset = TableStore.encoder._makeDateTimeValue(groupBy.offset);
-                }
-                if (groupBy.timeZone) {
-                    properties.timeZone = groupBy.timeZone;
-                }
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByDateHistogram.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_GEO_GRID: {
-                const properties = {
-                    fieldName: groupBy.fieldName,
-                };
-                if (groupBy.precision) {
-                    properties.precision = groupBy.precision;
-                }
-                if (groupBy.size) {
-                    properties.size = groupBy.size;
-                }
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByGeoGrid.create(properties);
-            }
-            case TableStore.GroupByType.GROUP_BY_COMPOSITE: {
-                const properties = {};
-                if (groupBy.nextToken) {
-                    properties.nextToken = groupBy.nextToken;
-                }
-                if (groupBy.size) {
-                    properties.size = groupBy.size;
-                }
-                if (groupBy.sources) {
-                    properties.sources = TableStore.encoder._makeGroupBys(groupBy.sources);
-                }
-                TableStore.encoder._makeSubAggsAndSubGroupBys(properties, groupBy);
-                return tsSearchProtos.GroupByComposite.create(properties);
-            }
-            default:
-                throw new Error("not exist GroupByType: " + groupByType);
-        }
-    },
-    _makeSubAggsAndSubGroupBys(properties, groupBy){
-        if (groupBy.subAggs) {
-            properties.subAggs = TableStore.encoder._makeAggregations(groupBy.subAggs);
-        }
-        if (groupBy.subGroupBys) {
-            properties.subGroupBys = TableStore.encoder._makeGroupBys(groupBy.subGroupBys);
-        }
-    },
-    _makeRange(aRanges) {
-        let ranges = []
-        TableStore.util.arrayEach(aRanges, function (range) {
-            ranges.push(tsSearchProtos.Range.create(range));
-        });
-        return ranges;
-    },
-    _makeFieldRange(aFieldRange) {
-        return {
-            min: TableStore.PlainBufferBuilder.serializeSearchValue(aFieldRange.min, "FieldRange.min"),
-            max: TableStore.PlainBufferBuilder.serializeSearchValue(aFieldRange.max, "FieldRange.max"),
-        };
-    },
-    _constrctQueryParam(queryType, aQuery) {
-        switch (queryType) {
-            case TableStore.QueryType.MATCH_QUERY://1
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    text: aQuery.text,
-                    weight: aQuery.weight,
-                };
-                if (typeof aQuery.minimumShouldMatch === "number") {
-                    properties.minimumShouldMatch = aQuery.minimumShouldMatch;
-                }
-                if (aQuery.operator) {
-                    properties.operator = aQuery.operator
-                }
-
-                var matchQuery = tsSearchProtos.MatchQuery.create(properties);
-
-                return matchQuery;
-                break;
-            case TableStore.QueryType.MATCH_PHRASE_QUERY://2
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    text: aQuery.text,
-                    weight: aQuery.weight,
-                };
-                var matchPhraseQuery = tsSearchProtos.MatchPhraseQuery.create(properties);
-
-                return matchPhraseQuery;
-                break;
-            case TableStore.QueryType.TERM_QUERY://3
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    term: TableStore.PlainBufferBuilder.serializeSearchValue(aQuery.term, "term"),
-                    weight: aQuery.weight,
-                };
-                var termQuery = tsSearchProtos.TermQuery.create(properties);
-
-                return termQuery;
-                break;
-            case TableStore.QueryType.RANGE_QUERY://4
-                var properties = {
-                    fieldName: aQuery.fieldName
-                };
-                if (aQuery.rangeFrom !== undefined && aQuery.rangeFrom !== null) {
-                    properties.rangeFrom= TableStore.PlainBufferBuilder.serializeSearchValue(aQuery.rangeFrom, "rangeFrom");
-                    if (aQuery.includeLower !== undefined) {
-                        properties.includeLower = aQuery.includeLower;
-                    }
-                }
-                if (aQuery.rangeTo !== undefined && aQuery.rangeTo !== null) {
-                    properties.rangeTo= TableStore.PlainBufferBuilder.serializeSearchValue(aQuery.rangeTo, "rangeTo");
-                    if (aQuery.includeUpper !== undefined) {
-                        properties.includeUpper = aQuery.includeUpper;
-                    }
-                }
-
-                var rangeQuery = tsSearchProtos.RangeQuery.create(properties);
-
-                return rangeQuery;
-                break;
-            case TableStore.QueryType.PREFIX_QUERY://5
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    prefix: aQuery.prefix,
-                    weight: aQuery.weight,
-                };
-
-                var prefixQuery = tsSearchProtos.PrefixQuery.create(properties);
-
-                return prefixQuery;
-                break;
-            case TableStore.QueryType.BOOL_QUERY://6
-                var properties = {};
-
-                if (Object.prototype.toString.call(aQuery.mustQueries) === '[object Array]') {
-                    properties.mustQueries = [];
-                    TableStore.util.arrayEach(aQuery.mustQueries, function (query) {
-                        properties.mustQueries.push(TableStore.encoder._makeQuery(query));
-                    })
-                }
-                if (Object.prototype.toString.call(aQuery.mustNotQueries) === '[object Array]') {
-                    properties.mustNotQueries = [];
-                    TableStore.util.arrayEach(aQuery.mustNotQueries, function (query) {
-                        properties.mustNotQueries.push(TableStore.encoder._makeQuery(query));
-                    })
-                }
-                if (Object.prototype.toString.call(aQuery.filterQueries) === '[object Array]') {
-                    properties.filterQueries = [];
-                    TableStore.util.arrayEach(aQuery.filterQueries, function (query) {
-                        properties.filterQueries.push(TableStore.encoder._makeQuery(query));
-                    })
-                }
-                if (Object.prototype.toString.call(aQuery.shouldQueries) === '[object Array]') {
-                    if (typeof aQuery.minimumShouldMatch !== 'number' || aQuery.minimumShouldMatch % 1 !== 0) {
-                        throw new Error("Expect minimumShouldMatch which should be an int32 number");
-                    }
-                    properties.minimumShouldMatch = aQuery.minimumShouldMatch;
-                    properties.shouldQueries = [];
-                    TableStore.util.arrayEach(aQuery.shouldQueries, function (query) {
-                        properties.shouldQueries.push(TableStore.encoder._makeQuery(query));
-                    })
-                }
-
-                var boolQuery = tsSearchProtos.BoolQuery.create(properties);
-
-                return boolQuery;
-                break;
-            case TableStore.QueryType.CONST_SCORE_QUERY://7
-                var properties = {
-                    filter: TableStore.encoder._makeQuery(aQuery.filter)
-                };
-                var constScoreQuery = tsSearchProtos.ConstScoreQuery.create(properties);
-
-                return constScoreQuery;
-                break;
-            case TableStore.QueryType.FUNCTION_SCORE_QUERY://8
-                var properties = {
-                    query: TableStore.encoder._makeQuery(aQuery.query)
-                };
-
-                if (!aQuery.fieldValueFactor || typeof aQuery.fieldValueFactor.fieldName !== 'string') {
-                    throw new Error("Except fieldValueFactor.fieldName which should be string");
-                }
-                var fieldValueFactorProperties = {
-                    fieldName: aQuery.fieldValueFactor.fieldName
-                };
-                var fieldValueFactor = tsSearchProtos.FieldValueFactor.create(fieldValueFactorProperties);
-
-                properties.fieldValueFactor = fieldValueFactor;
-
-                var functionScoreQuery = tsSearchProtos.FunctionScoreQuery.create(properties);
-
-                return functionScoreQuery;
-                break;
-            case TableStore.QueryType.NESTED_QUERY://9
-                var properties = {
-                    path: aQuery.path,
-                    query: TableStore.encoder._makeQuery(aQuery.query),
-                    scoreMode: aQuery.scoreMode ||  TableStore.ScoreMode.SCORE_MODE_AVG,
-                    weight: aQuery.weight,
-                };
-                if (aQuery.innerHits) {
-                    properties.innerHits = TableStore.encoder._makeInnerHits(aQuery.innerHits);
-                }
-
-                var nestedQeury = tsSearchProtos.NestedQuery.create(properties);
-
-                return nestedQeury;
-                break;
-            case TableStore.QueryType.WILDCARD_QUERY://10
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    value: aQuery.value,
-                    weight: aQuery.weight,
-                };
-
-                var wildcardQuery = tsSearchProtos.WildcardQuery.create(properties);
-
-                return wildcardQuery;
-                break;
-            case TableStore.QueryType.MATCH_ALL_QUERY://11
-                var matchAllQuery = tsSearchProtos.MatchAllQuery.create();
-
-                return matchAllQuery;
-                break;
-            case TableStore.QueryType.GEO_BOUNDING_BOX_QUERY://12
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    topLeft: aQuery.topLeft,
-                    bottomRight: aQuery.bottomRight
-                };
-                var geoBoundingBoxQuery = tsSearchProtos.GeoBoundingBoxQuery.create(properties);
-
-                return geoBoundingBoxQuery;
-                break;
-            case TableStore.QueryType.GEO_DISTANCE_QUERY://13
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    centerPoint: aQuery.centerPoint,
-                    distance: aQuery.distance
-                };
-                var geoDistanceQuery = tsSearchProtos.GeoDistanceQuery.create(properties);
-
-                return geoDistanceQuery;
-                break;
-            case TableStore.QueryType.GEO_POLYGON_QUERY://14
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    points: aQuery.points
-                };
-                var geoPolygonQuery = tsSearchProtos.GeoPolygonQuery.create(properties);
-
-                return geoPolygonQuery;
-                break;
-            case TableStore.QueryType.TERMS_QUERY://15
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                    terms: TableStore.encoder._makeTerms(aQuery.terms),
-                    weight: aQuery.weight,
-                };
-                var termsQuery = tsSearchProtos.TermsQuery.create(properties);
-
-                return termsQuery;
-                break;
-            case TableStore.QueryType.EXISTS_QUERY://16
-                var properties = {
-                    fieldName: aQuery.fieldName
-                };
-                var termsQuery = tsSearchProtos.TermsQuery.create(properties);
-
-                return termsQuery;
-                break;
-            case TableStore.QueryType.KNN_VECTOR_QUERY://17
-                var properties = {
-                    fieldName: aQuery.fieldName,
-                }
-                if (aQuery.topK) {
-                    properties.topK = aQuery.topK;
-                }
-                if (aQuery.float32QueryVector) {
-                    properties.float32QueryVector = aQuery.float32QueryVector;
-                }
-                if (aQuery.filter) {
-                    properties.filter = TableStore.encoder._makeQuery(aQuery.filter);
-                }
-                if (aQuery.weight) {
-                    properties.weight = aQuery.weight;
-                }
-                var knnVectorQuery = tsSearchProtos.KnnVectorQuery.create(properties);
-
-                return knnVectorQuery;
-                break;
-            case TableStore.QueryType.FUNCTIONS_SCORE_QUERY://18
-                var properties = {};
-                if(aQuery.query){
-                    properties.query = TableStore.encoder._makeQuery(aQuery.query);
-                }
-                if(aQuery.minScore){
-                    properties.minScore = aQuery.minScore;
-                }
-                if(aQuery.maxScore){
-                    properties.maxScore = aQuery.maxScore;
-                }
-                if(aQuery.scoreMode){
-                    properties.scoreMode = aQuery.scoreMode;
-                }
-                if(aQuery.combineMode){
-                    properties.combineMode = aQuery.combineMode;
-                }
-                properties.functions = [];
-                if(aQuery.functions){
-                    TableStore.util.arrayEach(aQuery.functions, function (scoreFunction) {
-                        var scoreFunctionProperties = {
-                            weight: scoreFunction.weight || null,
-                        }
-                        if(scoreFunction.filter) {
-                            scoreFunctionProperties.filter = TableStore.encoder._makeQuery(scoreFunction.filter);
-                        }
-                        if (scoreFunction.fieldValueFactorFunction) {
-                            scoreFunctionProperties.fieldValueFactor = tsSearchProtos.FieldValueFactorFunction.create(scoreFunction.fieldValueFactorFunction);
-                        }
-                        if (scoreFunction.decayFunction) {
-                            const paramBody = TableStore.encoder._constructDecayParam(scoreFunction.decayFunction.decayParamType, scoreFunction.decayFunction.decayParam);
-                            const writer = Object.getPrototypeOf(paramBody).constructor.encode(paramBody);
-                            var decayFunctionProperties = {
-                                fieldName: scoreFunction.decayFunction.fieldName,
-                                mathFunction: scoreFunction.decayFunction.mathFunction || null,
-                                paramType: scoreFunction.decayFunction.decayParamType,
-                                param: writer.finish(),
-                                decay: scoreFunction.decayFunction.decay || null,
-                                multiValueMode: scoreFunction.decayFunction.multiValueMode || null,
-                            }
-                            scoreFunctionProperties.decay = tsSearchProtos.DecayFunction.create(decayFunctionProperties);
-                        }
-                        if (scoreFunction.randomFunction) {
-                            scoreFunctionProperties.random = tsSearchProtos.RandomScoreFunction.create(scoreFunction.randomFunction);
-                        }
-                        properties.functions.push(scoreFunctionProperties);
-                    })
-                }
-                var functionsScoreQuery = tsSearchProtos.FunctionsScoreQuery.create(properties);
-
-                return functionsScoreQuery;
-                break;
-            default:
-                throw new Error("queryTypeExpectation not exist queryType: " + queryType);
-        }
-    },
-    _constructDecayParam(type, param){
-            if (type === TableStore.DecayFuncParamType.DF_DATE_PARAM) {
-                return tsSearchProtos.DecayFuncDateParam.create(param);
-            }
-            if (type === TableStore.DecayFuncParamType.DF_GEO_PARAM) {
-                return tsSearchProtos.DecayFuncGeoParam.create(param);
-            }
-            if (type === TableStore.DecayFuncParamType.DF_NUMERIC_PARAM) {
-                return tsSearchProtos.DecayFuncNumericParam.create(param);
-            }
-            return null;
-    },
-    _makeColumnToGet(aColumnToGet) {
-        var properties = {
-            returnType: aColumnToGet.returnType
-        };
-        if (aColumnToGet.returnType === TableStore.ColumnReturnType.RETURN_SPECIFIED) {
-            properties.columnNames = aColumnToGet.returnNames;
-        }
-
-        var columnsToGet = tsSearchProtos.ColumnsToGet.create(properties);
-
-        return columnsToGet;
-    },
-    _makeRoutingValues(routingValues) {
-        var values = [];
-        TableStore.util.arrayEach(routingValues, function(primaryKey) {
-            values.push(TableStore.PlainBufferBuilder.serializePrimaryKey(primaryKey))
-        });
-
-        return values;
-    },
-    // _makeSearchAfter(aSearchAfter) {
-    //     var searchAfter = new tsSearchProtos.SearchAfter();
-    //     var values = [];
-    //
-    //     TableStore.util.arrayEach(aSearchAfter.values, function(value) {
-    //         values.push(TableStore.PlainBufferBuilder.serializeSearchValue(value, "searchAfter.value"))
-    //     });
-    //     searchAfter.values = values;
-    //
-    //     return searchAfter;
-    // },
-    _makeTerms(terms) {
-        var theTerms = [];
-        if (Object.prototype.toString.call(terms) !== '[object Array]') {
-            return theTerms;
-        }
-
-        TableStore.util.arrayEach(terms, function (term) {
-            var theTerm = TableStore.PlainBufferBuilder.serializeSearchValue(term, "term");
-            theTerms.push(theTerm);
-        });
-
-        return theTerms;
-    },
-    _makeSort(aSort) {
-        var properties = {
-            sorter: []
-        };
-
-        TableStore.util.arrayEach(aSort.sorters, function(sorter) {
-            var theSorter = TableStore.encoder._makeSorter(sorter);
-            properties.sorter.push(theSorter);
-        });
-
-        var sort = tsSearchProtos.Sort.create(properties);
-
-        return sort;
-    },
-    _makeSorter(aSorter) {
-        const properties = {};
-
-        if (aSorter.fieldSort) {
-            var fieldSortProperties = {
-                fieldName: aSorter.fieldSort.fieldName,
-                order: aSorter.fieldSort.order,
-                mode: aSorter.fieldSort.mode
-            };
-            if (aSorter.fieldSort.missingValue) {
-                fieldSortProperties.missingValue = TableStore.PlainBufferBuilder.serializeSearchValue(aSorter.fieldSort.missingValue, "missingValue");
-            } else if (aSorter.fieldSort.missing) {
-                fieldSortProperties.missingValue = TableStore.PlainBufferBuilder.serializeSearchValue(aSorter.fieldSort.missing, "missing");
-            }
-            if (aSorter.fieldSort.nestedFilter) {
-                var nestedFilterProperties = {
-                    path: aSorter.fieldSort.nestedFilter.path,
-                    filter: TableStore.encoder._makeQuery(aSorter.fieldSort.nestedFilter.filter)
-                };
-                fieldSortProperties.nestedFilter = tsSearchProtos.NestedFilter.create(nestedFilterProperties);
-            }
-            if (aSorter.fieldSort.missingField) {
-                fieldSortProperties.missingField = aSorter.fieldSort.missingField;
-            }
-            properties.fieldSort = tsSearchProtos.FieldSort.create(fieldSortProperties);
-        } else if (aSorter.geoDistanceSort) {
-            var geoDistanceSortProperties = {
-                fieldName: aSorter.geoDistanceSort.fieldName,
-                points: aSorter.geoDistanceSort.points,
-                order: aSorter.geoDistanceSort.order,
-                mode: aSorter.geoDistanceSort.mode,
-                distanceType: aSorter.geoDistanceSort.distanceType
-            };
-            if (aSorter.geoDistanceSort.nestedFilter) {
-                var nestedFilterProperties = {
-                    path: aSorter.geoDistanceSort.nestedFilter.path,
-                    filter: TableStore.encoder._makeQuery(aSorter.geoDistanceSort.nestedFilter.filter)
-                };
-
-                geoDistanceSortProperties.nestedFilter = tsSearchProtos.NestedFilter.create(nestedFilterProperties);
-            }
-
-            var geoDistanceSort = tsSearchProtos.GeoDistanceSort.create(geoDistanceSortProperties);
-
-            properties.geoDistanceSort = geoDistanceSort;
-        } else if (aSorter.scoreSort) {
-            var scoreSortProperties = {
-                order: aSorter.scoreSort.order
-            };
-            var scoreSort = tsSearchProtos.ScoreSort.create(scoreSortProperties);
-
-            properties.scoreSort = scoreSort;
-        } else if (aSorter.primaryKeySort) {
-            var primaryKeySortProperties = {
-                order: aSorter.primaryKeySort.order
-            };
-            var primaryKeySort = tsSearchProtos.PrimaryKeySort.create(primaryKeySortProperties)
-
-            properties.pkSort = primaryKeySort;
-        } else if (aSorter.docSort) {
-            var docSortProperties = {
-                order: aSorter.docSort.order
-            }
-            var docSort = tsSearchProtos.DocSort.create(docSortProperties);
-
-            properties.docSort = docSort;
-        }
-
-        return tsSearchProtos.Sorter.create(properties);
-    },
-    _makeGroupBySort: function(aSort) {
-        const properties = {
-            sorters: []
-        };
-        TableStore.util.arrayEach(aSort.sorters, function(sorter) {
-            const theSorter = TableStore.encoder._makeGroupBySorter(sorter);
-            properties.sorters.push(theSorter);
-        });
-        return tsSearchProtos.GroupBySort.create(properties);
-    },
-    _makeGroupBySorter(aSorter) {
-        const properties = {};
-        if (aSorter.groupKeySort) {
-            const groupKeySortProperties = {
-                order: aSorter.groupKeySort.order,
-            };
-            properties.groupKeySort = tsSearchProtos.GroupKeySort.create(groupKeySortProperties);
-        } else if (aSorter.rowCountSort) {
-            const rowCountSortProperties = {
-                order: aSorter.rowCountSort.order,
-            };
-            properties.rowCountSort = tsSearchProtos.RowCountSort.create(rowCountSortProperties);
-        } else if (aSorter.subAggSort) {
-            const subAggSortProperties = {
-                subAggName: aSorter.subAggSort.subAggName,
-                order: aSorter.subAggSort.order,
-            };
-            properties.subAggSort = tsSearchProtos.SubAggSort.create(subAggSortProperties);
-        }
-        return tsSearchProtos.GroupBySorter.create(properties);
-    },
-    _makeDateTimeValue(dateTimeValue) {
-        const properties = {
-            value: dateTimeValue.value,
-            unit: dateTimeValue.unit
-        };
-        return tsSearchProtos.DateTimeValue.create(properties);
-    },
-    _makeInnerHits(innerHits){
-        var properties = {
-            offset: innerHits.offset || null,
-            limit : innerHits.limit || null,
-        };
-        if (innerHits.sort) {
-            properties.sort = TableStore.encoder._makeSort(innerHits.sort);
-        }
-        if(innerHits.highlight) {
-            properties.highlight = TableStore.encoder._makeHighlight(innerHits.highlight);
-        }
-        return tsSearchProtos.InnerHits.create(properties);
-    },
-    _makeHighlight(highlight) {
-        var properties = {
-            highlightEncoder: highlight.highlightEncoder,
-            highlightParameters: highlight.highlightParameters
-        }
-        return tsSearchProtos.Highlight.create(properties);
-    },
-    encodeCreateIndex: function(params) {
-        var request = tsProtos.CreateIndexRequest.create({
-            mainTableName: params.mainTableName,
-            includeBaseData: params.includeBaseData || false,
-            indexMeta: new tsProtos.IndexMeta({
-                name: params.indexMeta.name,
-                primaryKey: params.indexMeta.primaryKey,
-                definedColumn: params.indexMeta.definedColumn,
-                indexUpdateMode: params.indexMeta.indexUpdateMode || TableStore.IndexUpdateMode.IUM_ASYNC_INDEX,//默认增量
-                indexType: params.indexMeta.indexType || TableStore.IndexType.IT_GLOBAL_INDEX,//IT_GLOBAL_INDEX
-            })
-        });
-
-        return request;
-    },
-    encodeDropIndex: function(params) {
-        var request = tsProtos.DropIndexRequest.create({
-            mainTableName: params.mainTableName,
-            indexName: params.indexName
-        });
-        return request;
-    },
-    encodeStartLocalTransaction: function (params) {
-        var request = tsProtos.StartLocalTransactionRequest.create({
-            tableName: params.tableName,
-            key: TableStore.PlainBufferBuilder.serializePrimaryKey(params.primaryKey)
-        });
-        return request;
-    },
-    encodeCommitTransaction: function (params) {
-        var request = tsProtos.CommitTransactionRequest.create({
-            transactionId: typeof params === 'string' ? params : params.transactionId
-        });
-        return request;
-    },
-    encodeAbortTransaction: function (params) {
-        var request = tsProtos.AbortTransactionRequest.create({
-            transactionId: typeof params === 'string' ? params : params.transactionId
-        });
-        return request;
-    },
-    encodeSQLQuery: function (params) {
-        if (params.version && params.version !== TableStore.SQLPayloadVersion.SQL_FLAT_BUFFERS) {
-            throw new Error("SQL payload version only support: 'TableStore.SQLPayloadVersion.SQL_FLAT_BUFFERS', " +
-                "please use fixed tablestore node sdk version '5.2.2' to use 'TableStore.SQLPayloadVersion.SQL_PLAIN_BUFFER'");
-        }
-        const properties = {
-            query: params.query,
-            version: TableStore.SQLPayloadVersion.SQL_FLAT_BUFFERS,
-        };
-        return tsProtos.SQLQueryRequest.create(properties);
-    },
-};
-
-var tsMap = {
-    'createTable': TableStore.encoder.encodeCreateTable,
-    'listTable': TableStore.encoder.encodeListTable,
-    'deleteTable': TableStore.encoder.encodeDeleteTable,
-    'updateTable': TableStore.encoder.encodeUpdateTable,
-    'describeTable': TableStore.encoder.encodeDescribeTable,
-    'getRow': TableStore.encoder.encodeGetRow,
-    'putRow': TableStore.encoder.encodePutRow,
-    'updateRow': TableStore.encoder.encodeUpdateRow,
-    'deleteRow': TableStore.encoder.encodeDeleteRow,
-    'getRange': TableStore.encoder.encodeGetRange,
-    'batchGetRow': TableStore.encoder.encodeBatchGetRow,
-    'batchWriteRow': TableStore.encoder.encodeBatchWriteRow,
-    'listSearchIndex': TableStore.encoder.encodeListSearchIndex,
-    'describeSearchIndex': TableStore.encoder.encodeDescribeSearchIndex,
-    'updateSearchIndex': TableStore.encoder.encodeUpdateSearchIndex,
-    'createSearchIndex': TableStore.encoder.encodeCreateSearchIndex,
-    'deleteSearchIndex': TableStore.encoder.encodeDeleteSearchIndex,
-    'search': TableStore.encoder.encodeSearch,
-    'computeSplits': TableStore.encoder.encodeComputeSplits,
-    'parallelScan': TableStore.encoder.encodeParallelScan,
-    'createIndex': TableStore.encoder.encodeCreateIndex,
-    'dropIndex': TableStore.encoder.encodeDropIndex,
-    'startLocalTransaction': TableStore.encoder.encodeStartLocalTransaction,
-    'commitTransaction': TableStore.encoder.encodeCommitTransaction,
-    'abortTransaction': TableStore.encoder.encodeAbortTransaction,
-    'SQLQuery': TableStore.encoder.encodeSQLQuery,
-};