标签: window-functions

我的挑战是找到按时间戳相邻的行对，并仅保留值字段距离最小的那些对（差异的正值）

一个表measurement收集来自不同传感器的数据，带有时间戳和值。

id | sensor_id | timestamp | value
---+-----------+-----------+------
 1 |         1 | 12:00:00  |     5
 2 |         2 | 12:01:00  |     6
 3 |         1 | 12:02:00  |     4
 4 |         2 | 12:02:00  |     7
 5 |         2 | 12:03:00  |     3
 6 |         1 | 12:05:00  |     3
 7 |         2 | 12:06:00  |     4
 8 |         2 | 12:07:00  |     5
 9 |         1 | 12:08:00  |     6

传感器的值从其时间戳一直有效，直到其下一条记录的时间戳（相同的 sensor_id）。

图示

下面的绿线显示传感器 1（蓝线）和传感器 …

有谁知道 Apache Spark SQL 达到与标准 SQLqualify() + rnk 或 row_number 语句相同结果的最佳方法吗？

例如：

• 我有一个名为 statement_data 的 Spark 数据框，每个月有 12 条记录，每个记录有 100 个唯一的 account_numbers，因此总共有 1200 条记录
• 每个月记录都有一个名为“statement_date”的字段，可用于确定最近的记录

I want my final result to be a new Spark Dataframe with the 3 most recent records (as determined by statement_date descending) for each of the 100 unique account_numbers, therefore 300 final records in total.

In standard Teradata SQL, I can do the following:

select * from statement_data
qualify row_number ()
over(partition by acct_id order …

假设我有一个综合浏览事件列表，每个事件都有一个会话 ID。对于每个事件，我想添加该事件会话中按时间顺序排列的第一个综合浏览量的时间和 URL。例如，假设我的事件在表中test，如下所示：

uid | session_id | timestamp | url
----------------------------------------------------
u1    0            0           a.com/
u1    1            1           a.com/p1
u1    1            2           a.com/p2

我想要一个产生以下结果的 SQL 命令：

uid | session_id | timestamp | url      | s_timestamp | s_url
---------------------------------------------------------------------
u1    0            0           a.com/     0             a.com/
u1    1            1           a.com/p1   1             a.com/p1
u1    1            2           a.com/p2   1             a.com/p1

窗口函数似乎是这里的方法，但我对它们还很陌生。以下语句生成所需的表，但我想知道它是否不是最优的

SELECT
    uid,
    session_id,
    timestamp,
    url,
    first_value(url) OVER (PARTITION BY uid, session_id ORDER BY timestamp ASC) s_url,
    first_value(timestamp) OVER (PARTITION BY uid, …

样本数据

CREATE TABLE test
    (id integer, session_ID integer, value integer)
;

INSERT INTO test
    (id, session_ID, value)
VALUES
    (0, 2, 100),
    (1, 2, 120),
    (2, 2, 140),
    (3, 1, 900),
    (4, 1, 800),
    (5, 1, 500)
;

当前查询

select 
id,
last_value(value) over (partition by session_ID order by id) as last_value_window,
last_value(value) over (partition by session_ID order by id desc) as last_value_window_desc
from test
ORDER BY id

我在使用last_value()窗口函数时遇到问题：http : //sqlfiddle.com/#!15/bcec0/2

在小提琴中，我尝试使用last_value()查询中的排序方向。

编辑： 问题不在于：为什么我没有得到所有时间的最后一个值，以及如何使用frame子句（unbounded preceding和 …

我每天使用 Postgres 汇总一组产品的销售额，不仅需要知道何时发生销售，还需要知道何时不进行进一步处理。

SELECT 
sd.date, 
COUNT(sd.sale_id) AS sales, 
sd.product

FROM sales_data sd
-- sales per product, per day
GROUP BY sd.product, sd.date
ORDER BY sd.product, sd.date

这会产生以下结果：

    date    | sales |       product                           
------------+-------+-------------------
 2017-08-17 |  10   | soap
 2017-08-19 |   2   | soap
 2017-08-20 |   5   | soap
 2017-08-17 |   2   | shower gel
 2017-08-21 |   1   | shower gel

如您所见 - 每个产品的日期范围不连续，因为sales_data在某些日子里没有包含这些产品的任何信息。

我的目标是为sales = 0某个范围内任何一天都没有售出的每个产品添加一行 - 例如在这里，之间2017-08-17和2017-08-21给出如下所示的内容：

    date    | sales | …

我正在尝试在带有月度数据的 Pandas 数据框上使用滚动（）函数。但是，我删除了一些 NaN 值，所以现在我的时间序列中有一些差距。因此，基本窗口参数给出了一个误导性的答案，因为它只是查看之前的观察结果：

import pandas as pd
import numpy as np
import random
dft = pd.DataFrame(np.random.randint(0,10,size=len(dt)),index=dt)
dft.columns = ['value']
dft['value'] = np.where(dft['value'] < 3,np.nan,dft['value'])
dft = dft.dropna()
dft['basic'] = dft['value'].rolling(2).sum()

例如，参见 2017-08-31 条目，其总和为 3.0 和 9.0，但上一个条目是 2017-03-31。

In [57]: dft.tail()
Out[57]:
            value  basic
2017-02-28    8.0   12.0
2017-03-31    3.0   11.0
2017-08-31    9.0   12.0
2017-10-31    7.0   16.0
2017-11-30    7.0   14.0

自然的解决方案（我认为）是使用“2M”偏移量，但它给出了一个错误：

In [58]: dft['basic2M'] = dft['value'].rolling('2M').sum()
...<output omitted>...
ValueError: <2 * MonthEnds> is a non-fixed frequency

如果我移动每日偏移量，我可以让它工作，但这似乎是一个奇怪的解决方法：

In [59]: dft['basic32D'] …

请考虑以下表结构:

CREATE TABLE tb_log
(
  id INTEGER PRIMARY KEY,
  moment DATE,
  old INTEGER,
  actual INTEGER
);

包含数据:

INSERT INTO
  tb_log ( id, moment, old, actual )
VALUES
  ( 1, '2018-06-19', 10, 20 ),
  ( 2, '2018-06-21', 20, 30 ),
  ( 3, '2018-06-25', 30, 40 );

我试图从tb_log一个值生效的期间(开始日期和结束日期)开始.

试验#1 - 使用lag()功能:

SELECT
  lag( moment ) OVER (ORDER BY moment) date_start,
  moment AS date_end,
  old AS period_value
FROM
   tb_log;

返回以下数据:

| date_start |   date_end | period_value |
|------------|------------|--------------|
| …

为什么我无法在 MySQL 中使用无限关注？

我可以使用无界前置，对于相同的查询没有任何问题。

SELECT deptno,
       ENAME
       SAL,
       HIREDATE,
       last_value(HIREDATE) OVER (
           PARTITION BY deptno
           ORDER BY HIREDATE
           ROWS UNBOUNDED FOLLOWING
       )
FROM emp2
ORDER BY DEPTNO, HIREDATE;

输出：

[42000][1064] 您的 SQL 语法有错误；检查与您的 MySQL 服务器版本相对应的手册，了解
FOLLWOING ) FROM emp2 ORDER BY DEPTNO, HIREDATE第 2 行附近使用的正确语法

我需要根据另一列（绘图编号）获取一列（修订版）最大值。谁能告诉我此功能的 JPA 查询。

我编写了以下查询，但该查询不起作用。

请帮助我如何在 JPA 查询中编写 MAX 和 OVER (PARTITION BY) 函数。

    @Query("select dr FROM
        (SELECT MAX(dr.revision) over (PARTITION BY d.drawing_number) AS latest_revision
        FROM DrawingRate dr
        JOIN dr.drawing d
        JOIN d.modifiedBy mb
        WHERE mb.Id=:Id
        OR piu.Id=:Id
        ORDER BY d.localModifiedOn DESC NULLS LAST
        ) WHERE dr.revision = :latest_revision")

运行此 Spring 数据 JPA 查询时不起作用，显示以下错误：

引起原因：java.lang.IllegalArgumentException：org.hibernate.hql.internal.ast.QuerySyntaxException：意外标记：(第1行附近第16列[select dr from (select max(dr.revision) over (partition by d.drawing_number) ) AS last_enrolment_date 来自实体.DrawingRate dr join dr.drawing d JOIN d.modifiedBy mb left join dr.modifiedBy u WHERE mb.Id=:IdOR piu.Id=:Id …

假设我有以下数据库架构：

class A(Base):
    __tablename__ = "a_table"

    id = Column(Integer, primary_key=True, autoincrement=True)
    version = Column(Integer, primary_key=True, default=1)

    # More columns...

    bs = relationship(
        "B", secondary="a2b_table", back_populates="as"
    )

class B(Base):
    __tablename__ = "b_table"

    id = Column(Integer, primary_key=True)

    as = relationship(
        A, secondary="a2b_table", back_populates="bs"
    )

class A2B(Base):
    __tablename__ = "a2b_table"

    a_id = Column(
        Integer(),
        primary_key=True,
    )
    a_version = Column(
        Integer,
        primary_key=True,
    )
    b_id = sa.Column(
        Integer,
        ForeignKey("b.id", name="b_fk"),
        primary_key=True,
    )

    __table_args__ = (
        ForeignKeyConstraint(
            [a_id, a_version],
            [A.id, A.version],
            name="a_fk",
        ),
        {},
    )
    

每个 …