如何在 Sqlite 中使用时间序列，以及快速的时间范围查询？

Posted 2023-02-24

【中文标题】如何在 Sqlite 中使用时间序列，以及快速的时间范围查询？

【英文标题】：How to use time-series with Sqlite, with fast time-range queries?

【发布时间】：2021-04-01 23:52:27

【问题描述】：

假设我们在 Sqlite 数据库中使用 Unix 时间戳列 ts 记录事件：

CREATE TABLE data(ts INTEGER, text TEXT);   -- more columns in reality

我们希望快速查找日期时间范围，例如：

SELECT text FROM data WHERE ts BETWEEN 1608710000 and 1608718654;

像这样，EXPLAIN QUERY PLAN 给出了SCAN TABLE data，这很糟糕，所以一个明显的解决方案是使用CREATE INDEX dt_idx ON data(ts)创建一个索引。

那么问题就解决了，但是必须为已经增加的序列/已经排序的列 ts 维护一个索引是一个相当糟糕的解决方案，我们可以使用 直接在 O(log n) 中搜索 B-tree。在内部这将是索引：

ts           rowid
1608000001   1
1608000002   2
1608000012   3
1608000077   4

这是对数据库空间的浪费（当查询必须首先查看索引时会浪费 CPU）。

为了避免这种情况：

(1) 我们可以使用ts 作为INTEGER PRIMARY KEY，所以ts 就是rowid 本身。但这失败了，因为ts 不是唯一的：2 个事件可以在同一秒（甚至在同一毫秒）发生。

例如查看SQLite Autoincrement中给出的信息。

(2) 我们可以使用rowid 作为时间戳ts 连接一个递增的数字。示例：

 16087186540001      
 16087186540002
 [--------][--]
     ts     increasing number 

那么rowid 是唯一的并且严格递增（假设每秒事件少于 10k），并且不需要索引。查询 WHERE ts BETWEEN a AND b 将简单地变为 WHERE rowid BETWEEN a*10000 AND b*10000+9999。

但是有没有一种简单的方法可以让 Sqlite 向 INSERT 请求 rowid 大于或等于给定值的项目？假设当前时间戳为1608718654，出现了两个事件：

  CREATE TABLE data(ts_and_incr INTEGER PRIMARY KEY AUTOINCREMENT, text TEXT);
  INSERT INTO data VALUES (NEXT_UNUSED(1608718654), "hello")  #16087186540001 
  INSERT INTO data VALUES (NEXT_UNUSED(1608718654), "hello")  #16087186540002

更一般地说，如何使用 Sqlite 以最佳方式创建时间序列，以实现快速查询WHERE timestamp BETWEEN a AND b？

【问题讨论】：

您对微优化考虑得太多了。可能还有其他地方可以花费您的努力以获得更好的回报。规范的解决方案是使用索引，或者可能将列用作主键（但您可能希望以毫秒或微秒为单位的值）。

。 . (1) 索引相对于数据有多少开销取决于行的大小。 (2) 数据库根本不节省空间。一般来说，自定义代码更快更小。当然，要获得数据库的功能和可靠性，您的团队可能不得不花费数十年或数百年的时间编写代码。数据库是工具。

您可以查看RTree extension。

@GordonLinoff 查看我当前的答案（可能会进一步改进？）：通过避免使用额外的索引，所以值得研究。

@Shawn 你有 RTree 的例子吗？我已经开始使用它了，但它有一些要求：CREATE VIRTUAL TABLE data USING rtree(id INTEGER PRIMARY KEY, dt INTEGER, label INTEGER); INSERT INTO data(dt, label) VALUES (1600000000, 2); 不起作用，我们必须使用对 (min, max) 值，等等。你会在这里使用哪些对？

【参考方案1】：

第一个解决方案

问题中详述的方法（2）似乎效果很好。在基准测试中，我获得了：

简单方法，无索引：18 MB 数据库，86 ms 查询时间 简单方法，索引：32 MB 数据库，12 ms 查询时间 方法（2）：

18MB数据库，12ms查询时间

这里的关键是使用dt 作为INTEGER PRIMARY KEY，所以它将是行ID 本身（另见Is an index needed for a primary key in SQLite?），使用B-tree，然后不会成为另一个隐藏的rowid 列。因此，我们避免了一个额外的索引，它会与dt => rowid 建立对应关系：这里dt 是行ID。

我们还使用AUTOINCREMENT，它在内部创建了一个sqlite_sequence 表，用于跟踪最后添加的ID。这在插入时很有用：因为两个事件可能具有相同的时间戳（以秒为单位）（即使使用毫秒或微秒时间戳也是可能的，操作系统可能会截断精度），我们使用 timestamp*10000 和 @987654334 之间的最大值@ 以确保它是唯一的：

 MAX(?, (SELECT seq FROM sqlite_sequence) + 1)

代码：

import sqlite3, random, time
db = sqlite3.connect('test.db')
db.execute("CREATE TABLE data(dt INTEGER PRIMARY KEY AUTOINCREMENT, label TEXT);")

t = 1600000000
for i in range(1000*1000):
    if random.randint(0, 100) == 0:  # timestamp increases of 1 second with probability 1%
        t += 1
    db.execute("INSERT INTO data(dt, label) VALUES (MAX(?, (SELECT seq FROM sqlite_sequence) + 1), 'hello');", (t*10000, ))
db.commit()

# t will range in a ~ 10 000 seconds window
t1, t2 = 1600005000*10000, 1600005100*10000  # time range of width 100 seconds (i.e. 1%)
start = time.time()
for _ in db.execute("SELECT 1 FROM data WHERE dt BETWEEN ? AND ?", (t1, t2)): 
    pass
print(time.time()-start)

---

使用WITHOUT ROWID 表

这是另一种使用 WITHOUT ROWID 的方法，它提供 8 毫秒 的查询时间。我们必须自己实现一个自动递增的 id，因为使用 WITHOUT ROWID 时 AUTOINCREMENT 不可用。WITHOUT ROWID 在我们想要使用 PRIMARY KEY(dt, another_column1, another_column2, id) 并避免有额外的 rowid 列时很有用。我们将只拥有一个用于rowid 的 B-tree 和一个用于(dt, another_column1, ...) 的 B-tree，而不是一个。

db.executescript("""
    CREATE TABLE autoinc(num INTEGER); INSERT INTO autoinc(num) VALUES(0);

    CREATE TABLE data(dt INTEGER, id INTEGER, label TEXT, PRIMARY KEY(dt, id)) WITHOUT ROWID;
    
    CREATE TRIGGER insert_trigger BEFORE INSERT ON data BEGIN UPDATE autoinc SET num=num+1; END;
    """)

t = 1600000000
for i in range(1000*1000):
    if random.randint(0, 100) == 0: # timestamp increases of 1 second with probabibly 1%
        t += 1
    db.execute("INSERT INTO data(dt, id, label) VALUES (?, (SELECT num FROM autoinc), ?);", (t, 'hello'))
db.commit()

# t will range in a ~ 10 000 seconds window
t1, t2 = 1600005000, 1600005100  # time range of width 100 seconds (i.e. 1%)
start = time.time()
for _ in db.execute("SELECT 1 FROM data WHERE dt BETWEEN ? AND ?", (t1, t2)): 
    pass
print(time.time()-start)

---

粗略排序的 UUID

更一般地说，该问题与按日期时间“粗略排序”的 ID 有关。更多信息：

ULID（通用唯一的字典排序标识符） Snowflake MongoDB ObjectId

所有这些方法都使用一个 ID：

[---- timestamp ----][---- random and/or incremental ----]

【讨论】：

这些确实是“幼稚”的方法。只需打开file::memory: ...

我通常使用:memory: 数据库进行测试，但这里我模拟了一个真实情况（磁盘数据库）@MartinZeitler。

那么您可能不应该抱怨所涉及的瓶颈。除非采用升序索引，否则性能可能不会有太大提高。与其将所有这些排序到同一个表中，它可能有助于为每个系列创建一个优化的表。这仍然可以加载到内存中......虽然这样的组合索引对我来说似乎相当糟糕。简单总是等于性能……如果记录集不够简单，就应该简化。

@MartinZeitler file::memory: 与 :memory: 有什么不同吗？ （我猜它会将整个文件加载到内存中？）您可以发布带有更多详细信息的建议的答案吗？即组合索引与每个系列的优化表等。提前致谢！

【参考方案2】：

我不是 SqlLite 方面的专家，但我使用过数据库和时间序列。我以前也遇到过类似的情况，我会分享我的概念解决方案。

在你的问题中你有一些答案的部分，但不是这样做的方式。

我这样做的方式是，创建 2 个表，一个表 (main_logs) 将以秒为单位记录时间增量作为日期作为主键的整数，而其他表日志包含在该特定时间生成的所有日志 (main_sub_logs)您的案例每秒最多可以记录 10000 条日志。 main_sub_logs 引用了 main_logs，它包含每个日志秒和 X 个日志属于该秒，具有自己的计数器 id，重新开始。

通过这种方式，您可以将时间序列的查找时间限制在几秒的事件窗口内，而不是在一个地方查看所有日志。

通过这种方式，您可以连接这两个表，并且当您在 2 个特定时间之间从第一个表中查找时，您将获得两者之间的所有日志。

那么这就是我创建 2 个表的方式：

CREATE TABLE IF NOT EXISTS main_logs (
  id INTEGER PRIMARY KEY
);

CREATE TABLE IF NOT EXISTS main_sub_logs (
   id INTEGER,
   ref INTEGER,
   log_counter INTEGER,
   log_text text,
   PRIMARY KEY (id), 
   FOREIGN KEY (ref) REFERENCES main_logs(id)
)

我插入了一些虚拟数据：

现在让我们查询 1608718655 和 1608718656 之间的所有日志

SELECT * FROM main_logs AS A
JOIN main_sub_logs AS B ON A.id == B.Ref
WHERE A.id >= 1608718655 AND A.id <= 1608718656

会得到这个结果：

【讨论】：

我已经更新了我的答案，希望它现在有意义。 :)

感谢您的回答和更新！小问题：1）在现实生活中，你如何插入行，尤其是关于log_counter？看来我们必须手动保留另一个具有最新 log_counter 值的表，不是吗？你能举一个你的插入的例子吗？ --2）由于你使用了两张表（所以内部有两个B-trees结构），这种方法相比于只有一张表+unix时间戳列上的普通索引有什么好处？我已经开始了一些基准测试，但我目前没有看到“1 表 + 时间戳索引”解决方案如何改进。

@Basj 不客气，我现在正在度假，移动访问受限，我会尝试看看我是否可以尽快更新。祝你圣诞快乐?，新年快乐?

谢谢@maytham，祝你假期愉快:)