Ruby on rails 在ElasticSearch和Tire中使用缺少过滤器的面

我试图将facets用于包含缺少的过滤器的搜索查询，但它似乎没有考虑将使用缺少的过滤器过滤掉的记录

在Rails应用程序中：

@items = Item.search(per_page: 100, page: params[:page], load: true) do |search|
  search.query do |query|
    query.boolean do |boolean|
      boolean.must { |must| must.string params[:q], default_operator: "AND" }
      boolean.must { |must| must.term :project_id, @project.id }
    end
    query.filtered do
      filter :missing , :field =>  :user_id
    end
  end
  search.facet('tags') do
    terms :tag
  end
end

生成请求：

curl -X GET 'http://localhost:9200/items/user_story/item?load=true&size=100&pretty' -d '{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "*",
            "default_operator": "AND"
          }
        },
        {
          "term": {
            "project_id": {
              "term": 132
            }
          }
        }
      ]
    },
    "filtered": {
      "filter": {
        "and": [
          {
            "missing": {
              "field": "user_id"
            }
          }
        ]
      }
    }
  },
  "facets": {
    "tags": {
      "terms": {
        "field": "tag",
        "size": 10,
        "all_terms": false
      }
    }
  },
  "size": 100
}'

curl -X GET 'http://localhost:9200/user_stories/user_story/_search?load=true&size=100&pretty' -d '{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "*",
            "default_operator": "AND"
          }
        },
        {
          "term": {
            "project_id": {
              "term": 132
            }
          }
        }
      ]
    }
  },
  "facets": {
    "tags": {
      "terms": {
        "field": "tag",
        "size": 10,
        "all_terms": false
      }
    }
  },
  "filter": {
    "missing": {
      "field": "user_id"
    }
  },
  "size": 100
}'

对于面，它具有

nil

如果我将缺少的筛选器移出search.filter

@items = Item.search(per_page: 100, page: params[:page], load: true) do |search|
  search.query do |query|
    query.boolean do |boolean|
      boolean.must { |must| must.string params[:q], default_operator: "AND" }
      boolean.must { |must| must.term :project_id, @project.id }
    end
  end
  search.filter(:missing, :field => 'user_id' )
  search.facet('tags') do
    terms :tag
  end
end

……它提出以下请求：

curl -X GET 'http://localhost:9200/items/user_story/item?load=true&size=100&pretty' -d '{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "*",
            "default_operator": "AND"
          }
        },
        {
          "term": {
            "project_id": {
              "term": 132
            }
          }
        }
      ]
    },
    "filtered": {
      "filter": {
        "and": [
          {
            "missing": {
              "field": "user_id"
            }
          }
        ]
      }
    }
  },
  "facets": {
    "tags": {
      "terms": {
        "field": "tag",
        "size": 10,
        "all_terms": false
      }
    }
  },
  "size": 100
}'

curl -X GET 'http://localhost:9200/user_stories/user_story/_search?load=true&size=100&pretty' -d '{
  "query": {
    "bool": {
      "must": [
        {
          "query_string": {
            "query": "*",
            "default_operator": "AND"
          }
        },
        {
          "term": {
            "project_id": {
              "term": 132
            }
          }
        }
      ]
    }
  },
  "facets": {
    "tags": {
      "terms": {
        "field": "tag",
        "size": 10,
        "all_terms": false
      }
    }
  },
  "filter": {
    "missing": {
      "field": "user_id"
    }
  },
  "size": 100
}'

它确实得到了方面，但没有考虑过滤记录

---

有没有其他方法可以让我编写查询，这样我就可以得到同时考虑到缺少的筛选器的facet？

如果我理解正确，您遇到的问题是facet是根据查询限制的结果计算的，而不是由顶级

筛选器

元素计算的。而且，第一个查询在我看来并不正确

我会像这样重写请求：

require 'tire'

params = {:q => 'foo'}

s = Tire.search do |search|
  search.query do |search_query|
    search_query.filtered do |f|

      # Queries
      f.query do |q|
        q.string params[:q], default_operator: "AND"
      end

      # Filters
      f.filter :missing , :field => :user_id
      f.filter :term,     :project_id => '123'
    end
  end
  search.facet('tags') do
    terms :tag
  end
end

puts s.to_curl

基本上，我们使用

filtered

查询作为主查询，摆脱了布尔查询，并使用

filter

实现最大效率（缺失和术语）

当然，如果需要执行更多查询，可以使用

q.boolean

而不是

q.string

---

最后，

string

查询（即Lucene查询字符串查询）通常是常规搜索的次优选择，因为它向用户展示了整个“特殊Lucene语法”，并且容易出错。

match

查询通常是更好的选择。

感谢您的回复。今天晚些时候我会试试这个。