Pourquoi la clause must_not fonctionne-t-elle si on la place avant une requête nested mais pas si on la place à l'intérieur de la requête nested?

Bonjour,

J'écris une application pour rechercher des logs dans l'elastic de mon organisation et l'utilisateur peut rechercher des requêtes nested sous cette forme :

pathName:{ field1: "value1" AND field2: "value2" OR field3: "value3" }

J'aimerais que l'utilisateur puisse demander que certains champs dans la requête nested ne soient pas matchés.

Je peux le faire si je veux que toute la requête nested soit non matché, cela donne la requête suivante:

NOT pathName:{ field1: "value1" }

Et à partir de cette chaîne de caractère, je peux générer la requête suivante qui fonctionne bien :

(La clause must_not[] est placée avant la clause nested parceque c'est l'ensemble de la clause nested que je ne veux pas matcher)

"query": {
    "bool": {
    	"filter": [
            {
                "bool": {
                    "must_not": [
                        {"nested": {
                            "path": 'pathName',
                            "query": {
                                {"bool": {
                                    "should": [
                                        {
                                            "match": {
                                                "pathName.field1": "value1"
                                            }
                                        }
                                    ],
                                    "minimum_should_match": 1
                                }}
                            }
                        }}
                    ]
                }
            }
    		{"range": 
                {
    			    "@timestamp": {
    			    	"format": 'strict_date_optional_time',
    			    	"gte": "Sat Jul 09 2022 02:00:00 GMT+0200 (heure d’été d’Europe centrale)",
    			    	"lte": "Mon Aug 08 2022 02:00:00 GMT+0200 (heure d’été d’Europe centrale)"
                    }
                }
            }
        ]
    }
}

La requête ci-dessus fonctionne bien et renvoie le résultat attendu.

J'aimerais maintenant que mon utilisateur puisse demander à l'intérieur d'une requête nested de matcher certains champs et de ne pas matcher d'autres champs comme ceci: like this: pathName:{ NOT field1: "value1" AND field2: "value2" OR NOT field3: "value3" } .

Par exemple, pour la requête suivante :

pathName:{ NOT field1: "value1" } (En pratique, il y aura évidemment plus d'un élément dans la requête nested , mais pour simplifier, je n'ai mis qu'un seul élément dans la requête nested )

Je veux obtenir tous les objets qui ne match pas pathName.field1:value1.

A partir de la chaîne de caractère précédente, j'arrive à générer la requête suivante :

(La clause must_not[] est alors placée à l'intérieur de la clause nested car ce n'est qu'une partie des éléments de la clause nested que nous ne voulons pas matcher)

"query": {
    "bool": {
    	"filter": [
            {"nested": {
                "path": 'pathName',
                "query": {
                    {"bool": {
                        "must_not": [
                            {
                                "bool": {
                                    "should": [
                                        {
                                            "match": {
                                                "pathName.field1": "value1"
                                            }
                                        }
                                    ],
                                    "minimum_should_match": 1
                                }
                            }
                        ]
                    }}
                }
            }},
    		{"range": 
                {
    			    "@timestamp": {
    			    	"format": 'strict_date_optional_time',
    			    	"gte": "Sat Jul 09 2022 02:00:00 GMT+0200 (heure d’été d’Europe centrale)",
    			    	"lte": "Mon Aug 08 2022 02:00:00 GMT+0200 (heure d’été d’Europe centrale)"
                    }
                }
            }
        ]
    }
}

Mais cette requête renvoie les résultats sans prendre en compte les clauses must_not[] contenues dans la requête nested.

N'est-il pas possible de spécifier une clause must_not[] à l'intérieur d'une requête nested ou est-ce que je génère mal la requête envoyée à elastic ?

Merci d'avance si vous prenez le temps de m'aider.

Je suis surpris par la première requête. Elle est inexacte au sens qu'il manque une virgule.
Mais ce qui me surprend c'est le range sur le @timestamp...

Pour y voir plus clair, il faudrait que tu fournisses un exemple complet qu'on pourrait simplement exécuter dans la console Kibana. Incluant la création de l'index avec son mapping, et l'ajout de données et la requête.

This topic was automatically closed 28 days after the last reply. New replies are no longer allowed.