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