我使用的是PostgreSQL 9.5。
这是我data_store表的一部分：
id | starttime
-----+----------------------------
185 | 2011-09-12 15:24:03.248+02
189 | 2011-09-12 15:24:03.256+02
312 | 2011-09-12 15:24:06.112+02
313 | 2011-09-12 15:24:06.119+02
450 | 2011-09-12 15:24:09.196+02
451 | 2011-09-12 15:24:09.203+02
452 | 2011-09-12 15:24:09.21+02
... | ...
我想创建一个查询，它将按特定的时间间隔计算记录。例如，对于4秒的时间间隔 - 查询应该返回给我：
starttime-from | starttime-to | count
---------------------+---------------------+---------
2011-09-12 15:24:03 | 2011-09-12 15:24:07 | 4
2011-09-12 15:24:07 | 2011-09-12 15:24:11 | 3
2011-09-12 15:24:11 | 2011-09-12 15:24:15 | 0
... | ... | ...
最重要的事情：
1 second，37 seconds，50 minutes或某些混合：2 month and 30 mintues。时间间隔的可用单位为：millisecond，second，minute，hour，day，month，year。您如何看待，我需要一些通用/通用查询但我还可以为每个单元创建多个查询 - 这不是问题。问题是：查询应该如何实现？
我尝试转换我在以下主题中找到的解决方案，但我没有成功：
我删除了帖子的这一部分，以提高帖子的透明度。这部分没有必要回答我的问题。如果你想看看这里是什么，看看帖子的历史。
答案 0 :(得分：2)
您的查询似乎很复杂。您只需要生成时间序列，然后使用ctypes.windll.LoadLibrary(path)将它们组合在一起。 。 。和聚合：
left join注意：如果您希望间隔在精确的秒内开始（并且在1000中没有一些奇怪的毫秒数999倍），则使用select g.ts, g.ts + interval '4 second', count(ds.id)
from (select generate_series(min(starttime), max(strttime), interval '4 second') as ts
from data_store
) g left join
data_store ds
on ds.starttime >= g.ts and ds.starttime < g.ts + interval '4 second'
group by g.ts
order by g.ts;
。
编辑：
相关子查询是否更快可能值得一看：
date_trunc()答案 1 :(得分：1)
如果有帮助，我使用UDF创建动态日期/时间范围。
使用Join on SomeDate＆gt; = DateR1和SomeDate中的结果
Range，DatePart和Increment是参数
Declare @Date1 DateTime = '2011-09-12 15:24:03 '
Declare @Date2 DateTime = '2011-09-12 15:30:00 '
Declare @DatePart varchar(25)='SS'
Declare @Incr int=3
Select DateR1 = RetVal
,DateR2 = LEAD(RetVal,1,@Date2) OVER (ORDER BY RetVal)
From (Select * from [dbo].[udf-Create-Range-Date](@Date1,@Date2,@DatePart,@Incr) ) A
Where RetVal<@Date2
返回
DateR1 DateR2
2011-09-12 15:24:03.000 2011-09-12 15:24:06.000
2011-09-12 15:24:06.000 2011-09-12 15:24:09.000
2011-09-12 15:24:09.000 2011-09-12 15:24:12.000
2011-09-12 15:24:12.000 2011-09-12 15:24:15.000
2011-09-12 15:24:15.000 2011-09-12 15:24:18.000
2011-09-12 15:24:18.000 2011-09-12 15:24:21.000
...
2011-09-12 15:29:48.000 2011-09-12 15:29:51.000
2011-09-12 15:29:51.000 2011-09-12 15:29:54.000
2011-09-12 15:29:54.000 2011-09-12 15:29:57.000
2011-09-12 15:29:57.000 2011-09-12 15:30:00.000
UDF
CREATE FUNCTION [dbo].[udf-Create-Range-Date] (@DateFrom datetime,@DateTo datetime,@DatePart varchar(10),@Incr int)
Returns
@ReturnVal Table (RetVal datetime)
As
Begin
With DateTable As (
Select DateFrom = @DateFrom
Union All
Select Case @DatePart
When 'YY' then DateAdd(YY, @Incr, df.dateFrom)
When 'QQ' then DateAdd(QQ, @Incr, df.dateFrom)
When 'MM' then DateAdd(MM, @Incr, df.dateFrom)
When 'WK' then DateAdd(WK, @Incr, df.dateFrom)
When 'DD' then DateAdd(DD, @Incr, df.dateFrom)
When 'HH' then DateAdd(HH, @Incr, df.dateFrom)
When 'MI' then DateAdd(MI, @Incr, df.dateFrom)
When 'SS' then DateAdd(SS, @Incr, df.dateFrom)
End
From DateTable DF
Where DF.DateFrom < @DateTo
)
Insert into @ReturnVal(RetVal) Select DateFrom From DateTable option (maxrecursion 32767)
Return
End
-- Syntax Select * from [dbo].[udf-Create-Range-Date]('2016-10-01','2020-10-01','YY',1)
-- Syntax Select * from [dbo].[udf-Create-Range-Date]('2016-10-01','2020-10-01','DD',1)
-- Syntax Select * from [dbo].[udf-Create-Range-Date]('2016-10-01','2016-10-31','MI',15)
-- Syntax Select * from [dbo].[udf-Create-Range-Date]('2016-10-01','2016-10-02','SS',1)
答案 2 :(得分：0)
我刚刚改进了您在所选答案中可以找到的查询。
最终查询如下：
SELECT gp.tp AS starttime_from, gp.tp + interval '4 second' AS starttime_to, count(ds.id)
FROM (SELECT generate_series(min(starttime),max(starttime), interval '4 second') as tp
FROM data_store
WHERE id_user_table=1 and sip='147.32.84.138'
ORDER BY 1
) gp
LEFT JOIN data_store ds
ON ds.id_user_table=1 and ds.sip='147.32.84.138'
and ds.starttime >= gp.tp and ds.starttime < gp.tp + interval '4 second'
GROUP BY starttime_from
我已将ORDER BY移到子查询中。现在它快一点了。我还在WHERE子句中添加了requried列。最后，我在查询中始终使用的列上创建了多列索引：
CREATE INDEX my_index ON data_store (id_user_table, sip, starttime);
目前查询非常快。 请注意：对于非常小的时间间隔，查询结果包含大量零计数行。这些行消耗空间。在这种情况下，查询应包含HAVING count(ds.id) > 0限制，但您必须在客户端处理这些0。
此解决方案没有以前那么快，但下面的查询不使用多列索引，但它仍然很快。
查询中的两个重要内容，您可以在本答案的最后找到：
'second'是要截断输入值的精度。您还可以选择其他精度：millisecond，minute，day等。
'4 second'是时间间隔。时间间隔可以包含其他单位，例如millisecond，minute，day等。
您可以在此处找到查询说明：
generate_period查询生成从指定日期时间到特定日期时间的间隔。您可以手动或通过表格列指示此特定日期时间（就像我的情况一样）。对于4秒间隔时间间隔，查询返回：
tp
---------------------
2011-09-12 15:24:03
2011-09-12 15:24:07
2011-09-12 15:24:11
...
data_series查询计算日期时间特定精度的记录：for 1 second time interval，for 1 day time interval等。在我的情况下，具体精度为'second'，所以for 1 second time interval但是select操作的结果不包括未发生的日期时间的0值。在我的例子中，data_series查询返回：
starttime | ct
---------------------+-----------
2011-09-12 15:24:03 | 2
2011-09-12 15:24:06 | 2
2011-09-12 15:24:09 | 3
... | ...
最后，查询的最后一部分总结了特定时间段的ct列。查询返回：
starttime-from | starttime-to | ct
---------------------+---------------------+---------
2011-09-12 15:24:03 | 2011-09-12 15:24:07 | 4
2011-09-12 15:24:07 | 2011-09-12 15:24:11 | 3
2011-09-12 15:24:11 | 2011-09-12 15:24:15 | 0
... | ... | ...
以下是查询：
WITH generate_period AS(
SELECT generate_series(date_trunc('second',min(starttime)),
date_trunc('second',max(starttime)),
interval '4 second') as tp
FROM data_store
WHERE id_user_table=1 --other restrictions
), data_series AS(
SELECT date_trunc('second', starttime) AS starttime, count(*) AS ct
FROM data_store
WHERE id_user_table=1 --other restrictions
GROUP BY 1
)
SELECT gp.tp AS starttime-from,
gp.tp + interval '4 second' AS starttime-to,
COALESCE(sum(ds.ct),0) AS ct
FROM generate_period gp
LEFT JOIN data_series ds ON date_trunc('second',ds.starttime) >= gp.tp
and date_trunc('second',ds.starttime) < gp.tp + interval '4 second'
GROUP BY 1
ORDER BY 1;