弹性搜索范围和术语过滤器的组合

Question

我想要一个过滤器来返回带're_max' > 100和的文件language_id = 28.我是这样做的:

{
  "query": {
    "filtered": {
      "filter": {
        "range": {
          "re_max": {
            "gt": 100
          }
        },
        "term": {
          "language_id": 28
        }
      }
    }
  }
}

但似乎不正确.我应该怎么纠正呢？
这是错误:

{
  "error": "SearchPhaseExecutionException[Failed to execute phase [query], all shards failed; 
            shardFailures {[WkgqspjtQzmPkW-YdvE1Qg][rep][0]: SearchParseException[[rep][0]: 
              from[-1],size[-1]: 
              Parse Failure [Failed to parse source [
                {
                  "query": {
                    "filtered": {
                      "filter": {
                        "or": [
                          "range":
                          {
                            "re_max": {
                              "gt": 100
                            }
                          },
                          "term":
                          {
                            "language_id": 28
                          }
                        ]
                      }
                    }
                  }
                }
              ]]]; 
            nested: QueryParsingException[[rep] Failed to parse]; 
            nested: JsonParseException[Unexpected character (':' (code 58)): 
              was expecting comma to separate ARRAY entries\n at [Source: [B@3d44a542; line: 6, column: 19]]; }{[WkgqspjtQzmPkW-YdvE1Qg][rep][4]: 
              SearchParseException[[rep][4]: from[-1],size[-1]: 
                Parse Failure [Failed to parse source [
                  {
                    "query": {
                      "filtered": {
                        "filter": {
                          "or": [
                            "range":
                            {
                              "re_max": {
                                "gt": 100
                              }
                            },
                            "term":
                            {
                              "language_id": 28
                            }
                          ]
                        }
                      }
                    }
                  }
                ]]]; 
              nested: QueryParsingException[[rep] Failed to parse]; 
              nested: JsonParseException[Unexpected character (':' (code 58)): 
                was expecting comma to separate ARRAY entries\n at [Source: [B@3d44a542; line: 6, column: 19]]; }{[WkgqspjtQzmPkW-YdvE1Qg][rep][3]: 
                SearchParseException[[rep][3]: from[-1],size[-1]: 
                  Parse Failure [Failed to parse source [
                    {
                      "query": {
                        "filtered": {
                          "filter": {
                            "or": [
                              "range":
                              {
                                "re_max": {
                                  "gt": 100
                                }
                              },
                              "term":
                              {
                                "language_id": 28
                              }
                            ]
                          }
                        }
                      }
                    }
                  ]]]; 
                nested: QueryParsingException[[rep] Failed to parse]; 
                nested: JsonParseException[Unexpected character (':' (code 58)): 
                  was expecting comma to separate ARRAY entries\n at [Source: [B@3d44a542; line: 6, column: 19]]; }{[WkgqspjtQzmPkW-YdvE1Qg][rep][2]: 
                  SearchParseException[[rep][2]: from[-1],size[-1]: 
                    Parse Failure [Failed to parse source [
                      {
                        "query": {
                          "filtered": {
                            "filter": {
                              "or": [
                                "range":
                                {
                                  "re_max": {
                                    "gt": 100
                                  }
                                },
                                "term":
                                {
                                  "language_id": 28
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]]]; 
                  nested: QueryParsingException[[rep] Failed to parse]; 
                  nested: JsonParseException[Unexpected character (':' (code 58)): 
                    was expecting comma to separate ARRAY entries\n at [Source: [B@3d44a542; line: 6, column: 19]]; }{[WkgqspjtQzmPkW-YdvE1Qg][rep][1]: 
                    SearchParseException[[rep][1]: from[-1],size[-1]: 
                      Parse Failure [Failed to parse source [
                        {
                          "query": {
                            "filtered": {
                              "filter": {
                                "or": [
                                  "range":
                                  {
                                    "re_max": {
                                      "gt": 100
                                    }
                                  },
                                  "term":
                                  {
                                    "language_id": 28
                                  }
                                ]
                              }
                            }
                          }
                        }
                      ]]]; 
                    nested: QueryParsingException[[rep] Failed to parse]; 
                    nested: JsonParseException[Unexpected character (':' (code 58)): 
                      was expecting comma to separate ARRAY entries\n at [Source: [B@3d44a542; line: 6, column: 19]]; }]",
  "status": 400
}

Answer 1

"已过滤"查询在2.0中已弃用,在5.0中 已删除

可以使用Elasticsearch 5和6 过滤器:

{
  "query": { 
    "bool": { 
      "filter": [ 
        { "term":  { "language_id": 28  }},
        { "term":  { "some_other_term": "some string value"}},
        { "range": { "created_at_timestamp": { "gt": "2015-01-01" }}} 
      ]
    }
  }
}

Answer 2

你不是被过滤查询混淆的第一个人:)

 {
  "query": {
    "filtered": {
      "query": {
        "term": {
          "language_id": 28
        }
      },
      "filter": {
        "range": {
          "re_max": {
          "gt": 100
          }
        }
      }
    }
  }
}

更新:如果要将两个条件用作组合过滤器,可以将它们与bool或和filter连接,并完全省略查询部分.示例and如下:

{
    "query":{
        "filtered":{
            "filter":{
                "and":[
                    {
                        "range":{
                            "re_max":{
                                "gt":100
                            }
                        }
                    },
                    {
                        "term":{
                            "language_id":28
                        }
                    }
                ]
            }
        }
    }
}