标签: aggregate

我正在使用PostgreSQL 9.1,我有这样的数据结构:

A     B
-------
1     a
1     a
1     b
1     c
1     c
1     c
1     d
2     e
2     e

我需要一个产生这个结果的查询:

1    4     {{c,3},{a,2},{b,1},{d,1}}
2    1     {{e,2}}

A = 1,4行总共A = 1,部分计数(3行带c值,2行带值,.....)

• 列"A"的不同值
• 与"A"值相关的所有行的计数
• 数组包含与"A"值相关的所有元素及其自身的相对计数

数组所需的排序基于每个组的计数(如示例3,2,1,1).

我们有〜20M(酒店提供)存储在弹性(1.6.2)文件,关键是要通过多个字段组文档(duration, start_date, adults, kids),然后选择一个便宜的报价了各组.我们必须按成本字段对这些结果进行排序.

为了避免子聚合,我们将目标字段值合并为一个default_group_field通过将它们与点(.)连接而调用的值.

该字段的映射如下所示:

  "default_group_field": {
    "index": "not_analyzed",
    "fielddata": {
      "loading": "eager_global_ordinals"
    },
    "type": "string"
  }

我们执行的查询看起来像这样:

{
  "size": 0,
  "aggs": {
    "offers": {
      "terms": {
        "field": "default_group_field",
        "size": 5,
        "order": {
          "min_sort_value": "asc"
        }
      },
      "aggs": {
        "min_sort_value": {
          "min": {
            "field": "cost"
          }
        },
        "cheapest": {
          "top_hits": {
            "_source": {}
            },
            "sort": {
              "cost": "asc"
            },
            "size": 1
          }
        }
      }
    }
  },
  "query": {
    "filtered": {
      "filter": {
        "and": …

我经常需要计算R数据帧的新列(长格式),其值应取决于组的聚合函数(例如总和).例如,我可能想知道任何一天产品占销售额的比例:

daily fraction = revenue for product i on day d / sum or revenue for all products on day d

我目前的策略是总结和加入:

library(dplyr)

join_summary <- function(data, ...) left_join(data, summarise(data, ...))

data = data.frame(
  day = c(1,1,2,2,3,3),
  product = rep(c("A", "B"), 3),
  revenue = c(2, 4, 8, 7, 9, 2)
)

data2 <- data %>%
  group_by(day) %>%
  join_summary(daily_revenue = sum(revenue)) %>%
  mutate(revenue_fraction = revenue / daily_revenue)

这有效,但我不确定它是否是反模式.在多行上重复相同的数据(每日收入)似乎有点低效,使用聚合乱丢我的数据框.我的问题是:

• 我的目前做得好吗？
• 有没有更好的方法,最好是使用dplyr更广泛的Hadleyverse 工具？
• 我真的需要我的自定义功能join_summary,还是可以用现有的dplyr动词完成？(不过我更喜欢呆在"管道流"中.)

我正在遵循Flink的快速入门示例：监视Wikipedia编辑流。

该示例使用Java，并且正在Scala中实现，如下所示：

/**
 * Wikipedia Edit Monitoring
 */
object WikipediaEditMonitoring {
  def main(args: Array[String]) {
    // set up the execution environment
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val edits: DataStream[WikipediaEditEvent] = env.addSource(new WikipediaEditsSource)

    val result = edits.keyBy( _.getUser )
      .timeWindow(Time.seconds(5))
      .fold(("", 0L)) {
        (acc: (String, Long), event: WikipediaEditEvent) => {
          (event.getUser, acc._2 + event.getByteDiff)
        }
      }

    result.print

    // execute program
    env.execute("Wikipedia Edit Monitoring")
  }
}

但是，foldFlink中的功能已被弃用，aggregate建议使用该功能。

但我没有找到有关如何转换的过时的例子或教程fold来aggregrate。 …

我将脚步放在事件源模式上并试图弄清聚合的含义。我读过一些博客，现在我比以往任何时候都更加困惑。

根据我的推断，聚合应该以某种方式使用户能够在事件存储上运行不同的查询，以检索不同的事件流。

用例：

1. 我想在发票上重播事件，我想查看特定员工在余额上执行的所有操作。

2. 我想重播发票上的所有事件

我希望这些是有效的用例。

活动商店：

| event_id | invoice_id | EmployeeId | Event            | Payload |
|----------|------------|------------|------------------|---------|
| 1        | 12345      | 12345      | Invoice_InReview | JSON    |
| 2        | 12345      | 12345      | Invoice_Billed   | JSON    |
| 3        | 12345      | 45567      | Invoice_Paid     | JSON    |
| 4        | 12345      | 77341      | Invoice_Reversed | JSON    |
| 5        | 12345      | 98421      | Invoice_Paid     | JSON    | …

我有两个收藏

带架构

{
    a : Array,
    b : ObjectID
}

和 B 具有以下架构

{
    x : 'string',
    y : // some object schema
    ...
    b : ObjectID
}

我想使用 mongo 聚合在集合 B 中添加一个新字段，以仅包含使用 b 搜索的集合 A 中的 a。

我希望聚合后的值具有以下架构：

{
    x : 'string',
    newField : a // array from collection A
    y : // some object schema
    ...
    b : ObjectID
}

只有 $lookup 不起作用，因为我不想要整个对象，并且合并将删除 _id 并合并我不想要的其他对象。

我在 R 中有一个数据框，通常采用这种形式：

ID     Year     Amount  
3       2000      45  
3       2000      55  
3       2002      10  
3       2002      10  
3       2004      30  
4       2000      25  
4       2002      40  
4       2002      15  
4       2004      45  
4       2004      50

我想按 ID 对每年的金额求和，并使用此输出获取新的数据框。

ID      Year     Amount  
3       2000      100  
3       2002       20  
3       2004       30  
4       2000       25  
4       2002       55  
4       2004       95 

这是我需要做的一个例子，实际上数据要大得多。请帮忙，谢谢！

我在 MongoDB 中有一个集合，其中包含一个字段“events”，它是一个数组。我需要为此编写一个聚合查询来检查事件数组不为空，但找不到方法来执行此操作。

我想要这样的东西：

db.collection.aggregate([
    { 
        $match: { 
            events: {
                "$empty": false 
            }
        }
    }
]);

我有两个收藏

• 保存关注用户的集合
• 用户故事集合

我只想查看我关注的用户的故事

这是我的数据库的一个例子

db = {
  "follow": [
    {
      "_id": 1,
      "start": "user1",
      "end": "user2",
      
    },
    {
      "_id": 2,
      "start": "user2",
      "end": "user3",
      
    }
  ],
  "story": [
    {
      "_id": 1,
      "owner_id": "user2",
      "updated_at": 1638090000,
      "deleted_at": null
    },
    {
      "_id": 2,
      "owner_id": "user3",
      "updated_at": 1638080000,
      "deleted_at": null
    }
  ]
}

我想要这样的查询。当然，这是错误的：

db.story.aggregate([
  {
    "$match": {
      "deleted_at": null,
      "updated_at": {
        $gte: 1638081000
      },
      "owner_id": {
        $in: [
          db.follow.find({"start": "user1"})
        ]
      }
    }
  }
])

请注意，我希望所有这些都在一个查询中完成

在 mongo Playground 中查询：https://mongoplayground.net/p/ysRUDW4hRzh

我想知道如果域事件不是聚合状态更改的自然结果，如何实现它（在 DDD 中）。

我借用这篇文章的例子。

因此，假设我们需要一个像：TemperatureWasMeasured这样的事件，它可能是我们所做的某些建模的产物（例如在事件风暴会话中）。

此事件感觉像是某些读取操作的产物，而不是某些聚合的实际状态更改。

所以问题是： 这个事件在哪里以及如何有意义地被发射？。

我们可以创建一个实体或聚合，它可以有一个状态来计算读取次数，以便作为状态更改发出。但这真的有必要吗？

在现有的资源中，“领域事件”的定义似乎没有提到状态变化，而只是在领域中发生了一些事情。

那么测量的动作（在非量子力学环境中）被认为是一个域事件，就像TemperatureWasMeasured事件一样？

如果有人能澄清这些问题那就太好了，因为似乎没有明确的答案。