标签: aggregate

我有一个 SQL Server 2008 查询

SELECT TOP 10 *
FROM T
WHERE ...
ORDER BY ...

我还想获得总行数。obious 方法是进行第二次查询

SELECT COUNT(*)
FROM T
WHERE ...
ORDER BY ...

有没有有效的方法？

谢谢

如果我有一个包含重要 2 列的表格，

CREATE TABLE foo (id INT, a INT, b INT, KEY a, KEY b);

我怎样才能找到所有的行，a并且b在两行中都相同？例如，在这个数据集中

id | a | b
----------
1  | 1 | 2
2  | 5 | 42
3  | 1 | 42
4  | 1 | 2 
5  | 1 | 2
6  | 1 | 42

我想取回所有行，id=2因为它在(a,b). 基本上，我想找到所有会阻止

ALTER TABLE foo ADD UNIQUE (a, b);

比 n^2 for 循环更好的东西会很好，因为我的表有 10M 行。

对于奖励积分：如何删除除一行之外的所有行（我不在乎哪些行，只要还剩下一行）

考虑带有对象Post和的典型博客Comment。

对于我一直在构建的 DDD 演示示例，我（直到现在）发现实体Post和Comment都适用于同一个聚合——Post聚合。但现在我不太确定..

在我的控制器，我发现，像你所期望的，我需要添加和删除Comments的Posts。使用我当前的模型，我不会跟踪Comment全局的身份（就像蓝皮书建议的那样）。您可能期望我删除 a 的操作Comment可能如下所示：

public ActionResult DeleteComment(int postID, int commentID)

很显然，我需要Post的ID从资源库中，并标识为特定检索Comment上Post，我想删除。

我的问题是DeleteComment(动作的主体：

可以通过Post查询机制遍历以获取Comment删除吗？像这样：

var comment = this._postRepo.WithID(postID).Comments
    .SingleOrDefault(c => c.ID == commentID);
this._postRepo.Delete(comment);
return RedirectToAction("detail", new { id = postID });

..或者我应该Comment从类似于这个的回购中选择？：

var comment = this._postRepo.CommentWithID(commentID)

..或者：

var comment = this._postRepo.CommentWithID(postID, commentID)

上面的两个例子可能看起来有点傻，因为Post如果我可以 …

我有以下数据框：

> str(df)
 'data.frame':  52 obs. of  3 variables:
  $ n    : int  10 20 64 108 128 144 256 320 404 512 ...
  $ step : Factor w/ 4 levels "Step1","Step2",..: 1 1 1 1 1 1 1 1 1 1 ...
  $ value: num  0.00178 0.000956 0.001613 0.001998 0.002975 ...

现在我想归一化/除以df$value属于同一个 n 的值的总和，这样我就可以得到百分比。这不起作用，但显示了我想要实现的目标。在这里，我将属于相同 n 的值的总和预先计算到 dfa 中，并尝试将原始值除以匹配df$value的聚合总数：dfa$valuen

dfa <- aggregate(x=df$value, by=list(df$n), FUN=sum)
names(dfa)[names(dfa)=="Group.1"] <- "n"           
names(dfa)[names(dfa)=="x"] <- "value"
df$value <- df$value / …

我有以下模型类：

class Goods(models.Model):
    name = models.CharField(max_length=100)

class InRecord(models.Model):
    goods = models.ForeignKey(Goods, related_name='in_records')
    timestamp = models.DateTimeField()
    quantity = models.IntegerField()

class OutRecord(models.Model):
    goods = models.ForeignKey(Goods, related_name='out_records')
    timestamp = models.DateTimeField()
    quantity = models.IntegerField()

因此，我想获得一个 QuerySet，其中包含所有具有正存储库的商品。

另一种描述它的方式是，我想过滤具有比 OutRecord 摘要更大的 InRecord 数量摘要的 Goods。

我试过的：

首先，我使用annotate将摘要添加到查询集中：

qs = Goods.objects.annotate(
        qty_in=Sum(in_records__quantity), 
        qty_out=Sum(out_records_quantity)
    )

这似乎有效，但有一个问题，当某些商品没有相关的 in_records 或 out_records 时，注释的字段返回 None。

问题：那么，在这种情况下，我有什么方法可以设置默认值，就像ifnull(max(inreocrd.quantity), 0)sql 中的* 调用一样？

在此之后，我想在该 QuerySet 上添加一个过滤器：

我试过：

qs = qs.filter(qty_in__gt(F(qty_out)))

但是如果没有货物的记录，它仍然不起作用。

请帮忙。

我有一组具有唯一节点的连接边。它们使用父节点连接。考虑以下示例代码和插图：

CREATE TABLE network (
  node integer PRIMARY KEY,
  parent integer REFERENCES network(node),
  length numeric NOT NULL
);
CREATE INDEX ON network (parent);
INSERT INTO network (node, parent, length) VALUES
  (1, NULL, 1.3),
  (2, 1, 1.2),
  (3, 2, 0.9),
  (4, 3, 1.4),
  (5, 4, 1.6),
  (6, 2, 1.5),
  (7, NULL, 1.0);

在视觉上，可以识别两组边缘。如何使用 PostgreSQL 9.1 识别这两个组并length求和？预期结果显示：

 edges_in_group | total_edges | total_length
----------------+-------------+--------------
 {1,2,3,4,5,6}  |           6 |          7.9
 {7}            |           1 |          1.0
(2 rows)

我什至不知道从哪里开始。我需要自定义聚合或窗口函数吗？我可以WITH RECURSIVE用来迭代收集连接的边吗？我的真实案例是一个有 245,000 …

我有一个数据库查询，如：

SELECT 
  Foo,
  Foo2,
  some_calc as Bar,
  some_other_calc as Bar2,
From
 FooBar
-- some inner joins for the calcs
GROUP BY FOO
ORDER BY Bar DESC, Bar2 DESC;

我想使用 order 查询按数据库排序，然后将FOOs组合在一起，以便第一个分组块包含FOO具有最大 Bar 的块。FOOs的第二个分组块包含秒最高的 Bar 等。

但这不起作用，因为 Postgres 不允许随机分组：

column "Bar" must appear in the GROUP BY clause or be used in an aggregate function.

我怎样才能解决这个问题？

示例数据和输出：

????????????????????????????
? FO  ? Bar      ?  Bar 2  ?
????????????????????????????
?  6  ?     10   ?         ?
? …

如何以方便的方式选择表中的所有列和聚合函数？

即说我有一个有 100 列的表，我想发送以下内容

SELECT Max(Columns 44), ALL OTHER COLUMNS
FROM zz
Group by ALL OTHER COLUMNS 

谢谢！

搜索界面中的一个常见问题是您想要返回一组结果，但可能想要返回有关所有文档的信息。（例如，我想查看所有红色衬衫，但想知道还有哪些其他颜色可供选择）。

这有时被称为“分面结果”或“分面导航”。Elasticsearch 参考中的示例在解释原因/方式方面非常清楚，因此我将其用作此问题的基础。

摘要/问题：看起来我可以为此同时使用后过滤器或全局聚合。它们似乎都以不同的方式提供完全相同的功能。它们可能有我看不到的优点或缺点？如果是这样，我应该使用哪个？

我在下面包含了一个完整的示例，其中包含一些文档和基于参考指南中示例的两种类型方法的查询。

选项 1：后置过滤器

请参阅Elasticsearch 参考中的示例

我们可以做的是在我们的原始查询中获得更多结果，因此我们可以“对”这些结果进行聚合，然后过滤我们的实际结果。

这个例子很清楚地解释了它：

但也许您还想告诉用户有多少 Gucci 衬衫有其他颜色可供选择。如果你只是在颜色字段上添加一个术语聚合，你只会得到红色，因为你的查询只返回 Gucci 的红色衬衫。

相反，您希望在聚合期间包括所有颜色的衬衫，然后仅将颜色过滤器应用于搜索结果。

请参阅下面的示例代码中的内容。

一个问题是我们不能使用缓存。这是在（尚未适用于 5.1）elasticsearch 指南中警告：

性能考虑 仅当您需要对搜索结果和聚合进行差异过滤时才使用 post_filter。有时人们会使用 post_filter 进行常规搜索。

不要这样做！post_filter 的性质意味着它在查询之后运行，因此过滤（例如缓存）的任何性能优势都将完全丧失。

post_filter 应该仅与聚合结合使用，并且仅在需要差分过滤时使用。

然而，有一个不同的选择：

选项 2：全局聚合

有一种方法可以进行不受搜索查询影响的聚合。所以不是得到很多，聚合，然后过滤，我们只是得到我们过滤的结果，但对所有东西进行聚合。看看参考

我们可以得到完全相同的结果。我没有阅读任何关于缓存的警告，但似乎最终我们需要做同样多的工作。所以这可能是唯一的遗漏。

由于我们需要子聚合（您不能在同一“级别”上拥有global和 a ）filter，因此它稍微复杂一点。

我读到的关于使用此查询的唯一抱怨是，如果您需要对多个项目执行此操作，则可能必须重复自己。最后，我们可以生成大多数查询，因此重复自己对我的用例来说并不是什么大问题，而且我并不认为这是与“无法使用缓存”同等的问题。

题

似乎这两个功能至少重叠，或者可能提供完全相同的功能。这让我很困惑。除此之外，我想知道其中一个或另一个是否有我没有看到的优势，以及这里是否有任何最佳实践？

例子

这主要来自后过滤器参考页面，但我添加了全局过滤器查询。

映射和文件

PUT /shirts
{
    "mappings": {
        "item": {
            "properties": {
                "brand": { "type": "keyword"},
                "color": { "type": "keyword"},
                "model": …

我正在尝试groupby在 Pandas 中使用自定义函数。我发现 usingapply允许我通过以下方式做到这一点：

（从两组计算新平均值的示例）

import pandas as pd

def newAvg(x):
    x['cm'] = x['count']*x['mean']
    sCount = x['count'].sum()
    sMean = x['cm'].sum()
    return sMean/sCount

data = [['A', 4, 2.5], ['A', 3, 6], ['B', 4, 9.5], ['B', 3, 13]]
df = pd.DataFrame(data, columns=['pool', 'count', 'mean'])

df_gb = df.groupby(['pool']).apply(newAvg)

是否可以将其集成到agg函数中？沿着这些路线：

df.groupby(['pool']).agg({'count': sum, ['count', 'mean']: apply(newAvg)})