如何使用带有快速时间范围查询的 Sqlite 时间序列？
How to use time-series with Sqlite, with fast time-range queries?
假设我们使用 Unix 时间戳列 ts:
在 Sqlite 数据库中记录事件
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 树搜索。在内部这将是索引：
ts rowid
1608000001 1
1608000002 2
1608000012 3
1608000077 4
这是对数据库的浪费 space（当查询必须首先查看索引时 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?
第一个解决方案
问题中详述的方法（2）似乎很有效。在基准测试中，我获得了：
- 朴素的方法，没有索引：18 MB 数据库，86 毫秒查询时间
- 朴素方法，索引：32 MB 数据库，12 毫秒查询时间
- 方法（2）：18MB数据库，12ms查询时间
这里的关键是将 dt 用作 INTEGER PRIMARY KEY，因此 它将是行 ID 本身 （另请参阅 Is an index needed for a primary key in SQLite?)，使用 B 树，并且将 not 是另一个隐藏的 rowid 列。因此，我们避免了一个额外的索引，它会产生对应关系 dt => rowid：这里 dt 是 行 ID。
我们还使用 AUTOINCREMENT，它会在内部创建一个 sqlite_sequence table，它会跟踪最后添加的 ID。这在插入时很有用：因为两个事件可能具有相同的秒时间戳（即使使用毫秒或微秒时间戳也是可能的，OS 可能会截断精度），我们使用 [=] 之间的最大值21=] 和 last_added_ID + 1 以确保它是唯一的：
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 table
这是另一种使用 WITHOUT ROWID 的方法，它提供 8 毫秒 查询时间。我们必须自己实现一个自动递增的 id，因为在使用 WITHOUT ROWID.
时 AUTOINCREMENT 不可用
当我们想要使用 PRIMARY KEY(dt, another_column1, another_column2, id) 并避免有额外的 rowid 列时，WITHOUT ROWID 很有用。 rowid 有一个 B 树，(dt, another_column1, ...) 有一个 B 树，我们只有一个。
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（普遍唯一的词典排序table标识符）
- Snowflake
- MongoDB ObjectId
所有这些方法使用的 ID 是：
[---- timestamp ----][---- random and/or incremental ----]
我不是 SqlLite 专家，但曾使用过数据库和时间序列。我以前也遇到过类似的情况，分享一下我的概念性解决方案。
你的问题有部分答案，但没有答案。
我这样做的方式，创建 2 tables，一个 table (main_logs) 将以秒为单位记录时间增量作为日期作为整数作为主键，另一个 table 日志包含在那个特定时间生成的所有日志 (main_sub_logs)，在您的情况下，每秒最多可以生成 10000 个日志。 main_sub_logs 引用了 main_logs 并且它包含每个日志秒和 X 数量的日志属于具有自己的计数器 ID 的那一秒，重新开始。
通过这种方式，您可以限制时间序列查找事件的秒数 windows，而不是将所有日志都放在一个地方。
通过这种方式，您可以加入这两个 table，当您从第一个 table 开始查找时，您会在 2 个特定时间之间获得所有日志。
下面是我如何创建我的 2 tables:
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
会得到这样的结果：
假设我们使用 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 树搜索。在内部这将是索引：
ts rowid
1608000001 1
1608000002 2
1608000012 3
1608000077 4
这是对数据库的浪费 space（当查询必须首先查看索引时 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?
第一个解决方案
问题中详述的方法（2）似乎很有效。在基准测试中，我获得了：
- 朴素的方法，没有索引：18 MB 数据库，86 毫秒查询时间
- 朴素方法，索引：32 MB 数据库，12 毫秒查询时间
- 方法（2）：18MB数据库，12ms查询时间
这里的关键是将 dt 用作 INTEGER PRIMARY KEY，因此 它将是行 ID 本身 （另请参阅 Is an index needed for a primary key in SQLite?)，使用 B 树，并且将 not 是另一个隐藏的 rowid 列。因此，我们避免了一个额外的索引，它会产生对应关系 dt => rowid：这里 dt 是 行 ID。
我们还使用 AUTOINCREMENT，它会在内部创建一个 sqlite_sequence table，它会跟踪最后添加的 ID。这在插入时很有用：因为两个事件可能具有相同的秒时间戳（即使使用毫秒或微秒时间戳也是可能的，OS 可能会截断精度），我们使用 [=] 之间的最大值21=] 和 last_added_ID + 1 以确保它是唯一的：
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 table
这是另一种使用 WITHOUT ROWID 的方法，它提供 8 毫秒 查询时间。我们必须自己实现一个自动递增的 id，因为在使用 WITHOUT ROWID.
时 AUTOINCREMENT 不可用
当我们想要使用 PRIMARY KEY(dt, another_column1, another_column2, id) 并避免有额外的 rowid 列时，WITHOUT ROWID 很有用。 rowid 有一个 B 树，(dt, another_column1, ...) 有一个 B 树，我们只有一个。
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（普遍唯一的词典排序table标识符）
- Snowflake
- MongoDB ObjectId
所有这些方法使用的 ID 是：
[---- timestamp ----][---- random and/or incremental ----]
我不是 SqlLite 专家，但曾使用过数据库和时间序列。我以前也遇到过类似的情况，分享一下我的概念性解决方案。
你的问题有部分答案，但没有答案。
我这样做的方式，创建 2 tables，一个 table (main_logs) 将以秒为单位记录时间增量作为日期作为整数作为主键，另一个 table 日志包含在那个特定时间生成的所有日志 (main_sub_logs)，在您的情况下，每秒最多可以生成 10000 个日志。 main_sub_logs 引用了 main_logs 并且它包含每个日志秒和 X 数量的日志属于具有自己的计数器 ID 的那一秒，重新开始。
通过这种方式，您可以限制时间序列查找事件的秒数 windows，而不是将所有日志都放在一个地方。
通过这种方式，您可以加入这两个 table，当您从第一个 table 开始查找时，您会在 2 个特定时间之间获得所有日志。
下面是我如何创建我的 2 tables:
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
会得到这样的结果：