Uso de la consulta bool en TairSearch para ejecutar consultas compuestas - Tair (Redis® OSS-Compatible)

TairSearch es una estructura de datos interna para búsqueda de texto completo que utiliza sintaxis compatible con Elasticsearch. Este tema explica el funcionamiento de la consulta bool y muestra patrones comunes de consultas compuestas mediante las cláusulas must, must_not y should.

Funcionamiento

Una consulta bool combina varias condiciones mediante tipos de cláusula, cada uno con un comportamiento lógico distinto:

Cláusula	Equivalente lógico	Comportamiento
`must`	AND	Todas las condiciones deben coincidir. Los documentos que también coinciden con las cláusulas `should` reciben una puntuación de relevancia más alta, lo cual afecta su posición en los resultados.
`must_not`	NOT	Se excluyen de los resultados los documentos que coinciden con cualquiera de estas condiciones.
`should`	OR	Las condiciones son opcionales. Cuando `should` es el único tipo de cláusula, `minimum_should_match` toma el valor predeterminado `1` (como mínimo una debe coincidir). Al combinarse con `must` o `must_not`, `minimum_should_match` toma el valor predeterminado `0` (las cláusulas should se convierten en potenciadores opcionales de puntuación).

La evaluación de cláusulas sigue este orden de prioridad: must_not > must > should.

Las consultas bool, así como cualquier otro tipo de consulta, pueden anidarse dentro de otra consulta bool para expresar lógica compleja, como (A AND B) OR C.

TairSearch_bool

Para consultar la referencia completa de comandos de TairSearch, consulte Search.

Ejecución de consultas compuestas

Los siguientes ejemplos muestran cuatro patrones comunes de consulta bool. Todos utilizan el mismo índice y los mismos datos de documento.

Paso 1: Cree un índice

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

Paso 2: Agregue un documento

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

Paso 3: Consulte con lógica bool

Ejemplo 1: A = a AND B = b

Utilice must con varias condiciones term para exigir que todos los campos coincidan.

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

Ejemplo 2: A = a OR B = b

Utilice should para obtener los documentos donde al menos una condición sea verdadera.

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

Ejemplo 3: A = a AND B != b

Combine must y must_not para incluir los documentos que coinciden con un campo y excluir los que coinciden con otro.

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

Ejemplo 4: (A = a AND B = b) OR C = c

Anide una consulta bool dentro de una cláusula should para expresar lógica compuesta. La cláusula bool interna maneja la condición AND; la cláusula should externa agrega la rama OR.

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