Tablestore:Sorting and paging

Scenarios

Index presorting

By default, data in a search index is sorted based on the presorting settings that are specified by the IndexSort parameter. When you use a search index to query data, the presorting settings that are specified by the IndexSort parameter determine the default order in which the matched data is returned.

When you create a search index, you can specify presorting settings by configuring the IndexSort parameter. If you do not specify presorting settings, data in the search index is sorted by primary key value.

Specify a sorting method when you query data

Sorting can be enabled only for fields for which the enableSortAndAgg parameter is set to true.

You can specify a sorting method for each query. Search index-based queries support the following sorting methods. You can also specify multiple sorting methods based on different priorities.

ScoreSort

sort: {
    sorters: [
        {
            scoreSort: {
                order: TableStore.SortOrder.SORT_ORDER_ASC
            }
        }
    ]
}

PrimaryKeySort

You can use PrimaryKeySort to sort query results based on the primary key value.

sort: {
    sorters: [
        {
            primaryKeySort: {
                order: TableStore.SortOrder.SORT_ORDER_DESC // Sort the query results in descending order. 
                //order: TableStore.SortOrder.SORT_ORDER_ASC // Sort the query results in ascending order. 
            }
        }
    ]
}

FieldSort

• Sort the query results based on the values of a single column

  You can use FieldSort to sort query results based on the values of a specific column.

  sort: {
      sorters: [
          {
              fieldSort: {
                  fieldName: "Col_Keyword",
                  order: TableStore.SortOrder.SORT_ORDER_DESC
              }
          }
      ]
  }

• Sort the query results based on the values of multiple columns

  You can also sort query results based on the values of two columns in specific orders to determine the order in which the matched data is returned.

  sort: {
      sorters: [
          {
              fieldSort: {
                  fieldName: "Col_Keyword",
                  order: TableStore.SortOrder.SORT_ORDER_DESC
              }
          },
          {
              fieldSort: {
                  fieldName: "Col_Long",
                  order: TableStore.SortOrder.SORT_ORDER_DESC
              }
          }
      ]
  }

GeoDistanceSort

You can use GeoDistanceSort to sort query results by geographical location.

sort: {
    sorters: [
        {
            geoDistanceSort: {
                fieldName: "Col_Geo_Point",
                points: ["0,0"],// Specify the coordinate pair of the central point. 
                order: TableStore.SortOrder.SORT_ORDER_ASC // The query results are returned in ascending order of the distances between geographical locations and the central point. 
            }
        }
    ]
}

For the detailed sample code, see Search.

Specify a paging method

You can configure the limit and offset parameters or use tokens to page the rows in the response.

Configure the limit and offset parameters

If you do not specify values for the limit and offset parameters, the default values are used. The default value of the limit parameter is 10. The default value of the offset parameter is 0.

/**
 * Set offset to 90 and limit to 10 to scan data from line 90 to line 99. 
 */
client.search({
    tableName: TABLE_NAME,
    indexName: INDEX_NAME,
    searchQuery: {
        offset: 90,
        limit: 10, 
        query: {
            queryType: TableStore.QueryType.MATCH_ALL_QUERY
        },
        getTotalCount: true // Specify whether to return the total number of rows that meet the query conditions. Default value: false. 
    },
    columnToGet: { // Specify the columns that you want to return. You can set the columnToGet parameter to RETURN_SPECIFIED to return the specified columns, RETURN_ALL to return all columns, or RETURN_NONE to return only the primary key columns. 
        returnType: TableStore.ColumnReturnType.RETURN_ALL
    }
}, function (err, data) {
    if (err) {
        console.log('error:', err);
        return;
    }
    console.log('success:', JSON.stringify(data, null, 2));
});

Use a token

We recommend that you use a token for deep paging because this method has no limits on the paging depth.

If Tablestore cannot read all data that meets the query conditions, Tablestore returns nextToken. You can use nextToken to continue reading the subsequent data.

By default, you can only page backward when you use a token. However, you can cache and use the previous token to page forward because a token is valid during the query.

When you use a token, the sorting method is the same as the method that is used in the previous request. Tablestore sorts data based on the IndexSort parameter by default or based on the method that you specified. You cannot specify the sorting method when you use a token. You cannot configure the offset parameter when you use a token. Data is returned page by page in sequence. This results in a slow query.

/**
 * Use tokens to page rows in the response in synchronous and asynchronous modes. 
 */
var params = {
    tableName: TABLE_NAME,
    indexName: INDEX_NAME,
    searchQuery: {
        offset: 0,
        limit: 10,
        token: null,// Obtain nextToken as the start point to scan the next page. The data type is byte stream. 
        query: {
            queryType: TableStore.QueryType.MATCH_ALL_QUERY
        },
        getTotalCount: true
    },
    columnToGet: {
        returnType: TableStore.ColumnReturnType.RETURN_SPECIFIED,
        returnNames: ["pic_tag", "pic_description", "time_stemp", "pos"]
    }
};

/**
 * Use tokens to page rows in the response in synchronous mode. 
 */
(async () => { // Page rows in synchronous mode. 
  try {
    var data = await client.search(params);
    console.log('success:', JSON.stringify(data, null, 2));

    while (data.nextToken && data.nextToken.length) { // If nextToken is returned, Tablestore continues to read the subsequent data. 

      // Persist the tokens. 
      //1) Convert a token (nextToken) as binary data in the Buffer object to a Base64-encoded string and persist the string. 
      //2) You can convert the persisted Base64 string to binary data by creating a Buffer object to use nextToken as a parameter. 
      var nextToken = data.nextToken.toString("base64");
      var token =  Buffer.from(nextToken, "base64");

      params.searchQuery.token = token;// Update the token value to return more results. 
      data = await client.search(params);
      console.log('token success:', JSON.stringify(data, null, 2));
    }
  } catch (error) {
      console.log(error);
  }
})()

/**
 * Use tokens to page rows in the response in asynchronous mode. 
 */
client.search(params, function (err, data) { 
    console.log('success:', JSON.stringify(data, null, 2));

    if (data.nextToken && data.nextToken.length) {

        // Persist the tokens. 
        //1) Convert a token (nextToken) as binary data in the Buffer object to a Base64-encoded string and persist the string. 
        //2) You can convert the persisted Base64 string to binary data by creating a Buffer object to use nextToken as a parameter. 
        var nextToken = data.nextToken.toString("base64");
        var token =  Buffer.from(nextToken, "base64");

        params.searchQuery.token = token;// Update the token value to return more results. 
        client.search(params, function (err, data) {
            console.log('token success:', JSON.stringify(data, null, 2));
        });
    }
});