1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/TclScript/sqllimits1.test Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,850 @@
1.4 +# 2007 May 8
1.5 +#
1.6 +# Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.
1.7 +#
1.8 +# The author disclaims copyright to this source code. In place of
1.9 +# a legal notice, here is a blessing:
1.10 +#
1.11 +# May you do good and not evil.
1.12 +# May you find forgiveness for yourself and forgive others.
1.13 +# May you share freely, never taking more than you give.
1.14 +#
1.15 +#***********************************************************************
1.16 +#
1.17 +# This file contains tests to verify that the limits defined in
1.18 +# sqlite source file limits.h are enforced.
1.19 +#
1.20 +# $Id: sqllimits1.test,v 1.31 2008/07/15 00:27:35 drh Exp $
1.21 +
1.22 +set testdir [file dirname $argv0]
1.23 +source $testdir/tester.tcl
1.24 +
1.25 +# Verify that the default per-connection limits are the same as
1.26 +# the compile-time hard limits.
1.27 +#
1.28 +sqlite3 db2 :memory:
1.29 +do_test sqllimits1-1.1 {
1.30 + sqlite3_limit db SQLITE_LIMIT_LENGTH -1
1.31 +} $SQLITE_MAX_LENGTH
1.32 +do_test sqllimits1-1.2 {
1.33 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH -1
1.34 +} $SQLITE_MAX_SQL_LENGTH
1.35 +do_test sqllimits1-1.3 {
1.36 + sqlite3_limit db SQLITE_LIMIT_COLUMN -1
1.37 +} $SQLITE_MAX_COLUMN
1.38 +do_test sqllimits1-1.4 {
1.39 + sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH -1
1.40 +} $SQLITE_MAX_EXPR_DEPTH
1.41 +do_test sqllimits1-1.5 {
1.42 + sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT -1
1.43 +} $SQLITE_MAX_COMPOUND_SELECT
1.44 +do_test sqllimits1-1.6 {
1.45 + sqlite3_limit db SQLITE_LIMIT_VDBE_OP -1
1.46 +} $SQLITE_MAX_VDBE_OP
1.47 +do_test sqllimits1-1.7 {
1.48 + sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1
1.49 +} $SQLITE_MAX_FUNCTION_ARG
1.50 +do_test sqllimits1-1.8 {
1.51 + sqlite3_limit db SQLITE_LIMIT_ATTACHED -1
1.52 +} $SQLITE_MAX_ATTACHED
1.53 +do_test sqllimits1-1.9 {
1.54 + sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1
1.55 +} $SQLITE_MAX_LIKE_PATTERN_LENGTH
1.56 +do_test sqllimits1-1.10 {
1.57 + sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1
1.58 +} $SQLITE_MAX_VARIABLE_NUMBER
1.59 +
1.60 +# Limit parameters out of range.
1.61 +#
1.62 +do_test sqllimits1-1.20 {
1.63 + sqlite3_limit db SQLITE_LIMIT_TOOSMALL 123
1.64 +} {-1}
1.65 +do_test sqllimits1-1.21 {
1.66 + sqlite3_limit db SQLITE_LIMIT_TOOSMALL 123
1.67 +} {-1}
1.68 +do_test sqllimits1-1.22 {
1.69 + sqlite3_limit db SQLITE_LIMIT_TOOBIG 123
1.70 +} {-1}
1.71 +do_test sqllimits1-1.23 {
1.72 + sqlite3_limit db SQLITE_LIMIT_TOOBIG 123
1.73 +} {-1}
1.74 +
1.75 +
1.76 +# Decrease all limits by half. Verify that the new limits take.
1.77 +#
1.78 +if {$SQLITE_MAX_LENGTH>=2} {
1.79 + do_test sqllimits1-2.1.1 {
1.80 + sqlite3_limit db SQLITE_LIMIT_LENGTH \
1.81 + [expr {$::SQLITE_MAX_LENGTH/2}]
1.82 + } $SQLITE_MAX_LENGTH
1.83 + do_test sqllimits1-2.1.2 {
1.84 + sqlite3_limit db SQLITE_LIMIT_LENGTH -1
1.85 + } [expr {$SQLITE_MAX_LENGTH/2}]
1.86 +}
1.87 +if {$SQLITE_MAX_SQL_LENGTH>=2} {
1.88 + do_test sqllimits1-2.2.1 {
1.89 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH \
1.90 + [expr {$::SQLITE_MAX_SQL_LENGTH/2}]
1.91 + } $SQLITE_MAX_SQL_LENGTH
1.92 + do_test sqllimits1-2.2.2 {
1.93 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH -1
1.94 + } [expr {$SQLITE_MAX_SQL_LENGTH/2}]
1.95 +}
1.96 +if {$SQLITE_MAX_COLUMN>=2} {
1.97 + do_test sqllimits1-2.3.1 {
1.98 + sqlite3_limit db SQLITE_LIMIT_COLUMN \
1.99 + [expr {$::SQLITE_MAX_COLUMN/2}]
1.100 + } $SQLITE_MAX_COLUMN
1.101 + do_test sqllimits1-2.3.2 {
1.102 + sqlite3_limit db SQLITE_LIMIT_COLUMN -1
1.103 + } [expr {$SQLITE_MAX_COLUMN/2}]
1.104 +}
1.105 +if {$SQLITE_MAX_EXPR_DEPTH>=2} {
1.106 + do_test sqllimits1-2.4.1 {
1.107 + sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH \
1.108 + [expr {$::SQLITE_MAX_EXPR_DEPTH/2}]
1.109 + } $SQLITE_MAX_EXPR_DEPTH
1.110 + do_test sqllimits1-2.4.2 {
1.111 + sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH -1
1.112 + } [expr {$SQLITE_MAX_EXPR_DEPTH/2}]
1.113 +}
1.114 +if {$SQLITE_MAX_COMPOUND_SELECT>=2} {
1.115 + do_test sqllimits1-2.5.1 {
1.116 + sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT \
1.117 + [expr {$::SQLITE_MAX_COMPOUND_SELECT/2}]
1.118 + } $SQLITE_MAX_COMPOUND_SELECT
1.119 + do_test sqllimits1-2.5.2 {
1.120 + sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT -1
1.121 + } [expr {$SQLITE_MAX_COMPOUND_SELECT/2}]
1.122 +}
1.123 +if {$SQLITE_MAX_VDBE_OP>=2} {
1.124 + do_test sqllimits1-2.6.1 {
1.125 + sqlite3_limit db SQLITE_LIMIT_VDBE_OP \
1.126 + [expr {$::SQLITE_MAX_VDBE_OP/2}]
1.127 + } $SQLITE_MAX_VDBE_OP
1.128 + do_test sqllimits1-2.6.2 {
1.129 + sqlite3_limit db SQLITE_LIMIT_VDBE_OP -1
1.130 + } [expr {$SQLITE_MAX_VDBE_OP/2}]
1.131 +}
1.132 +if {$SQLITE_MAX_FUNCTION_ARG>=2} {
1.133 + do_test sqllimits1-2.7.1 {
1.134 + sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG \
1.135 + [expr {$::SQLITE_MAX_FUNCTION_ARG/2}]
1.136 + } $SQLITE_MAX_FUNCTION_ARG
1.137 + do_test sqllimits1-2.7.2 {
1.138 + sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1
1.139 + } [expr {$SQLITE_MAX_FUNCTION_ARG/2}]
1.140 +}
1.141 +if {$SQLITE_MAX_ATTACHED>=2} {
1.142 + do_test sqllimits1-2.8.1 {
1.143 + sqlite3_limit db SQLITE_LIMIT_ATTACHED \
1.144 + [expr {$::SQLITE_MAX_ATTACHED/2}]
1.145 + } $SQLITE_MAX_ATTACHED
1.146 + do_test sqllimits1-2.8.2 {
1.147 + sqlite3_limit db SQLITE_LIMIT_ATTACHED -1
1.148 + } [expr {$SQLITE_MAX_ATTACHED/2}]
1.149 +}
1.150 +if {$SQLITE_MAX_LIKE_PATTERN_LENGTH>=2} {
1.151 + do_test sqllimits1-2.9.1 {
1.152 + sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH \
1.153 + [expr {$::SQLITE_MAX_LIKE_PATTERN_LENGTH/2}]
1.154 + } $SQLITE_MAX_LIKE_PATTERN_LENGTH
1.155 + do_test sqllimits1-2.9.2 {
1.156 + sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1
1.157 + } [expr {$SQLITE_MAX_LIKE_PATTERN_LENGTH/2}]
1.158 +}
1.159 +if {$SQLITE_MAX_VARIABLE_NUMBER>=2} {
1.160 + do_test sqllimits1-2.10.1 {
1.161 + sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER \
1.162 + [expr {$::SQLITE_MAX_VARIABLE_NUMBER/2}]
1.163 + } $SQLITE_MAX_VARIABLE_NUMBER
1.164 + do_test sqllimits1-2.10.2 {
1.165 + sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1
1.166 + } [expr {$SQLITE_MAX_VARIABLE_NUMBER/2}]
1.167 +}
1.168 +
1.169 +# In a separate database connection, verify that the limits are unchanged.
1.170 +#
1.171 +do_test sqllimits1-3.1 {
1.172 + sqlite3_limit db2 SQLITE_LIMIT_LENGTH -1
1.173 +} $SQLITE_MAX_LENGTH
1.174 +do_test sqllimits1-3.2 {
1.175 + sqlite3_limit db2 SQLITE_LIMIT_SQL_LENGTH -1
1.176 +} $SQLITE_MAX_SQL_LENGTH
1.177 +do_test sqllimits1-3.3 {
1.178 + sqlite3_limit db2 SQLITE_LIMIT_COLUMN -1
1.179 +} $SQLITE_MAX_COLUMN
1.180 +do_test sqllimits1-3.4 {
1.181 + sqlite3_limit db2 SQLITE_LIMIT_EXPR_DEPTH -1
1.182 +} $SQLITE_MAX_EXPR_DEPTH
1.183 +do_test sqllimits1-3.5 {
1.184 + sqlite3_limit db2 SQLITE_LIMIT_COMPOUND_SELECT -1
1.185 +} $SQLITE_MAX_COMPOUND_SELECT
1.186 +do_test sqllimits1-3.6 {
1.187 + sqlite3_limit db2 SQLITE_LIMIT_VDBE_OP -1
1.188 +} $SQLITE_MAX_VDBE_OP
1.189 +do_test sqllimits1-3.7 {
1.190 + sqlite3_limit db2 SQLITE_LIMIT_FUNCTION_ARG -1
1.191 +} $SQLITE_MAX_FUNCTION_ARG
1.192 +do_test sqllimits1-3.8 {
1.193 + sqlite3_limit db2 SQLITE_LIMIT_ATTACHED -1
1.194 +} $SQLITE_MAX_ATTACHED
1.195 +do_test sqllimits1-3.9 {
1.196 + sqlite3_limit db2 SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1
1.197 +} $SQLITE_MAX_LIKE_PATTERN_LENGTH
1.198 +do_test sqllimits1-3.10 {
1.199 + sqlite3_limit db2 SQLITE_LIMIT_VARIABLE_NUMBER -1
1.200 +} $SQLITE_MAX_VARIABLE_NUMBER
1.201 +db2 close
1.202 +
1.203 +# Attempt to set all limits to the maximum 32-bit integer. Verify
1.204 +# that the limit does not exceed the compile-time upper bound.
1.205 +#
1.206 +do_test sqllimits1-4.1.1 {
1.207 + sqlite3_limit db SQLITE_LIMIT_LENGTH 0x7fffffff
1.208 + sqlite3_limit db SQLITE_LIMIT_LENGTH -1
1.209 +} $SQLITE_MAX_LENGTH
1.210 +do_test sqllimits1-4.2.1 {
1.211 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 0x7fffffff
1.212 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH -1
1.213 +} $SQLITE_MAX_SQL_LENGTH
1.214 +do_test sqllimits1-4.3.1 {
1.215 + sqlite3_limit db SQLITE_LIMIT_COLUMN 0x7fffffff
1.216 + sqlite3_limit db SQLITE_LIMIT_COLUMN -1
1.217 +} $SQLITE_MAX_COLUMN
1.218 +do_test sqllimits1-4.4.1 {
1.219 + sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH 0x7fffffff
1.220 + sqlite3_limit db SQLITE_LIMIT_EXPR_DEPTH -1
1.221 +} $SQLITE_MAX_EXPR_DEPTH
1.222 +do_test sqllimits1-4.5.1 {
1.223 + sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT 0x7fffffff
1.224 + sqlite3_limit db SQLITE_LIMIT_COMPOUND_SELECT -1
1.225 +} $SQLITE_MAX_COMPOUND_SELECT
1.226 +do_test sqllimits1-4.6.1 {
1.227 + sqlite3_limit db SQLITE_LIMIT_VDBE_OP 0x7fffffff
1.228 + sqlite3_limit db SQLITE_LIMIT_VDBE_OP -1
1.229 +} $SQLITE_MAX_VDBE_OP
1.230 +do_test sqllimits1-4.7.1 {
1.231 + sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG 0x7fffffff
1.232 + sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1
1.233 +} $SQLITE_MAX_FUNCTION_ARG
1.234 +do_test sqllimits1-4.8.1 {
1.235 + sqlite3_limit db SQLITE_LIMIT_ATTACHED 0x7fffffff
1.236 + sqlite3_limit db SQLITE_LIMIT_ATTACHED -1
1.237 +} $SQLITE_MAX_ATTACHED
1.238 +do_test sqllimits1-4.9.1 {
1.239 + sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH 0x7fffffff
1.240 + sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH -1
1.241 +} $SQLITE_MAX_LIKE_PATTERN_LENGTH
1.242 +do_test sqllimits1-4.10.1 {
1.243 + sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER 0x7fffffff
1.244 + sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1
1.245 +} $SQLITE_MAX_VARIABLE_NUMBER
1.246 +
1.247 +#--------------------------------------------------------------------
1.248 +# Test cases sqllimits1-5.* test that the SQLITE_MAX_LENGTH limit
1.249 +# is enforced.
1.250 +#
1.251 +db close
1.252 +sqlite3 db test.db
1.253 +set LARGESIZE 99999
1.254 +set SQLITE_LIMIT_LENGTH 100000
1.255 +sqlite3_limit db SQLITE_LIMIT_LENGTH $SQLITE_LIMIT_LENGTH
1.256 +
1.257 +do_test sqllimits1-5.1.1 {
1.258 + catchsql { SELECT randomblob(2147483647) }
1.259 +} {1 {string or blob too big}}
1.260 +do_test sqllimits1-5.1.2 {
1.261 + catchsql { SELECT zeroblob(2147483647) }
1.262 +} {1 {string or blob too big}}
1.263 +
1.264 +do_test sqllimits1-5.2 {
1.265 + catchsql { SELECT LENGTH(randomblob($::LARGESIZE)) }
1.266 +} [list 0 $LARGESIZE]
1.267 +
1.268 +do_test sqllimits1-5.3 {
1.269 + catchsql { SELECT quote(randomblob($::LARGESIZE)) }
1.270 +} {1 {string or blob too big}}
1.271 +
1.272 +do_test sqllimits1-5.4 {
1.273 + catchsql { SELECT LENGTH(zeroblob($::LARGESIZE)) }
1.274 +} [list 0 $LARGESIZE]
1.275 +
1.276 +do_test sqllimits1-5.5 {
1.277 + catchsql { SELECT quote(zeroblob($::LARGESIZE)) }
1.278 +} {1 {string or blob too big}}
1.279 +
1.280 +do_test sqllimits1-5.6 {
1.281 + catchsql { SELECT zeroblob(-1) }
1.282 +} {0 {{}}}
1.283 +
1.284 +do_test sqllimits1-5.9 {
1.285 + set ::str [string repeat A 65537]
1.286 + set ::rep [string repeat B 65537]
1.287 + catchsql { SELECT replace($::str, 'A', $::rep) }
1.288 +} {1 {string or blob too big}}
1.289 +
1.290 +do_test sqllimits1-5.10 {
1.291 + set ::str [string repeat %J 2100]
1.292 + catchsql { SELECT strftime($::str, '2003-10-31') }
1.293 +} {1 {string or blob too big}}
1.294 +
1.295 +do_test sqllimits1-5.11 {
1.296 + set ::str1 [string repeat A [expr {$SQLITE_LIMIT_LENGTH - 10}]]
1.297 + set ::str2 [string repeat B [expr {$SQLITE_LIMIT_LENGTH - 10}]]
1.298 + catchsql { SELECT $::str1 || $::str2 }
1.299 +} {1 {string or blob too big}}
1.300 +
1.301 +do_test sqllimits1-5.12 {
1.302 + set ::str1 [string repeat ' [expr {$SQLITE_LIMIT_LENGTH - 10}]]
1.303 + catchsql { SELECT quote($::str1) }
1.304 +} {1 {string or blob too big}}
1.305 +
1.306 +do_test sqllimits1-5.13 {
1.307 + set ::str1 [string repeat ' [expr {$SQLITE_LIMIT_LENGTH - 10}]]
1.308 + catchsql { SELECT hex($::str1) }
1.309 +} {1 {string or blob too big}}
1.310 +
1.311 +do_test sqllimits1-5.14.1 {
1.312 + set ::STMT [sqlite3_prepare db "SELECT ?" -1 TAIL]
1.313 + sqlite3_bind_zeroblob $::STMT 1 [expr {$SQLITE_LIMIT_LENGTH + 1}]
1.314 +} {}
1.315 +do_test sqllimits1-5.14.2 {
1.316 + sqlite3_step $::STMT
1.317 +} {SQLITE_ERROR}
1.318 +do_test sqllimits1-5.14.3 {
1.319 + sqlite3_reset $::STMT
1.320 +} {SQLITE_TOOBIG}
1.321 +do_test sqllimits1-5.14.4 {
1.322 + set np1 [expr {$SQLITE_LIMIT_LENGTH + 1}]
1.323 + set ::str1 [string repeat A $np1]
1.324 + catch {sqlite3_bind_text $::STMT 1 $::str1 -1} res
1.325 + set res
1.326 +} {SQLITE_TOOBIG}
1.327 +do_test sqllimits1-5.14.5 {
1.328 + catch {sqlite3_bind_text16 $::STMT 1 $::str1 -1} res
1.329 + set res
1.330 +} {SQLITE_TOOBIG}
1.331 +do_test sqllimits1-5.14.6 {
1.332 + catch {sqlite3_bind_text $::STMT 1 $::str1 $np1} res
1.333 + set res
1.334 +} {SQLITE_TOOBIG}
1.335 +do_test sqllimits1-5.14.7 {
1.336 + catch {sqlite3_bind_text16 $::STMT 1 $::str1 $np1} res
1.337 + set res
1.338 +} {SQLITE_TOOBIG}
1.339 +do_test sqllimits1-5.14.8 {
1.340 + set n [expr {$np1-1}]
1.341 + catch {sqlite3_bind_text $::STMT 1 $::str1 $n} res
1.342 + set res
1.343 +} {}
1.344 +do_test sqllimits1-5.14.9 {
1.345 + catch {sqlite3_bind_text16 $::STMT 1 $::str1 $n} res
1.346 + set res
1.347 +} {}
1.348 +sqlite3_finalize $::STMT
1.349 +
1.350 +do_test sqllimits1-5.15 {
1.351 + execsql {
1.352 + CREATE TABLE t4(x);
1.353 + INSERT INTO t4 VALUES(1);
1.354 + INSERT INTO t4 VALUES(2);
1.355 + INSERT INTO t4 SELECT 2+x FROM t4;
1.356 + }
1.357 + catchsql {
1.358 + SELECT group_concat(hex(randomblob(20000))) FROM t4;
1.359 + }
1.360 +} {1 {string or blob too big}}
1.361 +db eval {DROP TABLE t4}
1.362 +
1.363 +sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 0x7fffffff
1.364 +set strvalue [string repeat A $::SQLITE_LIMIT_LENGTH]
1.365 +do_test sqllimits1-5.16 {
1.366 + catchsql "SELECT '$strvalue'"
1.367 +} [list 0 $strvalue]
1.368 +do_test sqllimits1-5.17.1 {
1.369 + catchsql "SELECT 'A$strvalue'"
1.370 +} [list 1 {string or blob too big}]
1.371 +do_test sqllimits1-5.17.2 {
1.372 + sqlite3_limit db SQLITE_LIMIT_LENGTH 0x7fffffff
1.373 + catchsql {SELECT 'A' || $::strvalue}
1.374 +} [list 0 A$strvalue]
1.375 +do_test sqllimits1-5.17.3 {
1.376 + sqlite3_limit db SQLITE_LIMIT_LENGTH $SQLITE_LIMIT_LENGTH
1.377 + catchsql {SELECT 'A' || $::strvalue}
1.378 +} [list 1 {string or blob too big}]
1.379 +set blobvalue [string repeat 41 $::SQLITE_LIMIT_LENGTH]
1.380 +do_test sqllimits1-5.18 {
1.381 + catchsql "SELECT x'$blobvalue'"
1.382 +} [list 0 $strvalue]
1.383 +do_test sqllimits1-5.19 {
1.384 + catchsql "SELECT '41$blobvalue'"
1.385 +} [list 1 {string or blob too big}]
1.386 +unset blobvalue
1.387 +
1.388 +ifcapable datetime {
1.389 + set strvalue [string repeat D [expr {$SQLITE_LIMIT_LENGTH-12}]]
1.390 + do_test sqllimits1-5.20 {
1.391 + catchsql {SELECT strftime('%Y ' || $::strvalue, '2008-01-02')}
1.392 + } [list 0 [list "2008 $strvalue"]]
1.393 + do_test sqllimits1-5.21 {
1.394 + catchsql {SELECT strftime('%Y-%m-%d ' || $::strvalue, '2008-01-02')}
1.395 + } {1 {string or blob too big}}
1.396 +}
1.397 +unset strvalue
1.398 +
1.399 +#--------------------------------------------------------------------
1.400 +# Test cases sqllimits1-6.* test that the SQLITE_MAX_SQL_LENGTH limit
1.401 +# is enforced.
1.402 +#
1.403 +# Symbian OS: the next test fails because the max expression depth is limited to 250.
1.404 +if {$::tcl_platform(platform)!="symbian"} {
1.405 + do_test sqllimits1-6.1 {
1.406 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 50000
1.407 + set sql "SELECT 1 WHERE 1==1"
1.408 + set tail " /* A comment to take up space in order to make the string\
1.409 + longer without increasing the expression depth */\
1.410 + AND 1 == 1"
1.411 + set N [expr {(50000 / [string length $tail])+1}]
1.412 + append sql [string repeat $tail $N]
1.413 + catchsql $sql
1.414 + } {1 {String or BLOB exceeded size limit}}
1.415 +}
1.416 +do_test sqllimits1-6.3 {
1.417 + sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 50000
1.418 + set sql "SELECT 1 WHERE 1==1"
1.419 + set tail " /* A comment to take up space in order to make the string\
1.420 + longer without increasing the expression depth */\
1.421 + AND 1 == 1"
1.422 + set N [expr {(50000 / [string length $tail])+1}]
1.423 + append sql [string repeat $tail $N]
1.424 + set nbytes [string length $sql]
1.425 + append sql { AND 0}
1.426 + set rc [catch {sqlite3_prepare db $sql $nbytes TAIL} STMT]
1.427 + lappend rc $STMT
1.428 +} {1 {(18) statement too long}}
1.429 +do_test sqllimits1-6.4 {
1.430 + sqlite3_errmsg db
1.431 +} {statement too long}
1.432 +
1.433 +#--------------------------------------------------------------------
1.434 +# Test cases sqllimits1-7.* test that the limit set using the
1.435 +# max_page_count pragma.
1.436 +#
1.437 +do_test sqllimits1-7.1 {
1.438 + execsql {
1.439 + PRAGMA max_page_count = 1000;
1.440 + }
1.441 +} {1000}
1.442 +do_test sqllimits1-7.2 {
1.443 + execsql { CREATE TABLE trig (a INTEGER, b INTEGER); }
1.444 +
1.445 + # Set up a tree of triggers to fire when a row is inserted
1.446 + # into table "trig".
1.447 + #
1.448 + # INSERT -> insert_b -> update_b -> insert_a -> update_a (chain 1)
1.449 + # -> update_a -> insert_a -> update_b (chain 2)
1.450 + # -> insert_a -> update_b -> insert_b -> update_a (chain 3)
1.451 + # -> update_a -> insert_b -> update_b (chain 4)
1.452 + #
1.453 + # Table starts with N rows.
1.454 + #
1.455 + # Chain 1: insert_b (update N rows)
1.456 + # -> update_b (insert 1 rows)
1.457 + # -> insert_a (update N rows)
1.458 + # -> update_a (insert 1 rows)
1.459 + #
1.460 + # chains 2, 3 and 4 are similar. Each inserts more than N^2 rows, where
1.461 + # N is the number of rows at the conclusion of the previous chain.
1.462 + #
1.463 + # Therefore, a single insert adds (N^16 plus some) rows to the database.
1.464 + # A really long loop...
1.465 + #
1.466 + execsql {
1.467 + CREATE TRIGGER update_b BEFORE UPDATE ON trig
1.468 + FOR EACH ROW BEGIN
1.469 + INSERT INTO trig VALUES (65, 'update_b');
1.470 + END;
1.471 +
1.472 + CREATE TRIGGER update_a AFTER UPDATE ON trig
1.473 + FOR EACH ROW BEGIN
1.474 + INSERT INTO trig VALUES (65, 'update_a');
1.475 + END;
1.476 +
1.477 + CREATE TRIGGER insert_b BEFORE INSERT ON trig
1.478 + FOR EACH ROW BEGIN
1.479 + UPDATE trig SET a = 1;
1.480 + END;
1.481 +
1.482 + CREATE TRIGGER insert_a AFTER INSERT ON trig
1.483 + FOR EACH ROW BEGIN
1.484 + UPDATE trig SET a = 1;
1.485 + END;
1.486 + }
1.487 +} {}
1.488 +
1.489 +do_test sqllimits1-7.3 {
1.490 + execsql {
1.491 + INSERT INTO trig VALUES (1,1);
1.492 + }
1.493 +} {}
1.494 +
1.495 +do_test sqllimits1-7.4 {
1.496 + execsql {
1.497 + SELECT COUNT(*) FROM trig;
1.498 + }
1.499 +} {7}
1.500 +
1.501 +# This tries to insert so many rows it fills up the database (limited
1.502 +# to 1MB, so not that noteworthy an achievement).
1.503 +#
1.504 +do_test sqllimits1-7.5 {
1.505 + catchsql {
1.506 + INSERT INTO trig VALUES (1,10);
1.507 + }
1.508 +} {1 {database or disk is full}}
1.509 +
1.510 +do_test sqllimits1-7.6 {
1.511 + catchsql {
1.512 + SELECT COUNT(*) FROM trig;
1.513 + }
1.514 +} {0 7}
1.515 +
1.516 +# Now check the response of the library to opening a file larger than
1.517 +# the current max_page_count value. The response is to change the
1.518 +# internal max_page_count value to match the actual size of the file.
1.519 +if {[db eval {PRAGMA auto_vacuum}]} {
1.520 + set fsize 1700
1.521 +} else {
1.522 + set fsize 1691
1.523 +}
1.524 +do_test sqllimits1-7.7.1 {
1.525 + execsql {
1.526 + PRAGMA max_page_count = 1000000;
1.527 + CREATE TABLE abc(a, b, c);
1.528 + INSERT INTO abc VALUES(1, 2, 3);
1.529 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.530 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.531 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.532 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.533 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.534 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.535 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.536 + INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
1.537 + INSERT INTO abc SELECT a, b, c FROM abc;
1.538 + INSERT INTO abc SELECT b, a, c FROM abc;
1.539 + INSERT INTO abc SELECT c, b, a FROM abc;
1.540 + }
1.541 + expr [file size test.db] / 1024
1.542 +} $fsize
1.543 +do_test sqllimits1-7.7.2 {
1.544 + db close
1.545 + sqlite3 db test.db
1.546 + execsql {
1.547 + PRAGMA max_page_count = 1000;
1.548 + }
1.549 + execsql {
1.550 + SELECT count(*) FROM sqlite_master;
1.551 + }
1.552 +} {6}
1.553 +do_test sqllimits1-7.7.3 {
1.554 + execsql {
1.555 + PRAGMA max_page_count;
1.556 + }
1.557 +} $fsize
1.558 +do_test sqllimits1-7.7.4 {
1.559 + execsql {
1.560 + DROP TABLE abc;
1.561 + }
1.562 +} {}
1.563 +
1.564 +#--------------------------------------------------------------------
1.565 +# Test cases sqllimits1-8.* test the SQLITE_MAX_COLUMN limit.
1.566 +#
1.567 +set SQLITE_LIMIT_COLUMN 200
1.568 +sqlite3_limit db SQLITE_LIMIT_COLUMN $SQLITE_LIMIT_COLUMN
1.569 +do_test sqllimits1-8.1 {
1.570 + # Columns in a table.
1.571 + set cols [list]
1.572 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.573 + lappend cols "c$i"
1.574 + }
1.575 + catchsql "CREATE TABLE t([join $cols ,])"
1.576 +} {1 {too many columns on t}}
1.577 +
1.578 +do_test sqllimits1-8.2 {
1.579 + # Columns in the result-set of a SELECT.
1.580 + set cols [list]
1.581 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.582 + lappend cols "sql AS sql$i"
1.583 + }
1.584 + catchsql "SELECT [join $cols ,] FROM sqlite_master"
1.585 +} {1 {too many columns in result set}}
1.586 +
1.587 +do_test sqllimits1-8.3 {
1.588 + # Columns in the result-set of a sub-SELECT.
1.589 + set cols [list]
1.590 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.591 + lappend cols "sql AS sql$i"
1.592 + }
1.593 + catchsql "SELECT sql4 FROM (SELECT [join $cols ,] FROM sqlite_master)"
1.594 +} {1 {too many columns in result set}}
1.595 +
1.596 +do_test sqllimits1-8.4 {
1.597 + # Columns in an index.
1.598 + set cols [list]
1.599 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.600 + lappend cols c
1.601 + }
1.602 + set sql1 "CREATE TABLE t1(c);"
1.603 + set sql2 "CREATE INDEX i1 ON t1([join $cols ,]);"
1.604 + catchsql "$sql1 ; $sql2"
1.605 +} {1 {too many columns in index}}
1.606 +
1.607 +do_test sqllimits1-8.5 {
1.608 + # Columns in a GROUP BY clause.
1.609 + catchsql "SELECT * FROM t1 GROUP BY [join $cols ,]"
1.610 +} {1 {too many terms in GROUP BY clause}}
1.611 +
1.612 +do_test sqllimits1-8.6 {
1.613 + # Columns in an ORDER BY clause.
1.614 + catchsql "SELECT * FROM t1 ORDER BY [join $cols ,]"
1.615 +} {1 {too many terms in ORDER BY clause}}
1.616 +
1.617 +do_test sqllimits1-8.7 {
1.618 + # Assignments in an UPDATE statement.
1.619 + set cols [list]
1.620 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.621 + lappend cols "c = 1"
1.622 + }
1.623 + catchsql "UPDATE t1 SET [join $cols ,];"
1.624 +} {1 {too many columns in set list}}
1.625 +
1.626 +do_test sqllimits1-8.8 {
1.627 + # Columns in a view definition:
1.628 + set cols [list]
1.629 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.630 + lappend cols "c$i"
1.631 + }
1.632 + catchsql "CREATE VIEW v1 AS SELECT [join $cols ,] FROM t1;"
1.633 +} {1 {too many columns in result set}}
1.634 +
1.635 +do_test sqllimits1-8.9 {
1.636 + # Columns in a view definition (testing * expansion):
1.637 + set cols [list]
1.638 + for {set i 0} {$i < $SQLITE_LIMIT_COLUMN} {incr i} {
1.639 + lappend cols "c$i"
1.640 + }
1.641 + catchsql "CREATE TABLE t2([join $cols ,])"
1.642 + catchsql "CREATE VIEW v1 AS SELECT *, c1 AS o FROM t2;"
1.643 +} {1 {too many columns in result set}}
1.644 +do_test sqllimits1-8.10 {
1.645 + # ORDER BY columns
1.646 + set cols [list]
1.647 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.648 + lappend cols c
1.649 + }
1.650 + set sql "SELECT c FROM t1 ORDER BY [join $cols ,]"
1.651 + catchsql $sql
1.652 +} {1 {too many terms in ORDER BY clause}}
1.653 +do_test sqllimits1-8.11 {
1.654 + # ORDER BY columns
1.655 + set cols [list]
1.656 + for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
1.657 + lappend cols [expr {$i%3 + 1}]
1.658 + }
1.659 + set sql "SELECT c, c+1, c+2 FROM t1 UNION SELECT c-1, c-2, c-3 FROM t1"
1.660 + append sql " ORDER BY [join $cols ,]"
1.661 + catchsql $sql
1.662 +} {1 {too many terms in ORDER BY clause}}
1.663 +
1.664 +
1.665 +#--------------------------------------------------------------------
1.666 +# These tests - sqllimits1-9.* - test that the SQLITE_LIMIT_EXPR_DEPTH
1.667 +# limit is enforced. The limit refers to the number of terms in
1.668 +# the expression.
1.669 +#
1.670 +if {$SQLITE_MAX_EXPR_DEPTH==0} {
1.671 + puts -nonewline stderr "WARNING: Compile with -DSQLITE_MAX_EXPR_DEPTH to run "
1.672 + puts stderr "tests sqllimits1-9.X"
1.673 +} else {
1.674 + do_test sqllimits1-9.1 {
1.675 + set max $::SQLITE_MAX_EXPR_DEPTH
1.676 + set expr "(1 [string repeat {AND 1 } $max])"
1.677 + catchsql [subst {
1.678 + SELECT $expr
1.679 + }]
1.680 + } "1 {Expression tree is too large (maximum depth $::SQLITE_MAX_EXPR_DEPTH)}"
1.681 +
1.682 + # Attempting to beat the expression depth limit using nested SELECT
1.683 + # queries causes a parser stack overflow.
1.684 + do_test sqllimits1-9.2 {
1.685 + set max $::SQLITE_MAX_EXPR_DEPTH
1.686 + set expr "SELECT 1"
1.687 + for {set i 0} {$i <= $max} {incr i} {
1.688 + set expr "SELECT ($expr)"
1.689 + }
1.690 + catchsql [subst { $expr }]
1.691 + } "1 {parser stack overflow}"
1.692 +
1.693 +if 0 {
1.694 + do_test sqllimits1-9.3 {
1.695 + execsql {
1.696 + PRAGMA max_page_count = 1000000; -- 1 GB
1.697 + CREATE TABLE v0(a);
1.698 + INSERT INTO v0 VALUES(1);
1.699 + }
1.700 + db transaction {
1.701 + for {set i 1} {$i < 200} {incr i} {
1.702 + set expr "(a [string repeat {AND 1 } 50]) AS a"
1.703 + execsql [subst {
1.704 + CREATE VIEW v${i} AS SELECT $expr FROM v[expr {$i-1}]
1.705 + }]
1.706 + }
1.707 + }
1.708 + } {}
1.709 +
1.710 + do_test sqllimits1-9.4 {
1.711 + catchsql {
1.712 + SELECT a FROM v199
1.713 + }
1.714 + } "1 {Expression tree is too large (maximum depth $::SQLITE_MAX_EXPR_DEPTH)}"
1.715 +}
1.716 +}
1.717 +
1.718 +#--------------------------------------------------------------------
1.719 +# Test cases sqllimits1-10.* test that the SQLITE_MAX_VDBE_OP
1.720 +# limit works as expected. The limit refers to the number of opcodes
1.721 +# in a single VDBE program.
1.722 +#
1.723 +# TODO
1.724 +
1.725 +#--------------------------------------------------------------------
1.726 +# Test the SQLITE_LIMIT_FUNCTION_ARG limit works. Test case names
1.727 +# match the pattern "sqllimits1-11.*".
1.728 +#
1.729 +do_test sqllimits1-11.1 {
1.730 + set max $::SQLITE_MAX_FUNCTION_ARG
1.731 + set vals [list]
1.732 + for {set i 0} {$i < $SQLITE_MAX_FUNCTION_ARG} {incr i} {
1.733 + lappend vals $i
1.734 + }
1.735 + catchsql "SELECT max([join $vals ,])"
1.736 +} "0 [expr {$::SQLITE_MAX_FUNCTION_ARG - 1}]"
1.737 +do_test sqllimits1-11.2 {
1.738 + set max $::SQLITE_MAX_FUNCTION_ARG
1.739 + set vals [list]
1.740 + for {set i 0} {$i <= $SQLITE_MAX_FUNCTION_ARG} {incr i} {
1.741 + lappend vals $i
1.742 + }
1.743 + catchsql "SELECT max([join $vals ,])"
1.744 +} {1 {too many arguments on function max}}
1.745 +
1.746 +# Test that it is SQLite, and not the implementation of the
1.747 +# user function that is throwing the error.
1.748 +proc myfunc {args} {error "I don't like to be called!"}
1.749 +do_test sqllimits1-11.2 {
1.750 + db function myfunc myfunc
1.751 + set max $::SQLITE_MAX_FUNCTION_ARG
1.752 + set vals [list]
1.753 + for {set i 0} {$i <= $SQLITE_MAX_FUNCTION_ARG} {incr i} {
1.754 + lappend vals $i
1.755 + }
1.756 + catchsql "SELECT myfunc([join $vals ,])"
1.757 +} {1 {too many arguments on function myfunc}}
1.758 +
1.759 +
1.760 +#--------------------------------------------------------------------
1.761 +# Test cases sqllimits1-12.*: Test the SQLITE_MAX_ATTACHED limit.
1.762 +#
1.763 +ifcapable attach {
1.764 + do_test sqllimits1-12.1 {
1.765 + set max $::SQLITE_MAX_ATTACHED
1.766 + for {set i 0} {$i < ($max)} {incr i} {
1.767 + file delete -force test${i}.db test${i}.db-journal
1.768 + }
1.769 + for {set i 0} {$i < ($max)} {incr i} {
1.770 + execsql "ATTACH 'test${i}.db' AS aux${i}"
1.771 + }
1.772 + catchsql "ATTACH 'test${i}.db' AS aux${i}"
1.773 + } "1 {too many attached databases - max $::SQLITE_MAX_ATTACHED}"
1.774 + do_test sqllimits1-12.2 {
1.775 + set max $::SQLITE_MAX_ATTACHED
1.776 + for {set i 0} {$i < ($max)} {incr i} {
1.777 + execsql "DETACH aux${i}"
1.778 + }
1.779 + } {}
1.780 +}
1.781 +
1.782 +#--------------------------------------------------------------------
1.783 +# Test cases sqllimits1-13.*: Check that the SQLITE_MAX_VARIABLE_NUMBER
1.784 +# limit works.
1.785 +#
1.786 +do_test sqllimits1-13.1 {
1.787 + set max $::SQLITE_MAX_VARIABLE_NUMBER
1.788 + catchsql "SELECT ?[expr {$max+1}] FROM t1"
1.789 +} "1 {variable number must be between ?1 and ?$::SQLITE_MAX_VARIABLE_NUMBER}"
1.790 +do_test sqllimits1-13.2 {
1.791 + set max $::SQLITE_MAX_VARIABLE_NUMBER
1.792 + set vals [list]
1.793 + for {set i 0} {$i < ($max+3)} {incr i} {
1.794 + lappend vals ?
1.795 + }
1.796 + catchsql "SELECT [join $vals ,] FROM t1"
1.797 +} "1 {too many SQL variables}"
1.798 +
1.799 +
1.800 +#--------------------------------------------------------------------
1.801 +# Test cases sqllimits1-15.* verify that the
1.802 +# SQLITE_MAX_LIKE_PATTERN_LENGTH limit is enforced. This limit only
1.803 +# applies to the built-in LIKE operator, supplying an external
1.804 +# implementation by overriding the like() scalar function bypasses
1.805 +# this limitation.
1.806 +#
1.807 +# These tests check that the limit is not incorrectly applied to
1.808 +# the left-hand-side of the LIKE operator (the string being tested
1.809 +# against the pattern).
1.810 +#
1.811 +set SQLITE_LIMIT_LIKE_PATTERN 1000
1.812 +sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH $SQLITE_LIMIT_LIKE_PATTERN
1.813 +do_test sqllimits1-15.1 {
1.814 + set max $::SQLITE_LIMIT_LIKE_PATTERN
1.815 + set ::pattern [string repeat "A%" [expr $max/2]]
1.816 + set ::string [string repeat "A" [expr {$max*2}]]
1.817 + execsql {
1.818 + SELECT $::string LIKE $::pattern;
1.819 + }
1.820 +} {1}
1.821 +do_test sqllimits1-15.2 {
1.822 + set max $::SQLITE_LIMIT_LIKE_PATTERN
1.823 + set ::pattern [string repeat "A%" [expr {($max/2) + 1}]]
1.824 + set ::string [string repeat "A" [expr {$max*2}]]
1.825 + catchsql {
1.826 + SELECT $::string LIKE $::pattern;
1.827 + }
1.828 +} {1 {LIKE or GLOB pattern too complex}}
1.829 +
1.830 +#--------------------------------------------------------------------
1.831 +# This test case doesn't really belong with the other limits tests.
1.832 +# It is in this file because it is taxing to run, like the limits tests.
1.833 +#
1.834 +do_test sqllimits1-16.1 {
1.835 + set ::N [expr int(([expr pow(2,32)]/50) + 1)]
1.836 + expr (($::N*50) & 0xffffffff)<55
1.837 +} {1}
1.838 +#
1.839 +# Symbian: This test case is crashing tclsqlite3.exe if uncommented.
1.840 +#
1.841 +if {$tcl_platform(platform)!="symbian"} {
1.842 + do_test sqllimits1-16.2 {
1.843 + set ::format "[string repeat A 60][string repeat "%J" $::N]"
1.844 + catchsql {
1.845 + SELECT strftime($::format, 1);
1.846 + }
1.847 + } {1 {string or blob too big}}
1.848 +}
1.849 +
1.850 +foreach {key value} [array get saved] {
1.851 + catch {set $key $value}
1.852 +}
1.853 +finish_test