php - 在 Elasticsearch 5 上使用过滤器获取嵌套文档-6ren

php - 在 Elasticsearch 5 上使用过滤器获取嵌套文档

转载作者：行者123 更新时间：2023-12-02 22:30:27

我在 ES 5 中映射了以下文档:

{
   "appName" : {
      "mappings" : {
         "market_audit" : {
            "properties" : {
               "generation_date": {
                  "type": "date"
               },
               "customers" : {
                  "type" : "nested",
                  "properties" : {
                     "customer_id" : {
                        "type" : "integer"
                     },
   [... other properties ...]
}

“customers”节点中的多个条目可能具有相同的 customer_id，我试图仅检索具有特定 customer_id(即“1”)的条目以及顶级文档的“generation_date”(仅最新文件将被处理)。

我能够提出以下查询:

{
  "query": {},
  "sort": [
    { "generation_date": "desc" }
  ],
  "size": 1,
  "aggregations": {
    "nested": {
      "nested": {
        "path": "customers"
      },
      "aggregations": {
        "filter": {
          "filter": {
            "match": {
              "customers.customer_id": {
                "query": "1"
              }
            }
          },
          "aggregations": {
            "tophits_agg": {
              "top_hits": {}
            }
          }
        }
      }
    }
  }
}

这个查询让我获得了我感兴趣的数据，这些数据位于“聚合”数组中(以及包含整个文档的“命中”数组)。这里的问题是我使用的框架(ONGR 的 ElasticSearch 包以及 DSL 包，使用 Symfony3)每次尝试访问没有可用存储桶的实际数据时都会提示。

我已阅读 ES 文档，但无法提出添加存储桶的有效查询。我确定我遗漏了一些东西，一点帮助将非常受欢迎。如果您对如何适本地修改查询有一个想法，我想我可以想出 PHP 代码来生成它。

编辑:由于这个问题得到了一些观点并且没有答案(而且我仍然被困住)，我会接受任何允许我从生成的最新文档中检索有关特定“客户”(使用 customer_id)信息的查询(根据“generation_date”字段)。我给出的查询正是我能够提出的，我很确定有更好的方法来做到这一点。建议可能吗？

编辑2:
这是发送到 ES 的数据:

{
    "index": {
    "_type": "market_data_audit_document"
    }
}
{
    "customers": [
    {
        "customer_id": 1,
        "colocation_name": "colo1",
        "colocation_id": 26,
        "device_name": "device 1",
        "channels": [
        {
            "name": "channel1-5",
            "multicast":"1.2.1.5",
            "sugar_state":4,
            "network_state":1
        }
        ]
    },
    {
        "customer_id":2,
        "colocation_name":"colo2",
        "colocation_id":27,
        "device_name":"device 2",
        "channels": [
        {
            "name":"channel2-5",
            "multicast":"1.2.2.5",
            "sugar_state":4,
            "network_state":1
        }
        ]
    },
    {
        "customer_id":3,
        "colocation_name":"colo3",
        "colocation_id":28,
        "device_name":"device 3",
        "channels": [
        {
            "name":"channel3-5",
            "multicast":"1.2.3.5",
            "sugar_state":4,
            "network_state":1
        }
        ]
    },
    {
        "customer_id":4,
        "colocation_name":"colo4",
        "colocation_id":29,
        "device_name":"device 4"
        ,"channels": [
        {
            "name":"channel4-5",
            "multicast":"1.2.4.5",
            "sugar_state":4,
            "network_state":1
        }
        ]
    },
    {
        "customer_id":5,
        "colocation_name":"colo5",
        "colocation_id":30,
        "device_name":"device 5",
        "channels": [
        {
            "name":"channel5-5",
            "multicast":"1.2.5.5",
            "sugar_state":4,
            "network_state":1
        }
        ]
    }
    ],
    "generation_date":"2017-02-27T10:55:45+0100"
}

不幸的是，当我尝试发送这篇文章中列出的查询时，我发现聚合并没有像我预期的那样:它返回“好”数据，但来自全部存储的文件!这是一个输出示例:

{
   "timed_out" : false,
   "took" : 60,
   "hits" : {
      "total" : 2,
      "hits" : [
         {
            "_source" : {
               "customers" : [
                  {
                     "colocation_id" : 26,
                     "channels" : [
                        {
                           "name" : "channel1-5",
                           "sugar_state" : 4,
                           "network_state" : 1,
                           "multicast" : "1.2.1.5"
                        }
                     ],
                     "customer_id" : 1,
                     "colocation_name" : "colo1",
                     "device_name" : "device 1"
                  },
                  {
                     "colocation_id" : 27,
                     "channels" : [
                        {
                           "multicast" : "1.2.2.5",
                           "network_state" : 1,
                           "name" : "channel2-5",
                           "sugar_state" : 4
                        }
                     ],
                     "customer_id" : 2,
                     "device_name" : "device 2",
                     "colocation_name" : "colo2"
                  },
                  {
                     "device_name" : "device 3",
                     "colocation_name" : "colo3",
                     "customer_id" : 3,
                     "channels" : [
                        {
                           "multicast" : "1.2.3.5",
                           "network_state" : 1,
                           "sugar_state" : 4,
                           "name" : "channel3-5"
                        }
                     ],
                     "colocation_id" : 28
                  },
                  {
                     "channels" : [
                        {
                           "sugar_state" : 4,
                           "name" : "channel4-5",
                           "multicast" : "1.2.4.5",
                           "network_state" : 1
                        }
                     ],
                     "customer_id" : 4,
                     "colocation_id" : 29,
                     "colocation_name" : "colo4",
                     "device_name" : "device 4"
                  },
                  {
                     "device_name" : "device 5",
                     "colocation_name" : "colo5",
                     "colocation_id" : 30,
                     "channels" : [
                        {
                           "sugar_state" : 4,
                           "name" : "channel5-5",
                           "multicast" : "1.2.5.5",
                           "network_state" : 1
                        }
                     ],
                     "customer_id" : 5
                  }
               ],
               "generation_date" : "2017-02-27T11:45:37+0100"
            },
            "_type" : "market_data_audit_document",
            "sort" : [
               1488192337000
            ],
            "_index" : "mars",
            "_score" : null,
            "_id" : "AVp_LPeJdrvi0cWb8CrL"
         }
      ],
      "max_score" : null
   },
   "aggregations" : {
      "nested" : {
         "doc_count" : 10,
         "filter" : {
            "doc_count" : 2,
            "tophits_agg" : {
               "hits" : {
                  "max_score" : 1,
                  "total" : 2,
                  "hits" : [
                     {
                        "_nested" : {
                           "offset" : 0,
                           "field" : "customers"
                        },
                        "_score" : 1,
                        "_source" : {
                           "channels" : [
                              {
                                 "name" : "channel1-5",
                                 "sugar_state" : 4,
                                 "multicast" : "1.2.1.5",
                                 "network_state" : 1
                              }
                           ],
                           "customer_id" : 1,
                           "colocation_id" : 26,
                           "colocation_name" : "colo1",
                           "device_name" : "device 1"
                        }
                     },
                     {
                        "_source" : {
                           "colocation_id" : 26,
                           "customer_id" : 1,
                           "channels" : [
                              {
                                 "multicast" : "1.2.1.5",
                                 "network_state" : 1,
                                 "name" : "channel1-5",
                                 "sugar_state" : 4
                              }
                           ],
                           "device_name" : "device 1",
                           "colocation_name" : "colo1"
                        },
                        "_nested" : {
                           "offset" : 0,
                           "field" : "customers"
                        },
                        "_score" : 1
                     }
                  ]
               }
            }
         }
      }
   },
   "_shards" : {
      "total" : 13,
      "successful" : 1,
      "failures" : [
         {
            "reason" : {
               "index" : ".kibana",
               "index_uuid" : "bTkwoysSQ0y8Tt9yYFRStg",
               "type" : "query_shard_exception",
               "reason" : "No mapping found for [generation_date] in order to sort on"
            },
            "shard" : 0,
            "node" : "4ZUgOm4VRry6EtUK15UH3Q",
            "index" : ".kibana"
         },
         {
            "reason" : {
               "index_uuid" : "lN2mVF9bRjuDtiBF2qACfA",
               "index" : "archiv1_log",
               "type" : "query_shard_exception",
               "reason" : "No mapping found for [generation_date] in order to sort on"
            },
            "shard" : 0,
            "node" : "4ZUgOm4VRry6EtUK15UH3Q",
            "index" : "archiv1_log"
         },
         {
            "index" : "archiv1_session",
            "shard" : 0,
            "node" : "4ZUgOm4VRry6EtUK15UH3Q",
            "reason" : {
               "type" : "query_shard_exception",
               "index" : "archiv1_session",
               "index_uuid" : "cmMAW04YTtCb0khEqHpNyA",
               "reason" : "No mapping found for [generation_date] in order to sort on"
            }
         },
         {
            "shard" : 0,
            "node" : "4ZUgOm4VRry6EtUK15UH3Q",
            "reason" : {
               "reason" : "No mapping found for [generation_date] in order to sort on",
               "index" : "archiv1_users_dev",
               "index_uuid" : "AH48gIf5T0CXSQaE7uvVRg",
               "type" : "query_shard_exception"
            },
            "index" : "archiv1_users_dev"
         }
      ],
      "failed" : 12
   }
}

最佳答案

根据您的描述:

你将文档存储在具有一堆属性的elasticsearch

每个文档都包含数组中的客户列表(嵌套文档)

您只想提取与 customer.id 相关的嵌套文档

你的库不管理没有桶的 Elasticsearch 响应

您期望 Elasticsearch 返回嵌套文档

问题

它存在两种聚合:

桶

指标

在您的情况下，您在 Nested Agg 下有 2 个聚合:过滤器和指标。
筛选 :

Filter defines a single bucket of all the documents 但未在结果中提供“bucket”关键字。

Top hits 是一个 Metric，不提供桶。

解决方法:

我怀疑您的 PHP 库能否正确处理嵌套聚合结果，但您可以使用 Filter s 而不是 Filter Aggregations 来获取存储桶列表

{
  "aggregations": {
    "nested": {
      "nested": {
        "path": "customers"
      },
      "aggregations": {
        "filters_customer": {
          "filters": {
            "filters": [
              {
                "match": {
                  "customers.customer_id": "1"
                }
              }
            ]
          },
          "aggregations": {
            "top_hits_customer": {
              "top_hits": {}
            }
          }
        }
      }
    }
  }
}

将提供类似:

{
  "aggregations": {
    "nested": {
      "doc_count": 15,
      "filters_customer": {
        "buckets": [
          {
            "doc_count": 3,
            "top_hits_customer": {
              "hits": {
                "total": 3,
                "max_score": 1,
                "hits": [
                  {
                    "_nested": {
                      "field": "customers",
                      "offset": 0
                    },
                    "_score": 1,
                    "_source": {
                      "customer_id": 1,
                      "foo": "bar"
                    }
                  },
                  {
                    "_nested": {
                      "field": "customers",
                      "offset": 0
                    },
                    "_score": 1,
                    "_source": {
                      "customer_id": 1,
                      "foo": "bar"
                    }
                  },
                  {
                    "_nested": {
                      "field": "customers",
                      "offset": 0
                    },
                    "_score": 1,
                    "_source": {
                      "customer_id": 1,
                      "foo": "bar"
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  }
}

请注意您的 EDIT 2

Elasticsearch 将根据您的报告日期搜索所有文档，而不是“TOP 1”文档。按报告拆分结果的一种方法是在报告日期使用术语桶:

{
  "query": {},
  "size": 0,
  "aggregations": {
    "grp_report": {
      "terms": {
        "field": "generation_date"
      },
      "aggregations": {
        "nested_customers": {
          "nested": {
            "path": "customers"
          },
          "aggregations": {
            "filters_customer": {
              "filters": {
                "filters": [
                  {
                    "match": {
                      "customers.customer_id": "1"
                    }
                  }
                ]
              },
              "aggregations": {
                "top_hits_customer": {
                  "top_hits": {}
                }
              }
            }
          }
        }
      }
    }
  }
}

建议:

避免复杂的文档，更喜欢将您的报告拆分为具有相关键(例如reportId)的小文档。您将能够轻松过滤和聚合，而无需任何嵌套文档。添加关于女巫的客户文档信息，您将过滤所有类型(在这种情况下，冗余不是问题)。

用例示例:

报告列表

显示每个报告的客户信息

跨多个报告显示客户的历史记录

当前文档示例:/indexName/market_audit

{
  "generation_date": "...",
  "customers": [
    {
      "id": 1,
      "foo": "bar 1"
    },
    {
      "id": 2,
      "foo": "bar 2"
    },
    {
      "id": 3,
      "foo": "bar 3"
    }
  ]
}

改版文件:

/indexName/market_audit_report

{
  "report_id" : "123456"
  "generation_date": "...",
  "foo":"bar"
}

/indexName/market_audit_customer 文件

{
  "report_id" : "123456"
  "customer_id": 1,
  "foo": "bar 1"
}


{
  "report_id" : "123456"
  "customer_id": 2,
  "foo": "bar 2"
}


{
  "report_id" : "123456"
  "customer_id": 3,
  "foo": "bar 3"
}

如果您知道您的报告 ID，您将能够在一个请求中获取所有数据:

对报告 ID

的过滤器

类型上的术语聚合

类型报告的过滤器

一个 top_hit 聚合得到报告

过滤器聚合，仅获取类型客户和客户 ID 1

对客户 1 信息的 top_hit 聚合

或者

对报告 ID

的过滤器

类型上的术语聚合

类型报告的过滤器

一个 top_hit 聚合得到报告

客户 ID 上的术语聚合

一个 top_hit 聚合来检索每个客户的信息

热门点击聚合大小

不要忘记在你的 top_hits 中提供一个 size 否则你只会得到 top 3

关于php - 在 Elasticsearch 5 上使用过滤器获取嵌套文档，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42255998/

文章推荐： logging - ELK堆栈-如何将所有旧日志回填到elasticsearch中？

文章推荐： crash - win7上ring0 APC DLL注入(inject)崩溃目标进程

文章推荐： ms-access - SSIS 包在迁移到 64 位后失败

文章推荐： .net - 在.NET CF上播放PCM音频流

javascript - AngularJS 中的“过滤器”过滤器
我有一个对象数组，我想在键传入“filter”过滤器时提取值。下面是我尝试过的 Controller 代码片段，但我得到的响应类型未定义。请帮我找出哪里出错了。 var states = [{"HI
java - Servlet 过滤器 - 来自 servlet 的转发请求是否会进入 servlet 过滤器？
如果任何 J2EE 应用程序直接访问 servlet，然后 servlet 将相同的请求转发到某个 .jsp 页面。 request.getRequestDispatcher("Login.jsp")
jquery 过滤器.not()
我有一个带有图像缩略图的表单，可以通过复选框进行选择以进行下载。我想要一个包含 jQuery 中图像的数组，用于 Ajax 调用。 2个问题: - 表格顶部有一个复选框，用于切换我想要从映射中排除的所
mysqldump 过滤器？
我必须从服务器转储数据库，将 .sql 传输到另一台服务器，然后运行以下脚本以使用此语法删除某些行: DELETE wp_posts FROM wp_posts INNER JOIN wp_postm
Java文件目录(过滤器)
我想从目录中过滤掉特定类型的文件，但收到错误“ token 语法错误，删除这些 token ”: File dir = new File("c:/etc/etc"); File[] f
PHP 过滤器
几乎所有的 Web 应用程序都依赖外部的输入。这些数据通常来自用户或其他应用程序（比如 web 服务）。通过使用过滤器，您能够确保应用程序获得正确的输入类型。您应该始终对外部数据进行过滤！输
子项和返回父项的 OData 过滤器
我正在开发一个由 OData 服务提供支持的搜索功能。它将返回一个或一列标题对象作为结果。我们需要搜索的许多字段不在标题对象中。它们仅在子对象(导航属性)中。能够针对子字段执行 OData 搜索并仍然
带替换的 Django 过滤器
假设我有以下模型，它有一个方法 variants(): class Example(models.Model): text = models.CharField(max_length=255)
Python 过滤器 defaultdict
我有一个默认的列表列表，但我基本上想这样做: myDefaultDict = filter(lambda k: len(k)>1, myDefaultDict) 除了它似乎只适用于列表。我能做什么？
Django 过滤器 - 分页结果
我正在使用 django-filter 来输出我的模型的过滤结果。那里没有问题。下一步是添加一个分页器……尽管现在已经苦苦挣扎了好几天。 views.py: def funds_overview(re
解释计划分区上的 oracle 过滤器
我正在做一个概念证明，我正在试验一种奇怪的行为。我有一个按日期字段按范围分区的表，如果我设置固定日期或由 SYSDATE 创建的日期，查询的成本会发生很大变化。这些是解释计划: SQL> SELE
configuration - Log4Net 过滤器 "OR"
如果一个或另一个值匹配，是否可以制作一个过滤器，例如一个中性的 PropertyFilter(并传递给链中的下一个过滤器)？就像是: value1 val
基于另一个单元格的 VBA 过滤器
我是 VBA 初学者，正在尝试根据单元格值过滤数据，经过一番谷歌搜索后，我编写了一个有效的代码 Sub FilterDepartment_Sales() Sheet6.Activate
Excel 过滤器 - 仅显示过滤器中的相关值
假设我在 excel 数据透视表中有两个过滤器。两者最初都会显示筛选列的选定范围内的所有值。当我仅在过滤器 1 中选择几个值时，过滤器 2 仍会继续显示基础数据中所选范围内特定过滤器列中的所有值。
Freemarker - 定义自定义内置/过滤器
是否可以定义自定义 build-ins (名称不再适合)在 ftl？由于语义前提，我不想让它成为一个函数，而是一个内置的。最佳答案这是不可能的，?语法是为内置函数保留的。 (顺便说一句，这意味着
Wordpress 过滤器 user_row_actions
我试图在 Edit | 之外添加一个链接通过插件删除wordpress管理员>用户>所有用户列表中的链接..这是我第一次尝试通过查看其他插件或搜索google来制作wordpress插件.. 我添加了
带分页的 Django 过滤器
我正在尝试按照以下教程使用 django 过滤器进行分页，但该教程似乎缺少某些内容，而且我无法使用基于函数的 View 方法显示分页。 https://simpleisbetterthancomple
Powershell 过滤器 csv
由于我是 Powershell 新手，因此寻求最佳实践方面的帮助，我有一个 csv 文件，我想过滤掉 csv 中的每一行，除了包含“未安装”的行然后，我想根据包含计算机列表的单独 csv 文件过滤
我需要审查的项目的 Gerrit 过滤器
我正在尝试创建一个搜索查询，它会告诉我我作为审阅者添加到其中的打开更改，但我还没有提交最新补丁集的代码审查。这应该包括其他人已经评论过的更改，但我没有。我能找到的最接近的是 is:reviewer
java session 过滤器
在我的 Web 应用程序中，我有 3 个主要部分 1. 客户 2. 供应商 3. 管理员我正在使用 java session 过滤器来检查用户 session 并允许访问网站的特定部分。因此客户只

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

php - 在 Elasticsearch 5 上使用过滤器获取嵌套文档