Combining Queries with Bool
Explore the `bool` query to combine multiple queries using `must`, `should`, `must_not`, and `filter` clauses for complex logic.
Combining Queries with Bool is a free Elasticsearch & Full Text Search Systems lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Elasticsearch & Full Text Search Systems learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
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
statusof "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!
Frequently asked questions
Is the “Combining Queries with Bool” lesson free?
Yes — the full text of “Combining Queries with Bool” is free to read here on the web, and the Elasticsearch & Full Text Search Systems course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Elasticsearch & Full Text Search Systems course, upgrade to CoddyKit PRO.
What will I learn in “Combining Queries with Bool”?
Explore the `bool` query to combine multiple queries using `must`, `should`, `must_not`, and `filter` clauses for complex logic. You practise Elasticsearch & Full Text Search Systems with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Elasticsearch & Full Text Search Systems?
No prior experience is required. Elasticsearch & Full Text Search Systems on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Combining Queries with Bool” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Elasticsearch & Full Text Search Systems lesson?
Yes. Every Elasticsearch & Full Text Search Systems lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Introduction to Query DSL
- Term and Match Queries
- Combining Queries with Bool
- Filtering, Ranges, and Query Context