中文亚洲成a人片在线观看,五月天综合网缴情五月中文,看黄a大片日本真人视频直播

使用統計聚合功能可以實現求最小值、求最大值、求和、求平均值、統計行數、去重統計行數、按字段值分組、按范圍分組、按地理位置分組、按過濾條件分組等操作；同時多個統計聚合功能可以組合使用，滿足復雜的查詢需求。

流程

統計聚合的完整執行流程如下圖所示。

統計聚合是在服務端的“查詢”結束后執行，服務端會將“查詢”階段命中的所有文檔根據查詢請求進行統計聚合，因此統計聚合請求相比沒有統計聚合的請求會復雜。

背景信息

統計聚合的詳細功能請參見下表。

功能	說明
最小值	返回一個字段中的最小值，類似于SQL中的min。
最大值	返回一個字段中的最大值，類似于SQL中的max。
和	返回數值字段的總數，類似于SQL中的sum。
平均值	返回數值字段的平均值，類似于SQL中的avg。
統計行數	返回指定字段值的數量或者多元索引數據總行數，類似于SQL中的count。
去重統計行數	返回指定字段不同值的數量，類似于SQL中的count（distinct）。
百分位統計	百分位統計常用來統計一組數據的百分位分布情況，例如在日常系統運維中統計每次請求訪問的耗時情況時，需要關注系統請求耗時的P25、P50、P90、P99值等分布情況。
字段值分組	根據一個字段的值對查詢結果進行分組，相同的字段值放到同一分組內，返回每個分組的值和該值對應的個數。說明當分組較大時，按字段值分組可能會存在誤差。
范圍分組	根據一個字段的范圍對查詢結果進行分組，字段值在某范圍內放到同一分組內，返回每個范圍中相應的item個數。
地理位置分組	根據距離某一個中心點的范圍對查詢結果進行分組，距離差值在某范圍內放到同一分組內，返回每個范圍中相應的item個數。
過濾條件分組	按照過濾條件對查詢結果進行分組，獲取每個過濾條件匹配到的數量，返回結果的順序和添加過濾條件的順序一致。
直方圖統計	按照指定數據間隔對查詢結果進行分組，字段值在相同范圍內放到同一分組內，返回每個分組的值和該值對應的個數。
獲取統計聚合分組中的行	對查詢結果進行分組后，獲取每個分組內的一些行數據，可實現和MySQL中ANY_VALUE(field)類似的功能。

前提條件

已初始化Client。具體操作，請參見初始化。
已創建數據表并寫入數據。
已在數據表上創建多元索引。具體操作，請參見創建多元索引。

最小值

返回一個字段中的最小值，類似于SQL中的min。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double和Date類型。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "min_test",
                type: TableStore.AggregationType.AGG_MIN,
                body: {
                    fieldName: "col_long",
                    missing: 333,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

最大值

返回一個字段中的最大值，類似于SQL中的max。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double和Date類型。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "max_test",
                type: TableStore.AggregationType.AGG_MAX,
                body: {
                    fieldName: "col_long",
                    missing: 333,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

和

返回數值字段的總數，類似于SQL中的sum。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long和Double類型。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "sum_test",
                type: TableStore.AggregationType.AGG_SUM,
                body: {
                        fieldName: "col_long",
                        missing: 444,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

平均值

返回數值字段的平均值，類似于SQL中的avg。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double和Date類型。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "avg_test",
                type: TableStore.AggregationType.AGG_AVG,
                body: {
                        fieldName: "col_long",
                        missing: 111,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

統計行數

返回指定字段值的數量或者多元索引數據總行數，類似于SQL中的count。

說明

通過如下方式可以統計多元索引數據總行數或者某個query匹配的行數。

使用統計聚合的count功能，在請求中設置count(*)。
使用query功能的匹配行數，在query中設置setGetTotalCount(true)；如果需要統計多元索引數據總行數，則使用MatchAllQuery。

如果需要獲取多元索引數據某列出現的次數，則使用count（列名），可應用于稀疏列的場景。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double、Boolean、Keyword、Geo_point和Date類型。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "count_test",
                type: TableStore.AggregationType.AGG_COUNT,
                body: {
                        fieldName: "col_long",
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

去重統計行數

返回指定字段不同值的數量，類似于SQL中的count（distinct）。

說明

去重統計行數的計算結果是個近似值。

當去重統計行數小于1萬時，計算結果接近精確值。
當去重統計行數達到1億時，計算結果的誤差為2%左右。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double、Boolean、Keyword、Geo_point和Date類型。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "AGG_DISTINCT_COUNT_test",
                type: TableStore.AggregationType.AGG_DISTINCT_COUNT,
                body: {
                        fieldName: "col_long",
                        missing: 666,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

百分位統計

百分位統計常用來統計一組數據的百分位分布情況，例如在日常系統運維中統計每次請求訪問的耗時情況時，需要關注系統請求耗時的P25、P50、P90、P99值等分布情況。

說明

百分位統計為非精確統計，對不同百分位數值的計算精確度不同，較為極端的百分位數值更加準確，例如1%或99%的百分位數值會比50%的百分位數值準確。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double和Date類型。
percentiles	百分位分布例如50、90、99，可根據需要設置一個或者多個百分位。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    aggs: {
        aggs: [
            {
                name: "AGG_PERCENTILES_test",
                type: TableStore.AggregationType.AGG_PERCENTILES,
                body: {
                        fieldName: "col_long",
                        percentiles: [20, 50, 90, 100],
                        missing: 888,
                },
            },
        ],
    },
};
let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

字段值分組

根據一個字段的值對查詢結果進行分組，相同的字段值放到同一分組內，返回每個分組的值和該值對應的個數。

說明

當分組較大時，按字段值分組可能會存在誤差。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long、Double、Boolean、Keyword和Date類型。
sort	分組中的item排序規則，默認按照分組中item的數量降序排序，多個排序則按照添加的順序進行排列。支持的參數如下。按照值的字典序升序排列按照值的字典序降序排列按照行數升序排列按照行數降序排列按照子統計聚合結果中值升序排列按照子統計聚合結果中值降序排列
size	返回的分組數量，默認值為10。最大值為2000。當分組數量超過2000時，只會返回前2000個分組。
subAggs和subGroupBys	子統計聚合，子統計聚合會根據分組內容再進行一次統計聚合分析。場景統計每個類別的商品數量，且統計每個類別價格的最大值和最小值。方法最外層的統計聚合是根據類別進行分組，再添加兩個子統計聚合求價格的最大值和最小值。結果示例水果：5個（其中價格的最大值為15，最小值為3）洗漱用品：10個（其中價格的最大值為98，最小值為1）電子設備：3個（其中價格的最大值為8699，最小值為2300）其它：15個（其中價格的最大值為1000，最小值為80）

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            {
                name: "group_by_GROUP_BY_FIELD",
                type: TableStore.GroupByType.GROUP_BY_FIELD,
                body: {
                    fieldName: "city",
                    size: 111,
                    sort: {
                        sorters: [
                            {
                                groupKeySort: {
                                    order: TableStore.SortOrder.SORT_ORDER_ASC,
                                },
                            },
                            {
                                rowCountSort: {
                                    order: TableStore.SortOrder.SORT_ORDER_DESC,
                                },
                            },
                        ],
                    },
                    subGroupBys: { // 嵌套子GroupBy。
                        groupBys: [
                            {
                                name: "group_by_GROUP_BY_RANGE",
                                type: TableStore.GroupByType.GROUP_BY_RANGE,
                                body: {
                                    fieldName: "age",
                                    ranges: [
                                        {
                                            from: 4,
                                            to: 5,
                                        },
                                        {
                                            from: 6,
                                            to: 7,
                                        },
                                    ],
                                    subAggs: { // 嵌套子Agg。
                                        aggs: [
                                            {
                                                name: "AGG_COUNT_test",
                                                type: TableStore.AggregationType.AGG_COUNT,
                                                body: {
                                                    fieldName: "*",
                                                    missing: 8,
                                                },
                                            },
                                        ],
                                    },
                                },
                            },
                        ],
                    },
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

范圍分組

根據一個字段的范圍對查詢結果進行分組，字段值在某范圍內放到同一分組內，返回每個范圍中相應的item個數。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long和Double類型。
ranges[from, to)	分組的范圍。起始值from可以使用最小值Double.MIN_VALUE，結束值to可以使用最大值Double.MAX_VALUE。
subAggs和subGroupBys	子統計聚合，子統計聚合會根據分組內容再進行一次統計聚合分析。例如按銷量分組后再按省份分組，即可獲得某個銷量范圍內哪個省比重比較大，實現方法是GroupByRange下添加一個GroupByField。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            { 
                name: "group_by_GROUP_BY_RANGE",
                type: TableStore.GroupByType.GROUP_BY_RANGE,
                body: {
                    fieldName: "col_long",
                    ranges: [
                        {
                            from: 1,
                            to: 5,
                        },
                        {
                            from: 3,
                            to: 20,
                        },
                    ],
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

地理位置分組

根據距離某一個中心點的范圍對查詢結果進行分組，距離差值在某范圍內放到同一分組內，返回每個范圍中相應的item個數。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Geo_point類型。
origin(lat, lon)	起始中心點的經緯度。 lat是起始中心點緯度，lon是起始中心點經度。
ranges[from, to)	分組的范圍，單位為米。起始值from可以使用最小值Double.MIN_VALUE，結束值to可以使用最大值Double.MAX_VALUE。
subAggs和subGroupBys	子統計聚合，子統計聚合會根據分組內容再進行一次統計聚合分析。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            { 
                name: "group_by_GROUP_BY_GEO_DISTANCE",
                type: TableStore.GroupByType.GROUP_BY_GEO_DISTANCE,
                body: {
                    fieldName: "col_geo",
                    origin: {
                        lat: 50,
                        lon: 60,
                    },
                    ranges: [
                        {
                            from: 1,
                            to: 2,
                        },
                        {
                            from: 3,
                        },
                    ],
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

過濾條件分組

按照過濾條件對查詢結果進行分組，獲取每個過濾條件匹配到的數量，返回結果的順序和添加過濾條件的順序一致。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
filters	過濾條件，返回結果的順序和添加過濾條件的順序一致。
subAggs和subGroupBys	子統計聚合，子統計聚合會根據分組內容再進行一次統計聚合分析。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
            { 
                name: "group_by_GROUP_BY_FILTER",
                type: TableStore.GroupByType.GROUP_BY_FILTER,
                body: {
                    filters: [
                        {
                            queryType: TableStore.QueryType.MATCH_ALL_QUERY,
                        },
                        {
                            queryType: TableStore.QueryType.WILDCARD_QUERY,
                            query: {
                                fieldName: "col_keyword",
                                value: "1*"
                            },
                        },
                    ],
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

直方圖統計

按照指定數據間隔對查詢結果進行分組，字段值在相同范圍內放到同一分組內，返回每個分組的值和該值對應的個數。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
fieldName	用于統計聚合的字段，僅支持Long和Double類型。
interval	統計間隔。
fieldRange[min,max]	統計范圍，與interval參數配合使用限制分組的數量。`(fieldRange.max-fieldRange.min)/interval`的值不能超過2000。
minDocCount	最小行數。當分組中的行數小于最小行數時，不會返回此分組的統計結果。
missing	當某行數據中的字段為空時，字段值的默認值。如果未設置missing值，則在統計聚合時會忽略該行。如果設置了missing值，則使用missing值作為字段值的默認值參與統計聚合。

示例

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: false,
    groupBys: {
        groupBys: [
             { 
                name: "group_by_GROUP_BY_HISTOGRAM",
                type: TableStore.GroupByType.GROUP_BY_HISTOGRAM,
                body: {
                    fieldName: "col_long",
                    interval: Long.fromNumber(3),
                    missing: Long.fromNumber(123),
                    minDocCount: 5,
                    fieldRange: {
                        min: Long.fromNumber(1),
                        max: Long.fromNumber(999),
                    },
                    sort: {
                        sorters: [
                            {
                                groupKeySort: {
                                    order: TableStore.SortOrder.SORT_ORDER_ASC,
                                },
                            },
                            {
                                rowCountSort: {
                                    order: TableStore.SortOrder.SORT_ORDER_ASC,
                                },
                            },
                        ],
                    },
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: {返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

獲取統計聚合分組中的行

對查詢結果進行分組后，獲取每個分組內的一些行數據，可實現和MySQL中ANY_VALUE(field)類似的功能。

說明

獲取統計聚合分組中的行時，如果多元索引中包含嵌套類型、地理位置類型或者數組類型的字段，則返回結果中只會包含主鍵信息，請手動反查數據表獲取所需字段。

參數

參數	說明
name	自定義的統計聚合名稱，用于區分不同的統計聚合，可根據此名稱獲取本次統計聚合結果。
limit	每個分組內最多返回的數據行數，默認返回1行數據。
sort	分組內數據的排序方式。
columnsToGet	指定返回的字段，僅支持多元索引中的字段，且不支持數組、Date、Geopoint和Nested類型的字段。該參數復用SearchRequest中的columnsToGet參數，在SearchRequest中指定columnsToGet即可。

示例

某學校有一個活動報名表，活動報名表中包含學生姓名、班級、班主任、班長等信息，如果希望按班級進行分組，以查看每個班級的報名情況，同時獲取班級的屬性信息。等效的SQL語句是select className, ANY_VALUE(teacher), ANY_VALUE(monitor), COUNT(*) as number from table GROUP BY className。

let searchQuery = {
    offset: 0,
    limit: 0,
    query: {
        queryType: TableStore.QueryType.MATCH_ALL_QUERY,
    },
    getTotalCount: true,
    groupBys: {
        groupBys: [
            {
                name: "group_by_name_xxx",
                type: TableStore.GroupByType.GROUP_BY_FIELD,
                body: {
                    fieldName: "className",
                    size: 200,
                    subAggs: {
                        aggs: [
                            {
                                name: "top_row_name_xxx",
                                type: TableStore.AggregationType.AGG_TOP_ROWS,
                                body: {
                                    limit: 1,
                                    sort: {
                                        sorters: [
                                            {
                                                fieldSort: {
                                                    fieldName: "teacher",
                                                    order: TableStore.SortOrder.SORT_ORDER_DESC,
                                                },
                                            },
                                        ],
                                    },
                                },
                            },
                        ],
                    },
                },
            },
        ],
    },
};

let params = {
    tableName: tableName,
    indexName: indexName,
    searchQuery: searchQuery,
    columnToGet: { //返回列設置，可設置為RETURN_SPECIFIED（自定義返回列）、RETURN_ALL（返回所有列）、RETURN_ALL_FROM_INDEX（返回多元索引中的所有列）、RETURN_NONE（不返回）。
        returnType: TableStore.ColumnReturnType.RETURN_ALL_FROM_INDEX
    },
    timeoutMs: 30000,
}
client.search(params, function (err, data) {
    if (err) {
        console.log('search error:', err.toString());
    } else {
        console.log('search success:', data);
    }
});

日本熟妇hd丰满老熟妇,中文字幕一区二区三区在线不卡 ,亚洲成片在线观看,免费女同在线一区二区

流程