标签: group-by

我正在尝试为员工时间记录完成一些报告。

我们有两个专门针对这个问题的表格。员工列在Members表中，他们每天输入他们已完成工作的时间条目并存储在Time_Entry表中。

使用 SQL Fiddle 的示例设置：http ://sqlfiddle.com/#!3/e3806/7

最终的结果我要的是一个表，表示所有的Members列中的列表，然后将展示他们的总和小时，在其他列查询的日期。

问题似乎是，如果Time_Entry表中没有特定成员的行，那么该成员现在有行。我尝试了几种不同的连接类型（左、右、内、外、全外等），但似乎都没有给我想要的，这将是（基于 SQL Fiddle 中的最后一个示例）：

/*** Desired End Result ***/

Member_ID   | COUNTTime_Entry | TIMEENTRYDATE | SUMHOURS_ACTUAL | SUMHOURS_BILL
ADavis      | 0               | 11-10-2013    | 0               | 0
BTronton    | 0               | 11-10-2013    | 0               | 0
CJones      | 0               | 11-10-2013    | 0               | 0
DSmith      | 0               | 11-10-2013    | 0               | 0
EGirsch     | 1               | 11-10-2013    | 0.92 …

我有一个我认为可以使用窗口函数解决的情况，但我不确定。

想象一下下表

CREATE TABLE tmp
  ( date timestamp,        
    id_type integer
  ) ;

INSERT INTO tmp 
    ( date, id_type )
VALUES
    ( '2017-01-10 07:19:21.0', 3 ),
    ( '2017-01-10 07:19:22.0', 3 ),
    ( '2017-01-10 07:19:23.1', 3 ),
    ( '2017-01-10 07:19:24.1', 3 ),
    ( '2017-01-10 07:19:25.0', 3 ),
    ( '2017-01-10 07:19:26.0', 5 ),
    ( '2017-01-10 07:19:27.1', 3 ),
    ( '2017-01-10 07:19:28.0', 5 ),
    ( '2017-01-10 07:19:29.0', 5 ),
    ( '2017-01-10 07:19:30.1', 3 ),
    ( '2017-01-10 07:19:31.0', 5 ),
    ( '2017-01-10 07:19:32.0', 3 ), …

看看这个查询。它非常简单（有关表和索引定义以及重现脚本，请参见文章末尾）：

SELECT MAX(Revision)
FROM dbo.TheOneders
WHERE Id = 1 AND 1 = (SELECT 1);

注意：“AND 1 = (SELECT 1) 只是为了防止此查询被自动参数化，我觉得这使问题变得混乱 - 尽管有或没有该子句，它实际上获得了相同的计划

这是计划（粘贴计划链接）：

由于那里有一个“top 1”，我很惊讶地看到流聚合运算符。对我来说似乎没有必要，因为保证只有一行。

为了测试这个理论，我尝试了这个逻辑上等效的查询：

SELECT MAX(Revision)
FROM dbo.TheOneders
WHERE Id = 1
GROUP BY Id;

这是那个计划（粘贴计划链接）：

果然，group by 计划能够在没有流聚合操作符的情况下通过。

请注意，两个查询都从索引的末尾“向后”读取并执行“前 1”以获得最大修订。

我在这里缺少什么？ 流聚合是否在第一个查询中真正起作用，还是应该能够消除它（这只是优化器的一个限制，它不是）？

顺便说一下，我意识到这不是一个非常实际的问题（两个查询都报告 0 毫秒的 CPU 和经过时间），我只是对这里展示的内部/行为感到好奇。

这是我在运行上述两个查询之前运行的设置代码：

DROP TABLE IF EXISTS dbo.TheOneders;
GO

CREATE TABLE dbo.TheOneders
(
    Id INT NOT NULL,
    Revision SMALLINT NOT NULL,
    Something NVARCHAR(23),

    CONSTRAINT PK_TheOneders PRIMARY KEY NONCLUSTERED …

Microsoft 当前允许使用此语法。

SELECT *
FROM ( VALUES (1) ) AS g(x)
WHERE EXISTS (
  SELECT *
  FROM ( VALUES (1),(1) )
    AS t(x)
  WHERE g.x = t.x
  HAVING count(*) > 1
);

请注意，没有GROUP BY中EXISTS条款，是有效的ANSI SQL。或者它只是暴露了一个实现细节。

作为参考，PostgreSQL 中不允许使用相同的语法。

错误：列“tx”必须出现在 GROUP BY 子句中或用于聚合函数中

但是这种语法是允许的..

SELECT *
FROM ( VALUES (1) ) AS g(x)
WHERE EXISTS (
  SELECT 1  -- This changed from the first query
  FROM ( VALUES (1),(1) )
    AS t(x)
  WHERE g.x = t.x
  HAVING count(*) …

我习惯了包括 SQL Server 在内的 Microsoft 技术。今天我遇到了一个问答，其中引用了 MySQL 文档中的以下段落：

标准 SQL会拒绝您的查询，因为您不能在聚合查询中选择不属于 GROUP BY 子句的非聚合字段。MySQL 扩展了 GROUP BY 的使用，以便选择列表可以引用未在 GROUP BY 子句中命名的非聚合列。这意味着前面的查询在 MySQL 中是合法的。您可以使用此功能通过避免不必要的列排序和分组来获得更好的性能。但是，这主要在未在 GROUP BY 中命名的每个非聚合列中的所有值对于每个组都相同时很有用。服务器可以自由地从每个组中选择任何值，因此除非它们相同，否则选择的值是 不确定的。

MySQL允许这样做是否违反了标准？如何？允许这样做的结果是什么？

我在数据库中有一个消息表，其中包括发件人 ID 和消息类型（当然还有更多与此问题无关的列）。我尝试创建一个查询来计算用户发送的每种类型的消息数量。

例如，如果我有下表：

---------------------------
身份证 | 用户 ID | 消息类型
---------------------------
1 | 1 | 私人的
2 | 1 | 民众
3 | 1 | 私人的
---------------------------

然后我想得到以下内容：

---------------------
身份证 | 私人 | 民众
---------------------
1 | 2 | 1
---------------------

所以实际上我想按 message_type 和 user_id 分组，但不是为每个用户生成多行，我想创建多个列，每个 message_type 一个

我可以在不对查询中的消息类型进行硬编码的情况下实现这一点吗？

有 3 列的表：

ID  category    flag
1       A       1
2       A       0
3       A       0
4       B       0
5       C       0

我想选择flag = 1每个类别至少有一次的所有行。

预期成绩：

ID  category    flag
1       A       1
2       A       0
3       A       0

可以使用这样的临时表来解决：

select ID into #tempTable from someTable where flag = 1
select * from someTable join #tempTable on someTable.ID = #tempTable.ID

但我更喜欢分组的解决方案，我很难想出。任何帮助将不胜感激。

我balances在 PostgreSQL 9.3 中有一个表，如下所示：

CREATE TABLE balances (
  user_id INT
, balance INT
, as_of_date DATE
);

INSERT INTO balances (user_id, balance, as_of_date) VALUES
  (1, 100, '2016-01-03')
, (1,  50, '2016-01-02')
, (1,  10, '2016-01-01')
, (2, 200, '2016-01-01')
, (3,  30, '2016-01-03');

它只包含用户进行交易的日期的余额。我需要它为每个用户包含一行以及给定日期范围内每个日期的余额。

• 如果用户在范围内的给定日期没有行，我需要使用他们前一天的余额。
• 如果用户在范围内的给定日期之后创建了他们的帐户，我需要避免为该用户/日期组合创建一行。

我可以引用一个accounts表来获取用户的create_date：

CREATE TABLE accounts (
  user_id INT
, create_date DATE
);

INSERT INTO accounts (user_id, create_date) VALUES
  (1, '2015-12-01')
, (2, '2015-12-31')
, (3, '2016-01-03');

我想要的结果是这样的：

+---------+---------+--------------------------+
| …

例如，我们有：

element | group_value | value
a       | 1           | 2000
a       | 2           | 1500
a       | 2           | 2500
b       | 1           | 1000

我只想返回最后 3 条记录，因为这些记录是每个元素具有最大组值的记录。

我知道有一个带有子查询的解决方案，但有没有一个有效的解决方案？

澄清：对于元素“a”：

2 是最高的 group_value，因此它返回第 2 行和第 3 行>（而不是第一行，因为它的组值不是最高的），

对于元素“b”：

1 是 > 最高的 group_value 所以它返回第 4 行

我的（性能不好）解决问题的方法是：

select * 
from   x x1 
where (element, group_value) in (select   element, max(group_value) 
                                 from     x x2 
                                 where    x1.element = x2.element 
                                 group by x2.element)

给定band表格，其中一json列包含一个数组：

id | people
---+-------------
1  | ['John', 'Thomas']
2  | ['John', 'James']
3  | ['James', 'George']

如何列出每个名称所属的乐队数量？
期望的输出：

name   | count
-------+------------
John   | 2
James  | 2
Thomas | 1
George | 1