不正经

这个屌丝很懒，什么也没留下！

热门标签

Elasticsearch搜索引擎第十篇-Query DSL详解_es dsl match_phrase_prefix能多字段吗

作者：不正经 | 2024-05-07 04:18:36

踩

es dsl match_phrase_prefix能多字段吗

官网介绍链接： https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html

DSL介绍

Domain Specific Language：领域特定语言

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

一个查询可由两部分字句构成：

Leaf query clauses 叶子查询字句：Leaf query clauses 在指定的字段上查询指定的值, 如：match, term or range queries. 叶子字句可以单独使用.
Compound query clauses 复合查询字句：以逻辑方式组合多个叶子、复合查询为一个查询

一个查询字句的行为取决于它是用在query context 还是 filter context 中：

Query context 查询上下文：用在查询上下文中的字句回答“这个文档有多匹配这个查询?”。除了决定文档是否匹配，字句匹配的文档还会计算一个字句评分，来评定文档有多匹配，会参与相关性评分。查询上下文由 query 元素表示。
Filter context 过滤上下文：过滤上下文由 filter 元素或 bool 中的 must not 表示。用在过滤上下文中的字句回答“这个文档是否匹配这个查询？”，不参与相关性评分。被频繁使用的过滤器将被ES自动缓存，来提高查询性能。

如下语句：

GET /_search
{
  "query": { 
    "bool": { 
      "must": [
        { "match": { "title":   "Search"        }}, 
        { "match": { "content": "Elasticsearch" }}  
      ],
      "filter": [ 
        { "term":  { "status": "published" }}, 
        { "range": { "publish_date": { "gte": "2015-01-01" }}} 
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

query负责在查询上下文中使用查询字句来表示影响匹配文档得分的条件，filter负责在过滤上下文中使用所有其他查询字句

Match all query

查询所有

GET /_search
{
    "query": {
        "match_all": {}
    }
}

GET /_search
{
    "query": {
        "match_none": {}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

全文查询

官网：https://www.elastic.co/guide/en/elasticsearch/reference/current/full-text-queries.html

全文查询，用于对分词的字段进行搜索。会用查询字段的分词器对查询的文本进行分词生成查询。可用于短语查询、模糊查询、前缀查询、临近查询等查询场景。

match query

全文查询的标准查询，它可以对一个字段进行模糊、短语查询。 match queries 接收 text/numerics/dates, 对它们进行分词分析, 再组织成一个boolean查询。可通过operator 指定bool组合操作（or、and 默认是 or ），以及minimum_should_match 指定至少需多少个should(or)字句需满足。还可用ananlyzer指定查询用的特殊分析器。

GET /_search
{
    "query": {
        "match" : {
            "message" : "this is a test"  #message是字段名
        }
    }
}
1
2
3
4
5
6
7
8

新增两个文档：

PUT /ftq/_doc/1
{
  "title": "lucene solr and elasticsearch",
  "content": "lucene solr and elasticsearch for search"
}

PUT /ftq/_doc/2
{
  "title": "java spring boot",
  "content": "lucene is writerd by java"
}
1
2
3
4
5
6
7
8
9
10
11

执行查询：

GET ftq/_search
{
  "query": {
    "match": {
      "title": "lucene java"  #分词后用or
    }
  }
}

GET ftq/_search
{
  "query": {
    "match": {
      "title": {
        "query": "lucene java",
        "operator": "and"  #指定分词后用and
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

模糊查询，可以指定fuzziness最大编辑数

最大编辑数为2，说明query字符串中分词后，每个词允许编辑两次单个字符，可删除、新增、修改字符
fuzziness 参数可以被设置为 AUTO，此时字符串只有 1 到 2 个字符时是 0；字符串有 3 、4 或者 5 个字符时是 1；字符串大于 5 个字符时是 2
有时编辑距离 2 仍然是太多了，返回的结果似乎并不相关。把最大 fuzziness 设置为 1 ，可以得到更好的结果和更好的性能

GET ftq/_search
{
  "query": {
    "match": {
      "title": {
        "query": "ucen elatic",
        "fuzziness": 2
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

关于模糊查询fuzziness的说明，可以参看：https://www.elastic.co/guide/cn/elasticsearch/guide/current/fuzziness.html

还可以使用minimum_should_match指定最少需要满足几个词匹配：

GET ftq/_search
{
  "query": {
    "match": {
      "content": {
        "query": "ucen elatic java",
        "fuzziness": 2,
        "minimum_should_match": 2
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

还可用max_expansions 指定模糊匹配的最大词项数，默认是50。比如：反向索引中有 100 个词项与 ucen 模糊匹配，只选用前50 个。

GET ftq/_search
{
  "query": {
    "match": {
      "content": {
        "query": "ucen elatic java",
        "fuzziness": 2,
        "minimum_should_match": 2,
        "max_expansions ": 50
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

match phrase query

match_phrase 查询用来对一个字段进行短语查询，可以指定 analyzer、slop移动因子。

GET ftq/_search
{
  "query": {
    "match_phrase": {
      "title": "lucene solr"
    }
  }
}

GET ftq/_search
{
  "query": {
    "match_phrase": {
      "title": {
        "query": "lucene elasticsearch",
        "slop": 2
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

match phrase prefix query

match_phrase_prefix 在 match_phrase 的基础上支持对短语的最后一个词进行前缀匹配

查询f开头的：

GET /_search
{
    "query": {
        "match_phrase_prefix" : {
            "message" : "quick brown f"
        }
    }
}
1
2
3
4
5
6
7
8

指定前缀匹配选用的最大词项数量：

GET /_search
{
    "query": {
        "match_phrase_prefix" : {
            "message" : {
                "query" : "quick brown f",
                "max_expansions" : 10
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

multi match query

如果你需要在多个字段上进行文本搜索，可用multi_match 。multi_match在 match的基础上支持对多个字段进行文本查询。

GET ftq/_search
{
  "query": {
    "multi_match" : {
      "query":    "lucene java", 
      "fields": [ "title", "content" ] 
    }
  }
}
1
2
3
4
5
6
7
8
9

还可以使用*匹配多个字段：

GET ftq/_search
{
  "query": {
    "multi_match" : {
      "query":    "lucene java", 
      "fields": [ "title", "cont*" ] 
    }
  }
}
1
2
3
4
5
6
7
8
9

query string query

query_string 查询，让我们可以直接用lucene查询语法写一个查询串进行查询，ES中接到请求后，通过查询解析器解析查询串生成对应的查询。使用它要求掌握lucene的查询语法。

GET /_search
{
    "query": {
        "query_string" : {
            "default_field" : "content",
            "query" : "this AND that OR thus"
        }
    }
}

GET /_search
{
    "query": {
        "query_string" : {
            "fields" : ["content", "name"],
            "query" : "this AND that OR thus"
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

可与query同用的参数，如 default_field、fields，及query 串的语法请参考：
https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html

simple query string query

simple_query_string 查同 query_string 查询一样用lucene查询语法写查询串，较query_string不同的地方：更小的语法集；查询串有错误，它会忽略错误的部分，不抛出错误。更适合给用户使用。

GET /_search
{
  "query": {
    "simple_query_string" : {
        "query": "\"fried eggs\" +(eggplant | potato) -frittata",
        "fields": ["title^5", "body"],
        "default_operator": "and"
    }
  }
}
1
2
3
4
5
6
7
8
9
10

语法请参考：
https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-simple-query-string-query.html

词项查询

官网：https://www.elastic.co/guide/en/elasticsearch/reference/current/term-level-queries.html

term query

term 查询用于查询指定字段包含某个词项的文档。

POST _search
{
  "query": {
    "term" : { "user" : "Kimchy" } 
  }
}
1
2
3
4
5
6

terms query

terms 查询用于查询指定字段包含某些词项的文档。

GET /_search
{
    "query": {
        "terms" : { "user" : ["kimchy", "elasticsearch"]}
    }
}
1
2
3
4
5
6

Terms 查询支持嵌套查询的方式来获得查询词项，相当于 in (select term from other)

PUT /users/_doc/2
{
    "followers" : ["1", "3"]
}

PUT /tweets/_doc/1
{
    "user" : "1"
}

GET /tweets/_search
{
    "query" : {
        "terms" : {
            "user" : {
                "index" : "users",
                "type" : "_doc",
                "id" : "2",
                "path" : "followers"
            }
        }    
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

嵌套查询可用参数说明：
在这里插入图片描述

range query

范围查询

gte：大于等于
gt：大于
lte：小于等于
lt：小于
boost：查询权重

GET _search
{
    "query": {
        "range" : {
            "age" : {
                "gte" : 10,
                "lte" : 20,
                "boost" : 2.0
            }
        }
    }
}

GET _search
{
    "query": {
        "range" : {
            "date" : {
                "gte" : "now-1d/d",  #当前时间减1天后转成天数
                "lt" :  "now/d"  #当前时间转成条数
            }
        }
    }
}

GET _search
{
    "query": {
        "range" : {
            "born" : {
                "gte": "01/01/2012",
                "lte": "2013",
                "format": "dd/MM/yyyy||yyyy"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

时间舍入||说明：

gt：大于的情况下，四舍五入，比如2014-11-18||/M变成2014-11-30T23:59:59:999，不包含整个月
gte：大于等于的情况下，向下取整，比如2014-11-18||/M变成2014-11-01，包含整个月
lt：小于的情况下，向下取整，比如2014-11-18||/M变成2014-11-01，不包含整个月
lte：小于等于的情况下，四舍五入，比如2014-11-18||/M变成2014-11-30T23:59:59:999，包含整个月

时间数学计算规则请参考：
https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#date-math

exits query

查询指定字段值不为空的文档。相当 SQL 中的 column is not null

GET /_search
{
    "query": {
        "exists" : { "field" : "user" }
    }
}
1
2
3
4
5
6

prefix query 词项前缀查询

GET /_search
{ "query": {
    "prefix" : { "user" : "ki" }
  }
}
1
2
3
4
5

wildcard query 通配符查询

GET /_search
{
    "query": {
        "wildcard" : { "user" : "ki*y" }
    }
}

GET /_search
{
  "query": {
    "wildcard": {
      "user": {
        "value": "ki*y",
        "boost": 2
      }
    }
  }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

regexp query 正则查询

GET /_search
{
    "query": {
        "regexp":{
            "name.first": "s.*y"
        }
    }
}

GET /_search
{
    "query": {
        "regexp":{
            "name.first":{
                "value":"s.*y",
                "boost":1.2
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

正则语法参考：https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html#regexp-syntax

fuzzy query 模糊查询

GET /_search
{
    "query": {
       "fuzzy" : { "user" : "ki" }
    }
}

GET /_search
{
    "query": {
        "fuzzy" : {
            "user" : {
                "value": "ki",
                "boost": 1.0,
                "fuzziness": 2,
                "prefix_length": 0,
                "max_expansions": 100
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ids 根据文档id查询

GET /_search
{
    "query": {
        "ids" : {
            "type" : "_doc",
            "values" : ["1", "4", "100"]
        }
    }
}
1
2
3
4
5
6
7
8
9

复合查询

官网：https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html

constant score query

用来包装另一个查询，将查询匹配的文档的评分设为一个常值。

GET /_search
{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "user" : "kimchy"}
            },
            "boost" : 1.2
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

bool query

Bool 查询用bool操作来组合多个查询字句为一个查询。可用的关键字：

must：必须满足
filter：必须满足，但执行的是filter上下文，不参与、不影响评分
should：或
must_not：必须不满足，在filter上下文中执行，不参与、不影响评分

POST _search
{
  "query": {
    "bool" : {
      "must" : {
        "term" : { "user" : "kimchy" }
      },
      "filter": {
        "term" : { "tag" : "tech" }
      },
      "must_not" : {
        "range" : {
          "age" : { "gte" : 10, "lte" : 20 }
        }
      },
      "should" : [
        { "term" : { "tag" : "wow" } },
        { "term" : { "tag" : "elasticsearch" } }
      ],
      "minimum_should_match" : 1,
      "boost" : 1.0
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/547391