标签: aggregate

我有一个类似于以下的表:

    date    |   expiry
-------------------------    
2010-01-01  | 2010-02-01
2010-01-01  | 2010-03-02
2010-01-01  | 2010-04-04
2010-02-01  | 2010-03-01
2010-02-01  | 2010-04-02

在表中,每个日期可能有多个"到期"值.我需要一个返回每个日期中第n个最小到期的查询.例如,对于n = 2,我希望:

     date    |   expiry
-------------------------       
2010-01-01  | 2010-03-02
2010-02-01  | 2010-04-02

我的麻烦是AFAIK,没有聚合函数返回第n个最大/最小元素,所以我不能使用'GROUP BY'.更具体地说,如果我有一个神奇的MIN()聚合接受第二个参数'offset',我会写:

SELECT MIN(expiry, 1) FROM table WHERE date IN ('2010-01-01', '2010-02-01') GROUP BY date

有什么建议？

可以说我们有以下代码:

#include <iostream>
#include <string>

struct A
{
  A() {}
  A(const A&) { std::cout << "Copy" << std::endl; }
  A(A&&) { std::cout << "Move" << std::endl; }
  std::string s;
};

struct B
{
  A a;
};

int main()
{
  B{A()};
}

在这里,我认为struct A不是一个聚合,因为它既有非平凡的构造函数,也有std::string我认为不是聚合的成员.这可能意味着它B也不是一个聚合体.

然而,我可以聚合初始化B.此外,这可以在没有调用复制或移动构造函数的情况下完成(例如,在ideone上的C++ 0x GCC 4.5.1 ).

这种行为似乎是一种有用的优化,特别是对于没有廉价移动的大型堆栈类型的组合.

我的问题是:这种聚合初始化何时在C++ 0x下有效？

编辑+跟进问题:

下面的DeadMG回答如下:

这根本不是聚合初始化,它是统一初始化,基本上在这种情况下意味着调用构造函数,并且没有复制或移动可能由RVO和NRVO完成.

请注意,当我更改B为以下内容时:

struct B
{
  A a;
  B(const A& a_) : a(a_) {}
  B(A&& a_) : a(std::move(a_)) {} …

有没有办法用linq做这个而不枚举fooCollection两次？

var fooCollection = // get foo
var selectedIds = new List<int>();
var aggregateContent = String.Empty;

foreach (var f in foo)
{
    selectedIds.Add(foo.Id);
    aggregateContent += foo.Content
}

var results = new FooResults
{
    Content = aggregateContent,
    SelectedIds = selectedIds
};

return results;

假设您(在Postgres 9.1中)有这样一个表:

date | value 

它有一些空白(我的意思是:并非每个可能的日期在最小(日期)和最大(日期)之间有它的行).

我的问题是如何聚合这些数据,以便分别处理每个一致的组(没有间隙),如下所示:

min_date | max_date | [some aggregate of "value" column] 

有什么想法怎么做？我相信这是可能的窗口功能,但是过了一段时间,试图lag()和lead()我有点卡住了.

例如,如果数据是这样的:

 date          | value  
---------------+-------  
 2011-10-31    | 2  
 2011-11-01    | 8  
 2011-11-02    | 10  
 2012-09-13    | 1  
 2012-09-14    | 4  
 2012-09-15    | 5  
 2012-09-16    | 20  
 2012-10-30    | 10  

输出(sum作为聚合)将是:

   min     |    max     |  sum  
-----------+------------+-------  
2011-10-31 | 2011-11-02 |  20  
2012-09-13 | 2012-09-16 |  30  
2012-10-30 | 2012-10-30 |  10  

我是C#的初学者.我有一个这样的字典:

{
  {"tom", "student"},
  {"rob", "teacher"},
  {"david", "lawyer"}
}

我想形成这一行:

tom = student, rob = teacher, david = lawyer

我想使用聚合扩展方法,dictionary<>但当我这样做时:

Console.WriteLine(dic.Aggregate((a,b) => (a.Key + " = " + a.Value + ", " + b.Key + " = " + b.Value)));

我收到此错误:

无法将lambda表达式转换为委托类型.

所以看来我做错了.那么有人能告诉我如何使用这种方法吗？

在这里尝试aggregate另一个问题时,我遇到了一个相当奇怪的结果.我无法弄清楚为什么,我想知道我在做什么是完全错误的.

假设,我有data.frame这样的:

df <- structure(list(V1 = c(1L, 2L, 1L, 2L, 3L, 1L), 
                     V2 = c(2L, 3L, 2L, 3L, 4L, 2L), 
                     V3 = c(3L, 4L, 3L, 4L, 5L, 3L), 
                     V4 = c(4L, 5L, 4L, 5L, 6L, 4L)), 
                  .Names = c("V1", "V2", "V3", "V4"), 
        row.names = c(NA, -6L), class = "data.frame")
> df
#   V1 V2 V3 V4
# 1  1  2  3  4
# 2  2  3  4  5
# 3  1  2  3  4 …

我是Postgres的新手,来自MySQL,并希望你们中的一个能够帮助我.

我有三列的表:name,week,和value.此表记录了名称,记录高度的周数以及高度值.像这样的东西:

Name  |  Week  | Value
------+--------+-------
John  |  1     | 9
Cassie|  2     | 5
Luke  |  6     | 3
John  |  8     | 14
Cassie|  5     | 7
Luke  |  9     | 5
John  |  2     | 10
Cassie|  4     | 4
Luke  |  7     | 4

我想要的是每个用户的最小周和最大周值的列表.像这样的东西:

Name  |minWeek | Value |maxWeek | value
------+--------+-------+--------+-------
John  |  1     | 9     | 8      | 14
Cassie|  2     | 5     | 5 …

我有一个具有多个级别的树,其中叶节点可能具有属性"count".我想计算每个子树的总计数,并将这些值缓存在每个子树的根节点中.这可能在Gremlin？

这是一个优化问题,这是我目前的(工作)情况:

• Spark使用spark-jobserver以独立模式运行;
• 我有一个镶木地板文件,其中约有3M行作为一张表缓存在内存中;
• 该表是来自电子商务网站的所有数据的综合表,每行代表一个用户,但用户可以拥有更多行;

客户端请求是执行SQL查询,并将结果显示在某些表的网页上,每个表都代表一个带计数器的指标,如:

年龄=> 18-20:15位用户,21-35位:42位用户,......

国家=>美国:22个用户,GB:0个用户,......

等等.计算所有表(以及一些关于用户会话,基于活动,期间和年份生成的会话),我们目前有约200个指标.

生产中最后发布的系统使用(将df视为SQL查询产生的DataFrame):

df.rdd.aggregate(metricsMap) (

      (acc: MetricsMap, r:Row) => {
        acc.analyzeRow(r)
        acc
      },

      (acc1: MetricsMap, acc2: MetricsMap) => {
        acc1.merge(acc2)
        acc1
      }
    ) 

其中MetricsMap是用于提取和从行聚合数据的对象.

此操作非常占用CPU,并且在服务器上从没有参数的查询中提取数据需要大约20秒(因此来自镶木地板文件中的所有数据).

我决定使用聚合,因为对于他们的统计分析,他们想要多个预期:一些指标应该由用户密钥计数,另一个指标用户名(对于网站......)和另一个按产品密钥计算.使用这种方法我只需要循环一次结果,但我不知道这是否是更好的方法......

这是更好的方法,还是存在一些其他(更快)的方法来获得相同的结果？

关于预先计算度量的问题,他们可以对数据集进行的查询没有约束,所以我不知道这是否可能......你能举个例子吗？

回答一些问题

好像这段代码:

#include <string>
#include <vector>

struct bla
{
    std::string a;
    int b;
};

int main()
{
    std::vector<bla> v;
    v.emplace_back("string", 42);
}

可以在这种情况下正常工作,但它没有(我理解为什么).给bla构造函数解决了这个问题,但是删除了类型的聚合性,这可能会产生深远的影响.

这是标准中的疏忽吗？或者我错过了某些会在我脸上爆炸的情况,或者它不像我想的那么有用？