标签: window-functions

是否可以将用户定义的聚合(clr)与窗口函数(over)一起使用？

在文档中找不到答案:http://technet.microsoft.com/en-us/library/ms190678.aspx

像这样的 SQL

SELECT empno, deptno, 
COUNT(*) OVER (PARTITION BY deptno) DEPT_COUNT FROM emp WHERE deptno IN (20, 30);

非常有用。

我只是想知道在H2中，我们如何实现类似的功能？也许创建一个 java 程序会起作用。但是这个功能会在 H2 数据库的路线图中吗？

我正在尝试完成以下任务：

SELECT 
   *,
   CASE WHEN 1 THEN SUM(b.myField) ELSE AVG(b.myField) END OVER (PARTITION BY ID)
FROM tbl a
LEFT JOIN tbl2 b ON a.ID = b.aID

这可能与 SQL Server 中的窗口函数有关吗？

我能够在没有 case 语句的情况下完成以下操作：

SELECT 
   *,
   SUM(b.myField) OVER (PARTITION BY ID)
FROM tbl a
LEFT JOIN tbl2 b ON a.ID = b.aID

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

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 …

在 PostgreSQL 9.4 上，我试图在一些连续的行上实现我称之为“聚合函数”的东西。例子：

输入数据：

recipe  prod1   prod2   timestamp
0       5       4       2015-07-02 08:10:34.357
0       2       7       2015-07-02 08:13:45.352
0       7       0       2015-07-02 08:16:22.098
1       3       2       2015-07-02 08:22:14.678
1       9       4       2015-07-02 08:22:56.123
2       2       6       2015-07-02 08:26:37.564
2       1       7       2015-07-02 08:27:33.109
2       0       8       2015-07-02 08:31:11.687
0       3       5       2015-07-02 08:40:01.345
1       4       2       2015-07-02 08:42:23.210

期望的输出：

recipe  prod1_sum   prod2_avg   timestamp_first             timestamp_last
0       14          3.6666      2015-07-02 08:10:34.357     2015-07-02 08:16:22.098
1       12          3           2015-07-02 08:22:14.678     2015-07-02 08:22:56.123
2 …

我有一些看起来像这样的数据：

CustID  EventID     TimeStamp
1       17          1/1/15 13:23
1       17          1/1/15 14:32
1       13          1/1/25 14:54
1       13          1/3/15 1:34
1       17          1/5/15 2:54
1       1           1/5/15 3:00
2       17          2/5/15 9:12
2       17          2/5/15 9:18
2       1           2/5/15 10:02
2       13          2/8/15 7:43
2       13          2/8/15 7:50
2       1           2/8/15 8:00

我正在尝试使用 row_number 函数使其看起来像这样：

CustID  EventID     TimeStamp      SeqNum
1       17          1/1/15 13:23    1
1       17          1/1/15 14:32    1
1       13          1/1/25 14:54    2
1       13          1/3/15 1:34     2
1 …

下面是我试图在 Redshift 数据库中实现的示例。

我有一个变量current_value，我想创建一个新列value_desired：

• 一样 current_value前一行为空相同
• 如果前一行非空，则等于前一个非空值

这听起来像是一项简单的任务，但我还没有找到方法来做到这一点。

row_numb     current_value   value_desired
1
2
3            47              47
4
5            45              45
6
7
8            42              42
9            41              42
10           40              42
11           39              42
12           38              42
13
14           36              36
15
16
17           33              33
18           32              33

我已经尝试过 LAG() 函数，但我只能获得以前的值（不是“非空”块中的第一个值），这是我的看法：

SELECT *
    , CASE WHEN current_value is not null and LAG(current_value) is null THEN current_value
           WHEN current_value is not null and LAG(current_value) is …

我试图获取mode()分组数据集的 ，但没有对结果进行分组。（使用 Postgres 9.5，如果需要可以升级。）

例如，用户有一个“最喜欢的颜色”，并且属于一个组。获取mode()组内具有“最喜欢的颜色”的用户列表。

窗口函数适用于大多数聚合，但mode()似乎是与窗口函数不兼容的例外。有没有其他方法可以解决这个问题？这是我到目前为止一直在玩的东西......

有效但给出分组结果，我正在寻找未分组的结果：

SELECT group_id, 
    mode() WITHIN GROUP (ORDER BY color)
FROM users
GROUP BY group_id;

无效的语法（只是我试图完成的一个例子）：

SELECT id, color, group_id, 
    mode(color) OVER (PARTITION BY group_id)
FROM users;

或者：

SELECT id, color, group_id, 
    mode() WITHIN GROUP (ORDER BY color) OVER (PARTITION BY group_id)
FROM users;

我尝试使用横向连接，但如果不在连接WHERE内部和外部重新迭代我的子句，就无法使其正常工作（当此查询变得更复杂时，我不希望这样做）：

SELECT u1.id, u1.group_id, u1.color, mode_color
FROM users u1
LEFT JOIN LATERAL
    (SELECT group_id, mode() WITHIN GROUP (ORDER BY color) as mode_color
     FROM …

使用两个预定义边界在 Spark SQL 中指定窗口间隔的正确方法是什么？

我试图在“3 小时前到 2 小时前”的窗口中总结我的表中的值。

当我运行此查询时：

select *, sum(value) over (
partition by a, b
order by cast(time_value as timestamp)
range between interval 2 hours preceding and current row
) as sum_value
from my_temp_table;

那个有效。我得到了我期望的结果，即落入 2 小时滚动窗口的值的总和。

现在，我需要的是让滚动窗口不绑定到当前行，而是考虑 3 小时前和 2 小时前之间的行。我试过：

select *, sum(value) over (
partition by a, b
order by cast(time_value as timestamp)
range between interval 3 hours preceding and 2 hours preceding
) as sum_value
from my_temp_table;

但我得到extraneous input 'hours' expecting {'PRECEDING', …

有谁知道如何用字符串替换列中的空值，直到它遇到一个新字符串，然后该字符串替换它下面的所有空值？我有一个看起来像这样的专栏

原始列：

PAST_DUE_COL           
91 or more days pastdue        
Null
Null
61-90 days past due          
Null
Null
31-60 days past due
Null
0-30 days past due
Null       
Null
Null            

预期结果栏：

PAST_DUE_COL           
91 or more days past due        
91 or more days past due
91 or more days past due
61-90 days past due          
61-90 days past due 
61-90 days past due 
31-60 days past due
31-60 days past due
0-30 days past due
0-30 days past due      
0-30 days past due …