Elasticsearch过滤器/计数嵌套字段（elasticsearch 过滤器）

25-03-22 6

想了解Elasticsearch过滤器/计数嵌套字段的新动态吗？本文将为您提供详细的信息，我们还将为您解答关于elasticsearch过滤器的相关问题，此外，我们还将为您介绍关于DjangoElas

想了解Elasticsearch过滤器/计数嵌套字段的新动态吗？本文将为您提供详细的信息，我们还将为您解答关于elasticsearch 过滤器的相关问题，此外，我们还将为您介绍关于Django Elasticsearch中的递归嵌套字段、Elastic Search中嵌套字段的术语聚合、Elasticsearch 2.4，对嵌套对象不起作用存在过滤器、Elasticsearch nested 嵌套字段排序（qbit）的新知识。

本文目录一览：

Elasticsearch过滤器/计数嵌套字段（elasticsearch 过滤器）
Django Elasticsearch中的递归嵌套字段
Elastic Search中嵌套字段的术语聚合
Elasticsearch 2.4，对嵌套对象不起作用存在过滤器
Elasticsearch nested 嵌套字段排序（qbit）

Elasticsearch过滤器/计数嵌套字段（elasticsearch 过滤器）

我有带有嵌套字段的文档，如下所示：

..."results": [  {    "id": "1234",    "name": "asdf"  },  {    "id": "5678",    "name": "jklö"  }],"ip": "1.2.3.4"...

嵌套字段的映射如下所示：

"results": {  "type": "nested",  "properties": {    "id": {      "type": "string"    },    "name": {      "type": "string"    }  }}

在切换到elasticsearch 2之前，我有一个带有aggs的查询，该查询计算了没有结果的文档。这是查询的聚合部分：

"aggs": {  "no_result": {    "filter": {      "missing": {        "field": "results"      }    },    "aggs": {      "count": {        "value_count": {          "field": "ip"        }      }    }  }}

现在我切换到elasticserach 2，它只计算所有文档。我已经尝试过其他操作，例如计算所有文档和计算结果，以便可以减去结果，但是

"aggs": {  "results_count": {    "value_count": {      "field": "results"    }  }}

总是0

如何正确过滤/计数嵌套字段？

答案1

小编典典

如果您要计算产生结果的文档数量，可以执行此操作。

{  "size": 0,  "aggs": {    "count": {      "nested": {        "path": "results"      },      "aggs": {        "top_reverse_nested": {          "reverse_nested": {}        }      }    }  }}

数字计数将在top_reserve_nested doc_count中

Django Elasticsearch中的递归嵌套字段

如何解决Django Elasticsearch中的递归嵌套字段？

我正在为我的Web应用程序使用django rest框架

假设我想在这样的模型中存储家谱层次结构：

People（models.Model）

parent = models.ForeignKey(''self'',on_delete=models.SET_NULL,blank=True,null=True,related_name=''children'')

name = models.CharField(default="",max_length=100)

我做了这样的索引：

people = Index(''people'')

people.settings(
    number_of_shards=1,number_of_replicas=0
) 

@registry.register_document
@people.document
class PeopleDocument(Document):
    children = fields.nestedField(properties={
        ''name'': fields.TextField()
    })
    class Django:
        model = People
        fields = [
            ''id'',''name''
        ]
        related_models = [People]

    def get_instances_from_related(self,people_instance):
        return people_instance.parent

我得到了一个很好的结果，在我的Elasticsearch中，现在我有了每个家庭成员以及他们的孩子清单。但是问题是深度只有1，并且我不能有孙子孙辈，甚至没有其他用户，例如树尾的递归嵌套字段。

对此有什么解决办法吗？

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）

Elastic Search中嵌套字段的术语聚合

我在elasticsearch（YML中的定义）中具有字段的下一个映射：

              my_analyzer:                  type: custom                  tokenizer:  keyword                  filter: lowercase               products_filter:                    type: "nested"                    properties:                        filter_name: {"type" : "string", analyzer: "my_analyzer"}                        filter_value: {"type" : "string" , analyzer: "my_analyzer"}

每个文档都有很多过滤器，看起来像：

"products_filter": [{"filter_name": "Rahmengröße","filter_value": "33,5 cm"},{"filter_name": "color","filter_value": "gelb"},{"filter_name": "Rahmengröße","filter_value": "39,5 cm"},{"filter_name": "Rahmengröße","filter_value": "45,5 cm"}]

我试图获取唯一过滤器名称的列表以及每个过滤器的唯一过滤器值的列表。

我的意思是，我想获得结构是怎样的：Rahmengröße：
39.5厘米
45.5厘米
33.5厘米
颜色：
盖尔布

为了得到它，我尝试了几种聚合的变体，例如：

{  "aggs": {    "bla": {      "terms": {        "field": "products_filter.filter_name"      },      "aggs": {        "bla2": {          "terms": {            "field": "products_filter.filter_value"          }        }      }    }  }}

这个请求是错误的。

它将为我返回唯一过滤器名称的列表，并且每个列表将包含所有filter_values的列表。

"bla": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 103,"buckets": [{"key": "color","doc_count": 9,"bla2": {"doc_count_error_upper_bound": 4,"sum_other_doc_count": 366,"buckets": [{"key": "100","doc_count": 5},{"key": "cm","doc_count": 5},{"key": "unisex","doc_count": 5},{"key": "11","doc_count": 4},{"key": "160","doc_count": 4},{"key": "22","doc_count": 4},{"key": "a","doc_count": 4},{"key": "alu","doc_count": 4},{"key": "aluminium","doc_count": 4},{"key": "aus","doc_count": 4}]}},

另外，我尝试使用反向嵌套聚合，但这对我没有帮助。

所以我认为我的尝试有逻辑上的错误吗？

答案1

小编典典

如我所说。您的问题是您的文本被分析，elasticsearch总是在令牌级别聚合。因此，为了解决该问题，必须将字段值索引为单个标记。有两种选择：

不分析它们
使用关键字分析器+小写（不区分大小写的aggs）为它们编制索引

因此，将使用小写过滤器并删除重音符号（ö => o以及ß =>ss您的字段的其他字段，以创建自定义关键字分析器）来进行设置，以便将它们用于聚合（raw和keyword）：

PUT /test{  "settings": {    "analysis": {      "analyzer": {        "my_analyzer_keyword": {          "type": "custom",          "tokenizer": "keyword",          "filter": [            "asciifolding",            "lowercase"          ]        }      }    }  },  "mappings": {    "data": {      "properties": {        "products_filter": {          "type": "nested",          "properties": {            "filter_name": {              "type": "string",              "analyzer": "standard",              "fields": {                "raw": {                  "type": "string",                  "index": "not_analyzed"                },                "keyword": {                  "type": "string",                  "analyzer": "my_analyzer_keyword"                }              }            },            "filter_value": {              "type": "string",              "analyzer": "standard",              "fields": {                "raw": {                  "type": "string",                  "index": "not_analyzed"                },                "keyword": {                  "type": "string",                  "analyzer": "my_analyzer_keyword"                }              }            }          }        }      }    }  }}

测试文件，您给了我们：

PUT /test/data/1{  "products_filter": [    {      "filter_name": "Rahmengröße",      "filter_value": "33,5 cm"    },    {      "filter_name": "color",      "filter_value": "gelb"    },    {      "filter_name": "Rahmengröße",      "filter_value": "39,5 cm"    },    {      "filter_name": "Rahmengröße",      "filter_value": "45,5 cm"    }  ]}

这将是查询以使用raw字段进行汇总：

GET /test/_search{  "size": 0,  "aggs": {    "Nesting": {      "nested": {        "path": "products_filter"      },      "aggs": {        "raw_names": {          "terms": {            "field": "products_filter.filter_name.raw",            "size": 0          },          "aggs": {            "raw_values": {              "terms": {                "field": "products_filter.filter_value.raw",                "size": 0              }            }          }        }      }    }  }}

它确实带来了预期的结果（带有过滤器名称的存储桶和带有其值的子存储桶）：

{  "took": 1,  "timed_out": false,  "_shards": {    "total": 5,    "successful": 5,    "failed": 0  },  "hits": {    "total": 1,    "max_score": 0,    "hits": []  },  "aggregations": {    "Nesting": {      "doc_count": 4,      "raw_names": {        "doc_count_error_upper_bound": 0,        "sum_other_doc_count": 0,        "buckets": [          {            "key": "Rahmengröße",            "doc_count": 3,            "raw_values": {              "doc_count_error_upper_bound": 0,              "sum_other_doc_count": 0,              "buckets": [                {                  "key": "33,5 cm",                  "doc_count": 1                },                {                  "key": "39,5 cm",                  "doc_count": 1                },                {                  "key": "45,5 cm",                  "doc_count": 1                }              ]            }          },          {            "key": "color",            "doc_count": 1,            "raw_values": {              "doc_count_error_upper_bound": 0,              "sum_other_doc_count": 0,              "buckets": [                {                  "key": "gelb",                  "doc_count": 1                }              ]            }          }        ]      }    }  }}

另外，您可以将field与关键字分析器（以及一些规范化）结合使用，以获得更通用且不区分大小写的结果：

GET /test/_search{  "size": 0,  "aggs": {    "Nesting": {      "nested": {        "path": "products_filter"      },      "aggs": {        "keyword_names": {          "terms": {            "field": "products_filter.filter_name.keyword",            "size": 0          },          "aggs": {            "keyword_values": {              "terms": {                "field": "products_filter.filter_value.keyword",                "size": 0              }            }          }        }      }    }  }}

结果就是：

{  "took": 1,  "timed_out": false,  "_shards": {    "total": 5,    "successful": 5,    "failed": 0  },  "hits": {    "total": 1,    "max_score": 0,    "hits": []  },  "aggregations": {    "Nesting": {      "doc_count": 4,      "keyword_names": {        "doc_count_error_upper_bound": 0,        "sum_other_doc_count": 0,        "buckets": [          {            "key": "rahmengrosse",            "doc_count": 3,            "keyword_values": {              "doc_count_error_upper_bound": 0,              "sum_other_doc_count": 0,              "buckets": [                {                  "key": "33,5 cm",                  "doc_count": 1                },                {                  "key": "39,5 cm",                  "doc_count": 1                },                {                  "key": "45,5 cm",                  "doc_count": 1                }              ]            }          },          {            "key": "color",            "doc_count": 1,            "keyword_values": {              "doc_count_error_upper_bound": 0,              "sum_other_doc_count": 0,              "buckets": [                {                  "key": "gelb",                  "doc_count": 1                }              ]            }          }        ]      }    }  }}

Elasticsearch 2.4，对嵌套对象不起作用存在过滤器

我的映射是：

"properties": {
  "user": {
    "type": "nested","properties": {
      "id": {
        "type": "integer"
      },"is_active": {
        "type": "boolean","null_value": false
      },"username": {
        "type": "string"
      }
    }
  },

我想获取所有没有user字段的文档。

我试过了：

GET /index/type/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "exists": {
            "field": "user"
          }
        }
      ]
    }
  }
}

返回所有文档。基于ElasticSearch2.x，存在用于嵌套字段的过滤器不起作用的问题，我也尝试过：

GET /index/type/_search
{
  "query": {
    "nested": {
      "path": "user","query": {
        "bool": {
          "must_not": [
            {
              "exists": {
                "field": "user"
              }
            }
          ]
        }
      }
    }
  }
}

返回0个文档。

使所有缺少该user字段的文档的正确查询是什么？

Elasticsearch nested 嵌套字段排序（qbit）

前言

本文的例子来自铭毅天下，并得到了铭毅天下本人的指导
本文内容对 Elasticsearch 7.17 适用

示例

多商品在不同分类下有不同的排名，取某个分类下的topN
创建 mappings

PUT products
{
  "mappings": {
    "properties": {
      "product_id": {
        "type": "integer"
      },
      "product_name": {
        "type": "keyword"
      },
      "categories": {
        "type": "nested",
        "properties": {
          "category_name": {
            "type": "keyword"
          },
          "rank": {
            "type": "integer"
          }
        }
      }
    }
  }
}

写入样例数据

POST /products/_bulk
{"index":{"_id":1}}
{"product_id":1,"product_name":"智能手机","categories":[{"category_name":"A","rank":1},{"category_name":"B","rank":3},{"category_name":"C","rank":2}]}
{"index":{"_id":2}}
{"product_id":2,"product_name":"耳机","categories":[{"category_name":"A","rank":4},{"category_name":"B","rank":1},{"category_name":"C","rank":3}]}
{"index":{"_id":3}}
{"product_id":3,"product_name":"便携式充电器","categories":[{"category_name":"A","rank":2},{"category_name":"B","rank":5},{"category_name":"C","rank":1}]}
{"index":{"_id":4}}
{"product_id":4,"product_name":"智能手表","categories":[{"category_name":"A","rank":3},{"category_name":"B","rank":2},{"category_name":"C","rank":4}]}

铭毅天下 给的参考查询语句，用到了聚合

GET products/_search
{
  "size": 0,
  "aggs": {
    "filtered_category": {
      "nested": {
        "path": "categories"
      },
      "aggs": {
        "category_name": {
          "filter": {
            "term": {
              "categories.category_name": "A"
            }
          },
          "aggs": {
            "top_products": {
              "top_hits": {
                "size": 3,
                "sort": [
                  {
                    "categories.rank": {
                      "order": "asc"
                    }
                  }
                ]
              }
            }
          }
        }
      }
    }
  }
}

参考ES nested 字段排序官方示例不用聚合的查询语句

GET products/_search
{
  "sort": [
    {
      "categories.rank": {
        "order": "asc",
        "nested": {
          "path": "categories",
          "filter": {
            "term": {
              "categories.category_name": "A"
            }
          }
        }
      }
    }
  ],
  "size": 3
}