test/sqllimits1.test

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