标签: aggregation

我最近一直在将存储库模式视为一种在客户端代码所涉及的地毯上刷下所有持久性细节的方法。在阅读时，似乎[通常？]存储库负责聚合，而不仅仅是简单的类。

这对我来说很有意义，因为您可以有一个定义Posts的类和另一个定义Comments的类。由于这两者是密切相关的，因此这是合计的理想选择。但是，我将如何表示Users类及其与Posts的关系？

将用户与“ 帖子/评论”聚合在一起是有意义的，还是仅保留用户本身并仅通过良好的老式引用建立关联？

我曾尝试使用Google自己寻找答案，但我发现的许多示例都是独立的。即Posts / Comment或Order和OrderLine等。我找不到任何显示其他相关类如何组合在一起的东西。

尽管PHP或Java / C＃可能是我希望使用这些思想的领域，但我没有将其应用于任何特定的东西。无论如何，我只是在探索并试图在我逃跑并创建怪物之前弄清楚其中的一些想法和概念。:)

感谢您的时间。

我希望建立在C＃中的一些数据汇总的东西，我想一个类似于实时数据透视表，或某种形式的不断更新SQL查询，与支持select，sum，average，first，where，和group-by（其中first在LINQ的“给我第一价值”的意义）。

例如，我可能有某种形式的表对象的所谓Trans的列Name，Date和Total，并呼吁另一个表Price的列Name和Price。我想创建某种Query实例（在伪SQL中）

select Name, sum(Total), first(Price) from Trans, Price join on Name group by Name

并将其传递给Aggregator具有指向数据源链接的实例。与此同时，我想注册一个在查询产生的行发生更改时命中的回调。因此，如果名为“ XYZ”的实体的价格发生变化，则回调将触发一个对象，该对象包含该汇总行的新值。我还希望Aggregator尽可能高效，因此它将有某种索引方案，因此无论何时值更改都不需要进行表扫描。

我不太确定该怎么称呼，并且我希望能够完全用C＃来实现某些东西，前提是它并不比我想象的要复杂一个数量级。我已经读过Continuous LINQ和Bindable LINQ，但是我真的无法感觉是否适合这个问题，或者是否存在性能问题（例如，只要值改变，LINQ聚合就会枚举整个表）。

有谁知道一个项目可以执行类似的工作，或者对自己设计/构建有任何建议？

编辑：我应该注意，数据实际上不会在数据库中，而是会在内存中。

这有点难以用语言解释......我正在尝试计算矩阵中分组的不同值的总和.假设我有一个SQL查询返回的以下数据:

------------------------------------------------
| Group | ParentID | ChildID | ParentProdCount |
|     A |        1 |       1 |               2 |
|     A |        1 |       2 |               2 |
|     A |        1 |       3 |               2 |
|     A |        1 |       4 |               2 |
|     A |        2 |       5 |               3 |
|     A |        2 |       6 |               3 |
|     A |        2 |       7 |               3 |
|     A |        2 |       8 …

在设计类图时,我很难理解这些,从我所知的构成是一个"有一个"的关系但聚合？我不知道它是什么.还有一件事我什么时候才能在类图中使用Composition？什么时候才能知道在类图中使用聚合？一个例子将受到高度赞赏.

我只是想总结一列并在表格的底部显示总数.从查看示例看,使用聚合器似乎是最好的方法.但是,当我简单地添加

dataView.setAggregators([ new Slick.Data.Aggregators.Sum("value") ], false);

什么都没发生.我已经尝试了几个小时来让一个简单的聚合器基于分组示例工作,但分组示例太复杂了,我无法准确地告诉我需要什么.

编辑:替代修复:对于其他任何人,我最终没有使用聚合器.这些数据在Javascript中可用,这使得生活变得更加容易.总计可以从那里计算出来.

我有一个弹性搜索查询,它查询索引,然后根据特定字段进行聚合sender_not_analyzed.然后,我在同一个字段上使用术语聚合sender_not_analyzed,返回顶部"发件人"的存储桶.我的查询目前是:

{
   "size": 0,
   "query": {
      "regexp": {
         "sender_not_analyzed": ".*[@].*"
      }
   },
   "aggs": {
      "sender-stats": {
         "terms": {
            "field": "sender_not_analyzed"
         }
      }
   }
}

返回看起来像这样的桶:

"aggregations": {
      "sender-stats": {
         "buckets": [
            {
               "key": "<Mike <mike@fizzbuzz.com>@MISSING_DOMAIN>",
               "doc_count": 5017
            },
            {
               "key": "jon.doe@foo.com",
               "doc_count": 3963
            },
            {
               "key": "jane.doe@foo.com",
               "doc_count": 2857
            },
            {
              "key": "jon.doe@bar.com",
              "doc_count":1544
            }

我如何编写聚合,以便为每个唯一的电子邮件域获取单个存储桶,例如,foo.com将具有doc_count(3963 + 2857)6820？我可以使用正则表达式聚合来完成此操作,还是需要编写某种自定义分析器来将@中的字符串拆分为字符串的末尾？

考虑以下聚合和子聚合：

.Aggregations(a => a
                        .Terms("ByCustomerByImpressionCount", tad => tad
                            .Field(o => o.CustomerName)
                            .OrderDescending("sumImpressionCount")
                            .Aggregations(ad => ad
                                .Sum("sumImpressionCount", sad => sad
                                    .Field(o => o.ImpressionCount)
                                )                        
                            )
                        ))

查询工作正常，我得到结果。

我可以通过以下方式访问顶级聚合：

var agg = results.Aggs.Terms("ByCustomerByImpressionCount");

根据文档，我应该能够得到sub agg：

var subAgg = agg.Aggs.Sum("sumImpressionCount");

但是Aggs甚至不是agg的财产-有什么想法吗？

编辑：

这是我能够进行子聚合的唯一方法：

PopulateList(results.Aggs.Terms("CustomersByImpressionCount").Items, CustomersByImpressionCount);

private void PopulateList(IList<KeyItem> items, List<DataContainer> listToPopulate)
{
                items.ForEach(item =>
                {
                    listToPopulate
                        .Add(new DataContainer() { Name = item.Key, Sum = ((ValueMetric)item.Aggregations.First().Value).Value });
                });
}

...但这似乎过于复杂。这是ES查询：

"query": { 
    "bool": {
      "must": [
        { "range": { "requestedShipDate":   {
            "gte": "2014-11-26",
            "lte": …

我正在运行aggs查询并指定大小为100,但ES只返回10个桶.为什么？我错过了什么？

{   
  "size": 100
   ,"query": {
      "bool": {
        "must": [
          { "term": {"app": "cnn"} }
        ]
      }
    }
   ,"aggs": {
    "unique_client": {
      "terms": {"field": "client"}    
      }     
    }
}

我想获得子聚合.

    "size" :0 ,
     "aggs": {
            "classification of day": {
               "date_histogram": {
                  "field": "ALARM DATE",
                   "format" : "dd/MM/yyyy",
                  "interval": "day"

               },
               "aggs": {
                  "classification1": {
                     "terms": {
                        "field": "CLASSIFICATION",
                         "keyed":true
                     }
                  }
               }
            }
         }

above json query returns the following output.

    "aggregations": {
          "classification of day": {
             "buckets": [
                {
                   "key_as_string": "25/02/2016",
                   "key": 1456358400000,
                   "doc_count": 166,
                   "classification1": {
                      "doc_count_error_upper_bound": 0,
                      "sum_other_doc_count": 0,
                      "buckets": [
                         {
                            "key": "attack",
                            "doc_count": 58
                         },
                         {
                            "key": "compromise",
                            "doc_count": 30
                         },
                         {
                            "key": "error", …

我正在尝试为最终用户创建一个聚合文件,以避免让他们使用更大的文件处理多个源.要做到这一点,我:A)遍历所有源文件夹,删除最常请求的12个字段,在这些结果共处的新位置旋转镶木地板文件.B)我尝试返回在步骤A中创建的文件,并通过按12个字段分组重新聚合它们,以将其减少为每个唯一组合的摘要行.

我发现的是,步骤A减少了有效载荷5:1(大约250演出成为48.5演出).然而,步骤B,而不是进一步减少这一点,比步骤A增加50%.但是,我的计数匹配.

这是使用Spark 1.5.2
我的代码,仅修改为使用field1 ... field12替换字段名称以使其更具可读性,下面是我已经注意到的结果.

虽然我不一定期望再减少5:1,但我不知道我做错了什么来增加存储端以减少具有相同模式的行.有谁能帮我理解我做错了什么？

谢谢!

//for each eventName found in separate source folders, do the following:
//spit out one row with key fields from the original dataset for quicker availability to clients 
//results in a 5:1 reduction in size
val sqlStatement = "Select field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, cast(1 as bigint) as rCount from table"
sqlContext.sql(sqlCommand).coalesce(20).write.parquet("<aws folder>" + dt + "/" + eventName + "/")
//results in over 700 …