Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Clearification of some documentation text. Added requirements marks. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
8c1e85aab9e0d90726057e25e2ea0663 |
User & Date: | drh 2015-03-06 04:37:26.939 |
Context
2015-03-07
| ||
13:56 | Fix the LIKE optimization so that it finds BLOB entries in addition to text entries. Ticket [05f43be8fdda9f]. (check-in: 74cb0b032f user: drh tags: trunk) | |
2015-03-06
| ||
16:45 | The LIKE optimization must be applied twice, once for strings and a second time for BLOBs. Ticket [05f43be8fdda9f]. This check-in is a proof-of-concept of how that might be done. (check-in: 5757e803cb user: drh tags: like-opt-fix) | |
04:37 | Clearification of some documentation text. Added requirements marks. (check-in: 8c1e85aab9 user: drh tags: trunk) | |
03:31 | Clarification of documentation on sqlite3_backup. (check-in: 31d5e9b42e user: drh tags: trunk) | |
Changes
Changes to src/pragma.c.
︙ | ︙ | |||
313 314 315 316 317 318 319 320 321 322 323 324 325 326 | if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ goto pragma_out; } /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS ** connection. If it returns SQLITE_OK, then assume that the VFS ** handled the pragma and generate a no-op prepared statement. */ aFcntl[0] = 0; aFcntl[1] = zLeft; aFcntl[2] = zRight; aFcntl[3] = 0; db->busyHandler.nBusy = 0; rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl); | > > > > > > > > > > > | 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 | if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ goto pragma_out; } /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS ** connection. If it returns SQLITE_OK, then assume that the VFS ** handled the pragma and generate a no-op prepared statement. ** ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed, ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file ** object corresponding to the database file to which the pragma ** statement refers. ** ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA ** file control is an array of pointers to strings (char**) in which the ** second element of the array is the name of the pragma and the third ** element is the argument to the pragma or NULL if the pragma has no ** argument. */ aFcntl[0] = 0; aFcntl[1] = zLeft; aFcntl[2] = zRight; aFcntl[3] = 0; db->busyHandler.nBusy = 0; rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl); |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
747 748 749 750 751 752 753 754 755 756 757 758 | ** CAPI3REF: Standard File Control Opcodes ** KEYWORDS: {file control opcodes} {file control opcode} ** ** These integer constants are opcodes for the xFileControl method ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] ** interface. ** ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This ** opcode causes the xFileControl method to write the current state of ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) ** into an integer that the pArg argument points to. This capability | > > | | | | 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 | ** CAPI3REF: Standard File Control Opcodes ** KEYWORDS: {file control opcodes} {file control opcode} ** ** These integer constants are opcodes for the xFileControl method ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] ** interface. ** ** <ul> ** <li>[[SQLITE_FCNTL_LOCKSTATE]] ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This ** opcode causes the xFileControl method to write the current state of ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) ** into an integer that the pArg argument points to. This capability ** is used during testing and is only available when the SQLITE_TEST ** compile-time option is used. ** ** <li>[[SQLITE_FCNTL_SIZE_HINT]] ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS ** layer a hint of how large the database file will grow to be during the ** current transaction. This hint is not guaranteed to be accurate but it ** is often close. The underlying VFS might choose to preallocate database ** file space based on this hint in order to help writes to the database ** file run faster. |
︙ | ︙ | |||
879 880 881 882 883 884 885 | ** of the char** argument point to a string obtained from [sqlite3_mprintf()] ** or the equivalent and that string will become the result of the pragma or ** the error message if the pragma fails. ^If the ** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal ** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] ** file control returns [SQLITE_OK], then the parser assumes that the ** VFS has handled the PRAGMA itself and the parser generates a no-op | > > | | 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 | ** of the char** argument point to a string obtained from [sqlite3_mprintf()] ** or the equivalent and that string will become the result of the pragma or ** the error message if the pragma fails. ^If the ** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal ** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] ** file control returns [SQLITE_OK], then the parser assumes that the ** VFS has handled the PRAGMA itself and the parser generates a no-op ** prepared statement if result string is NULL, or that returns a copy ** of the result string if the string is non-NULL. ** ^If the [SQLITE_FCNTL_PRAGMA] file control returns ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means ** that the VFS encountered an error while handling the [PRAGMA] and the ** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] ** file control occurs at the beginning of pragma statement analysis and so ** it is able to override built-in [PRAGMA] statements. ** ** <li>[[SQLITE_FCNTL_BUSYHANDLER]] |
︙ | ︙ |
Changes to src/test_multiplex.c.
︙ | ︙ | |||
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 | case SQLITE_FCNTL_SIZE_HINT: case SQLITE_FCNTL_CHUNK_SIZE: /* no-op these */ rc = SQLITE_OK; break; case SQLITE_FCNTL_PRAGMA: { char **aFcntl = (char**)pArg; if( aFcntl[1] && sqlite3_stricmp(aFcntl[1],"multiplex_truncate")==0 ){ if( aFcntl[2] && aFcntl[2][0] ){ if( sqlite3_stricmp(aFcntl[2], "on")==0 || sqlite3_stricmp(aFcntl[2], "1")==0 ){ pGroup->bTruncate = 1; }else if( sqlite3_stricmp(aFcntl[2], "off")==0 || sqlite3_stricmp(aFcntl[2], "0")==0 ){ pGroup->bTruncate = 0; } } aFcntl[0] = sqlite3_mprintf(pGroup->bTruncate ? "on" : "off"); rc = SQLITE_OK; break; } /* If the multiplexor does not handle the pragma, pass it through ** into the default case. */ } | > > > > > > > > > > > > > | 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 | case SQLITE_FCNTL_SIZE_HINT: case SQLITE_FCNTL_CHUNK_SIZE: /* no-op these */ rc = SQLITE_OK; break; case SQLITE_FCNTL_PRAGMA: { char **aFcntl = (char**)pArg; /* ** EVIDENCE-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA ** file control is an array of pointers to strings (char**) in which the ** second element of the array is the name of the pragma and the third ** element is the argument to the pragma or NULL if the pragma has no ** argument. */ if( aFcntl[1] && sqlite3_stricmp(aFcntl[1],"multiplex_truncate")==0 ){ if( aFcntl[2] && aFcntl[2][0] ){ if( sqlite3_stricmp(aFcntl[2], "on")==0 || sqlite3_stricmp(aFcntl[2], "1")==0 ){ pGroup->bTruncate = 1; }else if( sqlite3_stricmp(aFcntl[2], "off")==0 || sqlite3_stricmp(aFcntl[2], "0")==0 ){ pGroup->bTruncate = 0; } } /* EVIDENCE-OF: R-27806-26076 The handler for an SQLITE_FCNTL_PRAGMA ** file control can optionally make the first element of the char** ** argument point to a string obtained from sqlite3_mprintf() or the ** equivalent and that string will become the result of the pragma ** or the error message if the pragma fails. */ aFcntl[0] = sqlite3_mprintf(pGroup->bTruncate ? "on" : "off"); rc = SQLITE_OK; break; } /* If the multiplexor does not handle the pragma, pass it through ** into the default case. */ } |
︙ | ︙ |
Changes to test/multiplex4.test.
︙ | ︙ | |||
55 56 57 58 59 60 61 62 63 64 65 66 67 68 | db eval { DELETE FROM t1; VACUUM; } multiplex_file_list mx4test } {mx4test.db} do_test multiplex4-1.2 { db eval {PRAGMA multiplex_truncate} } {on} do_test multiplex4-1.3 { db eval {PRAGMA multiplex_truncate=off} } {off} do_test multiplex4-1.4 { | > > > > > > > > | 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | db eval { DELETE FROM t1; VACUUM; } multiplex_file_list mx4test } {mx4test.db} # NB: The PRAGMA multiplex_truncate command is implemented using the # SQLITE_FCNTL_PRAGMA file-control... # # EVIDENCE-OF: R-12238-55120 Whenever a PRAGMA statement is parsed, an # SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file # object corresponding to the database file to which the pragma # statement refers. # do_test multiplex4-1.2 { db eval {PRAGMA multiplex_truncate} } {on} do_test multiplex4-1.3 { db eval {PRAGMA multiplex_truncate=off} } {off} do_test multiplex4-1.4 { |
︙ | ︙ | |||
79 80 81 82 83 84 85 86 87 88 89 90 91 92 | } {off} do_test multiplex4-1.8 { db eval {PRAGMA multiplex_truncate=1} } {on} do_test multiplex4-1.9 { db eval {PRAGMA multiplex_truncate=0} } {off} do_test multiplex4-1.10 { db eval { INSERT INTO t1(x) VALUES(randomblob(250000)); } multiplex_file_list mx4test } {mx4test.001 mx4test.db} | > > > > > > > > > > | 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | } {off} do_test multiplex4-1.8 { db eval {PRAGMA multiplex_truncate=1} } {on} do_test multiplex4-1.9 { db eval {PRAGMA multiplex_truncate=0} } {off} # EVIDENCE-OF: R-26188-08449 If the SQLITE_FCNTL_PRAGMA file control # returns SQLITE_OK, then the parser assumes that the VFS has handled # the PRAGMA itself and the parser generates a no-op prepared statement # if result string is NULL, or that returns a copy of the result string # if the string is non-NULL. # do_test multiplex4-1.9-explain { db eval {EXPLAIN PRAGMA multiplex_truncate=0;} } {/String8 \d \d \d off/} do_test multiplex4-1.10 { db eval { INSERT INTO t1(x) VALUES(randomblob(250000)); } multiplex_file_list mx4test } {mx4test.001 mx4test.db} |
︙ | ︙ |
Changes to test/rdonly.test.
︙ | ︙ | |||
28 29 30 31 32 33 34 35 36 37 38 39 40 41 | do_test rdonly-1.1 { execsql { CREATE TABLE t1(x); INSERT INTO t1 VALUES(1); SELECT * FROM t1; } } {1} do_test rdonly-1.1.1 { sqlite3_db_readonly db main } {0} # Changes the write version from 1 to 3. Verify that the database # can be read but not written. # | > > > > > | 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | do_test rdonly-1.1 { execsql { CREATE TABLE t1(x); INSERT INTO t1 VALUES(1); SELECT * FROM t1; } } {1} # EVIDENCE-OF: R-29639-16887 The sqlite3_db_readonly(D,N) interface # returns 1 if the database N of connection D is read-only, 0 if it is # read/write, or -1 if N is not the name of a database on connection D. # do_test rdonly-1.1.1 { sqlite3_db_readonly db main } {0} # Changes the write version from 1 to 3. Verify that the database # can be read but not written. # |
︙ | ︙ |
Changes to test/shrink.test.
︙ | ︙ | |||
20 21 22 23 24 25 26 27 28 29 30 31 32 33 | do_test shrink-1.1 { db eval { PRAGMA cache_size = 2000; CREATE TABLE t1(x,y); INSERT INTO t1 VALUES(randomblob(1000000),1); } set ::baseline sqlite3_memory_used sqlite3_db_release_memory db expr {$::baseline > [sqlite3_memory_used]+500000} } {1} do_test shrink-1.2 { set baseline [sqlite3_memory_used] db eval { UPDATE t1 SET y=y+1; | > > > | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | do_test shrink-1.1 { db eval { PRAGMA cache_size = 2000; CREATE TABLE t1(x,y); INSERT INTO t1 VALUES(randomblob(1000000),1); } set ::baseline sqlite3_memory_used # EVIDENCE-OF: R-58814-63508 The sqlite3_db_release_memory(D) interface # attempts to free as much heap memory as possible from database # connection D. sqlite3_db_release_memory db expr {$::baseline > [sqlite3_memory_used]+500000} } {1} do_test shrink-1.2 { set baseline [sqlite3_memory_used] db eval { UPDATE t1 SET y=y+1; |
︙ | ︙ |
Changes to test/sort4.test.
︙ | ︙ | |||
21 22 23 24 25 26 27 | sqlite3_shutdown sqlite3_config_pmasz 10 sqlite3_initialize sqlite3 db test.db # Configure the sorter to use 3 background threads. | > > > > > > | > > > > > > > | 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 | sqlite3_shutdown sqlite3_config_pmasz 10 sqlite3_initialize sqlite3 db test.db # Configure the sorter to use 3 background threads. # # EVIDENCE-OF: R-19249-32353 SQLITE_LIMIT_WORKER_THREADS The maximum # number of auxiliary worker threads that a single prepared statement # may start. # do_test sort4-init001 { db eval {PRAGMA threads=5} sqlite3_limit db SQLITE_LIMIT_WORKER_THREADS -1 } {5} do_test sort4-init002 { sqlite3_limit db SQLITE_LIMIT_WORKER_THREADS 3 db eval {PRAGMA threads} } {3} # Minimum number of seconds to run for. If the value is 0, each test # is run exactly once. Otherwise, tests are repeated until the timeout # expires. set SORT4TIMEOUT 0 if {[permutation] == "multithread"} { set SORT4TIMEOUT 300 } |
︙ | ︙ |
Changes to test/sqllimits1.test.
︙ | ︙ | |||
246 247 248 249 250 251 252 253 254 255 256 257 258 259 | 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. # 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 { | > > > | 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 | 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 { |
︙ | ︙ | |||
401 402 403 404 405 406 407 408 409 410 411 412 413 414 | } {1 {string or blob too big}} } unset strvalue #-------------------------------------------------------------------- # Test cases sqllimits1-6.* test that the SQLITE_MAX_SQL_LENGTH limit # is enforced. # 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" | > > > | 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 | } {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" |
︙ | ︙ | |||
562 563 564 565 566 567 568 569 570 571 572 573 574 575 | execsql { DROP TABLE abc; } } {} #-------------------------------------------------------------------- # Test cases sqllimits1-8.* test the SQLITE_MAX_COLUMN limit. # 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} { | > > > > > | 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 | 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} { |
︙ | ︙ | |||
666 667 668 669 670 671 672 673 674 675 676 677 678 679 | #-------------------------------------------------------------------- # 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. # 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])" | > > > | 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 | #-------------------------------------------------------------------- # 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])" |
︙ | ︙ | |||
724 725 726 727 728 729 730 731 732 733 734 735 736 737 | # in a single VDBE program. # # TODO #-------------------------------------------------------------------- # Test the SQLITE_LIMIT_FUNCTION_ARG limit works. Test case names # match the pattern "sqllimits1-11.*". # 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 | > > > | 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 | # 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 |
︙ | ︙ | |||
758 759 760 761 762 763 764 765 766 767 768 769 770 771 | catchsql "SELECT myfunc([join $vals ,])" } {1 {too many arguments on function myfunc}} } #-------------------------------------------------------------------- # Test cases sqllimits1-12.*: Test the SQLITE_MAX_ATTACHED limit. # 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} { | > > > | 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 | 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} { |
︙ | ︙ | |||
781 782 783 784 785 786 787 788 789 790 791 792 793 794 | } {} } #-------------------------------------------------------------------- # Test cases sqllimits1-13.*: Check that the SQLITE_MAX_VARIABLE_NUMBER # limit works. # 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] | > > > | 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 | } {} } #-------------------------------------------------------------------- # 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] |
︙ | ︙ | |||
802 803 804 805 806 807 808 809 810 811 812 813 814 815 | #-------------------------------------------------------------------- # 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. # # 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 { | > > > | 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 | #-------------------------------------------------------------------- # 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 { |
︙ | ︙ |