Tablestore:Exists query

1. Go to the Index Management tab.

   1. Log on to the Table Store console.

   2. In the top navigation bar, select a resource group and a region.

   3. On the Overview page, click the instance name or click Instance Management in the Actions column.

   4. On the Instance Details tab, in the Data Table List tab, click the data table name or click Index Management in the Actions column.

2. On the Index Management tab, find the target Search Index and click Search in the Actions column.

3. In the Search dialog box, configure the query.

   1. By default, all columns are returned. To return specific columns, turn off Retrieve All Columns and enter the column names, separated by commas.

      Note

      By default, Table Store returns the primary key columns of the data table.

   2. Select a logical operator: And, Or, or Not.

      If you select And, the query returns data that meets all specified conditions. If you select Or, the query returns data that meets at least one of the specified conditions. If you select Not, the query returns data that does not meet the specified conditions.

   3. Select an index field and click Add.

   4. Set the query type for the index field to Exists query (ExistsQuery).

   5. By default, sorting is disabled. To sort the results by a specific field, turn on Enable Sorting, add the sort field, and configure the sort order.

   6. By default, aggregation is disabled. To perform statistical aggregation on a specific field, turn on Enable Aggregation, add the field for aggregation, and configure the aggregation settings.

4. Click OK.

   The query results are displayed on the Index Management tab.

You can use the Tablestore CLI to run the search command to query data by using search indexes. For more information, see Search index.

1. Run the search command to use the search_index search index to query data and return all indexed columns of each row that meets the query conditions.

   search -n search_index --return_all_indexed

2. Enter the query conditions as prompted:

   {
       "Offset": -1,
       "Limit": 10,
       "Collapse": null,
       "Sort": null,
       "GetTotalCount": true,
       "Token": null,
       "Query": {
           "Name": "ExistsQuery",
           "Query": {
               "FieldName": "col_keyword"
           }
       }
   }

You can use the following Tablestore SDKs to perform an exists query: Tablestore SDK for Java, Tablestore SDK for Go, Tablestore SDK for Python, Tablestore SDK for Node.js, Tablestore SDK for .NET, and Tablestore SDK for PHP. In this example, Tablestore SDK for Java is used.

The following sample code provides an example on how to query all rows in which the specified column is not empty.

public static void existQuery(SyncClient syncClient) {
    // Query whether the col_keyword field exists. The col_keyword field is not a Nested field. 
    {
        {
            // The following sample code provides an example on how to query whether a field of a non-Nested type exists. 
            SearchQuery searchQuery = new SearchQuery();
            ExistsQuery existQuery = new ExistsQuery(); // Set the query type to ExistsQuery. 
            existQuery.setFieldName("col_keyword");
            searchQuery.setQuery(existQuery);
            SearchRequest searchRequest = new SearchRequest("<TABLE_NAME>", "<SEARCH_INDEX_NAME>", searchQuery);
            SearchResponse resp = syncClient.search(searchRequest);
        }
        {
            // Construct a builder. 
            SearchResponse resp = syncClient.search(SearchRequest.newBuilder()
                    .indexName("<SEARCH_INDEX_NAME>")
                    .tableName("<TABLE_NAME>")
                    .searchQuery(
                            SearchQuery.newBuilder()
                                    .query(QueryBuilders.exists("col_keyword"))
                                    .limit(10)
                                    .build())
                    .build());
        }
    }
    // The Nested structure is [{"keyword":"a","long":123}]. 
    {
        // Query whether the col_nested parent field exists. The col_nested field is of the Nested type. 
        {
            SearchResponse resp = syncClient.search(SearchRequest.newBuilder()
                    .indexName("<SEARCH_INDEX_NAME>")
                    .tableName("<TABLE_NAME>")
                    .searchQuery(
                            SearchQuery.newBuilder()
                                    .query(QueryBuilders.nested()
                                            .scoreMode(ScoreMode.None)
                                            .path("col_nested")
                                            .query(QueryBuilders.exists("col_nested")))
                                    .limit(10)
                                    .getTotalCount(false)
                                    .build())
                    .build());
        }
        // Query whether the col_nested.keyword field exists. The col_nested.keyword field is of the Nested type. 
        {
            SearchResponse resp = syncClient.search(SearchRequest.newBuilder()
                    .indexName("<SEARCH_INDEX_NAME>")
                    .tableName("<TABLE_NAME>")
                    .searchQuery(
                            SearchQuery.newBuilder()
                                    .query(QueryBuilders.nested()
                                            .scoreMode(ScoreMode.None)
                                            .path("col_nested")
                                            .query(QueryBuilders.exists("col_nested.keyword")))
                                    .limit(10)
                                    .getTotalCount(false)
                                    .build())
                    .build());
        }
    }
}