Utiliser la requête bool dans TairSearch pour implémenter des requêtes composites - Tair (Redis® OSS-Compatible)

TairSearch est une structure de données propriétaire dédiée à la recherche en texte intégral, compatible avec la syntaxe Elasticsearch. Cette rubrique explique le fonctionnement de la requête bool et présente des modèles courants de requêtes composites utilisant les clauses must, must_not et should.

Fonctionnement

Une requête bool combine plusieurs conditions via différents types de clauses, chacun ayant un comportement logique distinct :

Clause	Équivalent logique	Comportement
`must`	ET	Toutes les conditions doivent correspondre. Les documents correspondant également aux clauses `should` obtiennent un score de pertinence plus élevé, ce qui influence leur classement dans les résultats.
`must_not`	NON	Les documents correspondant à l'une de ces conditions sont exclus des résultats.
`should`	OU	Les conditions sont facultatives. Lorsque `should` est le seul type de clause présent, `minimum_should_match` vaut par défaut `1` (au moins une condition doit correspondre). Lorsqu'elle est combinée avec `must` ou `must_not`, `minimum_should_match` vaut par défaut `0` (les clauses should servent alors uniquement à augmenter le score).

L'évaluation des clauses suit l'ordre de priorité suivant : must_not > must > should.

Les requêtes bool, ainsi que tout autre type de requête, peuvent être imbriquées au sein d'une requête bool pour exprimer une logique complexe telle que (A AND B) OR C.

TairSearch_bool

Pour consulter la référence complète des commandes TairSearch, reportez-vous à la section Search.

Exécuter des requêtes composites

Les exemples suivants illustrent quatre modèles courants de requêtes bool. Tous utilisent le même index et les mêmes données de document.

Étape 1 : Créer un index

TFT.CREATEINDEX key '{
    "mappings": {
        "properties": {
            "A": { "type": "keyword" },
            "B": { "type": "keyword" },
            "C": { "type": "keyword" }
        }
    }
}'

Étape 2 : Ajouter un document

TFT.ADDDOC key '{
    "A": "a",
    "B": "b",
    "C": "c"
}'

Étape 3 : Interroger avec une logique bool

Exemple 1 : A = a ET B = b

Utilisez la clause must avec plusieurs conditions term pour exiger la correspondance de tous les champs.

TFT.SEARCH key '{
    "query": {
        "bool": {
            "must": [
                { "term": { "A": "a" } },
                { "term": { "B": "b" } }
            ]
        }
    }
}'

Exemple 2 : A = a OU B = b

Utilisez la clause should pour sélectionner les documents vérifiant au moins une condition.

TFT.SEARCH key '{
    "query": {
        "bool": {
            "should": [
                { "term": { "A": "a" } },
                { "term": { "B": "b" } }
            ]
        }
    }
}'

Exemple 3 : A = a ET B != b

Combinez les clauses must et must_not pour inclure les documents correspondant à un champ tout en excluant ceux correspondant à un autre.

TFT.SEARCH key '{
    "query": {
        "bool": {
            "must": [
                { "term": { "A": "a" } }
            ],
            "must_not": [
                { "term": { "B": "b" } }
            ]
        }
    }
}'

Exemple 4 : (A = a ET B = b) OU C = c

Imbriquez une requête bool dans une clause should pour exprimer une logique composite. La requête bool interne gère la condition ET ; la clause should externe ajoute la branche OU.

TFT.SEARCH key '{
    "query": {
        "bool": {
            "should": [
                {
                    "bool": {
                        "must": [
                            { "term": { "A": "a" } },
                            { "term": { "B": "b" } }
                        ]
                    }
                },
                { "term": { "C": "c" } }
            ]
        }
    }
}'