Tous les produits
Search
Centre de documentation

Tablestore:Requête booléenne

Dernière mise à jour :Oct 09, 2026

Une requête booléenne (BoolQuery) contient une ou plusieurs sous-requêtes et les utilise pour déterminer si une ligne de données répond aux conditions de recherche spécifiées. Chaque sous-requête peut être de n'importe quel type, y compris une autre BoolQuery.

Opérations API

Exécutez une requête booléenne à l'aide de l'opération API Search ou ParallelScan. Le type de requête est BoolQuery.

Paramètres

Paramètre

Description

mustQueries

Liste de requêtes. Une ligne de données doit correspondre à toutes les sous-requêtes pour être considérée comme une correspondance. Cela équivaut à l'opérateur AND.

mustNotQueries

Liste de requêtes. Une ligne de données ne doit correspondre à aucune des sous-requêtes pour être considérée comme une correspondance. Cela équivaut à l'opérateur NOT.

filterQueries

Liste de requêtes. Une ligne de données doit correspondre à tous les filtres pour être considérée comme une correspondance. Un filtre est similaire à une requête, mais il ne calcule pas de score de pertinence basé sur le nombre de filtres correspondant.

shouldQueries

Liste de requêtes. Ces requêtes peuvent correspondre ou non. Cela équivaut à l'opérateur OR.

Une ligne de données doit correspondre au moins au nombre minimal de sous-requêtes shouldQueries pour être considérée comme une correspondance.

Plus le nombre de sous-requêtes shouldQueries correspondant est élevé, plus le score de pertinence global est important.

minimumShouldMatch

Nombre minimal de sous-requêtes shouldQueries devant correspondre. La valeur par défaut est 1 si seules les shouldQueries existent au même niveau. La valeur par défaut est 0 si d'autres requêtes, telles que mustQueries, mustNotQueries et filterQueries, existent au même niveau.

getTotalCount

Indique s'il faut renvoyer le nombre total de lignes correspondantes. La valeur par défaut est false.

Le renvoi du nombre total de lignes correspondantes peut affecter les performances de la requête.

tableName

Nom de la table de données.

indexName

Nom de l'index de recherche.

columnsToGet

Indique s'il faut renvoyer toutes les colonnes. Cela inclut les paramètres returnAll et columns.

La valeur par défaut de returnAll est false, ce qui signifie que toutes les colonnes ne sont pas renvoyées. Dans ce cas, vous pouvez utiliser columns pour spécifier les colonnes à renvoyer. Si vous ne spécifiez pas les colonnes à renvoyer, seules les colonnes de clé primaire sont renvoyées.

Si vous définissez returnAll sur true, toutes les colonnes sont renvoyées.

Utilisation

Exécutez une requête booléenne à l'aide de la console, de l'interface de ligne de commande ou d'un SDK. Avant de commencer, effectuez les étapes suivantes.

Utiliser la console

  1. Accédez à l'onglet Index Management.

    1. Connectez-vous à la console Table Store.

    2. Dans la barre de navigation supérieure, sélectionnez un groupe de ressources et une région.

    3. Sur la page Overview, cliquez sur le nom de l'instance ou sur Instance Management dans la colonne Actions.

    4. Sous l'onglet Instance Details, dans l'onglet Data Table List, cliquez sur le nom de la table de données ou sur Index Management dans la colonne Actions.

  2. Sous l'onglet Index Management, localisez l'index de recherche cible et cliquez sur Search dans la colonne Actions.

  3. Interrogez les données dans la boîte de dialogue Query Data.

    1. Par défaut, toutes les colonnes sont renvoyées. Pour renvoyer des colonnes spécifiques, désactivez l'option Retrieve All Columns et saisissez les noms des colonnes, séparés par des virgules.

      Remarque

      Par défaut, Table Store renvoie les colonnes de clé primaire de la table de données.

    2. Sélectionnez un opérateur logique : And, Or ou Not.

      Si vous sélectionnez And, la requête renvoie les données qui remplissent toutes les conditions spécifiées. Si vous sélectionnez Or, la requête renvoie les données qui remplissent au moins l'une des conditions spécifiées. Si vous sélectionnez Not, la requête renvoie les données qui ne remplissent pas les conditions spécifiées.

    3. Sélectionnez un champ d'index, cliquez sur Add, puis définissez le type de requête pour le champ d'index et saisissez une valeur.

      Si nécessaire, répétez cette étape pour ajouter des configurations de requête pour plusieurs champs d'index.

    4. Par défaut, le tri est désactivé. Pour trier les résultats selon un champ spécifique, activez l'option Enable Sorting, ajoutez le champ de tri et configurez l'ordre de tri.

    5. Par défaut, l'agrégation est désactivée. Pour effectuer une agrégation statistique sur un champ spécifique, activez l'option Enable Aggregation, ajoutez le champ d'agrégation et configurez les paramètres d'agrégation.

  4. Cliquez sur OK.

    Les résultats de la requête s'affichent sous l'onglet Index Management.

Utiliser l'interface de ligne de commande

Exécutez la commande search dans l'interface de ligne de commande pour interroger les données d'un index de recherche. Pour plus d'informations, consultez la rubrique Index de recherche.

  1. Exécutez la commande de recherche pour interroger les données de la table à l'aide de l'index de recherche search_index. Cette commande renvoie toutes les colonnes indexées.

    search -n search_index --return_all_indexed
  2. Saisissez les conditions de requête comme indiqué. Voici un exemple :

    {
        "Offset": -1,
        "Limit": 10,
        "Collapse": null,
        "Sort": null,
        "GetTotalCount": true,
        "Token": null,
        "Query": {
            "Name": "BoolQuery",
            "Query": {
                "MinimumShouldMatch": null,
                "MustQueries": null,
                "MustNotQueries": null,
                "FilterQueries": null,
                "ShouldQueries": [{
                    "Name": "RangeQuery",
                    "Query": {
                        "FieldName": "gid",
                        "From": null,
                        "To": 10,
                        "IncludeLower": false,
                        "IncludeUpper": false
                    }
                }, {
                    "Name": "TermQuery",
                    "Query": {
                        "FieldName": "gid",
                        "Term": 77
                    }
                }]
            }
        },
        "Aggregations": [{
            "Name": "avg",
            "Aggregation": {
                "AggName": "agg1",
                "Field": "gid",
                "MissingValue": null
            }
        }]
    }

Utiliser un SDK

Exécutez une requête booléenne à l'aide du SDK Java, du SDK Go, du SDK Python, du SDK Node.js, du SDK .NET ou du SDK PHP. Cette rubrique utilise le SDK Java comme exemple.

Les exemples suivants montrent comment exécuter des requêtes booléennes.

Interroger les lignes qui répondent à toutes les conditions des sous-requêtes

Lorsque vous interrogez des lignes qui répondent à toutes les conditions des sous-requêtes, vous pouvez décider de calculer ou non les scores de pertinence pour les lignes en fonction de vos besoins métier.

Calculer les scores de pertinence pour les lignes

L'exemple de code suivant montre comment exécuter une requête booléenne pour interroger les lignes qui répondent à toutes les conditions des sous-requêtes et calculer les scores de pertinence pour ces lignes.

/**
 * Perform a Boolean query to query the rows that meet all subquery conditions.
 * @param client
 */
public static void andQuery(SyncClient client){
    /**
     * Condition 1: Perform a range query to query the rows in which the value of the Col_Long column is greater than 3.
     */
    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.setFieldName("Col_Long");
    rangeQuery.greaterThan(ColumnValue.fromLong(3));

    /**
     * Condition 2: Perform a match query to query the rows in which the value of the Col_Keyword column is hangzhou.
     */
    MatchQuery matchQuery = new MatchQuery();
    matchQuery.setFieldName("Col_Keyword");
    matchQuery.setText("hangzhou");

    SearchQuery searchQuery = new SearchQuery();
    {
        /**
         * Construct a Boolean query whose query results meet both Condition 1 and Condition 2.
         */
        BoolQuery boolQuery = new BoolQuery();
        boolQuery.setMustQueries(Arrays.asList(rangeQuery, matchQuery));
        searchQuery.setQuery(boolQuery);
        //searchQuery.setGetTotalCount(true);// Set the GetTotalCount parameter to true to return the total number of rows that meet the query conditions.

        SearchRequest searchRequest = new SearchRequest("<TABLE_NAME>", "<SEARCH_INDEX_NAME>", searchQuery);
        // You can configure the columnsToGet parameter to specify the columns to return or specify that all columns are returned. If you do not configure this parameter, only the primary key columns are returned.
        //SearchRequest.ColumnsToGet columnsToGet = new SearchRequest.ColumnsToGet();
        //columnsToGet.setReturnAll(true); // Set the ReturnAll parameter to true to return all columns.
        //columnsToGet.setColumns(Arrays.asList("ColName1","ColName2")); // Specify the columns that you want to return.
        //searchRequest.setColumnsToGet(columnsToGet);

        SearchResponse resp = client.search(searchRequest);
        //System.out.println("TotalCount: " + resp.getTotalCount()); // Specify that the total number of rows that meet the query conditions instead of the number of returned rows is displayed.
        System.out.println("Row: " + resp.getRows());
    }
}

Ne pas calculer les scores de pertinence pour les lignes

L'exemple de code suivant montre comment exécuter une requête booléenne pour interroger les lignes qui répondent à toutes les conditions des sous-requêtes sans calculer les scores de pertinence pour ces lignes.

/**
     * Perform a Boolean query to query the rows that meet all subquery conditions without calculating the relevance scores for the rows.
     * @param client
     */
    public static void filtersQuery(SyncClient client){
        /**
         * Condition 1: Perform a range query to query the rows in which the value of the Col_Long column is greater than 3.
         */
        RangeQuery rangeQuery = new RangeQuery();
        rangeQuery.setFieldName("Col_Long");
        rangeQuery.greaterThan(ColumnValue.fromLong(3));

        /**
         * Condition 2: Perform a match query to query the rows in which the value of the Col_Keyword column is hangzhou.
         */
        MatchQuery matchQuery = new MatchQuery();
        matchQuery.setFieldName("Col_Keyword");
        matchQuery.setText("hangzhou");

        SearchQuery searchQuery = new SearchQuery();
        {
            /**
             * Construct a Boolean query whose query results meet both Condition 1 and Condition 2.
             */
            BoolQuery boolQuery = new BoolQuery();
            boolQuery.setFilterQueries(Arrays.asList(rangeQuery, matchQuery));
            searchQuery.setQuery(boolQuery);
            //searchQuery.setGetTotalCount(true);// Set the GetTotalCount parameter to true to return the total number of rows that meet the query conditions.

            SearchRequest searchRequest = new SearchRequest("sampleTable", "sampleSearchIndex", searchQuery);
            // You can configure the columnsToGet parameter to specify the columns to return or specify that all columns are returned. If you do not configure this parameter, only the primary key columns are returned.
            //SearchRequest.ColumnsToGet columnsToGet = new SearchRequest.ColumnsToGet();
            //columnsToGet.setReturnAll(true); // Set the ReturnAll parameter to true to return all columns.
            //columnsToGet.setColumns(Arrays.asList("ColName1","ColName2")); // Specify the columns that you want to return.
            //searchRequest.setColumnsToGet(columnsToGet);

            SearchResponse resp = client.search(searchRequest);
            //System.out.println("TotalCount: " + resp.getTotalCount()); // Specify that the total number of rows that meet the query conditions instead of the number of returned rows is displayed.
            System.out.println("Row: " + resp.getRows());
        }
    }

Interroger les lignes qui répondent à au moins l'une des conditions des sous-requêtes

L'exemple de code suivant montre comment exécuter une requête booléenne pour interroger les lignes qui répondent à au moins l'une des conditions de sous-requête spécifiées :

/**
 * Perform a Boolean query to query the rows that meet at least one of the specified subquery conditions.
 * @param client
 */
public static void orQuery(SyncClient client) {

    /**
     * Condition 1: Perform a range query to query the rows in which the value of the Col_Long column is greater than 3.
     */
    RangeQuery rangeQuery = new RangeQuery();
    rangeQuery.setFieldName("Col_Long");
    rangeQuery.greaterThan(ColumnValue.fromLong(3));

    /**
     * Condition 2: Perform a match query to query the rows in which the value of the Col_Keyword column is hangzhou.
     */
    MatchQuery matchQuery = new MatchQuery();
    matchQuery.setFieldName("Col_Keyword");
    matchQuery.setText("hangzhou");

    SearchQuery searchQuery = new SearchQuery();
    {
    /**
     * Construct a Boolean query whose query results meet at least one of Condition 1 and Condition 2.
     */
    BoolQuery boolQuery = new BoolQuery();
    boolQuery.setShouldQueries(Arrays.asList(rangeQuery, matchQuery));
    boolQuery.setMinimumShouldMatch(1); // Specify that the results meet at least one of the subquery conditions.
    searchQuery.setQuery(boolQuery);
    //searchQuery.setGetTotalCount(true);// Set the GetTotalCount parameter to true to return the total number of rows that meet the query conditions.

    SearchRequest searchRequest = new SearchRequest("<TABLE_NAME>", "<SEARCH_INDEX_NAME>", searchQuery);
    // You can configure the columnsToGet parameter to specify the columns to return or specify that all columns are returned. If you do not configure this parameter, only the primary key columns are returned.
    //SearchRequest.ColumnsToGet columnsToGet = new SearchRequest.ColumnsToGet();
    //columnsToGet.setReturnAll(true); // Set the ReturnAll parameter to true to return all columns.
    //columnsToGet.setColumns(Arrays.asList("ColName1","ColName2")); // Specify the columns that you want to return.
    //searchRequest.setColumnsToGet(columnsToGet);

    SearchResponse resp = client.search(searchRequest);
    //System.out.println("TotalCount: " + resp.getTotalCount()); // Specify that the total number of rows that meet the query conditions instead of the number of returned rows is displayed.
    System.out.println("Row: " + resp.getRows());
    }
}

Interroger les lignes qui ne répondent à aucune condition des sous-requêtes

L'exemple de code suivant montre comment exécuter une requête booléenne pour interroger les lignes qui ne répondent à aucune condition des sous-requêtes :

/**
 * Perform a Boolean query to query the rows that do not meet any subquery conditions.
 * @param client
 */
public static void notQuery(SyncClient client) {

    /**
     * Condition 1: Perform a match query to query the rows in which the value of the Col_Keyword column is hangzhou.
     */
    MatchQuery matchQuery = new MatchQuery();
    matchQuery.setFieldName("Col_Keyword");
    matchQuery.setText("hangzhou");

    SearchQuery searchQuery = new SearchQuery();
    {
        /**
         * Construct a Boolean query whose query results do not meet Condition 1.
         */
        BoolQuery boolQuery = new BoolQuery();
        boolQuery.setMustNotQueries(Arrays.asList(matchQuery));
        searchQuery.setQuery(boolQuery);
        //searchQuery.setGetTotalCount(true);// Set the GetTotalCount parameter to true to return the total number of rows that meet the query conditions.

        SearchRequest searchRequest = new SearchRequest("<TABLE_NAME>", "<SEARCH_INDEX_NAME>", searchQuery);
        // You can configure the columnsToGet parameter to specify the columns to return or specify that all columns are returned. If you do not configure this parameter, only the primary key columns are returned.
        //SearchRequest.ColumnsToGet columnsToGet = new SearchRequest.ColumnsToGet();
        //columnsToGet.setReturnAll(true); // Set the ReturnAll parameter to true to return all columns.
        //columnsToGet.setColumns(Arrays.asList("ColName1","ColName2")); // Specify the columns that you want to return.
        //searchRequest.setColumnsToGet(columnsToGet);

        SearchResponse resp = client.search(searchRequest);
        //System.out.println("TotalCount: " + resp.getTotalCount()); // Specify that the total number of rows that meet the query conditions instead of the number of returned rows is displayed.
        System.out.println("Row: " + resp.getRows());
    }
}

Interroger les lignes qui répondent à une combinaison de conditions de sous-requêtes

L'exemple de code suivant montre comment exécuter une requête booléenne pour interroger les lignes qui répondent à une combinaison de conditions de sous-requêtes, soit (col2<4 ou col3<5) ou (col2 = 4 et (col3 = 5 ou col3 =6)). Dans la combinaison de conditions de sous-requêtes ci-dessus, les sous-requêtes booléennes sont connectées par l'opérateur AND ou OR.

/**
 * (col2<4 or col3<5) or (col2 = 4 and (col3 = 5 or col3 =6))
 * The Boolean subqueries are connected by the AND or OR operator.
 * @param client
*/
private static void boolQuery2(SyncClient client){
        // Condition 1: The value of the col2 column is less than 4.
        RangeQuery rangeQuery1 = new RangeQuery();
        rangeQuery1.setFieldName("col2");
        rangeQuery1.lessThan(ColumnValue.fromLong(4));

        // Condition 2: The value of the col3 column is less than 5.
        RangeQuery rangeQuery2 = new RangeQuery();
        rangeQuery2.setFieldName("col3");
        rangeQuery2.lessThan(ColumnValue.fromLong(5));

        // Condition 3: The value of the col2 column is equal to 4.
        TermQuery termQuery = new TermQuery();
        termQuery.setFieldName("col2");
        termQuery.setTerm(ColumnValue.fromLong(4));

        // Condition 4: The value of the col3 column is equal to 5 or the value of the col3 column is equal to 6.
        TermsQuery termsQuery = new TermsQuery();
        termsQuery.setFieldName("col3");
        termsQuery.addTerm(ColumnValue.fromLong(5));
        termsQuery.addTerm(ColumnValue.fromLong(6));

        SearchQuery searchQuery = new SearchQuery();

        List<Query> queryList1 = new ArrayList<>();
        queryList1.add(rangeQuery1);
        queryList1.add(rangeQuery2);

        // Composite condition 1: The value of the col2 column is less than 4 or the value of the col3 column is less than 5.
        BoolQuery boolQuery1 = new BoolQuery();
        boolQuery1.setShouldQueries(queryList1);

        // Composite condition 2: The value of the col2 column is equal to 4 and the value of the col3 column is equal to 5 or 6.
        List<Query> queryList2 = new ArrayList<>();
        queryList2.add(termQuery);
        queryList2.add(termsQuery);

        BoolQuery boolQuery2 = new BoolQuery();
        boolQuery2.setMustQueries(queryList2);

        // Composite conditions: The value of the col2 column is less than 4 or the value of the col3 column is less than 5, or the value of the col2 column is equal to 4 and the value of the col3 column is equal to 5 or 6.

        List<Query> queryList3 = new ArrayList<>();
        queryList3.add(boolQuery1);
        queryList3.add(boolQuery2);

        BoolQuery boolQuery = new BoolQuery();
        boolQuery.setShouldQueries(queryList3);

        searchQuery.setQuery(boolQuery);
        //searchQuery.setGetTotalCount(true);// Set the GetTotalCount parameter to true to return the total number of rows that meet the query conditions.

        SearchRequest searchRequest = new SearchRequest("<TABLE_NAME>", "<SEARCH_INDEX_NAME>", searchQuery);
        // You can configure the columnsToGet parameter to specify the columns to return or specify that all columns are returned. If you do not configure this parameter, only the primary key columns are returned.
        //SearchRequest.ColumnsToGet columnsToGet = new SearchRequest.ColumnsToGet();
        //columnsToGet.setReturnAll(true); // Set the ReturnAll parameter to true to return all columns.
        //columnsToGet.setColumns(Arrays.asList("ColName1","ColName2")); // Specify the columns that you want to return.
        //searchRequest.setColumnsToGet(columnsToGet);

        SearchResponse response = client.search(searchRequest);
        //System.out.println("TotalCount: " + resp.getTotalCount()); // Specify that the total number of rows that meet the query conditions instead of the number of returned rows is displayed.
        System.out.println(response.getRows());

    }

Facturation

L'interrogation des données à l'aide d'un Search Index consomme du débit de lecture. Pour plus d'informations, consultez la rubrique Mesure et facturation de Search Index.

FAQ

Références