› › ›

邻接矩阵聚合

一种桶聚合，返回一种邻接矩阵。该请求提供了一组命名的过滤器表达式，类似于 filters 聚合请求。响应中的每个桶表示相交过滤器矩阵中的非空单元格。

给定名为 A、B 和 C 的过滤器，响应将返回具有以下名称的桶：

	A	B	C
A	A	A&B	A&C
B		B	B&C
C			C

交叉桶，例如 A&C，使用两个过滤器名称的组合进行标记，默认分隔符为 &。请注意，响应不包含 C&A 桶，因为它与 A&C 相同的文档集。该矩阵被认为是对称的，因此我们只返回一半。为此，我们对过滤器名称字符串进行排序，并始终使用一对中的最低值作为分隔符左侧的值。

示例

编辑

以下 interactions 聚合使用 adjacency_matrix 来确定哪些个人组交换了电子邮件。

resp = client.bulk(
    index="emails",
    refresh=True,
    operations=[
        {
            "index": {
                "_id": 1
            }
        },
        {
            "accounts": [
                "hillary",
                "sidney"
            ]
        },
        {
            "index": {
                "_id": 2
            }
        },
        {
            "accounts": [
                "hillary",
                "donald"
            ]
        },
        {
            "index": {
                "_id": 3
            }
        },
        {
            "accounts": [
                "vladimir",
                "donald"
            ]
        }
    ],
)
print(resp)

resp1 = client.search(
    index="emails",
    size=0,
    aggs={
        "interactions": {
            "adjacency_matrix": {
                "filters": {
                    "grpA": {
                        "terms": {
                            "accounts": [
                                "hillary",
                                "sidney"
                            ]
                        }
                    },
                    "grpB": {
                        "terms": {
                            "accounts": [
                                "donald",
                                "mitt"
                            ]
                        }
                    },
                    "grpC": {
                        "terms": {
                            "accounts": [
                                "vladimir",
                                "nigel"
                            ]
                        }
                    }
                }
            }
        }
    },
)
print(resp1)

response = client.bulk(
  index: 'emails',
  refresh: true,
  body: [
    {
      index: {
        _id: 1
      }
    },
    {
      accounts: [
        'hillary',
        'sidney'
      ]
    },
    {
      index: {
        _id: 2
      }
    },
    {
      accounts: [
        'hillary',
        'donald'
      ]
    },
    {
      index: {
        _id: 3
      }
    },
    {
      accounts: [
        'vladimir',
        'donald'
      ]
    }
  ]
)
puts response

response = client.search(
  index: 'emails',
  body: {
    size: 0,
    aggregations: {
      interactions: {
        adjacency_matrix: {
          filters: {
            "grpA": {
              terms: {
                accounts: [
                  'hillary',
                  'sidney'
                ]
              }
            },
            "grpB": {
              terms: {
                accounts: [
                  'donald',
                  'mitt'
                ]
              }
            },
            "grpC": {
              terms: {
                accounts: [
                  'vladimir',
                  'nigel'
                ]
              }
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.bulk({
  index: "emails",
  refresh: "true",
  operations: [
    {
      index: {
        _id: 1,
      },
    },
    {
      accounts: ["hillary", "sidney"],
    },
    {
      index: {
        _id: 2,
      },
    },
    {
      accounts: ["hillary", "donald"],
    },
    {
      index: {
        _id: 3,
      },
    },
    {
      accounts: ["vladimir", "donald"],
    },
  ],
});
console.log(response);

const response1 = await client.search({
  index: "emails",
  size: 0,
  aggs: {
    interactions: {
      adjacency_matrix: {
        filters: {
          grpA: {
            terms: {
              accounts: ["hillary", "sidney"],
            },
          },
          grpB: {
            terms: {
              accounts: ["donald", "mitt"],
            },
          },
          grpC: {
            terms: {
              accounts: ["vladimir", "nigel"],
            },
          },
        },
      },
    },
  },
});
console.log(response1);

PUT emails/_bulk?refresh
{ "index" : { "_id" : 1 } }
{ "accounts" : ["hillary", "sidney"]}
{ "index" : { "_id" : 2 } }
{ "accounts" : ["hillary", "donald"]}
{ "index" : { "_id" : 3 } }
{ "accounts" : ["vladimir", "donald"]}

GET emails/_search
{
  "size": 0,
  "aggs" : {
    "interactions" : {
      "adjacency_matrix" : {
        "filters" : {
          "grpA" : { "terms" : { "accounts" : ["hillary", "sidney"] }},
          "grpB" : { "terms" : { "accounts" : ["donald", "mitt"] }},
          "grpC" : { "terms" : { "accounts" : ["vladimir", "nigel"] }}
        }
      }
    }
  }
}

响应包含每个过滤器和过滤器组合的文档计数的桶。响应中排除了没有匹配文档的桶。

{
  "took": 9,
  "timed_out": false,
  "_shards": ...,
  "hits": ...,
  "aggregations": {
    "interactions": {
      "buckets": [
        {
          "key":"grpA",
          "doc_count": 2
        },
        {
          "key":"grpA&grpB",
          "doc_count": 1
        },
        {
          "key":"grpB",
          "doc_count": 2
        },
        {
          "key":"grpB&grpC",
          "doc_count": 1
        },
        {
          "key":"grpC",
          "doc_count": 1
        }
      ]
    }
  }
}