ElasticSearch-查询语句详解

朴灿烈づ我的快乐病毒、 2022-11-17 05:21 227阅读 0赞

### url参数搜索 ###

这种方式就是类似于get请求，将请求参数拼接到链接上，例`GET /school/student/_search?参数`，多个参数用&分开

查询所有

命令：`GET /school/student/_search`

{
      "took": 7, //查询耗时，毫秒
      "timed_out": false, //是否超时，timeout 不是停止执行查询，它仅仅是告知正在协调的节点返回到目前为止收集的结果并且关闭连接
      "_shards": {
        "total": 5, //请求的分片数量，索引拆成了5个分片，所以对于搜索请求，会打到所有的primary shard
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 2, //符合条件的总条数，这里查的是所有
        "max_score": 1, //匹配分数
        "hits": [ //数据
          {
            "_index": "school",
            "_type": "student",
            "_id": "2",
            "_score": 1,
            "_source": {
              "name": "houyi",
              "age": 23,
              "class": 2,
              "gender": "男"
            }
          },
          {
            "_index": "school",
            "_type": "student",
            "_id": "1",
            "_score": 1,
            "_source": {
              "name": "吕布",
              "age": 21,
              "class": 2,
              "gender": "男"
            }
          }
        ]
      }
    }
    复制代码

多索引，多type搜索

在URL中指定特殊的索引和类型进行多索引，多type搜索

1.  `/_search`：在所有的索引中搜索所有的类型
2.  `/school/_search`：在 `school` 索引中搜索所有的类型
3.  `/school,ad/_search`：在 `school` 和`ad`索引中搜索所有的类型
4.  `/s*,a*/_search`：在所有以`g`和`a`开头的索引中所有所有的类型
5.  `/school/student/_search`：在`school`索引中搜索`student`类型
6.  `/school,ad/student,phone/_search`：在`school`和`ad`索引上搜索`student`和`phone`类型
7.  `/_all/student,phone/_search`：在所有的索引中搜索`student`和`phone`类型

按条件查询

命令：`GET /school/student/_search?q=name:houyi`

查询name是houyi的记录

更多查询参数：

### 查询DSL ###

elasticsearch提供了基于JSON的完整查询DSL来定义查询，DSL拥有一套查询组件，这些组件可以以无限组合的方式进行搭配，构建各种复杂的查询

叶子语句

叶子语句：就像match语句，被用于将查询的字符串与一个字段或多个字段进行对比（单个条件） 比如：

GET /ad/phone/_search
       {
         "query": {
           "match": {
             "name": "phone"
           }
         }
       }
    复制代码

复合查询

用户合并其他查询语句，比如一个`bool`语句，允许你在需要的时候组合其他语句，包括`must`，`must_not`，`should`和`filter`语句（多条件组合查询） 比如：

GET /ad/phone/_search
    {
      "query": {
        "bool": {
          "must": [
            {"match": {
              "name": "phone"
            }}
          ]
          , "must_not": [
            {"match": {
              "color": "red"
            }}
          ]
          , "should": [
            {"match": {
              "price": 5000
            }}
          ]
          , "filter": {
              "term": {
                "label": "phone"
              }
          }
        }
      }
    }
    复制代码

`must`：表示文档一定要包含查询的内容

`must_not`：表示文档一定不要包含查询的内容

`should`：表示如果文档匹配上可以增加文档相关性得分

事实上我们可以使用两种结构化语句： 结构化查询`query DSL`和结构化过滤`Filter DSL`

1.  结构化查询`query DSL`
    
    用于检查内容与条件是否匹配，内容查询中使用的bool和match字句，用于计算每个文档的匹配得分，元字段\_score表示匹配度，查询的结构中以query参数开始来执行内容查询
2.  结构化过滤`Filter DSL`
    
    只是简单的决定文档是否匹配，内容过滤中使用的term和range字句，会过滤 调不匹配的文档，并且不影响计算文档匹配得分
    
    使用过滤查询会被es自动缓存用来提高效率

原则上来说，使用查询语句做全文本搜索或其他需要进行相关性评分的时候，剩下的全部用过滤语句

**新建一个稍微复杂的索引，添加三条文档**

PUT /ad/phone/1
    {
      "name":"phone 8",
      "price": 6000,
      "color":"white",
      "ad":"this is a white phone",
      "label":["white","nice"]
    }
    
    PUT /ad/phone/2
    {
      "name":"xiaomi 8",
      "price": 4000,
      "color":"red",
      "ad":"this is a red phone",
      "label":["white","xiaomi"]
    }
    
    PUT /ad/phone/3
    {
      "name":"huawei p30",
      "price": 5000,
      "color":"white",
      "ad":"this is a white phone",
      "label":["white","huawei"]
    }
    
    复制代码

### 查询示例 ###

1. 获取所有

GET /ad/phone/_search
    {
      "query": {
        "match_all": {}
      }
    }
    复制代码

`match_all`匹配所有数据，返回的结果中元字段`_score`得分为1

2. 分页查询，从第二条开始，查两条（不要使用`from`，`size`进行深度分页，会有性能问题）

GET /ad/phone/_search
    {
      "query": {
        "match_all": {}
      },
      "from": 1,
      "size": 2
    }
    复制代码

这种分页方式如果进行深度分页，比如到100页，每页十条数据，它会从每个分片都查询出100\*10条数据，假设有五个分片，就是5000条数据，然后在内存中进行排序，然后返回拍过序之后的集合中的第1000-1010条数据

3. 指定查询出来的数据返回的字段

GET /ad/phone/_search
    {
      "query": {
        "match_all": {}
      },
      "_source": ["name","price"]
    }
    复制代码

返回的数据中只返回`name`和`price`字段

4. ad字段中包含单词white

GET /ad/phone/_search
    {
      "query": {
        "match": {
          "ad": "white"
        }
      }
    }
    复制代码

返回的结果中元字段`_score`有评分，说明使用`query`会计算评分

5. ad字段中包含单词white，并按照价格升序排列

GET /ad/phone/_search
    {
      "query": {
        "match": {
          "ad": "white"
        }
      }, 
      "sort": [
        {
          "price": {
            "order": "asc"
          }
        }
      ]
    }
    复制代码

6. 价格字段大于5000

GET /ad/phone/_search
    {
      "query": {
        "bool": {
          "filter": {
            "range": {
              "price": {
                "gt": 5000
              }
            }
          }
        }
      }
    }
    复制代码

返回的结果中元字段`_score`字段等于0，没评分，说明使用`filter`不会计算评分

7. ad字段中包含单词white，价格字段大于5000

GET /ad/phone/_search
    {
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "ad": "white"
              }
            }
          ], 
          "filter": {
            "range": {
              "price": {
                "gt": 5000
              }
            }
          }
        }
      }
    }
    复制代码

8. 查询`name`字段包含单词`phone`的文档的数量

GET /ad/phone/_count
    {
      "query": {
        "match": {
          "name": "phone"
        }
      }
    }
    复制代码

### 关键词详解 ###

1. `match_all`查询

查询简单的匹配所有文档

GET /ad/phone/_search
    {
      "query": {
        "match_all": {}
      }
    }
    复制代码

2. `match`查询

支持全文搜索和精确查询，取决于字段是否支持全文检索

全文检索：

GET /ad/phone/_search
    {
      "query": {
        "match": {
          "ad": "a red"
        }
      }
    }
    复制代码

全文检索会将查询的字符串先进行分词，`a red`会分成为`a`和`red`，然后在倒排索引中进行匹配，所以这条语句会将三条文档都查出来

精确查询：

GET /ad/phone/_search
    {
      "query": {
        "match": {
          "price": "6000"
        }
      }
    }
    复制代码

对于精确值的查询，可以使用 filter 语句来取代 query，因为 filter 将会被缓存

`operator`操作：

`match` 查询还可以接受 `operator` 操作符作为输入参数，默认情况下该操作符是 `or` 。我们可以将它修改成 `and` 让所有指定词项都必须匹配

GET /ad/phone/_search
    {
      "query": {
        "match": {
          "ad": {
            "query": "a red",
            "operator": "and"
          }
        }
      }
    }
    复制代码

精确度匹配：

`match` 查询支持 `minimum_should_match` 最小匹配参数， 可以指定必须匹配的词项数用来表示一个文档是否相关。我们可以将其设置为某个具体数字（指需要匹配倒排索引的词的数量），更常用的做法是将其设置为一个百分数，因为我们无法控制用户搜索时输入的单词数量

GET /ad/phone/_search
    {
      "query": {
        "match": {
          "ad": {
            "query": "a red",
            "minimum_should_match": "2"
          }
        }
      }
    }
    复制代码

只会返回匹配上`a`和`red`两个词的文档返回，如果`minimum_should_match`是1，则只要匹配上其中一个词，文档就会返回

3. `multi_match`查询

多字段查询，比如查询`color`和`ad`字段包含单词`red`的文档

GET /ad/phone/_search
    {
      "query": {
        "multi_match": {
          "query": "red",
          "fields": ["color","ad"]
        }
      }
    }
    复制代码

4. `range`查询

范围查询，查询价格大于4000小于6000的文档

GET /ad/phone/_search
    {
      "query": {
        "range": {
          "price": {
            "gt": 4000,
            "lt": 6000
          }
        }
      }
    }
    复制代码

范围查询操作符：`gt` （大于），`gte`（大于等于），`lt`（小于），`lte`（小于等于)；

5. `term`查询

精确值查询

查询`price`字段等于6000的文档

GET /ad/phone/_search
    {
      "query": {
        "term": {
          "price": {
            "value": "6000"
          }
        }
      }
    }
    复制代码

查询`name`字段等于`phone 8`的文档

GET /ad/phone/_search
    {
      "query": {
        "term": {
          "name": {
            "value": "phone 8"
          }
        }
      }
    }
    复制代码

返回值如下，没有查询到名称为`phone 8`的文档

{
      "took": 5,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 0,
        "max_score": null,
        "hits": []
      }
    }
    复制代码

为什么没有查到`phone 8`的这个文档那，这里需要介绍一下`term`的查询原理

`term`查询会去倒排索引中寻找确切的`term`,它并不会走分词器，只会去配倒排索引 ，而`name`字段的`type`类型是`text`，会进行分词，将`phone 8` 分为`phone`和`8`，我们使用`term`查询`phone 8`时倒排索引中没有`phone 8`，所以没有查询到匹配的文档

`term`查询与`match`查询的区别

*  `term`查询时，不会分词，直接匹配倒排索引
 *  `match`查询时会进行分词，查询`phone 8`时，会先分词成`phone`和`8`，然后去匹配倒排索引，所以结果会将`phone 8`和`xiaomi 8`两个文档都查出来

还有一点需要注意，因为`term`查询不会走分词器，但是回去匹配倒排索引，所以查询的结构就跟分词器如何分词有关系，比如新增一个`/ad/phone`类型下的文档，`name`字段赋值为`Oppo`，这时使用`term`查询`Oppo`不会查询出文档，这时因为es默认是用的`standard`分词器，它在分词后会将单词转成小写输出，所以使用`oppo`查不出文档，使用小写`oppo`可以查出来

GET /ad/phone/_search
    {
      "query": {
        "term": {
          "name": {
            "value": "Oppo" //改成oppo可以查出新添加的文档
          }
        }
      }
    }
    复制代码

这里说的并不是想让你了解`standard`分词器，而是要get到所有像`term`这类的查询结果跟选择的分词器有关系，了解选择的分词器分词方式有助于我们编写查询语句

6. `terms`查询

`terms`查询与`term`查询一样，但它允许你指定多直进行匹配，如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件

GET /ad/phone/_search
    {
      "query": {
        "terms": {
          "ad": ["red","blue"]
        }
      }
    }
    复制代码

7. `exists` 查询和 `missing` 查询

用于查找那些指定字段中有值 (`exists`) 或无值 (`missing`) 的文档

指定`name`字段有值：

GET /ad/phone/_search
    {
      "query": {
        "bool": {
          "filter": {
            "exists": {
              "field": "name"
            }
          }
        }
      }
    }
    复制代码

指定`name`字段无值：

GET /ad/phone/_search
    {
      "query": {
        "bool": {
          "filter": {
            "missing": {
              "field": "name"
            }
          }
        }
      }
    }
    复制代码

8. `match_phrase`查询

短语查询，精确匹配，查询`a red`会匹配`ad`字段包含`a red`短语的，而不会进行分词查询，也不会查询出包含`a 其他词 red`这样的文档

GET /ad/phone/_search
    {
      "query": {
        "match_phrase": {
          "ad": "a red"
        }
      }
    }
    复制代码

9. `scroll`查询

类似于分页查询，不支持跳页查询，只能一页一页往下查询，`scroll`查询不是针对实时用户请求，而是针对处理大量数据，例如为了将一个索引的内容重新索引到具有不同配置的新索引中

POST /ad/phone/_search?scroll=1m
    {
      "query": {
        "match_all": {}
      },
      "size": 1,
      "from": 0
    }
    复制代码

返回值包含一个 `"_scroll_id": "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAAQFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAERZVek91amNjWlQwS0RubmV3YmdIRWFBAAAAAAAAABIWVXpPdWpjY1pUMEtEbm5ld2JnSEVhQQAAAAAAAAATFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAFBZVek91amNjWlQwS0RubmV3YmdIRWFB"`

下次查询的时候使用`_scroll_id`就可以查询下一页的文档

POST /_search/scroll 
    {
        "scroll" : "1m", 
        "scroll_id" : "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAAYFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAGRZVek91amNjWlQwS0RubmV3YmdIRWFBAAAAAAAAABYWVXpPdWpjY1pUMEtEbm5ld2JnSEVhQQAAAAAAAAAXFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAFRZVek91amNjWlQwS0RubmV3YmdIRWFB" 
    }
    复制代码

10. `multi get`查询

允许基于索引，类型（可选）和id（以及可能的路由）获取多个文档，如果某个文档获取失败则将错误信息包含在响应中

```json
    GET /ad/phone/_mget
    {
      "ids": ["1","8"]
    }

复制代码

#### 11\. `bulk`批量操作
    
    `bulk`批量操作可以在单次API调用中实现多个文档的`create`、`index`、`update`或`delete`。这可以大大提高索引速度
    
    `bulk`请求体如下

\{ action: \{ metadata \}\}\\n  
\{ request body \}\\n  
\{ action: \{ metadata \}\}\\n  
\{ request body \}\\n  
...  
复制代码

**action**必须是以下几种：
    
    | 行为 | 解释 |
    | --- | --- |
    | create | 当文档不存在时创建 |
    | index | 创建新文档或替换已有文档 |
    | update | 局部更新文档 |
    | delete | 删除一个文档 |
    
    在索引、创建、更新或删除时必须指定文档的`_index`、`_type`、`_id`这些元数据(`metadata`)
    
    例：

PUT _bulk
    { "create" : { "_index" : "ad", "_type" : "phone", "_id" : "6" }}
    { "doc" : {"name" : "bulk"}}
    { "index" : { "_index" : "ad", "_type" : "phone", "_id" : "6" }}
    { "doc" : {"name" : "bulk"}}
    { "delete":{  "_index" : "ad", "_type" : "phone", "_id" : "1"}}
    { "update":{  "_index" : "ad", "_type" : "phone", "_id" : "3"}}
    { "doc" : {"name" : "huawei p20"}}

复制代码

{
      "took": 137,
      "errors": true, //如果任意一个文档出错，这里返回true,
      "items": [ //items数组，它罗列了每一个请求的结果，结果的顺序与我们请求的顺序相同
        {
          //create这个文档已经存在，所以异常
          "create": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "6",
            "status": 409,
            "error": {
              "type": "version_conflict_engine_exception",
              "reason": "[phone][6]: version conflict, document already exists (current version [2])",
              "index_uuid": "9F5FHqgISYOra_P09HReVQ",
              "shard": "2",
              "index": "ad"
            }
          }
        },
        {
          //index这个文档已经存在，会覆盖
          "index": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "6",
            "_version": 3,
            "result": "updated",
            "_shards": {
              "total": 2,
              "successful": 1,
              "failed": 0
            },
            "_seq_no": 6,
            "_primary_term": 5,
            "status": 200
          }
        },
        {
          //删除  
          "delete": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "1",
            "_version": 1,
            "result": "not_found",
            "_shards": {
              "total": 2,
              "successful": 1,
              "failed": 0
            },
            "_seq_no": 4,
            "_primary_term": 5,
            "status": 404
          }
        },
        {
          //修改  
          "update": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "3",
            "_version": 3,
            "result": "noop",
            "_shards": {
              "total": 2,
              "successful": 1,
              "failed": 0
            },
            "status": 200
          }
        }
      ]
    }

复制代码

`bulk`请求不是原子操作，它们不能实现事务。每个请求操作时分开的，所以每个请求的成功与否不干扰其它操作
    
    #### 12\. `fuzzy`查询
    
    模糊查询，`fuzzy` 查询会计算与关键词的拼写相似程度

GET /ad/phone/_search
    {
      "query": {
        "fuzzy": {
          "color":{
            "value": "res"
            , "fuzziness": 2,
            "prefix_length": 1
          }
        }
      }
    }

复制代码

参数设置：
    
    `fuzziness`：最大编辑距离，默认为`AUTO`
    
    `prefix_length`：不会“模糊化”的初始字符数。这有助于减少必须检查的术语数量，默认为`0`
    
    `max_expansions`：`fuzzy`查询将扩展到 的最大术语数。默认为`50`，设置小，有助于优化查询
    
    `transpositions`：是否支持模糊转置（`ab`→ `ba`），默认是`false`
    
    #### 13\. `wildcard`查询
    
    支持通配符的模糊查询，？匹配单个字符，*匹配任何字符
    
    为了防止极其缓慢通配符查询，`*`或`?`通配符项不应该放在通配符的开始

GET /ad/phone/_search
    {
      "query": {
        "wildcard": {
          "color": "r?d"
        }
      }
    }

复制代码

作者：Python智禅  
链接：https://www.jianshu.com/p/c377477df7fc  
来源：简书  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。