当前位置：首页 > news >正文

elasticsearch Query DSL(三)

news 来源：原创 2024/5/4 10:03:31

2019独角兽企业重金招聘Python工程师标准>>>

本文参考官方提供api提炼出来的

https://www.elastic.co/guide/en/elasticsearch/reference/current/search.html

Compound Queries

复合查询包装其他复合或叶子查询，以组合其结果和分数，更改其行为，或从查询切换到筛选器上下文。

Constant Score Query

一个包装另一个查询的查询，只返回一个等于筛选器中每个文档的查询提升的常量分数。

GET /_search
{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "user" : "kimchy"}
            },
            "boost" : 1.2
        }
    }
}

Bool Query

用于组合多个叶或化合物查询子句，作为默认查询 must，should，must_not，或filter条款。在must和should 条款有他们的分数相结合-更匹配的条款，更好的-而must_not和filter条款在过滤器上下文中执行。

发生	描述
`must`	子句（查询）必须出现在匹配的文档中，并有助于得分。
`filter`	子句（查询）必须出现在匹配的文档中。但是不同于 `must`查询的分数将被忽略。过滤器子句在过滤器上下文中执行，这意味着忽略评分并考虑使用子句进行高速缓存。
`should`	子句（查询）应出现在匹配的文档中。如果 `bool`查询位于查询上下文中并且具有`must`or`filter`子句，则`bool`即使没有 `should`查询匹配，文档也将与查询匹配。在这种情况下，这些条款仅用于影响分数。如果`bool`查询是过滤器上下文，或者既没有`must`或者`filter`至少有一个`should`查询必须与文档匹配，以便与`bool`查询匹配。可以通过设置`minimum_should_match`参数来显式控制此行为。
`must_not`	子句（查询）不得出现在匹配的文档中。子句在过滤器上下文中执行，这意味着忽略评分并考虑使用子句进行高速缓存。由于忽略了评分，因此`0`会返回所有文档的分数。

GET _search
{
  "query": {
    "bool": {
      "must": {
        "match_all": {}
      },
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

等价

GET _search
{
  "query": {
    "constant_score": {
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

Dis Max Query

一个接受多个查询的查询，并返回与任何查询子句匹配的任何文档。当bool查询组合来自所有匹配查询的分数时，dis_max查询使用单个最佳匹配查询子句的分数。

GET /_search
{
    "query": {
        "dis_max" : {
            "tie_breaker" : 0.7,
            "boost" : 1.2,
            "queries" : [
                {
                    "term" : { "age" : 34 }
                },
                {
                    "term" : { "age" : 35 }
                }
            ]
        }
    }
}

Function Score Query

function_score允许你修改的由查询检索文档的分数。

要使用function_score，用户必须定义查询和一个或多个函数，这些函数计算查询返回的每个文档的新分数。

GET /_search
{
    "query": {
        "function_score": {
            "query": { "match_all": {} },
            "boost": "5",
            "random_score": {},
            "boost_mode":"multiply"
        }
    }
}

GET /_search
{
    "query": {
        "function_score": {
          "query": { "match_all": {} },
          "boost": "5",
          "functions": [
              {
                  "filter": { "match": { "test": "bar" } },
                  "random_score": {},
                  "weight": 23
              },
              {
                  "filter": { "match": { "test": "cat" } },
                  "weight": 42
              }
          ],
          "max_boost": 42,
          "score_mode": "max",
          "boost_mode": "multiply",
          "min_score" : 42
        }
    }
}

每个文档都由定义的函数评分。该参数 score_mode指定计算得分的组合方式：

`multiply`	分数乘以（默认）
`sum`	得分总和
`avg`	分数是平均的
`first`	应用具有匹配过滤器的第一个函数
`max`	使用最高分
`min`	使用最低分数

该参数boost_mode定义：

`multiply`	查询得分和功能得分相乘（默认）
`replace`	仅使用功能得分，忽略查询得分
`sum`	查询得分和功能得分被添加
`avg`	平均
`max`	最大查询分数和功能分数
`min`	最小查询得分和功能得分

script_score函数允许您使用脚本表达式包装另一个查询并使用从doc中其他数字字段值派生的计算来自定义它的评分。

GET /_search
{
    "query": {
        "function_score": {
            "query": {
                "match": { "message": "elasticsearch" }
            },
            "script_score" : {
                "script" : {
                  "source": "Math.log(2 + doc['likes'].value)"
                }
            }
        }
    }
}

field_value_factor功能允许您使用文档中的字段来影响分数。它与使用该script_score函数类似，但它避免了脚本的开销。如果在多值字段上使用，则仅在计算中使用该字段的第一个值。

GET /_search
{
    "query": {
        "function_score": {
            "field_value_factor": {
                "field": "likes",
                "factor": 1.2,
                "modifier": "sqrt",
                "missing": 1
            }
        }
    }
}

这将转化为以下评分公式：

sqrt(1.2 * doc['likes'].value)

该功能有多种选择field_value_factor：

`field`	要从文档中提取的字段。
`factor`	将字段值乘以的可选因子，默认为`1`。
`modifier`	修改适用于该字段的值，可以是一个：`none`，`log`， `log1p`，`log2p`，`ln`，`ln1p`，`ln2p`，`square`，`sqrt`，或`reciprocal`。默认为`none`。

修改	含义
`none`	不要对字段值应用任何乘数
`log`	取字段值的常用对数
`log1p`	将1添加到字段值并采用常用对数
`log2p`	将2添加到字段值并采用常用对数
`ln`	取字段值的自然对数
`ln1p`	将1添加到字段值并采用自然对数
`ln2p`	将2添加到字段值并采用自然对数
`square`	平方字段值（乘以它自己）
`sqrt`	取字段值的平方根
`reciprocal`	报答字段值，同`1/x`那里`x`是该字段的值

missing

如果文档没有该字段，则使用的值。修饰符和因子仍然应用于它，就像从文档中读取一样。

Boosting Ｑuery

返回与positive查询匹配的文档，但减少与negative查询匹配的文档的分数。

GET /_search
{
    "query": {
        "boosting" : {
            "positive" : {
                "term" : {
                    "field1" : "value1"
                }
            },
            "negative" : {
                 "term" : {
                     "field2" : "value2"
                }
            },
            "negative_boost" : 0.2
        }
    }
}

Joining Queries

Nested Query

嵌套查询允许查询嵌套对象/文档

GET /_search
{
    "query": {
        "nested" : {
            "path" : "obj1",
            "score_mode" : "avg",
            "query" : {
                "bool" : {
                    "must" : [
                    { "match" : {"obj1.name" : "blue"} },
                    { "range" : {"obj1.count" : {"gt" : 5}} }
                    ]
                }
            }
        }
    }
}

Ｈas Child Query

has_child过滤器接受查询和子类型针对其运行，并导致具有子文档与查询匹配的父文件。

GET /_search
{
    "query": {
        "has_child" : {
            "type" : "blog_tag",
            "query" : {
                "term" : {
                    "tag" : "something"
                }
            }
        }
    }
}

has_child也有得分支持。支持的得分模式min，max，sum，avg或none。默认值为 noneand，产生与先前版本相同的行为。如果将得分模式设置为除了之外的其他值none，则将所有匹配的子文档的得分聚合到关联的父文档中。

GET /_search
{
    "query": {
        "has_child" : {
            "type" : "blog_tag",
            "score_mode" : "min",
            "query" : {
                "term" : {
                    "tag" : "something"
                }
            }
        }
    }
}

Ｈas Parent Query

该has_parent查询接受查询和父类型。查询在父文档空间中执行，该父文档空间由父类型指定。此查询返回关联父项已匹配的子文档。对于其余has_parent查询具有相同的选项，其工作方式与has_child查询相同。

GET /_search
{
    "query": {
        "has_parent" : {
            "parent_type" : "blog",
            "score" : true,
            "query" : {
                "term" : {
                    "tag" : "something"
                }
            }
        }
    }
}

Parent Id Query

parent_id查询可用于查找属于特定父级的子文档。

GET /my_index/_search
{
  "query": {
    "parent_id": {
      "type": "my_child",
      "id": "1"
    }
  }
}

此查询有两个必需参数：

`type`	该子类型名称，在指定的`join`领域。
`id`	父文档的ID。
`ignore_unmapped`	设置为`true`this时将忽略未映射，`type`并且不匹配此查询的任何文档。在查询可能具有不同映射的多个索引时，这非常有用。设置为`false`（默认值）时，如果`type`未映射，查询将引发异常。