Debian Codegraph @

test/whereL.test

raw
1 # 2018-07-26
2 #
3 # The author disclaims copyright to this source code. In place of
4 # a legal notice, here is a blessing:
5 #
6 # May you do good and not evil.
7 # May you find forgiveness for yourself and forgive others.
8 # May you share freely, never taking more than you give.
9 #
10 #***********************************************************************
11 # This file implements regression tests for SQLite library. The
12 # focus of this file is testing the WHERE-clause constant propagation
13 # optimization.
14 #
15 set testdir [file dirname $argv0]
16 source $testdir/tester.tcl
17 set ::testprefix whereL
18
19 do_execsql_test 100 {
20 CREATE TABLE t1(a INT PRIMARY KEY, b, c, d, e);
21 CREATE TABLE t2(a INT PRIMARY KEY, f, g, h, i);
22 CREATE TABLE t3(a INT PRIMARY KEY, j, k, l, m);
23 CREATE VIEW v4 AS SELECT * FROM t2 UNION ALL SELECT * FROM t3;
24 }
25 do_eqp_test 110 {
26 SELECT * FROM t1, v4 WHERE t1.a=?1 AND v4.a=t1.a;
27 } {
28 QUERY PLAN
29 `--COMPOUND QUERY
30 |--LEFT-MOST SUBQUERY
31 | |--SEARCH t1 USING INDEX sqlite_autoindex_t1_1 (a=?)
32 | `--SEARCH t2 USING INDEX sqlite_autoindex_t2_1 (a=?)
33 `--UNION ALL
34 |--SEARCH t1 USING INDEX sqlite_autoindex_t1_1 (a=?)
35 `--SEARCH t3 USING INDEX sqlite_autoindex_t3_1 (a=?)
36 }
37
38 # The scan of the t1 table goes first since that enables the ORDER BY
39 # sort to be omitted. This would not be possible without constant
40 # propagation because without it the t1 table would depend on t3.
41 #
42 do_eqp_test 120 {
43 SELECT * FROM t1, t2, t3
44 WHERE t1.a=t2.a AND t2.a=t3.j AND t3.j=5
45 ORDER BY t1.a;
46 } {
47 QUERY PLAN
48 |--SEARCH t1 USING INDEX sqlite_autoindex_t1_1 (a=?)
49 |--SEARCH t2 USING INDEX sqlite_autoindex_t2_1 (a=?)
50 `--SCAN t3
51 }
52 do_eqp_test 121 {
53 SELECT * FROM t1, t2, t3
54 WHERE t1.a=t2.a AND t2.a=t3.j AND t3.j=abs(5)
55 ORDER BY t1.a;
56 } {
57 QUERY PLAN
58 |--SEARCH t1 USING INDEX sqlite_autoindex_t1_1 (a=?)
59 |--SEARCH t2 USING INDEX sqlite_autoindex_t2_1 (a=?)
60 `--SCAN t3
61 }
62
63 # The sqlite3ExprIsConstant() routine does not believe that
64 # the expression "coalesce(5,random())" is constant. So the
65 # optimization does not apply in this case.
66 #
67 sqlite3_create_function db
68 do_eqp_test 122 {
69 SELECT * FROM t1, t2, t3
70 WHERE t1.a=t2.a AND t2.a=t3.j AND t3.j=coalesce(5,random())
71 ORDER BY t1.a;
72 } {
73 QUERY PLAN
74 |--SCAN t3
75 |--SEARCH t1 USING INDEX sqlite_autoindex_t1_1 (a=?)
76 |--SEARCH t2 USING INDEX sqlite_autoindex_t2_1 (a=?)
77 `--USE TEMP B-TREE FOR ORDER BY
78 }
79
80 # Constant propagation in the face of collating sequences:
81 #
82 do_execsql_test 200 {
83 CREATE TABLE c3(x COLLATE binary, y COLLATE nocase, z COLLATE binary);
84 CREATE INDEX c3x ON c3(x);
85 INSERT INTO c3 VALUES('ABC', 'ABC', 'abc');
86 SELECT * FROM c3 WHERE x=y AND y=z AND z='abc';
87 } {ABC ABC abc}
88
89 # If the constants are blindly propagated, as shown in the following
90 # query, the wrong answer results:
91 #
92 do_execsql_test 201 {
93 SELECT * FROM c3 WHERE x='abc' AND y='abc' AND z='abc';
94 } {}
95
96 # Constant propagation caused an incorrect answer in the following
97 # query. (Reported by Bentley system on 2018-08-09.)
98 #
99 do_execsql_test 300 {
100 CREATE TABLE A(id INTEGER PRIMARY KEY, label TEXT);
101 CREATE TABLE B(id INTEGER PRIMARY KEY, label TEXT, Aid INTEGER);
102 CREATE TABLE C(
103 id INTEGER PRIMARY KEY,
104 xx INTEGER NOT NULL,
105 yy INTEGER,
106 zz INTEGER
107 );
108 CREATE UNIQUE INDEX x2 ON C(yy);
109 CREATE UNIQUE INDEX x4 ON C(yy, zz);
110 INSERT INTO A(id) VALUES(1);
111 INSERT INTO B(id) VALUES(2);
112 INSERT INTO C(id,xx,yy,zz) VALUES(99,50,1,2);
113 SELECT 1
114 FROM A,
115 (SELECT id,xx,yy,zz FROM C) subq,
116 B
117 WHERE A.id='1'
118 AND A.id=subq.yy
119 AND B.id=subq.zz;
120 } {1}
121 do_execsql_test 301 {
122 SELECT 1
123 FROM A,
124 (SELECT id,xx,yy,zz FROM C) subq,
125 B
126 WHERE A.id=1
127 AND A.id=subq.yy
128 AND B.id=subq.zz;
129 } {1}
130 do_execsql_test 302 {
131 SELECT 1
132 FROM A,
133 (SELECT id,yy,zz FROM C) subq,
134 B
135 WHERE A.id='1'
136 AND A.id=subq.yy
137 AND B.id=subq.zz;
138 } {1}
139
140 # 2018-10-25: Ticket [cf5ed20f]
141 # Incorrect join result with duplicate WHERE clause constraint.
142 #
143 do_execsql_test 400 {
144 CREATE TABLE x(a, b, c);
145 CREATE TABLE y(a, b);
146 INSERT INTO x VALUES (1, 0, 1);
147 INSERT INTO y VALUES (1, 2);
148 SELECT x.a FROM x JOIN y ON x.c = y.a WHERE x.b = 1 AND x.b = 1;
149 } {}
150
151 # 2020-01-07: ticket 82ac75ba0093e5dc
152 # Incorrect join result due to mishandling of affinity in constant
153 # propagation.
154 #
155 reset_db
156 do_execsql_test 500 {
157 PRAGMA automatic_index=OFF;
158 CREATE TABLE t0(c0);
159 INSERT INTO t0 VALUES('0');
160 CREATE VIEW v0(c0) AS SELECT CAST(0 AS INT) FROM t0;
161 SELECT 200, * FROM t0, v0 WHERE 0 = t0.c0 AND t0.c0 = v0.c0;
162 } {}
163 do_execsql_test 510 {
164 SELECT 200, * FROM t0, v0 WHERE t0.c0 = 0 AND t0.c0 = v0.c0;
165 } {}
166 do_execsql_test 520 {
167 SELECT 200, * FROM t0, v0 WHERE 0 = t0.c0 AND v0.c0 = t0.c0;
168 } {}
169 do_execsql_test 530 {
170 SELECT 200, * FROM t0, v0 WHERE t0.c0 = 0 AND v0.c0 = t0.c0;
171 } {}
172
173 # 2020-02-13: ticket 1dcb4d44964846ad
174 # A problem introduced while making optimizations on the fixes above.
175 #
176 reset_db
177 do_execsql_test 600 {
178 CREATE TABLE t1(x TEXT);
179 CREATE TABLE t2(y TEXT);
180 INSERT INTO t1 VALUES('good'),('bad');
181 INSERT INTO t2 VALUES('good'),('bad');
182 SELECT * FROM t1 JOIN t2 ON x=y
183 WHERE x='good' AND y='good';
184 } {good good}
185
186 # 2020-04-24: Another test case for the previous (1dcb4d44964846ad)
187 # ticket. The test case comes from
188 # https://stackoverflow.com/questions/61399253/sqlite3-different-result-in-console-compared-to-python-script/
189 # Output verified against postgresql.
190 #
191 do_execsql_test 610 {
192 CREATE TABLE tableA(
193 ID int,
194 RunYearMonth int
195 );
196 INSERT INTO tableA VALUES(1,202003),(2,202003),(3,202003),(4,202004),
197 (5,202004),(6,202004),(7,202004),(8,202004);
198 CREATE TABLE tableB (
199 ID int,
200 RunYearMonth int
201 );
202 INSERT INTO tableB VALUES(1,202004),(2,202004),(3,202004),(4,202004),
203 (5,202004);
204 SELECT *
205 FROM (
206 SELECT *
207 FROM tableA
208 WHERE RunYearMonth = 202004
209 ) AS A
210 INNER JOIN (
211 SELECT *
212 FROM tableB
213 WHERE RunYearMonth = 202004
214 ) AS B
215 ON A.ID = B.ID
216 AND A.RunYearMonth = B.RunYearMonth;
217 } {4 202004 4 202004 5 202004 5 202004}
218
219 # 2023-02-10 https://sqlite.org/forum/forumpost/0a539c76db3b9e29
220 # The original constant propagation implementation caused a performance
221 # regression. Because "abs(v)" was rewritten into "abs(1)" it no longer
222 # matches the indexed column and the index is not used.
223 #
224 reset_db
225 do_execsql_test 700 {
226 CREATE TABLE t1(v INTEGER);
227 WITH RECURSIVE c(x) AS (VALUES(-10) UNION ALL SELECT x+1 FROM c WHERE x<10)
228 INSERT INTO t1(v) SELECT x FROM c;
229 CREATE INDEX idx ON t1( abs(v) );
230 SELECT v FROM t1 WHERE abs(v)=1 and v=1;
231 } 1
232 do_eqp_test 710 {
233 SELECT v FROM t1 WHERE abs(v)=1 and v=1;
234 } {
235 QUERY PLAN
236 `--SEARCH t1 USING INDEX idx (<expr>=?)
237 }
238
239 # 2024-03-07 https://sqlite.org/forum/forumpost/ecdfc02339
240 # A refinement is needed to the enhancements tested by the prior test case
241 # to avoid another problem with indexes on constant expressions.
242 #
243 reset_db
244 db null NULL
245 do_execsql_test 800 {
246 CREATE TABLE t0(c0, c1);
247 CREATE TABLE t1(c2);
248 CREATE INDEX i0 ON t1(NULL);
249 INSERT INTO t1(c2) VALUES (0.2);
250 CREATE VIEW v0(c3) AS SELECT DISTINCT c2 FROM t1;
251 SELECT * FROM v0 LEFT JOIN t0 ON c3<NULL LEFT JOIN t1 ON 1;
252 } {0.2 NULL NULL 0.2}
253 do_execsql_test 810 {
254 SELECT * FROM v0 LEFT JOIN t0 ON c3<NULL LEFT JOIN t1 ON 1 WHERE c2/0.1;
255 } {0.2 NULL NULL 0.2}
256
257 #-------------------------------------------------------------------------
258 # 2025-04-10 https://sqlite.org/forum/forumpost/0109bca824
259 reset_db
260
261 do_execsql_test 900 {
262 SELECT * FROM (SELECT 1.0 AS abc) WHERE abc=1;
263 } {1.0}
264 do_execsql_test 910 {
265 SELECT * FROM (SELECT 1.0 AS abc) WHERE abc LIKE '1.0';
266 } {1.0}
267 do_execsql_test 920 {
268 SELECT * FROM (SELECT 1.0 AS abc) WHERE abc=1 AND abc LIKE '1.0';
269 } {1.0}
270
271 do_execsql_test 930 {
272 CREATE TABLE IF NOT EXISTS t0 (c0 BLOB);
273 CREATE TABLE IF NOT EXISTS t1 (c0 INTEGER);
274
275 INSERT INTO t1 VALUES ('1');
276 INSERT INTO t0 VALUES (''), (''), ('2');
277 }
278
279 do_execsql_test 940 {
280 SELECT *
281 FROM (SELECT 0.0 AS col_0) as subQuery
282 LEFT JOIN t0 ON ((CASE ''
283 WHEN t0.c0 THEN subQuery.col_0
284 ELSE (t0.c0) END) LIKE (((((subQuery.col_0))))))
285 LEFT JOIN t1 ON ((subQuery.col_0) == (false));
286 } {0.0 {} 1 0.0 {} 1}
287
288 do_execsql_test 950 {
289 SELECT *
290 FROM (SELECT 0.0 AS col_0) as subQuery
291 LEFT JOIN t0 ON ((CASE ''
292 WHEN t0.c0 THEN subQuery.col_0
293 ELSE (t0.c0) END) LIKE (((((subQuery.col_0))))))
294 LEFT JOIN t1 ON ((subQuery.col_0) == (false)) WHERE t1.c0;
295 } {0.0 {} 1 0.0 {} 1}
296
297 finish_test