Tablestore:Sorting and Paging

ScoreSort

Sorts results by their relevance score, calculated with the BM25 algorithm. This method is suitable for scenarios that require relevance ranking, such as full-text search.

searchQuery := search.NewSearchQuery()
searchQuery.SetSort(&search.Sort{
    []search.Sorter{
        &search.ScoreSort{
            Order: search.SortOrder_DESC.Enum(), // Sort in descending order of score.
        },
    },
})

PrimaryKeySort

Sorts results by primary key, which is useful for ordering items by their unique identifiers.

searchQuery := search.NewSearchQuery()
searchQuery.SetSort(&search.Sort{
    []search.Sorter{
        &search.PrimaryKeySort{
            Order: search.SortOrder_ASC.Enum(),
        },
    },
})

FieldSort

Sorts results by the value of a specific field. This method is useful in e-commerce or social media applications where you might want to sort items by attributes like sales volume or page views.

// Sort the results based on the Col_Long field in descending order.
searchQuery.SetSort(&search.Sort{
    []search.Sorter{
        &search.FieldSort{
            FieldName: "Col_Long",
            Order:     search.SortOrder_DESC.Enum(),
        },
    },
})

searchQuery.SetSort(&search.Sort{
    []search.Sorter{
        &search.FieldSort{
            FieldName: "col1",
            Order:     search.SortOrder_ASC.Enum(),
        },
        &search.FieldSort{
            FieldName: "col2",
            Order:     search.SortOrder_DESC.Enum(),
        },
    },
})

GeoDistanceSort

Sorts results by distance from a geographic point. This is useful for applications in mapping and logistics, such as sorting nearby restaurants by their distance from your current location.

searchQuery.SetSort(&search.Sort{
    []search.Sorter{
        &search.GeoDistanceSort{
            FieldName: "location",   // Specify the name of the GeoPoint field.
            Points:    []string{"40,-70"}, // Specify the center point.
        },
    },
})

Paging with Limit and Offset

You can use Limit and Offset for paging. The sum of Limit and Offset must be less than or equal to 100,000, and the maximum value for Limit is 100.

If you do not specify these parameters, Limit defaults to 10 and Offset defaults to 0.

searchQuery := search.NewSearchQuery()
searchQuery.SetLimit(10)
searchQuery.SetOffset(10) 

Paging with a token

For deep paging, use a token, as this method has no depth limitations.

If a query returns more results than a single response can hold, the server provides a NextToken. Use this token in a subsequent request to retrieve the next page.

By default, token-based paging only allows you to move forward. However, since a token remains valid for the duration of a query session, you can cache previous tokens to implement backward paging.

When using a token, the sorting method from the previous request is automatically applied. Therefore, you cannot specify the Sort or Offset parameters in a token-based request. You can only read data sequentially, one page at a time.

/**
 * Read data page by page by using a token.
 * If a SearchResponse contains a NextToken, you can use it to initiate the next query.
 * A nil NextToken indicates that all matching data has been retrieved.
 */
func QueryRowsWithToken(client *tablestore.TableStoreClient, tableName string, indexName string) {
    querys := []search.Query{
        &search.MatchAllQuery{},
        &search.TermQuery{
            FieldName: "Col_Keyword",
            Term:      "tablestore",
        },
    }
    for _, query := range querys {
        fmt.Printf("Test query: %#v\n", query)
        searchRequest := &tablestore.SearchRequest{}
        searchRequest.SetTableName(tableName)
        searchRequest.SetIndexName(indexName)
        searchQuery := search.NewSearchQuery()
        searchQuery.SetQuery(query)
        searchQuery.SetLimit(10)
        searchQuery.SetGetTotalCount(true)
        searchRequest.SetSearchQuery(searchQuery)
        searchResponse, err := client.Search(searchRequest)
        if err != nil {
            fmt.Printf("%#v", err)
            return
        }
        rows := searchResponse.Rows
        requestCount := 1
        for searchResponse.NextToken != nil {           
            {  
	              // To persist or send the NextToken, Base64-encode it.
	              // The token is a byte slice, not a string; direct conversion causes data loss.
	              tokenAsString := base64.StdEncoding.EncodeToString(searchResponse.NextToken)
	              // Decode the string back into a byte slice.
	              tokenAsByte, err := base64.StdEncoding.DecodeString(tokenAsString)
	              if err != nil {
		                fmt.Printf("len:%d, %#v",len(tokenAsByte), err)
		                return
	              }
            }
            searchQuery.SetToken(searchResponse.NextToken)
            searchResponse, err = client.Search(searchRequest)
            if err != nil {
                fmt.Printf("%#v", err)
                return
            }
            requestCount++
            for _, r := range searchResponse.Rows {
                rows = append(rows, r)
            }
        }
        fmt.Println("IsAllSuccess: ", searchResponse.IsAllSuccess)
        fmt.Println("TotalCount: ", searchResponse.TotalCount)
        fmt.Println("RowsSize: ", len(rows))
        fmt.Println("RequestCount: ", requestCount)
    }
}