Elasticsearch & Full Text Search Systems · Aula

Combinando consultas com Bool

Explore a consulta `bool` para combinar várias consultas usando as cláusulas `must`, `should`, `must_not` e `filter` em lógicas complexas.

Aula 3 de 412 etapas

Combinando consultas com Bool é uma aula grátis de Elasticsearch & Full Text Search Systems no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Elasticsearch & Full Text Search Systems, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Elasticsearch & Full Text Search Systems inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Combine Search Logic

Welcome to combining queries! Up until now, we've looked at single search conditions. But real-world searches often need multiple criteria.

Elasticsearch's bool query is your go-to for building complex search logic. It lets you combine several queries using AND, OR, and NOT conditions.

Anatomy of a Bool Query

A bool query acts like a container for other queries. It has four main clauses:

  • must: All queries inside must match (AND).
  • should: At least one query inside should match (OR).
  • must_not: Queries inside must NOT match (NOT).
  • filter: Queries inside must match, but don't affect relevancy score.

We'll explore each one!

`must`: All Conditions Must Match

The must clause is like an "AND" operator. All queries listed within must must be true for a document to be considered a match.

Documents that satisfy all must clauses contribute positively to the relevancy score.

Example: `must` Clause

This query finds products that are both "laptop" AND "gaming".

{
  "query": {
    "bool": {
      "must": [
        { "match": { "category": "laptop" } },
        { "match": { "tags": "gaming" } }
      ]
    }
  }
}

`should`: At Least One Condition

The should clause is like an "OR" operator. If a document matches any of the queries listed in should, it's considered a potential match.

The more should queries a document matches, the higher its relevancy score usually is.

By default, if there are no must clauses, at least one should clause must match for a document to be returned.

Example: `should` Clause

This query finds products that are either "laptop" OR "tablet".

{
  "query": {
    "bool": {
      "should": [
        { "match": { "category": "laptop" } },
        { "match": { "category": "tablet" } }
      ]
    }
  }
}

`must_not`: Exclude Documents

The must_not clause is like a "NOT" operator. Documents matching any query inside must_not will be excluded from the results.

Queries in must_not do not contribute to the relevancy score.

Example: `must_not` Clause

This query finds all products EXCEPT those in the "refurbished" category.

{
  "query": {
    "bool": {
      "must_not": [
        { "match": { "category": "refurbished" } }
      ]
    }
  }
}

`filter`: Fast, Non-Scoring AND

The filter clause is similar to must in that all queries within it must match. However, there's a key difference:

  • No Scoring: Filter queries don't affect the relevancy score of documents.
  • Caching: Filter queries are often cached, making them very fast for frequently used criteria.

Use filter for "yes/no" conditions where you just want to include or exclude documents without influencing their rank.

Advanced: Multiple Clauses

You can combine all these clauses within a single bool query to build powerful, precise searches. This example finds:

  • Products with "laptop" in the name (must)
  • THAT are either "gaming" OR "ultrabook" (should)
  • BUT are NOT "refurbished" (must_not)
  • AND have a status of "available" (filter)
{
  "query": {
    "bool": {
      "must": { "match": { "name": "laptop" } },
      "should": [
        { "match": { "tags": "gaming" } },
        { "match": { "tags": "ultrabook" } }
      ],
      "must_not": { "term": { "condition": "refurbished" } },
      "filter": { "term": { "status.keyword": "available" } }
    }
  }
}

Complex Query Logic

Consider a bool query designed to find articles:

  • About "Elasticsearch" (must)
  • Published in "2023" OR "2024" (should)
  • But NOT written by "John Doe" (must_not)

Which of the following statements is TRUE regarding this query's behavior?

Recap: Bool Query Power

Great job! You've learned how to combine simple queries into powerful, complex search logic using Elasticsearch's bool query.

  • must: All conditions must be met (AND).
  • should: At least one condition should be met (OR).
  • must_not: Documents must NOT match these conditions (NOT).
  • filter: Conditions must be met, but don't affect relevancy (fast & cached).

Understanding bool queries is crucial for building precise and effective search applications!

Grátis para começar

Aprenda Elasticsearch & Full Text Search Systems com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
12
Aulas
48

Perguntas Frequentes

A aula “Combinando consultas com Bool” é grátis?

Sim — o texto completo de “Combinando consultas com Bool” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Elasticsearch & Full Text Search Systems, atualize para CoddyKit PRO. O curso de Elasticsearch & Full Text Search Systems inclui 4 aulas no total.

O que vou aprender em “Combinando consultas com Bool”?

Explore a consulta `bool` para combinar várias consultas usando as cláusulas `must`, `should`, `must_not` e `filter` em lógicas complexas. Você pratica Elasticsearch & Full Text Search Systems com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Elasticsearch & Full Text Search Systems?

Nenhuma experiência prévia é necessária. Elasticsearch & Full Text Search Systems no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Combinando consultas com Bool”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Elasticsearch & Full Text Search Systems?

Sim. Cada aula de Elasticsearch & Full Text Search Systems inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Introdução à DSL de consultas
  2. Consultas por termo e correspondência
  3. Combinando consultas com Bool
  4. Filtragem, intervalos e contexto de consulta
← Voltar para Elasticsearch & Full Text Search Systems