标签: aggregate

目前我有这个查询：

select 
    sum(case when my_table.property_type = 'FLAT' then my_table.price else 0 end) as Flat_Current_Asking_Price,
    sum(case when my_table.property_type_mapped = 'SEMIDETACHED' then my_table.price else 0 end) as Semidetached_Current_Asking_Price
from 
    my_table;

所以如果my_table有以下值：

property_type | price
--------------+-------
FLAT          | 5000
SEMIDETACHED  | 9000
FLAT          | 6000

查询将返回：

Flat_Current_Asking_Price | Semidetached_Current_Asking_Price
--------------------------+-----------------------------------
11000                     | 9000

如何替换将sum值累积到数组中以获取？

Flat_Current_Asking_Price | Semidetached_Current_Asking_Price
--------------------------+-----------------------------------
{5000, 6000}              | {9000}

我对float/real数据类型的聚合下推有问题。根据文档，“任何数据类型 <= 64 位”或 8 字节 () 支持聚合下推：

• 支持的聚合运算符有 MIN、MAX、SUM、COUNT、AVG
• 支持任何 <= 64 位的数据类型。例如，支持 bigint 是因为它的大小是 8 个字节，但不支持十进制 (38,6)，因为它的大小是 17 个字节。此外，不支持字符串类型
• 聚合运算符必须位于 SCAN 节点或带有 group by 的 SCAN 节点之上

无论我做什么，它都不起作用。我尝试使列可以为空而不为空。分组和无分组。

我们在最新版本的 SQL Server 2016 (SP1-CU3) 上运行。我想知道有人经历过吗？这对我来说似乎是一个错误。我错过了什么吗？

如果您遇到同样的问题，请为我的 SQL Server 反馈请求点赞。现在我面临着将float列转换为numeric. 但是numeric类型的操作通常比较慢。所以我可能在一个地方赢了，在另一个地方输了。我已成功测试numeric(15,12)。

这是说明问题的脚本（请启用实际执行计划以查看问题）：

DROP TABLE IF EXISTS dbo.TestTable;

CREATE TABLE dbo.TestTable 
(
     cKey             INT               NOT NULL
   , cGroup           INT               NOT NULL
   , cNumeric36_3     NUMERIC(36, 3)    NULL
   , …

给定一个数据集（GIN索引为values）：

key | values
-------------
 1  | {4,2,1}
 1  | {2,5}
 2  | {4,1,3}

我想聚合数组：

key | values
-------------
 1  | {4,2,1,5}
 2  | {4,1,3}

我的第一个想法不起作用：

SELECT key, array_agg(DISTINCT unnest(values)) AS values FROM data GROUP BY key

[0A000] 错误：聚合函数调用不能包含返回集合的函数调用
提示：您可以将返回集合的函数移动到 LATERAL FROM 项中。

不熟悉LATERAL FROM，对我来说如何实现所需的输出并不明显。

我正在尝试编写一个 PostgreSQL array_agg() 变体，它返回空数组'{}'而不是 NULL。为了避免自定义聚合函数对性能的影响CREATE AGGRGATE，我尝试重新使用内置的array_agg_transfn和array_agg_finalfn。从文档中的代码示例开始，类似于 array_agg 的初始版本可以工作（作为数据库超级用户）：

CREATE AGGREGATE array_agg_z (anynonarray)
(
    sfunc = array_agg_transfn,
    stype = internal,
    finalfunc = array_agg_finalfn,
    finalfunc_extra
);

它按预期在空输入上返回 NULL：

=> SELECT array_agg_z(i) IS NULL FROM (SELECT 0 WHERE 1 = 2) t(i);
 ?column? 
----------
 t
(1 row)

现在，要更改array_agg_z()为在空输入上返回空数组，我尝试将其设置initcond为'{}'如下：

CREATE AGGREGATE array_agg_z (anynonarray)
(
    sfunc = array_agg_transfn,
    stype = internal,
    finalfunc = array_agg_finalfn,
    initcond = '{}',
    finalfunc_extra
); …

我们有一个租用的数据仓库，我们正在做报告。查询开始需要很长时间，我们正在寻找减少这种情况的选项。目前有两个想法。

1. 创建租户特定的聚合表，并从中查询。

2. 根据租户对数据进行水平分区。

第一个选项意味着对于每个加入的新租户，我们都需要创建一组新表。这并不难，因为新租户的注册会提前几周通知，如果我们忘记了，就会很早就发现缺少报告。

对我来说，对数据进行分区听起来是一种更好的方法，因为我们不会复制数据。我们不必依赖于将新数据传输到聚合表的过程。

我想知道这些选项中的哪一个会更好，如果有人以前有过类似的经历。对数据进行分区真的有帮助吗？或者与将所有数据放在一个“空间”中没有太大区别？

而且，在 Oracle 10g 中，如何对数据进行水平分区？如果我有下表：

TABLE Transaction(id, tenant_id, a, b, c, d)

我们将很快迁移到 Oracle 11g，因此将不胜感激跨版本分区的任何差异。

（注意：我尝试使用分区标签，但没有足够的代表，如果其他人可以添加一个很酷的标签）

我有一个 MySQL 数据库服务器，它接受大量移动应用程序数据进行分析。我想知道出于优化原因，以下架构是否有意义且合适：

我想将 MySQL 数据库服务器拆分为两个单独的服务器，如下所示：

• 服务器 A（主）将接收统计数据进行计算。
• 服务器 B（主）将保留
  • 按需聚合（预先计算的数据）Master
  • 应用
  • 用户数据。

关系黑白服务器将是主-主。

• 服务器 A -> 服务器 B：发送聚合（计算）数据
• 服务器 B -> 服务器 A：发送新的应用程序和用户数据，以便为新跟踪的应用程序执行聚合。

如果我的推理是正确的，你能解释一下我如何准确地做到这一点吗？

假设我有一个表employees，如下所示：

Name     Sex     Role

Bob      M       Developer
Joe      M       QA

现在，我在这个表中遇到了重复行的问题。我会在某个时候修复它，但这不是问题。我目前需要的是查询这样一个表的东西：

Name     Sex     Role

Bob      M       Developer
Bob      M       Janitor
Joe      M       QA
Joe      M       CEO

并将输出以下行：

Name     Role

Bob      Developer, Janitor
Joe      QA, CEO

对我来说，“角色”将被拆分为单独的列还是具有多个值的单个列，这对我来说并不重要。

如果重要，请使用 SQL Server 2008。

我正在检查索引的某些列的选择性。
这种“忽略我给你的”行为记录在哪里？

这给出了 4,851,908、4,841,060 和 1,000,052

SELECT
     COUNT(*), 
     COUNT(DISTINCT Col1), COUNT(DISTINCT Col2)
FROM Sometable;

根据 MySQL 扩展，这提供了 4,843,634 个唯一对

SELECT COUNT(DISTINCT Col1, Col2) FROM Sometable

以下是错误的：无论任何填充列或表达式顺序如何，单个 COUNT(DISTINCT colx) 都给出 4,843,634 唯一对计数。

我预期COUNT(DISTINCT Col1) = 4,841,060，和COUNT(DISTINCT Col1) = 1,000,052。

SELECT COUNT(DISTINCT Col1), COUNT(DISTINCT Col2) FROM Sometable

SELECT COUNT(DISTINCT Col2), COUNT(DISTINCT Col1) FROM Sometable

SELECT COUNT(DISTINCT Col1), 1 AS Filler, COUNT(DISTINCT Col2) FROM Sometable

但这再次给出了另一个聚合的正确值（COUNT(*)如上）

SELECT COUNT(DISTINCT Col1), MAX(col1) AS Filler, COUNT(DISTINCT Col2) FROM Sometable

问题，如果不清楚： …

我不是数据库管理员——只是一个软件工程师。我想知道是否可以减少以下 T-SQL 查询：

SELECT 
  SUM(Price * Quantity) as 'Total',
  SUM(Price * Quantity) * 0.95,
FROM
  SomeTables;

对于这样的事情：

SELECT
  SUM(Price * Quantity) as 'Total',
  'Total' * 0.95,
FROM
  SomeTables;

注意：这只是澄清/支持我的问题的示例。我当前的 SQL 查询比这更大更复杂。

假设我有一个 SELECT 语句，如下所示：

SELECT ..., field1
  FROM ...
 GROUP BY field1

现在假设我想返回第二个字段field2. 碰巧，field2 在功能上依赖于field1（例如，field1 和field2 可能来自同一个表，而field1 是该表的主键）。我现在有两种等效的方法可以将 field2 添加到查询中：

选项1：

SELECT ..., field1, field2
  FROM ...
 GROUP BY field1, field2

选项 2：

SELECT ..., field1, MIN(field2)  /* or some other, arbitrary aggregate function */
  FROM ...
 GROUP BY field1

同样，由于 field2 在功能上依赖于 field1，两个查询都应该返回相同的结果集。

有什么好的理由更喜欢一种选择吗？