Elasticsearch入门之HTTP高级查询操作

SunnyRivers2024-12-08 9:50

前言

上一篇博客我们学习了es的一些基础操作如下：

  1. 创建索引（创建表 create table）
  2. 查看索引（查看表show tables）
  3. 查看单个索引（查看单个表show create table）
  4. 删除索引（删除表）
  5. 创建文档（插入数据）
  6. 根据唯一标识查看文档（根据主键查看一条数据）
  7. 根据唯一标识修改文档所有字段值（根据主键修改一条数据）
  8. 根据唯一标识修改文档指定字段值（根据主键修改指定字段的值）
  9. 根据唯一标识删除文档（根据主键删除对应的一条数据）
  10. 条件删除文档（根据条件删除数据）
  11. 创建映射（mysql中一般就是创建表，只不过es可以动态生成映射）
  12. 查看映射（查看表结构）

本篇我们继续学习es http的其它操作

高级查询

Elasticsearch 提供了基于 JSON 提供完整的查询 DSL 来定义查询

定义数据 :

# POST /student/_doc/1001
{
"name":"zhangsan",
"nickname":"zhangsan",
 "sex":"男",
 "age":30
}
# POST /student/_doc/1002
{
"name":"lisi",
"nickname":"lisi",
 "sex":"男",
 "age":20
}
# POST /student/_doc/1003
{
"name":"wangwu",
 "nickname":"wangwu",
 "sex":"女",
 "age":40
}
# POST /student/_doc/1004
{
"name":"zhangsan1",
"nickname":"zhangsan1",
 "sex":"女",
 "age":50
}
# POST /student/_doc/1005
{
"name":"zhangsan aa",
"nickname":"zhangsan2",
 "sex":"女",
 "age":30
}

我们先根据上面的数据，用自定义的id给student索引中插入文档：

其它文档操作类似，这里就不截图展示了。

  1. 查询所有文档（类似于查询表中所有数据：select * from table）

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
 "query": {
 "match_all": {}
 }
}
# "query"：这里的 query 代表一个查询对象，里面可以有不同的查询属性
# "match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等
# {查询条件}：查询条件会根据类型的不同，写法也有差异

服务器响应结果如下：

这里就展示一部分数据。

{
 "took【查询花费时间，单位毫秒】" : 1116,
 "timed_out【是否超时】" : false,
 "_shards【分片信息】" : {
 "total【总数】" : 1,
 "successful【成功】" : 1,
 "skipped【忽略】" : 0,
 "failed【失败】" : 0
 },
 "hits【搜索命中结果】" : {
 "total"【搜索条件匹配的文档总数】: {
 "value"【总命中计数的值】: 3,
 "relation"【计数规则】: "eq" # eq 表示计数准确， gte 表示计数不准确
 },
 "max_score【匹配度分值】" : 1.0,
 "hits【命中结果集合】" : [
 。。。
 }
 ]
 }
}
  1. 匹配查询

match 匹配类型查询，会把查询条件进行分词 ，然后进行查询，多个词条之间是 or 的关系

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

服务器响应结果为：（篇幅原因这里json就不格式化了）

这里特别要注意，不同的es版本对于分词的处理也不同，我们可以看到zhangsan1并没有查出来，但是zhangsan aa查出来了，说明本次并没有把zhangsan1拆分出zhangsan来，因此查不出来。

  1. 字段匹配查询

multi_match 与 match 类似，不同的是它可以在多个字段中查询。

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

服务器响应结果：

  1. 关键字精确查询（类似于：select * from table where name = 'zhangsan'）
    term 查询，精确的关键词匹配查询，不对查询条件进行分词。
    在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

    {
    "query": {
    "term": {
    "name": {
    "value": "zhangsan"
    }
    }
    }
    }

服务器响应结果：

  1. 多关键字精确查询（类似于：select * from table where name in ('zhangsan','lisi')）

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。

如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于 mysql 的 in

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "query": {
        "terms": {
            "name": [
                "zhangsan",
                "lisi"
            ]
        }
    }
}

服务器响应结果：

  1. 指定查询字段（类似于：select name,nickname from table where nickname = 'zhangsan'）

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在_source 的所有字段都返回。

如果我们只想获取其中的部分字段，我们可以添加_source 的过滤

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "_source": [
        "name",
        "nickname"
    ],
    "query": {
        "terms": {
            "nickname": [
                "zhangsan"
            ]
        }
    }
}

服务器响应结果：

  1. 过滤字段（还是类似与select 指定的字段）

我们也可以通过：

  • includes：来指定想要显示的字段（这个和上面一样，只不过上面是把includes忽略了）
  • excludes：来指定不想要显示的字段（这个在mysql中并没有类似的，一般mysql想选择什么字段，需要一个一个些出来，感觉用处是有，但没有那么大）

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "_source": {
        "includes": [
            "name",
            "nickname"
        ]
    },
    "query": {
        "terms": {
            "nickname": [
                "zhangsan"
            ]
        }
    }
}

服务器响应结果：

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "_source": {
        "excludes": [
            "name",
            "nickname"
        ]
    },
    "query": {
        "terms": {
            "nickname": [
                "zhangsan"
            ]
        }
    }
}

服务器响应结果：

  1. 组合查询
    bool把各种其它查询通过must（必须 ）、must_not（必须不）、should（应该）的方式进行组合

  • must
    含义：所有包含在 must 数组中的查询条件都必须为真（即所有条件都必须满足），文档才会被返回。
    等价逻辑运算符：AND
    应用场景：当你需要确保多个条件同时成立时使用。
    假设你想查找姓名中包含"shangsan"并且nickname是"zhangsan"的学生，可以这样写：

    {
    "query": {
    "bool": {
    "must": [
    {
    "match": {
    "name": "zhangsan"
    }
    },
    {
    "match": {
    "nickname": "zhangsan"
    }
    }
    ]
    }
    }
    }

  • must_not
    含义：所有包含在 must_not 数组中的查询条件都必须为假（即这些条件都不能满足），文档才会被返回。
    等价逻辑运算符：NOT
    应用场景：当你想要排除某些特定条件时使用。
    如果你想查找name中包含"zhangsan"，但nickname不是"lisi"的学生，可以这样写：

    {
    "query": {
    "bool": {
    "must": [
    {
    "match": {
    "name": "zhangsan"
    }
    }
    ],
    "must_not": [
    {
    "match": {
    "nickname": "lis"
    }
    }
    ]
    }
    }
    }

  • should
    含义：should 数组中的查询条件至少有一个为真即可（即满足任意一个条件即可），文档就会被返回。你可以通过设置 minimum_should_match 参数来指定最少需要满足的条件数量。
    等价逻辑运算符：OR
    应用场景：当你希望满足任意一个或多个条件时使用。
    如果你想查找name中包含"zhangsan"或nickname是"zhangsan1"的学生，可以这样写：

    {
    "query": {
    "bool": {
    "should": [
    {
    "match": {
    "name": "zhangsan"
    }
    },
    {
    "match": {
    "nickname": "zhangsan1"
    }
    }
    ]
    }
    }
    }

当然可以组合查询：在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "name": "zhangsan"
                    }
                }
            ],
            "must_not": [
                {
                    "match": {
                        "nickname": "lisi"
                    }
                }
            ]
        }
    }
}

服务器响应结果：

  1. 范围查询

range 查询找出那些落在指定区间内的数字或者时间。range 查询允许以下字符

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "query": {
        "range": {
            "age": {
                "gte": 30,
                "lte": 35
            }
        }
    }
}

报错了：Cannot search on field [age] since it is not indexed

根据上一篇博客，我们知道index一旦为false，那么就不能用来查询，所以我们看看age字段的index是不是为false:

果不其然，这就是上篇博客说的动态映射的缺点了，我们需要更改一下映射，更改索引的方法看下面修改索引，我们临时修改改了一个名字叫tmp_student的索引，修改完后我们再次执行

服务器响应结果：

  1. 模糊查询（相当于sql中的select * from table where name like '%zhangsan%'）

返回包含与搜索字词相似的字词的文档。

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：

  • 更改字符（box → fox）
  • 删除字符（black → lack）
  • 插入字符（sic → sick）
  • 转置两个相邻字符（act → cat）

为了找到相似的术语，fuzzy 查询会在指定的编辑距离内创建一组搜索词的所有可能的变体

或扩展。然后查询返回每个扩展的完全匹配。

通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离。

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}

服务器响应结果：

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan",
                "fuzziness": 2
            }
        }
    }
}

fuzziness设置为2，

服务器响应结果：

  1. 单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc

升序。

我们现在索引中name为zhangsan相关的两个年龄都为30，我们再插入一条数据方便进行排序测试：

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/tmp_student/_search

{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        }
    ]
}

服务器响应结果：

  1. 多字段排序

假定我们想要结合使用 age 和 _id 进行查询，并且匹配的结果首先按照年龄排序，然后

按照id排序

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        },
        {
            "_id": {
                "order": "desc"
            }
        }
    ]
}
  1. 高亮查询

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。

Elasticsearch 可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。

在使用 match 查询的同时，加上一个 highlight 属性：

  • pre_tags：前置标签
  • post_tags：后置标签
  • fields：需要高亮的字段
  • title：这里声明 title 字段需要高亮，后面可以为这个字段设置特有配置，也可以空

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/tmp_student/_search

{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "highlight": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>",
        "fields": {
            "name": {}
        }
    }
}
  1. 分页查询

from：当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size

size：每页显示多少条

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/tmp_student/_search

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        }
    ],
    "from": 0,
    "size": 2
}
  1. 聚合查询

聚合允许使用者对 es 文档进行统计分析，类似与关系型数据库中的 group by，当然还有很多其他的聚合，例如取最大值、平均值等等。

  • 对某个字段取平均值 avg

    {
    "aggs": {
    "avg_age": {
    "avg": {
    "field": "age"
    }
    }
    },
    "size": 0
    }

  • 对某个字段的值进行去重之后再取总数
    在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/tmp_student/_search

    {
    "aggs": {
    "distinct_age": {
    "cardinality": {
    "field": "age"
    }
    }
    },
    "size": 0
    }

  • State 聚合
    stats 聚合，对某个字段一次性返回 count，max，min，avg 和 sum 五个指标
    在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/tmp_student/_search

    {
    "aggs": {
    "stats_age": {
    "stats": {
    "field": "age"
    }
    }
    },
    "size": 0
    }

  1. 桶聚合查询

桶聚和相当于 sql 中的 group by 语句

修改索引

在es中，是不支持更改现有字段的映射或字段类型的，如果我们非得需要更改字段的类型，怎么办，数据迁移，重建索引，建立我们想要的正确的映射规则；

  1. 查看旧的索引

    {
    "student": {
    "mappings": {
    "properties": {
    "age": {
    "type": "long",
    "index": false
    },
    "name": {
    "type": "text"
    },
    "nickname": {
    "type": "text",
    "fields": {
    "keyword": {
    "type": "keyword",
    "ignore_above": 256
    }
    }
    },
    "sex": {
    "type": "text",
    "index": false
    }
    }
    }
    }
    }

  2. 创建新的索引

    {
    "mappings": {
    "properties": {
    "age": {
    "type": "long",
    "index": true
    },
    "name": {
    "type": "text"
    },
    "nickname": {
    "type": "text",
    "fields": {
    "keyword": {
    "type": "keyword",
    "ignore_above": 256
    }
    }
    },
    "sex": {
    "type": "text",
    "index": false
    }
    }
    }
    }

  3. 数据迁移

    {
    "source": {
    "index": "student"
    },
    "dest": {
    "index": "tmp_student"
    }
    }

match和term

当然可以。match 查询和 term 查询在 Elasticsearch 中确实有不同的行为，特别是在处理分析（分词）和全文搜索方面。下面通过具体的例子来说明它们之间的区别。

示例场景：图书索引

假设你有一个包含书籍信息的索引 books，每个文档代表一本书，并且有以下字段：

  • title: 书名，类型为 text，并且默认包含一个 keyword 子字段 title.keyword。
  • author: 作者名，类型为 text，并且默认包含一个 keyword 子字段 author.keyword。
示例数据
id title author
1 Elasticsearch Guide John Doe
2 Learning Elasticsearch Jane Smith
3 Mastering Elasticsearch John Doe-Smith
4 Elasticsearch Basics John Doe Jr.
使用 match 查询

match 查询会分析查询字符串，并尝试匹配文档中的相应词条。这使得它可以用于全文搜索，支持部分匹配和模糊匹配。

示例查询：查找包含 "elasticsearch" 的书籍
json 复制代码 
GET /books/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "title": "elasticsearch"
          }
        }
      ]
    }
  }
}

这段查询会返回所有标题中包含词条 "elasticsearch" 的书籍，例如：

  • id: 1 - "Elasticsearch Guide"
  • id: 2 - "Learning Elasticsearch"
  • id: 3 - "Mastering Elasticsearch"
  • id: 4 - "Elasticsearch Basics"

这是因为 match 查询会对查询字符串 "elasticsearch" 进行分析，并将其视为单个词条来匹配。

示例查询：查找作者名为 "John Doe" 的书籍
json 复制代码 
GET /books/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "author": "John Doe"
          }
        }
      ]
    }
  }
}

这段查询会返回所有作者名中包含词条 "john" 和 "doe" 的书籍，例如：

  • id: 1 - "John Doe"
  • id: 3 - "John Doe-Smith"
  • id: 4 - "John Doe Jr."

这是因为 match 查询会对查询字符串 "John Doe" 进行分析，并将它分解为两个词条 "john" 和 "doe" 来匹配。

使用 term 查询

term 查询不会对查询字符串进行任何分析或分词，而是直接将整个值作为单个词条来查找。这意味着它适合用于精确匹配，如用户ID、状态码、类别名称等。

示例查询：查找标题恰好为 "Elasticsearch Guide" 的书籍
json 复制代码 
GET /books/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "title.keyword": "Elasticsearch Guide"
          }
        }
      ]
    }
  }
}

这段查询只会返回 id: 1 的那本书，因为它完全匹配了给定的字符串。

示例查询：查找作者名为 "John Doe" 的书籍
json 复制代码 
GET /books/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "author.keyword": "John Doe"
          }
        }
      ]
    }
  }
}

这段查询只会返回 id: 1 的那本书，因为它完全匹配了给定的字符串 "John Doe"。id: 3 和 id: 4 的书籍不会被返回，因为它们的作者名不完全匹配。

关键区别总结

  • match 查询：

    • 分析：对查询字符串进行分析（分词），然后匹配包含这些词条的文档。
    • 应用场景：适用于全文搜索，支持部分匹配和模糊匹配。
    • 示例 ：查询 "John Doe" 可能返回包含 "John", "Doe", "John Doe-Smith", "John Doe Jr." 等文档。

  • term 查询：

    • 不分析：不进行分析，直接匹配完整词条。
    • 应用场景：适用于精确匹配，如用户ID、状态码、类别名称等。
    • 示例 ：查询 "John Doe" 只会返回完全匹配 "John Doe" 的文档。
总结

match 查询和 term 查询在 Elasticsearch 中有着不同的用途和行为：

  • match 查询 更适合用于全文搜索，支持分析和部分匹配，适用于 text 类型的字段。
  • term 查询 更适合用于精确匹配，不涉及分析过程，适用于 keyword 类型的字段。

通过正确理解和选择 match 和 term 查询，你可以构建更加高效和准确的查询逻辑。如果你需要进行全文搜索，请使用 match 查询；如果你需要进行精确匹配，请使用 term 查询并针对 keyword 字段。

模糊匹配（类似于sql中的like）

如果你希望查询能够匹配部分相似的字段，可以考虑以下几种方法：

1. 使用 wildcard 查询

wildcard 查询允许你使用通配符模式来进行模糊匹配。你可以用 * 表示任意数量的字符：

json 复制代码 
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "name": "zhangsan*"
          }
        }
      ]
    }
  }
}

这种方法适用于前缀匹配，但它可能比 match 查询更慢，特别是在大数据集上。

2. 使用 prefix 查询

prefix 查询用于查找以指定字符串开头的所有文档：

json 复制代码 
{
  "query": {
    "bool": {
      "must": [
        {
          "prefix": {
            "name": "zhangsan"
          }
        }
      ]
    }
  }
}

这将返回所有 name 以 "zhangsan" 开头的文档。

3. 使用 fuzzy 查询

fuzzy 查询允许一定范围内的编辑距离（Levenshtein 距离），从而实现模糊匹配：

json 复制代码 
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": {
              "query": "zhangsan",
              "fuzziness": "AUTO"
            }
          }
        }
      ]
    }
  }
}

这将返回与 "zhangsan" 接近的名称，包括拼写错误或其他轻微变化。

4. 使用 keyword 子字段进行精确匹配或前缀匹配

如果你希望进行精确匹配或者基于原始值的前缀匹配，可以利用 name.keyword 子字段（假设你已经在映射中定义了这个子字段）：

json 复制代码 
{
  "query": {
    "bool": {
      "must": [
        {
          "prefix": {
            "name.keyword": "zhangsan"
          }
        }
      ]
    }
  }
}

这种方法确保了查询不会受到分析器的影响，提供了更精确的匹配。

总结

match 查询的行为是基于词条匹配的，而不是基于整个字符串的精确匹配。因此，它只会返回那些明确包含查询词条的文档。如果你想匹配部分相似的名字，可以考虑使用 wildcard、prefix、fuzzy 查询，或者直接针对 keyword 子字段进行查询。选择哪种方法取决于你的具体需求和性能考虑。

如果你的目标是实现类似于 MySQL LIKE 的前缀匹配行为，prefix 或 wildcard 查询通常是更好的选择。

相关推荐
成长的小牛2331 小时前
es使用knn向量检索中numCandidates和k应该如何配比更合适
大数据·elasticsearch·搜索引擎
Elastic 中国社区官方博客3 小时前
Elasticsearch：什么是查询语言？
大数据·数据库·elasticsearch·搜索引擎·oracle
启明真纳3 小时前
elasticache备份
运维·elasticsearch·云原生·kubernetes
Graceful_scenery8 小时前
https双向认证
服务器·网络·网络协议·http·https
幽弥千月13 小时前
【ELK】ES单节点升级为集群并开启https【亲测可用】
elk·elasticsearch·https
运维&陈同学13 小时前
【Elasticsearch05】企业级日志分析系统ELK之集群工作原理
运维·开发语言·后端·python·elasticsearch·自动化·jenkins·哈希算法
njnu@liyong19 小时前
图解HTTP-HTTP状态码
网络协议·计算机网络·http
代码洁癖症患者21 小时前
HTTP请求的奇幻旅程：从发起至响应的全方位探索
网络·网络协议·http
寻找沙漠的人1 天前
HTTP—02
网络·网络协议·http
Y编程小白1 天前
Git版本控制工具--基础命令和分支管理
大数据·git·elasticsearch
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04机器人编程怎么入门？05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07SQL 主从数据库实时备份08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10VSCode插件 —— Cody AI （免费AI助手！）