|
1 # 2007 May 8 |
|
2 # |
|
3 # Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved. |
|
4 # |
|
5 # The author disclaims copyright to this source code. In place of |
|
6 # a legal notice, here is a blessing: |
|
7 # |
|
8 # May you do good and not evil. |
|
9 # May you find forgiveness for yourself and forgive others. |
|
10 # May you share freely, never taking more than you give. |
|
11 # |
|
12 #*********************************************************************** |
|
13 # |
|
14 # This file contains tests to verify that the limits defined in |
|
15 # sqlite source file limits.h are enforced. |
|
16 # |
|
17 # $Id: sqllimits1.test,v 1.31 2008/07/15 00:27:35 drh Exp $ |
|
18 |
|
19 set testdir [file dirname $argv0] |
|
20 source $testdir/tester.tcl |
|
21 |
|
22 # Verify that the default per-connection limits are the same as |
|
23 # the compile-time hard limits. |
|
24 # |
|
25 sqlite3 db2 :memory: |
|
26 do_test sqllimits1-1.1 { |
|
27 sqlite3_limit db SQLITE_LIMIT_LENGTH -1 |
|
28 } $SQLITE_MAX_LENGTH |
|
29 do_test sqllimits1-1.2 { |
|
30 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH -1 |
|
31 } $SQLITE_MAX_SQL_LENGTH |
|
32 do_test sqllimits1-1.3 { |
|
33 sqlite3_limit db SQLITE_LIMIT_COLUMN -1 |
|
34 } $SQLITE_MAX_COLUMN |
|
35 do_test sqllimits1-1.4 { |
|
36 sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH -1 |
|
37 } $SQLITE_MAX_EXPR_DEPTH |
|
38 do_test sqllimits1-1.5 { |
|
39 sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT -1 |
|
40 } $SQLITE_MAX_COMPOUND_SELECT |
|
41 do_test sqllimits1-1.6 { |
|
42 sqlite3_limit db SQLITE_LIMIT_VDBE_OP -1 |
|
43 } $SQLITE_MAX_VDBE_OP |
|
44 do_test sqllimits1-1.7 { |
|
45 sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1 |
|
46 } $SQLITE_MAX_FUNCTION_ARG |
|
47 do_test sqllimits1-1.8 { |
|
48 sqlite3_limit db SQLITE_LIMIT_ATTACHED -1 |
|
49 } $SQLITE_MAX_ATTACHED |
|
50 do_test sqllimits1-1.9 { |
|
51 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1 |
|
52 } $SQLITE_MAX_LIKE_PATTERN_LENGTH |
|
53 do_test sqllimits1-1.10 { |
|
54 sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1 |
|
55 } $SQLITE_MAX_VARIABLE_NUMBER |
|
56 |
|
57 # Limit parameters out of range. |
|
58 # |
|
59 do_test sqllimits1-1.20 { |
|
60 sqlite3_limit db SQLITE_LIMIT_TOOSMALL 123 |
|
61 } {-1} |
|
62 do_test sqllimits1-1.21 { |
|
63 sqlite3_limit db SQLITE_LIMIT_TOOSMALL 123 |
|
64 } {-1} |
|
65 do_test sqllimits1-1.22 { |
|
66 sqlite3_limit db SQLITE_LIMIT_TOOBIG 123 |
|
67 } {-1} |
|
68 do_test sqllimits1-1.23 { |
|
69 sqlite3_limit db SQLITE_LIMIT_TOOBIG 123 |
|
70 } {-1} |
|
71 |
|
72 |
|
73 # Decrease all limits by half. Verify that the new limits take. |
|
74 # |
|
75 if {$SQLITE_MAX_LENGTH>=2} { |
|
76 do_test sqllimits1-2.1.1 { |
|
77 sqlite3_limit db SQLITE_LIMIT_LENGTH \ |
|
78 [expr {$::SQLITE_MAX_LENGTH/2}] |
|
79 } $SQLITE_MAX_LENGTH |
|
80 do_test sqllimits1-2.1.2 { |
|
81 sqlite3_limit db SQLITE_LIMIT_LENGTH -1 |
|
82 } [expr {$SQLITE_MAX_LENGTH/2}] |
|
83 } |
|
84 if {$SQLITE_MAX_SQL_LENGTH>=2} { |
|
85 do_test sqllimits1-2.2.1 { |
|
86 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH \ |
|
87 [expr {$::SQLITE_MAX_SQL_LENGTH/2}] |
|
88 } $SQLITE_MAX_SQL_LENGTH |
|
89 do_test sqllimits1-2.2.2 { |
|
90 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH -1 |
|
91 } [expr {$SQLITE_MAX_SQL_LENGTH/2}] |
|
92 } |
|
93 if {$SQLITE_MAX_COLUMN>=2} { |
|
94 do_test sqllimits1-2.3.1 { |
|
95 sqlite3_limit db SQLITE_LIMIT_COLUMN \ |
|
96 [expr {$::SQLITE_MAX_COLUMN/2}] |
|
97 } $SQLITE_MAX_COLUMN |
|
98 do_test sqllimits1-2.3.2 { |
|
99 sqlite3_limit db SQLITE_LIMIT_COLUMN -1 |
|
100 } [expr {$SQLITE_MAX_COLUMN/2}] |
|
101 } |
|
102 if {$SQLITE_MAX_EXPR_DEPTH>=2} { |
|
103 do_test sqllimits1-2.4.1 { |
|
104 sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH \ |
|
105 [expr {$::SQLITE_MAX_EXPR_DEPTH/2}] |
|
106 } $SQLITE_MAX_EXPR_DEPTH |
|
107 do_test sqllimits1-2.4.2 { |
|
108 sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH -1 |
|
109 } [expr {$SQLITE_MAX_EXPR_DEPTH/2}] |
|
110 } |
|
111 if {$SQLITE_MAX_COMPOUND_SELECT>=2} { |
|
112 do_test sqllimits1-2.5.1 { |
|
113 sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT \ |
|
114 [expr {$::SQLITE_MAX_COMPOUND_SELECT/2}] |
|
115 } $SQLITE_MAX_COMPOUND_SELECT |
|
116 do_test sqllimits1-2.5.2 { |
|
117 sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT -1 |
|
118 } [expr {$SQLITE_MAX_COMPOUND_SELECT/2}] |
|
119 } |
|
120 if {$SQLITE_MAX_VDBE_OP>=2} { |
|
121 do_test sqllimits1-2.6.1 { |
|
122 sqlite3_limit db SQLITE_LIMIT_VDBE_OP \ |
|
123 [expr {$::SQLITE_MAX_VDBE_OP/2}] |
|
124 } $SQLITE_MAX_VDBE_OP |
|
125 do_test sqllimits1-2.6.2 { |
|
126 sqlite3_limit db SQLITE_LIMIT_VDBE_OP -1 |
|
127 } [expr {$SQLITE_MAX_VDBE_OP/2}] |
|
128 } |
|
129 if {$SQLITE_MAX_FUNCTION_ARG>=2} { |
|
130 do_test sqllimits1-2.7.1 { |
|
131 sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG \ |
|
132 [expr {$::SQLITE_MAX_FUNCTION_ARG/2}] |
|
133 } $SQLITE_MAX_FUNCTION_ARG |
|
134 do_test sqllimits1-2.7.2 { |
|
135 sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1 |
|
136 } [expr {$SQLITE_MAX_FUNCTION_ARG/2}] |
|
137 } |
|
138 if {$SQLITE_MAX_ATTACHED>=2} { |
|
139 do_test sqllimits1-2.8.1 { |
|
140 sqlite3_limit db SQLITE_LIMIT_ATTACHED \ |
|
141 [expr {$::SQLITE_MAX_ATTACHED/2}] |
|
142 } $SQLITE_MAX_ATTACHED |
|
143 do_test sqllimits1-2.8.2 { |
|
144 sqlite3_limit db SQLITE_LIMIT_ATTACHED -1 |
|
145 } [expr {$SQLITE_MAX_ATTACHED/2}] |
|
146 } |
|
147 if {$SQLITE_MAX_LIKE_PATTERN_LENGTH>=2} { |
|
148 do_test sqllimits1-2.9.1 { |
|
149 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH \ |
|
150 [expr {$::SQLITE_MAX_LIKE_PATTERN_LENGTH/2}] |
|
151 } $SQLITE_MAX_LIKE_PATTERN_LENGTH |
|
152 do_test sqllimits1-2.9.2 { |
|
153 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1 |
|
154 } [expr {$SQLITE_MAX_LIKE_PATTERN_LENGTH/2}] |
|
155 } |
|
156 if {$SQLITE_MAX_VARIABLE_NUMBER>=2} { |
|
157 do_test sqllimits1-2.10.1 { |
|
158 sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER \ |
|
159 [expr {$::SQLITE_MAX_VARIABLE_NUMBER/2}] |
|
160 } $SQLITE_MAX_VARIABLE_NUMBER |
|
161 do_test sqllimits1-2.10.2 { |
|
162 sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1 |
|
163 } [expr {$SQLITE_MAX_VARIABLE_NUMBER/2}] |
|
164 } |
|
165 |
|
166 # In a separate database connection, verify that the limits are unchanged. |
|
167 # |
|
168 do_test sqllimits1-3.1 { |
|
169 sqlite3_limit db2 SQLITE_LIMIT_LENGTH -1 |
|
170 } $SQLITE_MAX_LENGTH |
|
171 do_test sqllimits1-3.2 { |
|
172 sqlite3_limit db2 SQLITE_LIMIT_SQL_LENGTH -1 |
|
173 } $SQLITE_MAX_SQL_LENGTH |
|
174 do_test sqllimits1-3.3 { |
|
175 sqlite3_limit db2 SQLITE_LIMIT_COLUMN -1 |
|
176 } $SQLITE_MAX_COLUMN |
|
177 do_test sqllimits1-3.4 { |
|
178 sqlite3_limit db2 SQLITE_LIMIT_EXPR_DEPTH -1 |
|
179 } $SQLITE_MAX_EXPR_DEPTH |
|
180 do_test sqllimits1-3.5 { |
|
181 sqlite3_limit db2 SQLITE_LIMIT_COMPOUND_SELECT -1 |
|
182 } $SQLITE_MAX_COMPOUND_SELECT |
|
183 do_test sqllimits1-3.6 { |
|
184 sqlite3_limit db2 SQLITE_LIMIT_VDBE_OP -1 |
|
185 } $SQLITE_MAX_VDBE_OP |
|
186 do_test sqllimits1-3.7 { |
|
187 sqlite3_limit db2 SQLITE_LIMIT_FUNCTION_ARG -1 |
|
188 } $SQLITE_MAX_FUNCTION_ARG |
|
189 do_test sqllimits1-3.8 { |
|
190 sqlite3_limit db2 SQLITE_LIMIT_ATTACHED -1 |
|
191 } $SQLITE_MAX_ATTACHED |
|
192 do_test sqllimits1-3.9 { |
|
193 sqlite3_limit db2 SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1 |
|
194 } $SQLITE_MAX_LIKE_PATTERN_LENGTH |
|
195 do_test sqllimits1-3.10 { |
|
196 sqlite3_limit db2 SQLITE_LIMIT_VARIABLE_NUMBER -1 |
|
197 } $SQLITE_MAX_VARIABLE_NUMBER |
|
198 db2 close |
|
199 |
|
200 # Attempt to set all limits to the maximum 32-bit integer. Verify |
|
201 # that the limit does not exceed the compile-time upper bound. |
|
202 # |
|
203 do_test sqllimits1-4.1.1 { |
|
204 sqlite3_limit db SQLITE_LIMIT_LENGTH 0x7fffffff |
|
205 sqlite3_limit db SQLITE_LIMIT_LENGTH -1 |
|
206 } $SQLITE_MAX_LENGTH |
|
207 do_test sqllimits1-4.2.1 { |
|
208 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 0x7fffffff |
|
209 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH -1 |
|
210 } $SQLITE_MAX_SQL_LENGTH |
|
211 do_test sqllimits1-4.3.1 { |
|
212 sqlite3_limit db SQLITE_LIMIT_COLUMN 0x7fffffff |
|
213 sqlite3_limit db SQLITE_LIMIT_COLUMN -1 |
|
214 } $SQLITE_MAX_COLUMN |
|
215 do_test sqllimits1-4.4.1 { |
|
216 sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH 0x7fffffff |
|
217 sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH -1 |
|
218 } $SQLITE_MAX_EXPR_DEPTH |
|
219 do_test sqllimits1-4.5.1 { |
|
220 sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT 0x7fffffff |
|
221 sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT -1 |
|
222 } $SQLITE_MAX_COMPOUND_SELECT |
|
223 do_test sqllimits1-4.6.1 { |
|
224 sqlite3_limit db SQLITE_LIMIT_VDBE_OP 0x7fffffff |
|
225 sqlite3_limit db SQLITE_LIMIT_VDBE_OP -1 |
|
226 } $SQLITE_MAX_VDBE_OP |
|
227 do_test sqllimits1-4.7.1 { |
|
228 sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG 0x7fffffff |
|
229 sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1 |
|
230 } $SQLITE_MAX_FUNCTION_ARG |
|
231 do_test sqllimits1-4.8.1 { |
|
232 sqlite3_limit db SQLITE_LIMIT_ATTACHED 0x7fffffff |
|
233 sqlite3_limit db SQLITE_LIMIT_ATTACHED -1 |
|
234 } $SQLITE_MAX_ATTACHED |
|
235 do_test sqllimits1-4.9.1 { |
|
236 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH 0x7fffffff |
|
237 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1 |
|
238 } $SQLITE_MAX_LIKE_PATTERN_LENGTH |
|
239 do_test sqllimits1-4.10.1 { |
|
240 sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER 0x7fffffff |
|
241 sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1 |
|
242 } $SQLITE_MAX_VARIABLE_NUMBER |
|
243 |
|
244 #-------------------------------------------------------------------- |
|
245 # Test cases sqllimits1-5.* test that the SQLITE_MAX_LENGTH limit |
|
246 # is enforced. |
|
247 # |
|
248 db close |
|
249 sqlite3 db test.db |
|
250 set LARGESIZE 99999 |
|
251 set SQLITE_LIMIT_LENGTH 100000 |
|
252 sqlite3_limit db SQLITE_LIMIT_LENGTH $SQLITE_LIMIT_LENGTH |
|
253 |
|
254 do_test sqllimits1-5.1.1 { |
|
255 catchsql { SELECT randomblob(2147483647) } |
|
256 } {1 {string or blob too big}} |
|
257 do_test sqllimits1-5.1.2 { |
|
258 catchsql { SELECT zeroblob(2147483647) } |
|
259 } {1 {string or blob too big}} |
|
260 |
|
261 do_test sqllimits1-5.2 { |
|
262 catchsql { SELECT LENGTH(randomblob($::LARGESIZE)) } |
|
263 } [list 0 $LARGESIZE] |
|
264 |
|
265 do_test sqllimits1-5.3 { |
|
266 catchsql { SELECT quote(randomblob($::LARGESIZE)) } |
|
267 } {1 {string or blob too big}} |
|
268 |
|
269 do_test sqllimits1-5.4 { |
|
270 catchsql { SELECT LENGTH(zeroblob($::LARGESIZE)) } |
|
271 } [list 0 $LARGESIZE] |
|
272 |
|
273 do_test sqllimits1-5.5 { |
|
274 catchsql { SELECT quote(zeroblob($::LARGESIZE)) } |
|
275 } {1 {string or blob too big}} |
|
276 |
|
277 do_test sqllimits1-5.6 { |
|
278 catchsql { SELECT zeroblob(-1) } |
|
279 } {0 {{}}} |
|
280 |
|
281 do_test sqllimits1-5.9 { |
|
282 set ::str [string repeat A 65537] |
|
283 set ::rep [string repeat B 65537] |
|
284 catchsql { SELECT replace($::str, 'A', $::rep) } |
|
285 } {1 {string or blob too big}} |
|
286 |
|
287 do_test sqllimits1-5.10 { |
|
288 set ::str [string repeat %J 2100] |
|
289 catchsql { SELECT strftime($::str, '2003-10-31') } |
|
290 } {1 {string or blob too big}} |
|
291 |
|
292 do_test sqllimits1-5.11 { |
|
293 set ::str1 [string repeat A [expr {$SQLITE_LIMIT_LENGTH - 10}]] |
|
294 set ::str2 [string repeat B [expr {$SQLITE_LIMIT_LENGTH - 10}]] |
|
295 catchsql { SELECT $::str1 || $::str2 } |
|
296 } {1 {string or blob too big}} |
|
297 |
|
298 do_test sqllimits1-5.12 { |
|
299 set ::str1 [string repeat ' [expr {$SQLITE_LIMIT_LENGTH - 10}]] |
|
300 catchsql { SELECT quote($::str1) } |
|
301 } {1 {string or blob too big}} |
|
302 |
|
303 do_test sqllimits1-5.13 { |
|
304 set ::str1 [string repeat ' [expr {$SQLITE_LIMIT_LENGTH - 10}]] |
|
305 catchsql { SELECT hex($::str1) } |
|
306 } {1 {string or blob too big}} |
|
307 |
|
308 do_test sqllimits1-5.14.1 { |
|
309 set ::STMT [sqlite3_prepare db "SELECT ?" -1 TAIL] |
|
310 sqlite3_bind_zeroblob $::STMT 1 [expr {$SQLITE_LIMIT_LENGTH + 1}] |
|
311 } {} |
|
312 do_test sqllimits1-5.14.2 { |
|
313 sqlite3_step $::STMT |
|
314 } {SQLITE_ERROR} |
|
315 do_test sqllimits1-5.14.3 { |
|
316 sqlite3_reset $::STMT |
|
317 } {SQLITE_TOOBIG} |
|
318 do_test sqllimits1-5.14.4 { |
|
319 set np1 [expr {$SQLITE_LIMIT_LENGTH + 1}] |
|
320 set ::str1 [string repeat A $np1] |
|
321 catch {sqlite3_bind_text $::STMT 1 $::str1 -1} res |
|
322 set res |
|
323 } {SQLITE_TOOBIG} |
|
324 do_test sqllimits1-5.14.5 { |
|
325 catch {sqlite3_bind_text16 $::STMT 1 $::str1 -1} res |
|
326 set res |
|
327 } {SQLITE_TOOBIG} |
|
328 do_test sqllimits1-5.14.6 { |
|
329 catch {sqlite3_bind_text $::STMT 1 $::str1 $np1} res |
|
330 set res |
|
331 } {SQLITE_TOOBIG} |
|
332 do_test sqllimits1-5.14.7 { |
|
333 catch {sqlite3_bind_text16 $::STMT 1 $::str1 $np1} res |
|
334 set res |
|
335 } {SQLITE_TOOBIG} |
|
336 do_test sqllimits1-5.14.8 { |
|
337 set n [expr {$np1-1}] |
|
338 catch {sqlite3_bind_text $::STMT 1 $::str1 $n} res |
|
339 set res |
|
340 } {} |
|
341 do_test sqllimits1-5.14.9 { |
|
342 catch {sqlite3_bind_text16 $::STMT 1 $::str1 $n} res |
|
343 set res |
|
344 } {} |
|
345 sqlite3_finalize $::STMT |
|
346 |
|
347 do_test sqllimits1-5.15 { |
|
348 execsql { |
|
349 CREATE TABLE t4(x); |
|
350 INSERT INTO t4 VALUES(1); |
|
351 INSERT INTO t4 VALUES(2); |
|
352 INSERT INTO t4 SELECT 2+x FROM t4; |
|
353 } |
|
354 catchsql { |
|
355 SELECT group_concat(hex(randomblob(20000))) FROM t4; |
|
356 } |
|
357 } {1 {string or blob too big}} |
|
358 db eval {DROP TABLE t4} |
|
359 |
|
360 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 0x7fffffff |
|
361 set strvalue [string repeat A $::SQLITE_LIMIT_LENGTH] |
|
362 do_test sqllimits1-5.16 { |
|
363 catchsql "SELECT '$strvalue'" |
|
364 } [list 0 $strvalue] |
|
365 do_test sqllimits1-5.17.1 { |
|
366 catchsql "SELECT 'A$strvalue'" |
|
367 } [list 1 {string or blob too big}] |
|
368 do_test sqllimits1-5.17.2 { |
|
369 sqlite3_limit db SQLITE_LIMIT_LENGTH 0x7fffffff |
|
370 catchsql {SELECT 'A' || $::strvalue} |
|
371 } [list 0 A$strvalue] |
|
372 do_test sqllimits1-5.17.3 { |
|
373 sqlite3_limit db SQLITE_LIMIT_LENGTH $SQLITE_LIMIT_LENGTH |
|
374 catchsql {SELECT 'A' || $::strvalue} |
|
375 } [list 1 {string or blob too big}] |
|
376 set blobvalue [string repeat 41 $::SQLITE_LIMIT_LENGTH] |
|
377 do_test sqllimits1-5.18 { |
|
378 catchsql "SELECT x'$blobvalue'" |
|
379 } [list 0 $strvalue] |
|
380 do_test sqllimits1-5.19 { |
|
381 catchsql "SELECT '41$blobvalue'" |
|
382 } [list 1 {string or blob too big}] |
|
383 unset blobvalue |
|
384 |
|
385 ifcapable datetime { |
|
386 set strvalue [string repeat D [expr {$SQLITE_LIMIT_LENGTH-12}]] |
|
387 do_test sqllimits1-5.20 { |
|
388 catchsql {SELECT strftime('%Y ' || $::strvalue, '2008-01-02')} |
|
389 } [list 0 [list "2008 $strvalue"]] |
|
390 do_test sqllimits1-5.21 { |
|
391 catchsql {SELECT strftime('%Y-%m-%d ' || $::strvalue, '2008-01-02')} |
|
392 } {1 {string or blob too big}} |
|
393 } |
|
394 unset strvalue |
|
395 |
|
396 #-------------------------------------------------------------------- |
|
397 # Test cases sqllimits1-6.* test that the SQLITE_MAX_SQL_LENGTH limit |
|
398 # is enforced. |
|
399 # |
|
400 # Symbian OS: the next test fails because the max expression depth is limited to 250. |
|
401 if {$::tcl_platform(platform)!="symbian"} { |
|
402 do_test sqllimits1-6.1 { |
|
403 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 50000 |
|
404 set sql "SELECT 1 WHERE 1==1" |
|
405 set tail " /* A comment to take up space in order to make the string\ |
|
406 longer without increasing the expression depth */\ |
|
407 AND 1 == 1" |
|
408 set N [expr {(50000 / [string length $tail])+1}] |
|
409 append sql [string repeat $tail $N] |
|
410 catchsql $sql |
|
411 } {1 {String or BLOB exceeded size limit}} |
|
412 } |
|
413 do_test sqllimits1-6.3 { |
|
414 sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 50000 |
|
415 set sql "SELECT 1 WHERE 1==1" |
|
416 set tail " /* A comment to take up space in order to make the string\ |
|
417 longer without increasing the expression depth */\ |
|
418 AND 1 == 1" |
|
419 set N [expr {(50000 / [string length $tail])+1}] |
|
420 append sql [string repeat $tail $N] |
|
421 set nbytes [string length $sql] |
|
422 append sql { AND 0} |
|
423 set rc [catch {sqlite3_prepare db $sql $nbytes TAIL} STMT] |
|
424 lappend rc $STMT |
|
425 } {1 {(18) statement too long}} |
|
426 do_test sqllimits1-6.4 { |
|
427 sqlite3_errmsg db |
|
428 } {statement too long} |
|
429 |
|
430 #-------------------------------------------------------------------- |
|
431 # Test cases sqllimits1-7.* test that the limit set using the |
|
432 # max_page_count pragma. |
|
433 # |
|
434 do_test sqllimits1-7.1 { |
|
435 execsql { |
|
436 PRAGMA max_page_count = 1000; |
|
437 } |
|
438 } {1000} |
|
439 do_test sqllimits1-7.2 { |
|
440 execsql { CREATE TABLE trig (a INTEGER, b INTEGER); } |
|
441 |
|
442 # Set up a tree of triggers to fire when a row is inserted |
|
443 # into table "trig". |
|
444 # |
|
445 # INSERT -> insert_b -> update_b -> insert_a -> update_a (chain 1) |
|
446 # -> update_a -> insert_a -> update_b (chain 2) |
|
447 # -> insert_a -> update_b -> insert_b -> update_a (chain 3) |
|
448 # -> update_a -> insert_b -> update_b (chain 4) |
|
449 # |
|
450 # Table starts with N rows. |
|
451 # |
|
452 # Chain 1: insert_b (update N rows) |
|
453 # -> update_b (insert 1 rows) |
|
454 # -> insert_a (update N rows) |
|
455 # -> update_a (insert 1 rows) |
|
456 # |
|
457 # chains 2, 3 and 4 are similar. Each inserts more than N^2 rows, where |
|
458 # N is the number of rows at the conclusion of the previous chain. |
|
459 # |
|
460 # Therefore, a single insert adds (N^16 plus some) rows to the database. |
|
461 # A really long loop... |
|
462 # |
|
463 execsql { |
|
464 CREATE TRIGGER update_b BEFORE UPDATE ON trig |
|
465 FOR EACH ROW BEGIN |
|
466 INSERT INTO trig VALUES (65, 'update_b'); |
|
467 END; |
|
468 |
|
469 CREATE TRIGGER update_a AFTER UPDATE ON trig |
|
470 FOR EACH ROW BEGIN |
|
471 INSERT INTO trig VALUES (65, 'update_a'); |
|
472 END; |
|
473 |
|
474 CREATE TRIGGER insert_b BEFORE INSERT ON trig |
|
475 FOR EACH ROW BEGIN |
|
476 UPDATE trig SET a = 1; |
|
477 END; |
|
478 |
|
479 CREATE TRIGGER insert_a AFTER INSERT ON trig |
|
480 FOR EACH ROW BEGIN |
|
481 UPDATE trig SET a = 1; |
|
482 END; |
|
483 } |
|
484 } {} |
|
485 |
|
486 do_test sqllimits1-7.3 { |
|
487 execsql { |
|
488 INSERT INTO trig VALUES (1,1); |
|
489 } |
|
490 } {} |
|
491 |
|
492 do_test sqllimits1-7.4 { |
|
493 execsql { |
|
494 SELECT COUNT(*) FROM trig; |
|
495 } |
|
496 } {7} |
|
497 |
|
498 # This tries to insert so many rows it fills up the database (limited |
|
499 # to 1MB, so not that noteworthy an achievement). |
|
500 # |
|
501 do_test sqllimits1-7.5 { |
|
502 catchsql { |
|
503 INSERT INTO trig VALUES (1,10); |
|
504 } |
|
505 } {1 {database or disk is full}} |
|
506 |
|
507 do_test sqllimits1-7.6 { |
|
508 catchsql { |
|
509 SELECT COUNT(*) FROM trig; |
|
510 } |
|
511 } {0 7} |
|
512 |
|
513 # Now check the response of the library to opening a file larger than |
|
514 # the current max_page_count value. The response is to change the |
|
515 # internal max_page_count value to match the actual size of the file. |
|
516 if {[db eval {PRAGMA auto_vacuum}]} { |
|
517 set fsize 1700 |
|
518 } else { |
|
519 set fsize 1691 |
|
520 } |
|
521 do_test sqllimits1-7.7.1 { |
|
522 execsql { |
|
523 PRAGMA max_page_count = 1000000; |
|
524 CREATE TABLE abc(a, b, c); |
|
525 INSERT INTO abc VALUES(1, 2, 3); |
|
526 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
527 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
528 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
529 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
530 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
531 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
532 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
533 INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc; |
|
534 INSERT INTO abc SELECT a, b, c FROM abc; |
|
535 INSERT INTO abc SELECT b, a, c FROM abc; |
|
536 INSERT INTO abc SELECT c, b, a FROM abc; |
|
537 } |
|
538 expr [file size test.db] / 1024 |
|
539 } $fsize |
|
540 do_test sqllimits1-7.7.2 { |
|
541 db close |
|
542 sqlite3 db test.db |
|
543 execsql { |
|
544 PRAGMA max_page_count = 1000; |
|
545 } |
|
546 execsql { |
|
547 SELECT count(*) FROM sqlite_master; |
|
548 } |
|
549 } {6} |
|
550 do_test sqllimits1-7.7.3 { |
|
551 execsql { |
|
552 PRAGMA max_page_count; |
|
553 } |
|
554 } $fsize |
|
555 do_test sqllimits1-7.7.4 { |
|
556 execsql { |
|
557 DROP TABLE abc; |
|
558 } |
|
559 } {} |
|
560 |
|
561 #-------------------------------------------------------------------- |
|
562 # Test cases sqllimits1-8.* test the SQLITE_MAX_COLUMN limit. |
|
563 # |
|
564 set SQLITE_LIMIT_COLUMN 200 |
|
565 sqlite3_limit db SQLITE_LIMIT_COLUMN $SQLITE_LIMIT_COLUMN |
|
566 do_test sqllimits1-8.1 { |
|
567 # Columns in a table. |
|
568 set cols [list] |
|
569 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
570 lappend cols "c$i" |
|
571 } |
|
572 catchsql "CREATE TABLE t([join $cols ,])" |
|
573 } {1 {too many columns on t}} |
|
574 |
|
575 do_test sqllimits1-8.2 { |
|
576 # Columns in the result-set of a SELECT. |
|
577 set cols [list] |
|
578 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
579 lappend cols "sql AS sql$i" |
|
580 } |
|
581 catchsql "SELECT [join $cols ,] FROM sqlite_master" |
|
582 } {1 {too many columns in result set}} |
|
583 |
|
584 do_test sqllimits1-8.3 { |
|
585 # Columns in the result-set of a sub-SELECT. |
|
586 set cols [list] |
|
587 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
588 lappend cols "sql AS sql$i" |
|
589 } |
|
590 catchsql "SELECT sql4 FROM (SELECT [join $cols ,] FROM sqlite_master)" |
|
591 } {1 {too many columns in result set}} |
|
592 |
|
593 do_test sqllimits1-8.4 { |
|
594 # Columns in an index. |
|
595 set cols [list] |
|
596 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
597 lappend cols c |
|
598 } |
|
599 set sql1 "CREATE TABLE t1(c);" |
|
600 set sql2 "CREATE INDEX i1 ON t1([join $cols ,]);" |
|
601 catchsql "$sql1 ; $sql2" |
|
602 } {1 {too many columns in index}} |
|
603 |
|
604 do_test sqllimits1-8.5 { |
|
605 # Columns in a GROUP BY clause. |
|
606 catchsql "SELECT * FROM t1 GROUP BY [join $cols ,]" |
|
607 } {1 {too many terms in GROUP BY clause}} |
|
608 |
|
609 do_test sqllimits1-8.6 { |
|
610 # Columns in an ORDER BY clause. |
|
611 catchsql "SELECT * FROM t1 ORDER BY [join $cols ,]" |
|
612 } {1 {too many terms in ORDER BY clause}} |
|
613 |
|
614 do_test sqllimits1-8.7 { |
|
615 # Assignments in an UPDATE statement. |
|
616 set cols [list] |
|
617 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
618 lappend cols "c = 1" |
|
619 } |
|
620 catchsql "UPDATE t1 SET [join $cols ,];" |
|
621 } {1 {too many columns in set list}} |
|
622 |
|
623 do_test sqllimits1-8.8 { |
|
624 # Columns in a view definition: |
|
625 set cols [list] |
|
626 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
627 lappend cols "c$i" |
|
628 } |
|
629 catchsql "CREATE VIEW v1 AS SELECT [join $cols ,] FROM t1;" |
|
630 } {1 {too many columns in result set}} |
|
631 |
|
632 do_test sqllimits1-8.9 { |
|
633 # Columns in a view definition (testing * expansion): |
|
634 set cols [list] |
|
635 for {set i 0} {$i < $SQLITE_LIMIT_COLUMN} {incr i} { |
|
636 lappend cols "c$i" |
|
637 } |
|
638 catchsql "CREATE TABLE t2([join $cols ,])" |
|
639 catchsql "CREATE VIEW v1 AS SELECT *, c1 AS o FROM t2;" |
|
640 } {1 {too many columns in result set}} |
|
641 do_test sqllimits1-8.10 { |
|
642 # ORDER BY columns |
|
643 set cols [list] |
|
644 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
645 lappend cols c |
|
646 } |
|
647 set sql "SELECT c FROM t1 ORDER BY [join $cols ,]" |
|
648 catchsql $sql |
|
649 } {1 {too many terms in ORDER BY clause}} |
|
650 do_test sqllimits1-8.11 { |
|
651 # ORDER BY columns |
|
652 set cols [list] |
|
653 for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} { |
|
654 lappend cols [expr {$i%3 + 1}] |
|
655 } |
|
656 set sql "SELECT c, c+1, c+2 FROM t1 UNION SELECT c-1, c-2, c-3 FROM t1" |
|
657 append sql " ORDER BY [join $cols ,]" |
|
658 catchsql $sql |
|
659 } {1 {too many terms in ORDER BY clause}} |
|
660 |
|
661 |
|
662 #-------------------------------------------------------------------- |
|
663 # These tests - sqllimits1-9.* - test that the SQLITE_LIMIT_EXPR_DEPTH |
|
664 # limit is enforced. The limit refers to the number of terms in |
|
665 # the expression. |
|
666 # |
|
667 if {$SQLITE_MAX_EXPR_DEPTH==0} { |
|
668 puts -nonewline stderr "WARNING: Compile with -DSQLITE_MAX_EXPR_DEPTH to run " |
|
669 puts stderr "tests sqllimits1-9.X" |
|
670 } else { |
|
671 do_test sqllimits1-9.1 { |
|
672 set max $::SQLITE_MAX_EXPR_DEPTH |
|
673 set expr "(1 [string repeat {AND 1 } $max])" |
|
674 catchsql [subst { |
|
675 SELECT $expr |
|
676 }] |
|
677 } "1 {Expression tree is too large (maximum depth $::SQLITE_MAX_EXPR_DEPTH)}" |
|
678 |
|
679 # Attempting to beat the expression depth limit using nested SELECT |
|
680 # queries causes a parser stack overflow. |
|
681 do_test sqllimits1-9.2 { |
|
682 set max $::SQLITE_MAX_EXPR_DEPTH |
|
683 set expr "SELECT 1" |
|
684 for {set i 0} {$i <= $max} {incr i} { |
|
685 set expr "SELECT ($expr)" |
|
686 } |
|
687 catchsql [subst { $expr }] |
|
688 } "1 {parser stack overflow}" |
|
689 |
|
690 if 0 { |
|
691 do_test sqllimits1-9.3 { |
|
692 execsql { |
|
693 PRAGMA max_page_count = 1000000; -- 1 GB |
|
694 CREATE TABLE v0(a); |
|
695 INSERT INTO v0 VALUES(1); |
|
696 } |
|
697 db transaction { |
|
698 for {set i 1} {$i < 200} {incr i} { |
|
699 set expr "(a [string repeat {AND 1 } 50]) AS a" |
|
700 execsql [subst { |
|
701 CREATE VIEW v${i} AS SELECT $expr FROM v[expr {$i-1}] |
|
702 }] |
|
703 } |
|
704 } |
|
705 } {} |
|
706 |
|
707 do_test sqllimits1-9.4 { |
|
708 catchsql { |
|
709 SELECT a FROM v199 |
|
710 } |
|
711 } "1 {Expression tree is too large (maximum depth $::SQLITE_MAX_EXPR_DEPTH)}" |
|
712 } |
|
713 } |
|
714 |
|
715 #-------------------------------------------------------------------- |
|
716 # Test cases sqllimits1-10.* test that the SQLITE_MAX_VDBE_OP |
|
717 # limit works as expected. The limit refers to the number of opcodes |
|
718 # in a single VDBE program. |
|
719 # |
|
720 # TODO |
|
721 |
|
722 #-------------------------------------------------------------------- |
|
723 # Test the SQLITE_LIMIT_FUNCTION_ARG limit works. Test case names |
|
724 # match the pattern "sqllimits1-11.*". |
|
725 # |
|
726 do_test sqllimits1-11.1 { |
|
727 set max $::SQLITE_MAX_FUNCTION_ARG |
|
728 set vals [list] |
|
729 for {set i 0} {$i < $SQLITE_MAX_FUNCTION_ARG} {incr i} { |
|
730 lappend vals $i |
|
731 } |
|
732 catchsql "SELECT max([join $vals ,])" |
|
733 } "0 [expr {$::SQLITE_MAX_FUNCTION_ARG - 1}]" |
|
734 do_test sqllimits1-11.2 { |
|
735 set max $::SQLITE_MAX_FUNCTION_ARG |
|
736 set vals [list] |
|
737 for {set i 0} {$i <= $SQLITE_MAX_FUNCTION_ARG} {incr i} { |
|
738 lappend vals $i |
|
739 } |
|
740 catchsql "SELECT max([join $vals ,])" |
|
741 } {1 {too many arguments on function max}} |
|
742 |
|
743 # Test that it is SQLite, and not the implementation of the |
|
744 # user function that is throwing the error. |
|
745 proc myfunc {args} {error "I don't like to be called!"} |
|
746 do_test sqllimits1-11.2 { |
|
747 db function myfunc myfunc |
|
748 set max $::SQLITE_MAX_FUNCTION_ARG |
|
749 set vals [list] |
|
750 for {set i 0} {$i <= $SQLITE_MAX_FUNCTION_ARG} {incr i} { |
|
751 lappend vals $i |
|
752 } |
|
753 catchsql "SELECT myfunc([join $vals ,])" |
|
754 } {1 {too many arguments on function myfunc}} |
|
755 |
|
756 |
|
757 #-------------------------------------------------------------------- |
|
758 # Test cases sqllimits1-12.*: Test the SQLITE_MAX_ATTACHED limit. |
|
759 # |
|
760 ifcapable attach { |
|
761 do_test sqllimits1-12.1 { |
|
762 set max $::SQLITE_MAX_ATTACHED |
|
763 for {set i 0} {$i < ($max)} {incr i} { |
|
764 file delete -force test${i}.db test${i}.db-journal |
|
765 } |
|
766 for {set i 0} {$i < ($max)} {incr i} { |
|
767 execsql "ATTACH 'test${i}.db' AS aux${i}" |
|
768 } |
|
769 catchsql "ATTACH 'test${i}.db' AS aux${i}" |
|
770 } "1 {too many attached databases - max $::SQLITE_MAX_ATTACHED}" |
|
771 do_test sqllimits1-12.2 { |
|
772 set max $::SQLITE_MAX_ATTACHED |
|
773 for {set i 0} {$i < ($max)} {incr i} { |
|
774 execsql "DETACH aux${i}" |
|
775 } |
|
776 } {} |
|
777 } |
|
778 |
|
779 #-------------------------------------------------------------------- |
|
780 # Test cases sqllimits1-13.*: Check that the SQLITE_MAX_VARIABLE_NUMBER |
|
781 # limit works. |
|
782 # |
|
783 do_test sqllimits1-13.1 { |
|
784 set max $::SQLITE_MAX_VARIABLE_NUMBER |
|
785 catchsql "SELECT ?[expr {$max+1}] FROM t1" |
|
786 } "1 {variable number must be between ?1 and ?$::SQLITE_MAX_VARIABLE_NUMBER}" |
|
787 do_test sqllimits1-13.2 { |
|
788 set max $::SQLITE_MAX_VARIABLE_NUMBER |
|
789 set vals [list] |
|
790 for {set i 0} {$i < ($max+3)} {incr i} { |
|
791 lappend vals ? |
|
792 } |
|
793 catchsql "SELECT [join $vals ,] FROM t1" |
|
794 } "1 {too many SQL variables}" |
|
795 |
|
796 |
|
797 #-------------------------------------------------------------------- |
|
798 # Test cases sqllimits1-15.* verify that the |
|
799 # SQLITE_MAX_LIKE_PATTERN_LENGTH limit is enforced. This limit only |
|
800 # applies to the built-in LIKE operator, supplying an external |
|
801 # implementation by overriding the like() scalar function bypasses |
|
802 # this limitation. |
|
803 # |
|
804 # These tests check that the limit is not incorrectly applied to |
|
805 # the left-hand-side of the LIKE operator (the string being tested |
|
806 # against the pattern). |
|
807 # |
|
808 set SQLITE_LIMIT_LIKE_PATTERN 1000 |
|
809 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH $SQLITE_LIMIT_LIKE_PATTERN |
|
810 do_test sqllimits1-15.1 { |
|
811 set max $::SQLITE_LIMIT_LIKE_PATTERN |
|
812 set ::pattern [string repeat "A%" [expr $max/2]] |
|
813 set ::string [string repeat "A" [expr {$max*2}]] |
|
814 execsql { |
|
815 SELECT $::string LIKE $::pattern; |
|
816 } |
|
817 } {1} |
|
818 do_test sqllimits1-15.2 { |
|
819 set max $::SQLITE_LIMIT_LIKE_PATTERN |
|
820 set ::pattern [string repeat "A%" [expr {($max/2) + 1}]] |
|
821 set ::string [string repeat "A" [expr {$max*2}]] |
|
822 catchsql { |
|
823 SELECT $::string LIKE $::pattern; |
|
824 } |
|
825 } {1 {LIKE or GLOB pattern too complex}} |
|
826 |
|
827 #-------------------------------------------------------------------- |
|
828 # This test case doesn't really belong with the other limits tests. |
|
829 # It is in this file because it is taxing to run, like the limits tests. |
|
830 # |
|
831 do_test sqllimits1-16.1 { |
|
832 set ::N [expr int(([expr pow(2,32)]/50) + 1)] |
|
833 expr (($::N*50) & 0xffffffff)<55 |
|
834 } {1} |
|
835 # |
|
836 # Symbian: This test case is crashing tclsqlite3.exe if uncommented. |
|
837 # |
|
838 if {$tcl_platform(platform)!="symbian"} { |
|
839 do_test sqllimits1-16.2 { |
|
840 set ::format "[string repeat A 60][string repeat "%J" $::N]" |
|
841 catchsql { |
|
842 SELECT strftime($::format, 1); |
|
843 } |
|
844 } {1 {string or blob too big}} |
|
845 } |
|
846 |
|
847 foreach {key value} [array get saved] { |
|
848 catch {set $key $value} |
|
849 } |
|
850 finish_test |