【ES常用查询操作】

进击的程序汪

于 2024-08-30 16:23:11 发布

阅读量1.8k

点赞数 28

文章标签： elasticsearch 大数据搜索引擎

本文链接：https://blog.csdn.net/weixin_46356409/article/details/141721001

版权

在 Elasticsearch (ES) 中，多条件检索可以通过组合多个查询条件来实现。Elasticsearch 提供了多种查询类型和组合方式，常见的有 bool 查询、must、should、must_not 和 filter 等。以下是一些常见的多条件检索示例。

1. 使用 `bool` 查询

bool 查询允许你组合多个查询条件，并指定它们之间的逻辑关系。

示例：必须匹配 `field1` 和 `field2`，并且可以选择性匹配 `field3`

{
  "query": {
    "bool": {
      "must": [
        { "match": { "field1": "value1" } },
        { "match": { "field2": "value2" } }
      ],
      "should": [
        { "match": { "field3": "value3" } }
      ],
      "minimum_should_match": 1
    }
  }
}

在这个示例中，文档必须匹配 field1 和 field2，并且至少匹配 field3 中的一个条件。

2. 使用 `filter` 查询

filter 查询用于过滤文档，不计算相关性评分，通常用于结构化数据查询。

示例：必须匹配 `field1` 和 `field2`，并且过滤 `field4`

{
  "query": {
    "bool": {
      "must": [
        { "match": { "field1": "value1" } },
        { "match": { "field2": "value2" } }
      ],
      "filter": [
        { "term": { "field4": "value4" } }
      ]
    }
  }
}

在这个示例中，文档必须匹配 field1 和 field2，并且 field4 必须等于 value4。

3. 使用 `must_not` 查询

must_not 查询用于排除匹配特定条件的文档。

示例：必须匹配 `field1`，但不能匹配 `field2`

{
  "query": {
    "bool": {
      "must": [
        { "match": { "field1": "value1" } }
      ],
      "must_not": [
        { "match": { "field2": "value2" } }
      ]
    }
  }
}

在这个示例中，文档必须匹配 field1，但不能匹配 field2。

4. 组合查询示例

示例：复杂组合查询

{
  "query": {
    "bool": {
      "must": [
        { "match": { "field1": "value1" } },
        { "range": { "field2": { "gte": 10, "lte": 20 } } }
      ],
      "should": [
        { "match": { "field3": "value3" } },
        { "term": { "field4": "value4" } }
      ],
      "must_not": [
        { "term": { "field5": "value5" } }
      ],
      "filter": [
        { "term": { "field6": "value6" } }
      ],
      "minimum_should_match": 1
    }
  }
}

在这个示例中：

文档必须匹配 field1 和 field2 的范围条件。
文档应该匹配 field3 或 field4 中的一个条件。
文档不能匹配 field5。
文档必须匹配 field6。

5. 使用 `multi_match` 查询

multi_match 查询允许你在多个字段中搜索相同的关键词。

示例：在 `field1` 和 `field2` 中搜索 `value`

{
  "query": {
    "multi_match": {
      "query": "value",
      "fields": ["field1", "field2"]
    }
  }
}

在这个示例中，Elasticsearch 将在 field1 和 field2 中搜索 value。

6. 使用 `nested` 查询

如果你的文档包含嵌套对象，可以使用 nested 查询。

示例：嵌套查询

假设你的文档结构如下：

{
  "name": "John",
  "address": {
    "city": "New York",
    "zipcode": "10001"
  }
}

你可以使用 nested 查询来检索嵌套对象中的字段。

示例：嵌套查询

{
  "query": {
    "nested": {
      "path": "address",
      "query": {
        "bool": {
          "must": [
            { "match": { "address.city": "New York" } },
            { "match": { "address.zipcode": "10001" } }
          ]
        }
      }
    }
  }
}

在这个示例中，查询将检索 address 对象中的 city 和 zipcode 字段。

7. 使用 `terms` 查询

terms 查询允许你匹配多个值中的任意一个。

示例：匹配 `field1` 中的多个值

{
  "query": {
    "terms": {
      "field1": ["value1", "value2", "value3"]
    }
  }
}

在这个示例中，查询将匹配 field1 中的任意一个值：value1、value2 或 value3。

8. 使用 `range` 查询

range 查询允许你匹配数值、日期或字符串范围。

示例：匹配 `field1` 的范围

{
  "query": {
    "range": {
      "field1": {
        "gte": 10,
        "lte": 20
      }
    }
  }
}

在这个示例中，查询将匹配 field1 的值在 10 到 20 之间的文档。

9. 使用 `exists` 查询

exists 查询用于匹配包含特定字段的文档。

示例：匹配包含 `field1` 的文档

{
  "query": {
    "exists": {
      "field": "field1"
    }
  }
}

在这个示例中，查询将匹配所有包含 field1 字段的文档。

10. 使用 `wildcard` 查询

wildcard 查询允许你使用通配符进行模式匹配。

示例：匹配 `field1` 中的模式

{
  "query": {
    "wildcard": {
      "field1": "val*"
    }
  }
}

在这个示例中，查询将匹配 field1 中以 val 开头的所有值。

11. 使用 `prefix` 查询

prefix 查询用于匹配以特定前缀开头的字段值。

示例：匹配 `field1` 中的前缀

{
  "query": {
    "prefix": {
      "field1": "val"
    }
  }
}

在这个示例中，查询将匹配 field1 中以 val 开头的所有值。

12. 使用 `fuzzy` 查询

fuzzy 查询用于模糊匹配，允许一定程度的拼写错误。

示例：模糊匹配 `field1`

{
  "query": {
    "fuzzy": {
      "field1": "value"
    }
  }
}

在这个示例中，查询将模糊匹配 field1 中接近 value 的所有值。

13. 使用 `regexp` 查询

regexp 查询允许你使用正则表达式进行模式匹配。

示例：正则表达式匹配 `field1`

{
  "query": {
    "regexp": {
      "field1": "val.*"
    }
  }
}

在这个示例中，查询将匹配 field1 中符合正则表达式 val.* 的所有值。

14. 使用 `script` 查询

script 查询允许你使用脚本进行复杂的条件匹配。

示例：使用脚本查询

{
  "query": {
    "script": {
      "script": {
        "source": "doc['field1'].value > params.value",
        "params": {
          "value": 10
        }
      }
    }
  }
}

在这个示例中，查询将匹配 field1 的值大于 10 的文档。

15. 使用 `match_phrase` 查询

match_phrase 查询用于匹配包含特定短语的文档。

示例：匹配 `field1` 中的短语

{
  "query": {
    "match_phrase": {
      "field1": "quick brown fox"
    }
  }
}

在这个示例中，查询将匹配 field1 中包含短语 “quick brown fox” 的文档。

16. 使用 `match_phrase_prefix` 查询

match_phrase_prefix 查询用于匹配以特定短语前缀开头的文档。

示例：匹配 `field1` 中的短语前缀

{
  "query": {
    "match_phrase_prefix": {
      "field1": "quick brown"
    }
  }
}

在这个示例中，查询将匹配 field1 中以 “quick brown” 开头的短语。

17. 使用 `geo_distance` 查询

geo_distance 查询用于匹配在特定地理距离内的文档。

示例：匹配在特定地理距离内的文档

{
  "query": {
    "geo_distance": {
      "distance": "200km",
      "location": {
        "lat": 40.7128,
        "lon": -74.0060
      }
    }
  }
}

在这个示例中，查询将匹配在距离 (40.7128, -74.0060) 200 公里范围内的文档。

18. 使用 `geo_bounding_box` 查询

geo_bounding_box 查询用于匹配在特定地理边界框内的文档。

示例：匹配在特定地理边界框内的文档

{
  "query": {
    "geo_bounding_box": {
      "location": {
        "top_left": {
          "lat": 40.73,
          "lon": -74.1
        },
        "bottom_right": {
          "lat": 40.01,
          "lon": -71.12
        }
      }
    }
  }
}

在这个示例中，查询将匹配在指定地理边界框内的文档。

19. 使用 `geo_polygon` 查询

geo_polygon 查询用于匹配在特定地理多边形内的文档。

示例：匹配在特定地理多边形内的文档

{
  "query": {
    "geo_polygon": {
      "location": {
        "points": [
          { "lat": 40.73, "lon": -74.1 },
          { "lat": 40.01, "lon": -71.12 },
          { "lat": 40.73, "lon": -71.12 }
        ]
      }
    }
  }
}

在这个示例中，查询将匹配在指定地理多边形内的文档。

20. 使用 `more_like_this` 查询

more_like_this 查询用于查找与给定文档相似的文档。

示例：查找与给定文档相似的文档

{
  "query": {
    "more_like_this": {
      "fields": ["field1", "field2"],
      "like": "text to find similar documents",
      "min_term_freq": 1,
      "max_query_terms": 12
    }
  }
}

在这个示例中，查询将查找与给定文本相似的文档。

21. 使用 `ids` 查询

ids 查询用于根据文档 ID 匹配文档。

示例：根据文档 ID 匹配文档

{
  "query": {
    "ids": {
      "values": ["1", "2", "3"]
    }
  }
}

在这个示例中，查询将匹配 ID 为 1、2 和 3 的文档。

22. 使用 `constant_score` 查询

constant_score 查询用于将查询的相关性评分设置为常量值。

示例：将查询的相关性评分设置为常量值

{
  "query": {
    "constant_score": {
      "filter": {
        "term": { "field1": "value1" }
      },
      "boost": 1.2
    }
  }
}

在这个示例中，查询将匹配 field1 为 value1 的文档，并将相关性评分设置为常量值 1.2。

23. 使用 `function_score` 查询

function_score 查询允许你根据特定函数调整文档的相关性评分。

示例：根据特定函数调整相关性评分

{
  "query": {
    "function_score": {
      "query": {
        "match": { "field1": "value1" }
      },
      "functions": [
        {
          "filter": { "match": { "field2": "value2" } },
          "weight": 2
        },
        {
          "filter": { "range": { "field3": { "gte": 10 } } },
          "weight": 1.5
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

在这个示例中，查询将首先匹配 field1 为 value1 的文档，然后根据 field2 和 field3 的条件调整相关性评分。

24. 使用 `dis_max` 查询

dis_max 查询用于组合多个查询，并返回得分最高的文档。

示例：组合多个查询并返回得分最高的文档

{
  "query": {
    "dis_max": {
      "queries": [
        { "match": { "field1": "value1" } },
        { "match": { "field2": "value2" } }
      ],
      "tie_breaker": 0.7
    }
  }
}

在这个示例中，查询将组合 field1 和 field2 的匹配条件，并返回得分最高的文档。

25. 使用 `boosting` 查询

boosting 查询用于提升某些查询的得分，同时降低其他查询的得分。

示例：提升和降低特定查询的得分

{
  "query": {
    "boosting": {
      "positive": {
        "match": { "field1": "value1" }
      },
      "negative": {
        "match": { "field2": "value2" }
      },
      "negative_boost": 0.2
    }
  }
}

在这个示例中，查询将提升 field1 为 value1 的文档的得分，同时降低 field2 为 value2 的文档的得分。

26. 使用 `script_score` 查询

script_score 查询允许你使用脚本计算文档的相关性评分。

示例：使用脚本计算相关性评分

{
  "query": {
    "script_score": {
      "query": {
        "match": { "field1": "value1" }
      },
      "script": {
        "source": "doc['field2'].value * params.factor",
        "params": {
          "factor": 1.5
        }
      }
    }
  }
}

在这个示例中，查询将首先匹配 field1 为 value1 的文档，然后使用脚本计算相关性评分。

27. 使用 `highlight` 查询

highlight 查询用于在查询结果中高亮显示匹配的部分。

示例：高亮显示匹配的部分

{
  "query": {
    "match": { "field1": "value1" }
  },
  "highlight": {
    "fields": {
      "field1": {}
    }
  }
}

在这个示例中，查询将匹配 field1 为 value1 的文档，并在结果中高亮显示匹配的部分。

28. 使用 `rescore` 查询

rescore 查询用于对初始查询结果进行重新评分。

示例：对初始查询结果进行重新评分

{
  "query": {
    "match": { "field1": "value1" }
  },
  "rescore": {
    "window_size": 50,
    "query": {
      "rescore_query": {
        "match_phrase": { "field1": "value1" }
      },
      "query_weight": 0.7,
      "rescore_query_weight": 1.2
    }
  }
}

在这个示例中，查询将首先匹配 field1 为 value1 的文档，然后在前 50 个结果中使用 match_phrase 查询进行重新评分。

29. 使用 `percolate` 查询

percolate 查询用于查找与特定文档匹配的查询。

示例：查找与特定文档匹配的查询

{
  "query": {
    "percolate": {
      "field": "query",
      "document": {
        "field1": "value1"
      }
    }
  }
}

在这个示例中，查询将查找与文档 {"field1": "value1"} 匹配的查询。

30. 使用 `parent_id` 查询

parent_id 查询用于查找具有特定父文档 ID 的子文档。

示例：查找具有特定父文档 ID 的子文档

{
  "query": {
    "parent_id": {
      "type": "child_type",
      "id": "parent_id_value"
    }
  }
}

在这个示例中，查询将查找父文档 ID 为 parent_id_value 的子文档。

31. 使用 `has_child` 查询

has_child 查询用于查找具有特定子文档的父文档。

示例：查找具有特定子文档的父文档

{
  "query": {
    "has_child": {
      "type": "child_type",
      "query": {
        "match": { "field1": "value1" }
      }
    }
  }
}

在这个示例中，查询将查找具有 field1 为 value1 的子文档的父文档。

32. 使用 `has_parent` 查询

has_parent 查询用于查找具有特定父文档的子文档。

示例：查找具有特定父文档的子文档

{
  "query": {
    "has_parent": {
      "parent_type": "parent_type",
      "query": {
        "match": { "field1": "value1" }
      }
    }
  }
}

在这个示例中，查询将查找具有 field1 为 value1 的父文档的子文档。

33. 使用 `terms_set` 查询

terms_set 查询用于匹配字段值与查询中的多个值集合的交集。

示例：匹配字段值与查询中的多个值集合的交集

{
  "query": {
    "terms_set": {
      "field1": {
        "terms": ["value1", "value2", "value3"],
        "minimum_should_match_field": "required_matches"
      }
    }
  }
}

在这个示例中，查询将匹配 field1 的值与 ["value1", "value2", "value3"] 集合的交集，并且交集的大小由 required_matches 字段指定。

34. 使用 `intervals` 查询

intervals 查询用于基于间隔匹配文本。

示例：基于间隔匹配文本

{
  "query": {
    "intervals": {
      "field1": {
        "all_of": {
          "intervals": [
            { "match": { "query": "value1" } },
            { "match": { "query": "value2" } }
          ],
          "max_gaps": 5,
          "ordered": true
        }
      }
    }
  }
}

在这个示例中，查询将匹配 field1 中包含 value1 和 value2，并且它们之间的最大间隔为 5 且顺序一致的文档。

35. 使用 `rank_feature` 查询

rank_feature 查询用于基于特征字段的值对文档进行排名。

示例：基于特征字段的值对文档进行排名

{
  "query": {
    "rank_feature": {
      "field": "feature_field",
      "boost": 1.5
    }
  }
}

在这个示例中，查询将基于 feature_field 的值对文档进行排名，并应用一个 1.5 的提升因子。

36. 使用 `distance_feature` 查询

distance_feature 查询用于基于距离对文档进行排名。

示例：基于距离对文档进行排名

{
  "query": {
    "distance_feature": {
      "field": "date_field",
      "pivot": "7d",
      "origin": "now"
    }
  }
}

在这个示例中，查询将基于 date_field 的值与当前时间的距离对文档进行排名，使用 7d 作为基准距离。

37. 使用 `script` 查询

script 查询允许你使用脚本来定义自定义查询逻辑。

示例：使用脚本定义自定义查询逻辑

{
  "query": {
    "script": {
      "script": {
        "source": "doc['field1'].value > params.threshold",
        "params": {
          "threshold": 10
        }
      }
    }
  }
}

在这个示例中，查询将匹配 field1 的值大于 10 的文档。

38. 使用 `wrapper` 查询

wrapper 查询用于包装一个 Base64 编码的查询。

示例：包装一个 Base64 编码的查询

{
  "query": {
    "wrapper": {
      "query": "eyJ0ZXJtIjp7ImZpZWxkMSI6InZhbHVlMSJ9fQ=="
    }
  }
}

在这个示例中，查询将解码 Base64 编码的查询 eyJ0ZXJtIjp7ImZpZWxkMSI6InZhbHVlMSJ9fQ== 并执行它。

39. 使用 `exists` 查询

exists 查询用于匹配包含特定字段的文档。

示例：匹配包含特定字段的文档

{
  "query": {
    "exists": {
      "field": "field1"
    }
  }
}

在这个示例中，查询将匹配包含 field1 字段的文档。

40. 使用 `type` 查询

type 查询用于匹配特定类型的文档。

示例：匹配特定类型的文档

{
  "query": {
    "type": {
      "value": "type1"
    }
  }
}

在这个示例中，查询将匹配类型为 type1 的文档。

41. 使用 `terms` 查询

terms 查询用于匹配字段值在给定集合中的文档。

示例：匹配字段值在给定集合中的文档

{
  "query": {
    "terms": {
      "field1": ["value1", "value2", "value3"]
    }
  }
}

在这个示例中，查询将匹配 field1 的值在 ["value1", "value2", "value3"] 集合中的文档。

42. 使用 `wildcard` 查询

wildcard 查询用于匹配包含通配符的字段值。

示例：匹配包含通配符的字段值

{
  "query": {
    "wildcard": {
      "field1": "val*"
    }
  }
}

在这个示例中，查询将匹配 field1 的值以 val 开头的文档。

43. 使用 `regexp` 查询

regexp 查询用于匹配符合正则表达式的字段值。

示例：匹配符合正则表达式的字段值

{
  "query": {
    "regexp": {
      "field1": "val.*"
    }
  }
}

在这个示例中，查询将匹配 field1 的值符合正则表达式 val.* 的文档。

44. 使用 `prefix` 查询

prefix 查询用于匹配匹配以特定前缀开头的字段值。

示例：匹配以特定前缀开头的字段值

{
  "query": {
    "prefix": {
      "field1": "val"
    }
  }
}

在这个示例中，查询将匹配 field1 的值以 val 开头的文档。

45. 使用 `fuzzy` 查询

fuzzy 查询用于匹配与给定值相似的字段值，允许一定程度的模糊匹配。

示例：匹配与给定值相似的字段值

{
  "query": {
    "fuzzy": {
      "field1": {
        "value": "value1",
        "fuzziness": "AUTO"
      }
    }
  }
}

在这个示例中，查询将匹配 field1 的值与 value1 相似的文档，模糊度设置为 AUTO。

46. 使用 `ids` 查询

ids 查询用于匹配特定 ID 的文档。

示例：匹配特定 ID 的文档

{
  "query": {
    "ids": {
      "values": ["1", "2", "3"]
    }
  }
}

在这个示例中，查询将匹配 ID 为 1、2 或 3 的文档。

47. 使用 `geo_shape` 查询

geo_shape 查询用于匹配地理形状字段。

示例：匹配地理形状字段

{
  "query": {
    "geo_shape": {
      "location": {
        "shape": {
          "type": "envelope",
          "coordinates": [[13.0, 53.0], [14.0, 52.0]]
        },
        "relation": "within"
      }
    }
  }
}

在这个示例中，查询将匹配 location 字段在指定的地理形状内的文档。

48. 使用 `geo_bounding_box` 查询

geo_bounding_box 查询用于匹配在指定地理边界框内的文档。

示例：匹配在指定地理边界框内的文档

{
  "query": {
    "geo_bounding_box": {
      "location": {
        "top_left": {
          "lat": 53.0,
          "lon": 13.0
        },
        "bottom_right": {
          "lat": 52.0,
          "lon": 14.0
        }
      }
    }
  }
}

在这个示例中，查询将匹配 location 字段在指定地理边界框内的文档。

49. 使用 `geo_distance` 查询

geo_distance 查询用于匹配在指定距离内的文档。

示例：匹配在指定距离内的文档

{
  "query": {
    "geo_distance": {
      "distance": "200km",
      "location": {
        "lat": 52.0,
        "lon": 13.0
      }
    }
  }
}

在这个示例中，查询将匹配 location 字段在距离 52.0, 13.0 200 公里范围内的文档。

50. 使用 `geo_polygon` 查询

geo_polygon 查询用于匹配在指定地理多边形内的文档。

示例：匹配在指定地理多边形内的文档

{
  "query": {
    "geo_polygon": {
      "location": {
        "points": [
          { "lat": 52.0, "lon": 13.0 },
          { "lat": 53.0, "lon": 14.0 },
          { "lat": 52.5, "lon": 13.5 }
        ]
      }
    }
  }
}