标签: aggregate

我有一个像这样的哈希数组：

my_array_of_hashes = [
  { :customer=>"Matthew",
    :fruit=>"Apples",
    :quantity=>2,
    :order_month => "January"
  },
  { :customer => "Philip",
    :fruit => "Oranges",
    :quantity => 3,
    :order_month => "July"
  },
  { :customer => "Matthew",
    :fruit => "Oranges",
    :quantity => 1,
    :order_month => "March"
  },
  { :customer => "Charles",
    :fruit => "Pears",
    :quantity => 3,
    :order_month => "January"
  },
  { :customer => "Philip",
    :fruit => "Apples",
    :quantity => 2,
    :order_month => "April"
  },
  { :customer => "Philip",
    :fruit => "Oranges",
    :quantity => 1,
    :order_month => …

为了说明这个问题，我们使用一个简单的例子：有两个聚合 -Lamp和Socket。必须始终强制执行以下业务规则： aLamp和 aSocket都不能同时连接多次。为了提供适当的命令，我们设想了一个Connector带有Connect(Lamp, Socket)-method 的服务来插入它们。

因为我们希望遵守一个事务只涉及一个聚合的规则，所以不建议在事务中对两个聚合设置关联Connect。所以我们需要一个象征Connection自身的中间蕴。因此Connect-transaction 只会Connection使用给定的组件创建一个新的。不幸的是，此时麻烦开始了；如何保证连接状态的一致性？可能会发生许多并发用户想要在同一时间插入相同的组件，因此我们的“一致性检查”不会拒绝该请求。新的Connection聚合将被存储，因为我们只锁定聚合级别。即使不知道这一点，系统也会不一致。

但是我们应该如何设定聚合的边界来确保我们的业务规则呢？我们可以设想一个Connections聚合，它收集所有活动连接（作为Connection实体），从而使我们的锁定算法能够正确拒绝重复的Connect请求。另一方面，这种方法效率低下且无法扩展，而且在领域语言方面也是违反直觉的。

你知道我错过了什么吗？

编辑：为了总结这个问题，想象一个聚合User。由于聚合的定义是基于事务的单元，我们可以通过锁定每个事务的该单元来强制不变量。一切皆好。但现在出现了一条业务规则：用户名必须是唯一的。因此，我们必须以某种方式使我们的总体边界与这一新要求相协调。假设有数百万用户同时注册，这就成了一个问题。我们尝试确保非锁定状态下的这种不变性，因为多个用户意味着多个聚合。

根据 Eric Evans 所著的《领域驱动设计》一书，一旦单个事务中涉及多个聚合，就应该应用最终一致性。但这真的是这样吗？这有道理吗？

在这里应用最终一致性需要注册User并随后使用用户名检查不变量。如果两个Users 实际上设置了相同的用户名，系统将撤消第二次注册并通知User. 想到这种情况让我感到不安，因为它扰乱了整个注册过程。例如，发送确认电子邮件必须延迟等等。

我想我只是忘记了一些一般的事情，但我不知道是什么。在我看来，我需要类似Repository级别上的不变量之类的东西。

我在使用Loopback获取 mongoDB 上的聚合结果时遇到一些问题。

这是我的环回配置：

• "环回": "^3.19.0",
• "环回启动": "^2.27.1",
• "环回组件资源管理器": "^4.0.0",
• "环回组件存储": "^3.3.1",
• "环回连接器-mongodb": "^3.4.3",
• "loopback-datasource-juggler": "^3.18.1",

这是我编写的用于执行聚合的代码：

 return new Promise((resolve, reject) => {
  Model.getDataSource().connector.connect(function(err, db) {
  if (err)
    return reject(err);

  let aggregatePipe = [
    {
      $group: {
        "_id": "$address.region",
        "count": {$sum: 1},
        "geoPoint": {$addToSet: "$geoPoint"}
      }
    }];
  let results = db.collection('Location').aggregate(aggregatePipe, (err, results) => {
    console.log(results);
    return resolve(results);
  });
});

然而， results不包含聚合的结果，但包含游标...

AggregationCursor {
  pool: null,
  server: null,
  disconnectHandler:
   Store {
     s: { storedOps: [], storeOptions: [Object], topology: …

我正在尝试将 InfluxDB 查询迁移到 Google Cloud BigQuery。

InfluxDB 是一个时间序列数据库，因此按时间间隔进行聚合非常容易。给定这个数据集：

name: h2o_feet
--------------
time                   water_level   location
2015-08-18T00:00:00Z   8.12          coyote_creek
2015-08-18T00:00:00Z   2.064         santa_monica
2015-08-18T00:06:00Z   8.005         coyote_creek
2015-08-18T00:06:00Z   2.116         santa_monica
2015-08-18T00:12:00Z   7.887         coyote_creek
2015-08-18T00:12:00Z   2.028         santa_monica
2015-08-18T00:18:00Z   7.762         coyote_creek
2015-08-18T00:18:00Z   2.126         santa_monica
2015-08-18T00:24:00Z   7.635         coyote_creek
2015-08-18T00:24:00Z   2.041         santa_monica
2015-08-18T00:30:00Z   7.5           coyote_creek
2015-08-18T00:30:00Z   2.051         santa_monica

下面的查询将查询结果分组为 12 分钟间隔：

SELECT COUNT("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
--------------
time                   count
2015-08-18T00:00:00Z   2
2015-08-18T00:12:00Z   2
2015-08-18T00:24:00Z …

我有一个只有两列的表，如下所示

mysql> select * from stuff_table;
+------+-------+
| name | stuff |
+------+-------+
| John | shoes |
| Jim  | bag   |
| Ely  | book  |
| Tom  | bag   |
| Will | shoes |
| Pitt | book  |
| Dean | bag   |
| Luke | bag   |
+------+-------+

我尝试了很多我发现的解决方案

select distinct
max(case when stuff='shoes' then name else name is null) end as shoes,
max(case when stuff='bag' then name else name is null end) as …

我有一个表引用名为“InvoiceHeader”的数据集并使用该数据集中的字段。我希望能够从当前表中引用另一个名为“TaxRate”的数据集。我正在尝试这样做：

= First(Fields!CurrencyDisplay.Value, "TaxRate")

我的错误是：

\n

文本框 \xe2\x80\x98textbox5\xe2\x80\x99 的值表达式直接引用\n 字段 \xe2\x80\x98TAXRATE\xe2\x80\x99，而不指定数据集聚合

\n

我一直在处理 Pandas 中的一个数据框，其中包含重复条目以及列中的非重复条目。数据框看起来像这样：

    country_name  values  category
0   country_1     10       a
1   country_2     20       b
2   country_1     50       a
3   country_2     10       b
4   country_3     100      c
5   country_4     10       d

我想写一些东西来转换（替换）重复项及其平均值在我的数据框中。理想的输出类似于以下内容：

    country_name  values    category
0   country_1      30        a
1   country_2      15        b
2   country_3      100       c
3   country_4      10        d

我已经为此苦苦挣扎了一段时间，因此我将不胜感激任何帮助。我忘记添加类别栏。groupby()现在，当您调用该方法时，该方法的问题mean()不会返回category列。我的解决方案是采用数字列和具有重复项的列一起应用groupby().mean()，然后连接回分类列。所以我正在寻找一个比我所做的更短的解决方案。
当您处理许多分类列时，我的方法会变得乏味。

我有一个包含两列的表，其中包含 ID 和 JSON 对象 (jsonb)。每个 json 对象都包含多个嵌套在对象内部的值（例如 url）。我可以使用 jsonb_path_query 使用 [*] 提取所有这些值，但它们以每行一个值的形式返回。如何以结果表与原始表具有相同行数的方式聚合返回值？

这是示例：

CREATE TABLE IF NOT EXISTS test (
  oid integer,
  object jsonb
  );

INSERT INTO test
VALUES 
    (1, '{"links": [
            {"title": "a", "url": "w"},
            {"title": "b", "url": "x"}
        ]}'),
    (2, '{"links": [
            {"title": "c", "url": "y"},
            {"title": "d", "url": "z"}
        ]}');

SELECT 
  oid,
  jsonb_path_query(object, '$.links[*].url')
FROM test;

select 查询返回下表：

| oid | jsonb_path_query |
| --- | ---------------- |
|  1  |       w          |
|  1  | …

我有一个大表，我正在尝试计算按位置分组的某些列的总和（有条件）。

我的代码看起来像这样，并且我的列越来越多

df.groupBy(location_column).agg(
        F.sum(F.when(F.col(col1) == True, F.col(value))).alias("SUM " + col1),
        F.sum(F.when(F.col(col2) == True, F.col(value))).alias("SUM " + col2),
        F.sum(F.when(F.col(col3) == True, F.col(value))).alias("SUM " + col3),
        ....
        # Additional lines for additional columns (around 20)
)

我想通过基本上做类似的事情来重构我的代码，使其看起来不那么愚蠢

cols = [col1, col2, col3, ... , coln]
df.groupBy(location_column).agg([F.sum(F.when(F.col(x) == True, F.col(value))).alias("SUM " + x)] for x in cols)

它不起作用，因为 agg() 函数不接受列表：

assert all(isinstance(c, Column) for c in exprs), "all exprs should be Column"

有重构的解决方案吗？谢谢

我有一个包含两列的数据框

df = DataFrame.from_records([
  {"time": 10, "amount": 200},
  {"time": 70, "amount": 1000},
  {"time": 10, "amount": 300},
  {"time": 10, "amount": 100},
])

我想要，给定一段时间80ms，计算可能的最大数量，在这种情况下，输出应该是 1300，因为在此期间，可能的最大数量是 1300。

熊猫可以吗？我想过使用聚合，但我不知道如何使用它