标签: window-functions

我正在使用PostgreSQL版本9.1并查看Postgres文档,我知道可以执行以下操作:

SELECT salary, sum(salary) OVER (ORDER BY salary) FROM empsalary;

这适用于我的查询.

现在我需要能够在？中指定别名而不是列名OVER (ORDER BY ...)？

我试过这个:

编辑:我以前忘了添加rank()到此查询:

SELECT salary, <complex expression> as result, rank() OVER (ORDER BY result) FROM empsalary;

我说错了 column "result" does not exist.

是否可以在此处指定别名而不是列名？我错过了一些特殊的语法吗？

编辑:

我正在使用Hibernate,一些本机SQL用于窗口功能.生成并执行的完整SQL如下:

select 
       rank() OVER (ORDER BY deltahdlcOverruns DESC) as rank, 

       this_.deviceNo as y1_, 

       (SELECT _dev_.hdlcOverruns FROM abstractperformancestatistic _abs_ 
        INNER JOIN enddevicestatistic _dev_ ON _dev_.id = _abs_.id 
        INNER JOIN linkstatistic _link_ ON _link_.id = _dev_.linkStatistic_id 
        INNER …

我正在使用Postgresql版本9.1.9:

select version();
"PostgreSQL 9.1.9 on armv7l-unknown-linux-gnueabihf,
 compiled by gcc (Debian 4.6.3-14+rpi1) 4.6.3, 32-bit"

我有一个简单的表(称为Test),它有一个可以为空的bigint列(称为A).该表包含以下数据:

NULL
1
2

现在我想创建一个密集的排名(因此使用dense_rank()函数)所以我做了以下查询:

select "A", dense_rank() over (order by "A" desc) from public."Test"

返回:

NULL,1
2,2
1,3

有趣的是,如果我在SQL Server 2008 R2中设置完全相同的东西并运行相同的查询它返回:

2,1
1,2
NULL,3

所以,我感兴趣的是谁是正确的,但更实际的是,我想要的是SQL Server行为,那么,我怎样才能使PostgreSQL将null视为排名的底部？

(即将NULLS排序为小于任何值)

我在dense_rank页面上注意到了这一点,但它并没有特别谈论这个函数,但也许这是一个线索？

注意:SQL标准为lead,lag,first_value,last_value和nth_value定义了RESPECT NULLS或IGNORE NULLS选项.这在PostgreSQL中没有实现:行为总是与标准的默认行为相同,即RESPECT NULLS.同样,未实现nth_value的标准FROM FIRST或FROM LAST选项:仅支持默认的FROM FIRST行为.(您可以通过反转ORDER BY排序来实现FROM LAST的结果.)

我正在使用PostgreSQL 9.2.
我有一些表,其中包含一些设备停止运行的时间.

+----------+----------+---------------------+
| event_id |  device  |         time        |
+----------+----------+---------------------+
|        1 | Switch4  | 2013-09-01 00:01:00 |
|        2 | Switch1  | 2013-09-01 00:02:30 |
|        3 | Switch10 | 2013-09-01 00:02:40 |
|        4 | Switch51 | 2013-09-01 03:05:00 |
|        5 | Switch49 | 2013-09-02 13:00:00 |
|        6 | Switch28 | 2013-09-02 13:01:00 |
|        7 | Switch9  | 2013-09-02 13:02:00 |
+----------+----------+---------------------+

我希望将行分组+/- 3分钟的时差,如下所示:

+----------+----------+---------------------+--------+
| event_id |  device  |         time        |  group …

我必须计算产品的库存成本，因此对于每次购买后的每种产品，我必须重新计算加权平均成本。

我认为每次进出后都会带给我当前产品的库存：

document_type   document_date   product_id  qty_out qty_in  price       row_num stock_balance
SI              01/01/2014      52          0       600     1037.28     1           600
SI              01/01/2014      53          0       300     1357.38     2           300
LC              03/02/2014      53          100     0       1354.16     3           200
LC              03/02/2014      53          150     0       1355.25     4           50
LC              03/02/2014      52          100     0       1035.26     5           500
LC              03/02/2014      52          200     0       1035.04     6           300
LF              03/02/2014      53          0       1040    1356.44     7           1090
LF              03/02/2014      52          0       1560    1045        8           1860
LC              04/02/2014      52          120 …

假设您有以下PostgreSQL稀疏表列出预订日期:

CREATE TABLE reserved_dates (
    reserved_days_id    SERIAL  NOT NULL,
    reserved_date       DATE    NOT NULL
);

INSERT INTO reserved_dates (reserved_date) VALUES
    ('2014-10-11'),
    ('2014-10-12'),
    ('2014-10-13'),
    -- gap
    ('2014-10-15'),
    ('2014-10-16'),
    -- gap
    ('2014-10-18'),
    -- gap
    ('2014-10-20'),
    ('2014-10-21');

如何将这些日期汇总到连续日期范围(没有间隙的范围)？如:

 start_date | end_date
------------+------------
 2014-10-11 | 2014-10-13
 2014-10-15 | 2014-10-16
 2014-10-18 | 2014-10-18
 2014-10-20 | 2014-10-21

这是我到目前为止所提出的,但我只能start_date这样:

WITH reserved_date_ranges AS (
    SELECT reserved_date,
           reserved_date
           - LAG(reserved_date) OVER (ORDER BY reserved_date) AS difference
    FROM reserved_dates
)
SELECT *
FROM reserved_date_ranges
WHERE difference > 1 OR …

我写了这个并在Oracle中成功执行

COUNT (DISTINCT APEC.COURSE_CODE) OVER (
                                            PARTITION BY s.REGISTRATION_NUMBER
                                            ,APEC.APE_ID
                                            ,COV.ACADEMIC_SESSION
                                            ) APE_COURSES_PER_ACADEMIC_YEAR

我正在尝试在SQL Server中实现相同的结果(我们的源数据库使用Oracle,但我们的仓库使用SQL Server).

我知道SQL Server 2008中的窗口函数不支持distinct - 有人可以提出替代方案吗？

我有这样一张桌子:

Name   activity  time

user1  A1        12:00
user1  E3        12:01
user1  A2        12:02
user2  A1        10:05
user2  A2        10:06
user2  A3        10:07
user2  M6        10:07
user2  B1        10:08
user3  A1        14:15
user3  B2        14:20
user3  D1        14:25
user3  D2        14:30

现在,我需要这样的结果:

Name   activity  next_activity

user1  A2        NULL
user2  A3        B1
user3  A1        B2

我想检查每个用户A组的最后一项活动以及接下来B组的活动类型(B组的活动总是在A组活动后进行).其他类型的活动对我来说并不感兴趣.我试过使用该lead()功能,但它没有奏效.

我怎么能解决我的问题？

我有两张桌子。一种是Reference表，用来排序优先级，一种是Customer表格。该Reference表用于为表中的每一列赋予优先级Customer，为单个客户的各个列提供不同的顺序。

参考表：

---------------------------------------
| Priority |   Attribute |  sourceID  |
---------------------------------------
|   1      |     EMAIL   |      1     |
|   2      |     EMAIL   |      2     |
|   3      |     EMAIL   |      3     |
|   2      |     NAME    |      1     |
|   1      |     NAME    |      2     |
|   3      |     NAME    |      3     |
---------------------------------------

客户表：

-----------------------------------------------------------------------
| CustomerID |  Name   |       Email        |  SourceID |     Date    |
-----------------------------------------------------------------------
|    1 …

我在Django,A和B中有两个模型.

每个A都有几个B分配给它,并且Bs是有序的,这是用字段B.order_index完成的,该字段从任何A的零向上计数.

我想写一个查询,检查是否有任何A,其中一些B有间隙或重复order_index值.

在SQL中,这可以这样做:

SELECT order_index, RANK() OVER(PARTITION BY a_id ORDER BY order_index ASC) - 1 AS rnk
WHERE rnk = order_index'

但是,当我在Django中尝试使用此代码时:

B.objects.annotate(rank=RawSQL("RANK() OVER(PARTITION BY a_id ORDER BY order_index ASC) - 1", [])).filter(rank=F('order_index'))

我收到一个错误说:

django.db.utils.ProgrammingError: window functions are not allowed in WHERE
LINE 1: ...- 1) AS "rank" FROM "main_b" WHERE (RANK() OVE...

在SQL中,这很容易通过将整个事物包装在子查询中并将Where子句应用于该子查询来修复.我怎样才能在Django中做同样的事情？

我有一个 pyspark 数据框，其中包含以下数据：

| y | date       | amount| id |
 ----------------------------- 
| 1 | 2017-01-01 | 10    | 1  |
| 0 | 2017-01-01 | 2     | 1  |
| 1 | 2017-01-02 | 20    | 1  |
| 0 | 2017-01-02 | 3     | 1  |
| 1 | 2017-01-03 | 2     | 1  |
| 0 | 2017-01-03 | 5     | 1  |

我想应用窗口函数，但sum仅应用聚合函数 y==1 的列，但仍保留其他列。我要应用的窗口是：

w = Window \
        .partitionBy(df.id) \
        .orderBy(df.date.asc()) \
        .rowsBetween(Window.unboundedPreceding, …