1

我有一个由 6 个数字组成的表作为主键

CREATE TABLE table1 ( num1 decimal, num2 int, num3 int, num4 bigint, num5 bigint, num6 bigint,
PRIMARY KEY (num1, num2, num3, num4, num5, num6))

我需要按排序顺序访问该表，并且经常需要查询该表以按顺序查找下一个 N 大数及其相关数据。

所以我写的查询是这样的

SELECT * FROM table1 WHERE  
 num1 >? OR (  
 (num1 == ? AND num2 > ?) OR (  
 (num1 == ? AND num2 == ? AND num3 > ?) OR (  
 (num1 == ? AND num2 == ? AND num3 == ? AND num4 > ? OR (  
 (num1 == ? AND num2 == ? AND num3 == ? AND num4 == ? AND num5 > ?) OR (  
 (num1 == ? AND num2 == ? AND num3 == ?  
 AND num4 == ? AND num5 == ? AND num6 > ?)))))) ORDER BY num1, num2, num3, num4, num5, num6  
 LIMIT ?;

这是我能看到的找到下一个最大键的最好方法，而且它确实按照索引的顺序进行查询……但是查询需要几秒钟，这是我不喜欢的。

有什么方法可以提高性能吗？这需要几秒钟才能在 1000 万行的表上执行，我需要它在 100 毫秒左右执行更多。

查询计划：

"SEARCH TABLE table1 USING INDEX sqlite_autoindex_table1_1 (num1>?) (~250000 rows)"
"SEARCH TABLE table1 USING INDEX sqlite_autoindex_table1_1 (num1=? AND num2>?) (~2 rows)"
"SEARCH TABLE table1 USING INDEX sqlite_autoindex_table1_1 (num1=? AND num2=? AND num3>?) (~2 rows)"
"SEARCH TABLE table1 USING INDEX sqlite_autoindex_table1_1 (num1=? AND num2=? AND num3=? AND num4>?) (~2 rows)"
"SEARCH TABLE table1 USING INDEX sqlite_autoindex_table1_1 (num1=? AND num2=? AND num3=? AND num4=? AND num5>?) (~1 rows)"
"SEARCH TABLE table1 USING INDEX sqlite_autoindex_table1_1 (num1=? AND num2=? AND num3=? AND num4=? AND num5=? AND num6>?) (~1 rows)"
"USE TEMP B-TREE FOR ORDER BY"

编辑：

为什么这是不可能的？我真的想在 INDEXED ORDER 中获取东西，与ORDER BY关键字生成的顺序相同吗？

4

3 回答 3

1

如果这是对您的问题的有效解决方案：您应该真正考虑使用单个代理键而不是六部分自然键。

从您自己的示例中可以看出，仅基于主键进行查找过于复杂。需要执行多个索引查找，而不是只考虑一列。每个索引查找都涉及磁盘延迟，在您的情况下，它很容易支配整个处理时间。

只需查看您发布的查询计划，在第一次查找后返回的行数已经减少到两个，并且与每个步骤之后可以遗漏的行数（0-1 行）相比，查询剩余索引的成本很高。

因此，如果您只需要查询一个整数类型的列作为主键，您应该会遇到一些显着的性能提升，正如您从SQLite 文档中看到的那样：

SQLite 中每个表的数据都存储为 B-Tree 结构，其中包含每个表行的条目，使用 rowid 值作为键。这意味着按 rowid 检索或排序记录很快。搜索具有特定 rowid 的记录或具有指定范围内的 rowid 的所有记录的速度大约是通过指定任何其他 PRIMARY KEY 或索引值进行的类似搜索的两倍。

除了一个例外，如果表的主键由单个列组成，并且该列的声明类型为“INTEGER”（大小写任意混合），则该列将成为 rowid 的别名。这样的列通常称为“整数主键”。

此外，您的 SQL 查询将更简单，更易于维护。

于 2012-08-10T23:10:51.213 回答
1

我认为查询优化器应该处理这种情况，但是在 aqlite 中它非常简单，所以像@cyroxx 所写的那样更改表结构确实会更好。

其他想法：您也可以尝试以其他方式重写查询，并且可能优化器会理解需要什么。例如，您可以尝试：

SELECT * FROM table1 WHERE
    num1 > 1   OR
  ( num1 = 1   AND ( num2 > 2 OR
                   ( num2 = 2 AND ( num3 > 3 OR
                                  ( num3 = 3 AND ( num4 > 4 OR
                                                 ( num4 = 4 AND ( num5 > 5 OR
                                                                ( num5 = 5 AND num6 > 6)
                                                                )
                                                 )
                                                 )
                                  )
                                  )
                   )
                   )
  )

可能会变得更好（或更糟:)）。

于 2012-08-13T14:36:04.443 回答
1

与其他更复杂的 RDBMS 不同，sqlite 有一个基于规则的查询优化器，这意味着执行计划主要取决于查询的编写方式（以及子句的顺序）。它使优化器非常可预测，如果您知道 sqlite 如何生成执行计划，您可以利用这种可预测性来解决您的问题。

第一个想法是注意各种子句，如 (num1>?) 或 (num1=? and num2>?) 正在产生不相交的结果，并且这些结果自然地在彼此之间排序。如果查询被分成子查询（每个子查询处理部分条件）产生排序的结果，那么如果子查询以正确的顺序执行，那么所有结果集的连接也会被排序。

例如，考虑以下查询：

select * from table1 where num1=? and num2>? order by num1,num2
select * from table1 where num1>? order by num1,num2

这些查询产生的两个结果集是不相交的，第一个结果集的行总是排在第二个结果集的行之前。

第二个想法是了解 sqlite 如何处理 LIMIT 子句。实际上，它在查询开始时声明了一个计数器，并在每个选定的行上递减和测试这个计数器，因此它可以提前停止查询。

例如，考虑以下查询：

.explain
explain select * from (
   select * from table1 where num1=? and num2>?
   union all
   select * from table1 where num1>?
) limit 10;

sqlite 将按照查询中指定的顺序评估子查询。如果第一个子查询返回的行数超过 10 行，则甚至不会执行第二个子查询。可以通过显示计划轻松检查：

addr  opcode         p1    p2    p3    p4             p5  comment      
----  -------------  ----  ----  ----  -------------  --  -------------
0     Trace          0     0     0                    00               
1     Integer        10    1     0                    00               
2     Variable       1     2     2                    00               
3     Goto           0     44    0                    00               
4     OpenRead       3     3     0     keyinfo(6,BINARY,BINARY)  00               
5     SCopy          2     4     0                    00               
6     IsNull         4     23    0                    00               
7     SCopy          3     5     0                    00               
8     IsNull         5     23    0                    00               
9     Affinity       4     2     0     cd             00               
10    SeekGt         3     23    4     2              00               
11    IdxGE          3     23    4     1              01               
12    Column         3     1     6                    00               
13    IsNull         6     22    0                    00               
14    Column         3     0     7                    00               
15    Column         3     1     8                    00               
16    Column         3     2     9                    00               
17    Column         3     3     10                   00               
18    Column         3     4     11                   00               
19    Column         3     5     12                   00               
20    ResultRow      7     6     0                    00               
21    IfZero         1     23    -1                   00               
22    Next           3     11    0                    00               
23    Close          3     0     0                    00               
24    IfZero         1     43    0                    00               
25    Variable       3     13    1                    00               
26    OpenRead       4     3     0     keyinfo(6,BINARY,BINARY)  00               
27    SCopy          13    14    0                    00               
28    IsNull         14    42    0                    00               
29    Affinity       14    1     0     c              00               
30    SeekGt         4     42    14    1              00               
31    Column         4     0     6                    00               
32    IsNull         6     41    0                    00               
33    Column         4     0     7                    00               
34    Column         4     1     8                    00               
35    Column         4     2     9                    00               
36    Column         4     3     10                   00               
37    Column         4     4     11                   00               
38    Column         4     5     12                   00               
39    ResultRow      7     6     0                    00               
40    IfZero         1     42    -1                   00               
41    Next           4     31    0                    00               
42    Close          4     0     0                    00               
43    Halt           0     0     0                    00               
44    Transaction    0     0     0                    00               
45    VerifyCookie   0     3     0                    00               
46    TableLock      0     2     0     table1         00               
47    Goto           0     4     0                    00

计数器被声明为第 1 步，并在第 21、24、40 步递减/测试。

通过结合这两个评论，我们可以提出一个不漂亮的查询，但会产生一个有效的执行计划：

SELECT * FROM (
  SELECT * FROM ( SELECT * FROM table1
                  WHERE num1 == ? AND num2 == ? AND num3 == ? AND num4 == ? AND num5 == ? AND num6 > ?
                  ORDER BY num1, num2, num3, num4, num5, num6 )
  UNION ALL
  SELECT * FROM ( SELECT * FROM table1
                  WHERE num1 == ? AND num2 == ? AND num3 == ? AND num4 == ? AND num5 > ?
                  ORDER BY num1, num2, num3, num4, num5, num6 )
  UNION ALL
  SELECT * FROM ( SELECT * FROM table1
                  WHERE num1 == ? AND num2 == ? AND num3 == ? AND num4 > ?
                  ORDER BY num1, num2, num3, num4, num5, num6 )
  UNION ALL
  SELECT * FROM ( SELECT * FROM table1
                  WHERE num1 == ? AND num2 == ? AND num3 > ?
                  ORDER BY num1, num2, num3, num4, num5, num6 )
  UNION ALL
  SELECT * FROM ( SELECT * FROM table1
                  WHERE num1 == ? AND num2 > ?
                  ORDER BY num1, num2, num3, num4, num5, num6 )
  UNION ALL
  SELECT * FROM ( SELECT * FROM table1
                  WHERE num1 > ?
                  ORDER BY num1, num2, num3, num4, num5, num6 )
) LIMIT ?;

请注意，由于外部查询中不需要“order by”子句，因此 sqlite 不需要执行所有子查询。所以它可以在它有正确的行数时停止。子查询的顺序很关键。

需要第二级内部子查询，因为不能在“union all”之前使用“order by”。它们被 sqlite 优化掉了，所以这不是问题。

在包含 777K 行的虚拟表上，初始查询成本：

strace -c -eread,lseek sqlite3 toto.db < q1.sql
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 63.57    0.001586           0     18556           read
 36.43    0.000909           0     18544           lseek
------ ----------- ----------- --------- --------- ----------------
100.00    0.002495                 37100           total

而我的只有成本：

strace -c -eread,lseek sqlite3 toto.db < q3.sql
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
  -nan    0.000000           0        18           read
  -nan    0.000000           0         8           lseek
------ ----------- ----------- --------- --------- ----------------
100.00    0.000000                    26           total
于 2012-08-14T18:12:10.577 回答