标签: aggregate

我目前正在深入研究DDD,需要一点点启发.

我有两个实体

• Temple
• TempleVariant

Temple(耳机)包含基本信息(名称,描述,...),并有n个变体,其中包含技术说明(CAD绘图,尺寸,...)

我的第一印象是: Temple并TempleVariant形成一个聚合 - 它们属于一起:它们似乎非常紧密耦合

• 如果我删除一个Temple全部TempleVariants应该同样删除
• TempleVariant没有 Temple(至少没有意义)s 不可能存在

但后来我读到,聚合根之外的任何内容都不允许引用另一个聚合内的实体.但实际上并没有Temple被外部实体引用而是引用了TempleVariants.

这是否意味着在(DDD)现实中Temple并且TempleVariant是不同的聚合,它们似乎只是一个聚合体？

但是,如果我删除Temple怎么办？正如我所说,TempleVariants也必须删除.但那会违反规则"一次聚合 - 改变 - 一次交易"(或者所谓的:),因为我的"感觉"是我必须在一次交易中删除它们......

所以我的问题是:

• 那两个聚合？
• 如果是这样:如何处理删除？

Lg
warappa

我有这个查询的结果

SELECT
    myTable.Branch AS Branch,
    myTable.Quarter AS Quarter,
    SUM(myTable.Sales) AS Sales
FROM
    myTable
GROUP BY
    myTable.Branch,
    myTable.Quarter

Branch  Quarter Sales
B1      Q1      17
B1      Q2      7
B1      Q3      1
B1      Q4      8
B1      Q5      12
B2      Q1      8
B2      Q2      5
B2      Q3      2
B2      Q4      14
B2      Q5      17

现在我想得到计算成员让我们说Q1-Q3结果应该是这样的

Branch  Quarter     Sales
B1      Q1          17
B1      Q2          7
B1      Q3          1
B1      Q4          8
B1      Q5          12
B1      Q1-Q3       16
B2      Q1          8
B2      Q2          5 …

我一直收到这个错误,我不太清楚这意味着什么.我的所有变量名都是一致的,没有拼写错误.我在这里错过了什么吗？

代码

datNewagg <- aggregate (dataNew, by = list('x', 'y', 'z', 'a', 'ab'), 
                                                             FUN = mean)  

产生错误

  Error in aggregate.data.frame(datNew, by = list("x", "y",  : 
  arguments must have same length

我今天正在对一些慢速SQL查询进行故障排除,并且不太了解下面的性能差异:

当尝试max(timestamp)基于某些条件从数据表中提取时,使用MAX()比ORDER BY timestamp LIMIT 1匹配行存在时慢,但如果找不到匹配的行则相当快.

SELECT timestamp
FROM data JOIN sensors ON ( sensors.id = data.sensor_id )
WHERE sensor.station_id = 4
ORDER BY timestamp DESC
LIMIT 1;
(0 rows)  
Time: 1314.544 ms

SELECT timestamp
FROM data JOIN sensors ON ( sensors.id = data.sensor_id )
WHERE sensor.station_id = 5
ORDER BY timestamp DESC
LIMIT 1;
(1 row)  
Time: 10.890 ms

SELECT MAX(timestamp)
FROM data JOIN sensors ON ( sensors.id = data.sensor_id )
WHERE sensor.station_id …

请考虑以下代码:

struct A {
  int x;
};

int main() {
  A a;
  A b{a};
}

这个程序是否符合C++ 11标准？在我的N3797副本中说

8.5.4列表初始化 [dcl.init.list]

3:对象或类型引用的列表初始化T定义如下:
- 如果T是聚合,则执行聚合初始化(8.5.1).
- 否则,如果T是std::initializer_list<E>,...的特化
- 否则,如果T是类类型,则考虑构造函数.枚举适用的构造函数,并使用重载决策选择最佳构造函数.如果转换任何类型需要缩小转换,则程序格式错误.
- 否则,如果初始化列表具有单个元素类型E且要么T不是引用类型,要么与引用相关E,则从该元素初始化对象或引用; 如果将元素转换为需要缩小转换T,则程序格式错误.
- 否则,如果T是引用类型,则类型引用的临时值pr T是copy-list-initialized或direct-list-initialized,具体取决于引用的初始化类型,引用绑定到该临时.
- 否则,如果初始化列表没有元素,则对象进行值初始化.
- 否则,该程序格式不正确.

示例的要点是,类型是聚合,但列表初始化应该调用复制构造函数.在gcc 4.8和gcc 4.9,在C++ 11标准,它失败:

main.cpp: In function ‘int main()’:
main.cpp:7:8: error: cannot convert ‘A’ to ‘int’ in initialization
   A …

通常,组中的所有行都将传递给聚合函数.我想使用条件过滤行,以便只将组中的某些行传递给聚合函数.PostgreSQL可以实现这样的操作.我想用Spark SQL DataFrame(Spark 2.0.0)做同样的事情.

代码可能看起来像这样:

val df = ... // some data frame
df.groupBy("A").agg(
  max("B").where("B").less(10), // there is no such method as `where` :(
  max("C").where("C").less(5)
)

所以对于像这样的数据框:

| A | B | C |
|  1| 14|  4|
|  1|  9|  3|
|  2|  5|  6|

结果将是:

|A|max(B)|max(C)|
|1|    9|      4|
|2|    5|   null|

是否可以使用Spark SQL？

请注意,通常max可以使用任何其他聚合函数,并且在具有任意过滤条件的同一列上可能存在多个聚合.

是否有可能预先计算(缓存)两个信号差异的值的聚合(最小值/最大值/平均值)？

我有几个通道(例如50个),每秒进行一次或多次测量,我可以轻松存储预先计算的1分钟或15分钟聚合,以便更快地显示.

但其中一个要求是显示相对值的图表.例如,如果我有频道C1,C2并且C3用户希望在单独的图表上查看平均值C1和平均值(C2 - C3)(或最小值/最大值15分钟).

例如,假设我有这两个频道(还有48个频道):

t(min)    0    +1   +2   +3   +4   +5   +6   +7   +8   +9   +10
C1       0.0  0.1  0.2 -0.1  0.0  0.1  0.3  0.5  0.7  0.9  0.2
C2       0.1  0.4  0.2  0.1 -0.1  0.5  0.6  0.1  0.2  0.3  0.0

我可以预先计算并存储5分钟的聚合:

t(min)    0 to +4    +5 to +10
C1_min     -0.1         0.1
C1_max      0.2         0.9
C2_min     -0.1         0.0
C2_max      0.4         0.6

并且很容易从中获得10分钟或15分钟的聚合.

但是,如果用户想要查看min(C2-C1)或max(C2-C1)5分钟聚合,对于这50个频道的任何组合,似乎我无法重复使用此信息. …

我正在尝试从数据树结构中计算出小时数.我可以直接在父节点下添加小时数,但是我不能包括分配给树中父节点的小时数.任何建议都会很棒.

这就是我得到的:

levelName hours totalhours 1 Ned NA 1 2 °--John 1 3 3 °--Kate 1 3 4 ¦--Dan 1 1 5 ¦--Ron 1 1 6 °--Sienna 1 1

这就是我要找的东西:

levelName hours totalHours 1 Ned NA 5 2 °--John 1 5 3 °--Kate 1 4 4 ¦--Dan 1 1 5 ¦--Ron 1 1 6 °--Sienna 1 1

这是我的代码:

# Install package
install.packages('data.tree')
library(data.tree)

# Create data frame
to <- c("Ned", "John", "Kate", "Kate", "Kate")
from <- c("John", "Kate", "Dan", "Ron", …

我想在一组(纬度,经度)对上使用单个LINQ聚合,并产生两个(纬度,经度)对:

public Location {
   public double Latitude;
   public double Longitude;
}

List<Location> border = ...;

我可以通过以下方式轻松获得最小(纬度,经度)对:

var minBorder =  border.Aggregate( new Location()
                                 { Latitude = double.MaxValue, Longitude = double.MaxValue },
                                 (current, next) =>
                                   new Location()
                                   {
                                     Latitude = (next.Latitude < current.Latitude) ? next.Latitude : current.Latitude,
                                     Longitude = (next.Longitude < current.Longitude) ? next.Longitude : current.Longitude
                                   }) ;

如果可能的话,我想使用单个聚合返回两个位置; 最小(纬度,经度)对和最大(纬度,经度)对而不是一对.

如果我为结果声明一个类:

public class BorderBounds {

   public double MinLatitude;
   public double MinLongitude;

   public double MaxLatitude;
   public double MaxLongitude;
}

并修改聚合:

var borderBounds = …

我有一个与此类似的问题，但由collect_list操作的列数由名称列表给出。例如：

scala> w.show
+---+-----+----+-----+
|iid|event|date|place|
+---+-----+----+-----+
|  A|   D1|  T0|   P1|
|  A|   D0|  T1|   P2|
|  B|   Y1|  T0|   P3|
|  B|   Y2|  T2|   P3|
|  C|   H1|  T0|   P5|
|  C|   H0|  T9|   P5|
|  B|   Y0|  T1|   P2|
|  B|   H1|  T3|   P6|
|  D|   H1|  T2|   P4|
+---+-----+----+-----+


scala> val combList = List("event", "date", "place")
combList: List[String] = List(event, date, place)

scala> val v = w.groupBy("iid").agg(collect_list(combList(0)), collect_list(combList(1)), collect_list(combList(2)))
v: org.apache.spark.sql.DataFrame = [iid: string, collect_list(event): …