/ Check-in [1bb23a3b]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Fix up requirements marks for syntax diagrams to reflect the new and improved GIF renderings.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1:1bb23a3b5297e07e08c26362f71aef0c5b978875
User & Date: drh 2011-12-30 16:07:37
Context
2011-12-30
16:09
Change dbstatus.test to account for the fact that the value reported by DBSTATUS_SCHEMA_USED may be slightly lower than the actual memory used on osx check-in: 6f2010c8 user: dan tags: trunk
16:07
Fix up requirements marks for syntax diagrams to reflect the new and improved GIF renderings. check-in: 1bb23a3b user: drh tags: trunk
15:17
Update the text of requirements associated with sqlite3_pcache_methods2. Update requirements marks embedded in code. All of the above are comment changes only; there are no changes to code in this check-in. check-in: f945c41a user: drh tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to test/e_createtable.test.

    54     54         db eval "SELECT DISTINCT tbl_name FROM $master ORDER BY tbl_name"
    55     55       ]
    56     56     }
    57     57     set res
    58     58   }
    59     59   
    60     60   
    61         -# EVIDENCE-OF: R-25262-01881 -- syntax diagram type-name
           61  +# EVIDENCE-OF: R-47266-09114 -- syntax diagram type-name
    62     62   #
    63     63   do_createtable_tests 0.1.1 -repair {
    64     64     drop_all_tables
    65     65   } {
    66     66     1   "CREATE TABLE t1(c1 one)"                        {}
    67     67     2   "CREATE TABLE t1(c1 one two)"                    {}
    68     68     3   "CREATE TABLE t1(c1 one two three)"              {}
................................................................................
    75     75   do_createtable_tests 0.1.2 -error {
    76     76     near "%s": syntax error
    77     77   } {
    78     78     1   "CREATE TABLE t1(c1 one(number))"                {number}
    79     79   }
    80     80   
    81     81   
    82         -# EVIDENCE-OF: R-18762-12428 -- syntax diagram column-constraint
    83         -#
    84         -#   Note: Not shown in the syntax diagram is the "NULL" constraint. This
    85         -#         is the opposite of "NOT NULL" - it implies that the column may
    86         -#         take a NULL value. This is the default anyway, so this type of
    87         -#         constraint is rarely used.
           82  +# EVIDENCE-OF: R-60689-48779 -- syntax diagram column-constraint
    88     83   #
    89     84   do_createtable_tests 0.2.1 -repair {
    90     85     drop_all_tables 
    91     86     execsql { CREATE TABLE t2(x PRIMARY KEY) }
    92     87   } {
    93     88     1.1   "CREATE TABLE t1(c1 text PRIMARY KEY)"                         {}
    94     89     1.2   "CREATE TABLE t1(c1 text PRIMARY KEY ASC)"                     {}
................................................................................
   127    122     8.2   {
   128    123       CREATE TABLE t1(c1 
   129    124         REFERENCES t1 DEFAULT 123 CHECK(c1 IS 'ten') UNIQUE NOT NULL PRIMARY KEY 
   130    125       );
   131    126     } {}
   132    127   }
   133    128   
   134         -# EVIDENCE-OF: R-17905-31923 -- syntax diagram table-constraint
          129  +# EVIDENCE-OF: R-58169-51804 -- syntax diagram table-constraint
   135    130   #
   136    131   do_createtable_tests 0.3.1 -repair {
   137    132     drop_all_tables 
   138    133     execsql { CREATE TABLE t2(x PRIMARY KEY) }
   139    134   } {
   140    135     1.1   "CREATE TABLE t1(c1, c2, PRIMARY KEY(c1))"                         {}
   141    136     1.2   "CREATE TABLE t1(c1, c2, PRIMARY KEY(c1, c2))"                     {}
................................................................................
   146    141     2.3   "CREATE TABLE t1(c1, c2, UNIQUE(c1, c2) ON CONFLICT IGNORE)"       {}
   147    142   
   148    143     3.1   "CREATE TABLE t1(c1, c2, CHECK(c1 IS NOT c2))"                     {}
   149    144   
   150    145     4.1   "CREATE TABLE t1(c1, c2, FOREIGN KEY(c1) REFERENCES t2)"           {}
   151    146   }
   152    147   
   153         -# EVIDENCE-OF: R-18765-31171 -- syntax diagram column-def
          148  +# EVIDENCE-OF: R-44826-22243 -- syntax diagram column-def
   154    149   #
   155    150   do_createtable_tests 0.4.1 -repair {
   156    151     drop_all_tables 
   157    152   } {
   158    153     1     {CREATE TABLE t1(
   159    154              col1,
   160    155              col2 TEXT,
................................................................................
   161    156              col3 INTEGER UNIQUE,
   162    157              col4 VARCHAR(10, 10) PRIMARY KEY,
   163    158              "name with spaces" REFERENCES t1
   164    159            );
   165    160           } {}
   166    161   }
   167    162   
   168         -# EVIDENCE-OF: R-59573-11075 -- syntax diagram create-table-stmt
          163  +# EVIDENCE-OF: R-45698-45677 -- syntax diagram create-table-stmt
   169    164   #
   170    165   do_createtable_tests 0.5.1 -repair {
   171    166     drop_all_tables 
   172    167     execsql { CREATE TABLE t2(a, b, c) }
   173    168   } {
   174    169     1     "CREATE TABLE t1(a, b, c)"                                    {}
   175    170     2     "CREATE TEMP TABLE t1(a, b, c)"                               {}
................................................................................
   186    181     12    "CREATE TEMPORARY TABLE IF NOT EXISTS temp.t1(a, b, c)"       {}
   187    182   
   188    183     13    "CREATE TABLE t1 AS SELECT * FROM t2"                         {}
   189    184     14    "CREATE TEMP TABLE t1 AS SELECT c, b, a FROM t2"              {}
   190    185     15    "CREATE TABLE t1 AS SELECT count(*), max(b), min(a) FROM t2"  {}
   191    186   }
   192    187   
   193         -# EVIDENCE-OF: R-32138-02228 -- syntax diagram foreign-key-clause
          188  +# EVIDENCE-OF: R-24369-11919 -- syntax diagram foreign-key-clause
   194    189   #
   195    190   #   1:         Explicit parent-key columns.
   196    191   #   2:         Implicit child-key columns.
   197    192   #
   198    193   #   1:         MATCH FULL
   199    194   #   2:         MATCH PARTIAL
   200    195   #   3:         MATCH SIMPLE

Changes to test/e_delete.test.

    20     20   }
    21     21   
    22     22   do_execsql_test e_delete-0.0 {
    23     23     CREATE TABLE t1(a, b);
    24     24     CREATE INDEX i1 ON t1(a);
    25     25   } {}
    26     26   
    27         -# EVIDENCE-OF: R-24177-52883 -- syntax diagram delete-stmt
           27  +# EVIDENCE-OF: R-62077-19799 -- syntax diagram delete-stmt
    28     28   #
    29         -# EVIDENCE-OF: R-12802-60464 -- syntax diagram qualified-table-name
           29  +# EVIDENCE-OF: R-60796-31013 -- syntax diagram qualified-table-name
    30     30   #
    31     31   do_delete_tests e_delete-0.1 {
    32     32     1  "DELETE FROM t1"                              {}
    33     33     2  "DELETE FROM t1 INDEXED BY i1"                {}
    34     34     3  "DELETE FROM t1 NOT INDEXED"                  {}
    35     35     4  "DELETE FROM main.t1"                         {}
    36     36     5  "DELETE FROM main.t1 INDEXED BY i1"           {}
................................................................................
   283    283   }
   284    284   
   285    285   # EVIDENCE-OF: R-40026-10531 If SQLite is compiled with the
   286    286   # SQLITE_ENABLE_UPDATE_DELETE_LIMIT compile-time option, then the syntax
   287    287   # of the DELETE statement is extended by the addition of optional ORDER
   288    288   # BY and LIMIT clauses:
   289    289   #
   290         -# EVIDENCE-OF: R-45897-01670 -- syntax diagram delete-stmt-limited
          290  +# EVIDENCE-OF: R-52694-53361 -- syntax diagram delete-stmt-limited
   291    291   #
   292    292   do_delete_tests e_delete-3.1 {
   293    293     1   "DELETE FROM t1 LIMIT 5"                                    {}
   294    294     2   "DELETE FROM t1 LIMIT 5-1 OFFSET 2+2"                       {}
   295    295     3   "DELETE FROM t1 LIMIT 2+2, 16/4"                            {}
   296    296     4   "DELETE FROM t1 ORDER BY x LIMIT 5"                         {}
   297    297     5   "DELETE FROM t1 ORDER BY x LIMIT 5-1 OFFSET 2+2"            {}

Changes to test/e_droptrigger.test.

    65     65       CREATE TRIGGER aux.tr1 BEFORE $event ON t3 BEGIN SELECT r('aux.tr1') ; END;
    66     66       CREATE TRIGGER aux.tr2 AFTER  $event ON t3 BEGIN SELECT r('aux.tr2') ; END;
    67     67       CREATE TRIGGER aux.tr3 AFTER  $event ON t3 BEGIN SELECT r('aux.tr3') ; END;
    68     68     "
    69     69   }
    70     70   
    71     71   
    72         -# EVIDENCE-OF: R-52650-16855 -- syntax diagram drop-trigger-stmt
           72  +# EVIDENCE-OF: R-27975-10951 -- syntax diagram drop-trigger-stmt
    73     73   #
    74     74   do_droptrigger_tests 1.1 -repair {
    75     75     droptrigger_reopen_db
    76     76   } -tclquery {
    77     77     list_all_triggers 
    78     78   } {
    79     79     1   "DROP TRIGGER main.tr1"            

Changes to test/e_dropview.test.

    66     66     set res
    67     67   }
    68     68   
    69     69   proc do_dropview_tests {nm args} {
    70     70     uplevel do_select_tests $nm $args
    71     71   }
    72     72   
    73         -# EVIDENCE-OF: R-21739-51207 -- syntax diagram drop-view-stmt
           73  +# EVIDENCE-OF: R-53136-36436 -- syntax diagram drop-view-stmt
    74     74   #
    75     75   # All paths in the syntax diagram for DROP VIEW are tested by tests 1.*.
    76     76   #
    77     77   do_dropview_tests 1 -repair {
    78     78     dropview_reopen_db
    79     79   } -tclquery {
    80     80     list_all_views

Changes to test/e_expr.test.

   623    623          [sqlite3_column_type $stmt 3] 
   624    624   } {NULL NULL NULL NULL}
   625    625   do_test e_expr-11.7.1 { sqlite3_finalize $stmt } SQLITE_OK
   626    626   
   627    627   #-------------------------------------------------------------------------
   628    628   # "Test" the syntax diagrams in lang_expr.html.
   629    629   #
   630         -# EVIDENCE-OF: R-62067-43884 -- syntax diagram signed-number
          630  +# EVIDENCE-OF: R-02989-21050 -- syntax diagram signed-number
   631    631   #
   632    632   do_execsql_test e_expr-12.1.1 { SELECT 0, +0, -0 } {0 0 0}
   633    633   do_execsql_test e_expr-12.1.2 { SELECT 1, +1, -1 } {1 1 -1}
   634    634   do_execsql_test e_expr-12.1.3 { SELECT 2, +2, -2 } {2 2 -2}
   635    635   do_execsql_test e_expr-12.1.4 { 
   636    636     SELECT 1.4, +1.4, -1.4 
   637    637   } {1.4 1.4 -1.4}
................................................................................
   638    638   do_execsql_test e_expr-12.1.5 { 
   639    639     SELECT 1.5e+5, +1.5e+5, -1.5e+5 
   640    640   } {150000.0 150000.0 -150000.0}
   641    641   do_execsql_test e_expr-12.1.6 { 
   642    642     SELECT 0.0001, +0.0001, -0.0001 
   643    643   } {0.0001 0.0001 -0.0001}
   644    644   
   645         -# EVIDENCE-OF: R-21258-25489 -- syntax diagram literal-value
          645  +# EVIDENCE-OF: R-43188-60852 -- syntax diagram literal-value
   646    646   #
   647    647   set sqlite_current_time 1
   648    648   do_execsql_test e_expr-12.2.1 {SELECT 123}               {123}
   649    649   do_execsql_test e_expr-12.2.2 {SELECT 123.4e05}          {12340000.0}
   650    650   do_execsql_test e_expr-12.2.3 {SELECT 'abcde'}           {abcde}
   651    651   do_execsql_test e_expr-12.2.4 {SELECT X'414243'}         {ABC}
   652    652   do_execsql_test e_expr-12.2.5 {SELECT NULL}              {{}}
   653    653   do_execsql_test e_expr-12.2.6 {SELECT CURRENT_TIME}      {00:00:01}
   654    654   do_execsql_test e_expr-12.2.7 {SELECT CURRENT_DATE}      {1970-01-01}
   655    655   do_execsql_test e_expr-12.2.8 {SELECT CURRENT_TIMESTAMP} {{1970-01-01 00:00:01}}
   656    656   set sqlite_current_time 0
   657    657   
   658         -# EVIDENCE-OF: R-57598-59332 -- syntax diagram expr
          658  +# EVIDENCE-OF: R-50544-32159 -- syntax diagram expr
   659    659   #
   660    660   forcedelete test.db2
   661    661   execsql {
   662    662     ATTACH 'test.db2' AS dbname;
   663    663     CREATE TABLE dbname.tblname(cname);
   664    664   }
   665    665   
................................................................................
   808    808       incr x
   809    809       do_test e_expr-12.3.$tn.$x { 
   810    810         set rc [catch { execsql "SELECT $e FROM tblname" } msg]
   811    811       } {0}
   812    812     }
   813    813   }
   814    814   
   815         -# EVIDENCE-OF: R-49462-56079 -- syntax diagram raise-function
          815  +# EVIDENCE-OF: R-39820-63916 -- syntax diagram raise-function
   816    816   #
   817    817   foreach {tn raiseexpr} {
   818    818     1 "RAISE(IGNORE)"
   819    819     2 "RAISE(ROLLBACK, 'error message')"
   820    820     3 "RAISE(ABORT, 'error message')"
   821    821     4 "RAISE(FAIL, 'error message')"
   822    822   } {

Changes to test/e_insert.test.

    41     41     CREATE TABLE a4(c UNIQUE, d);
    42     42   } {}
    43     43   
    44     44   proc do_insert_tests {args} {
    45     45     uplevel do_select_tests $args
    46     46   }
    47     47   
    48         -# EVIDENCE-OF: R-41448-54465 -- syntax diagram insert-stmt
           48  +# EVIDENCE-OF: R-55375-41353 -- syntax diagram insert-stmt
    49     49   #
    50     50   do_insert_tests e_insert-0 {
    51     51        1  "INSERT             INTO a1 DEFAULT VALUES"                   {}
    52     52        2  "INSERT             INTO main.a1 DEFAULT VALUES"              {}
    53     53        3  "INSERT OR ROLLBACK INTO main.a1 DEFAULT VALUES"              {}
    54     54        4  "INSERT OR ROLLBACK INTO a1 DEFAULT VALUES"                   {}
    55     55        5  "INSERT OR ABORT    INTO main.a1 DEFAULT VALUES"              {}

Changes to test/e_reindex.test.

    22     22   
    23     23   do_execsql_test e_reindex-0.0 {
    24     24     CREATE TABLE t1(a, b);
    25     25     CREATE INDEX i1 ON t1(a, b);
    26     26     CREATE INDEX i2 ON t1(b, a);
    27     27   } {}
    28     28   
    29         -# EVIDENCE-OF: R-57021-15304 -- syntax diagram reindex-stmt
           29  +# EVIDENCE-OF: R-51477-38549 -- syntax diagram reindex-stmt
    30     30   #
    31     31   do_reindex_tests e_reindex-0.1 {
    32     32     1   "REINDEX"           {}
    33     33     2   "REINDEX nocase"    {}
    34     34     3   "REINDEX binary"    {}
    35     35     4   "REINDEX t1"        {}
    36     36     5   "REINDEX main.t1"   {}
    37         -  4   "REINDEX i1"        {}
    38         -  5   "REINDEX main.i1"   {}
           37  +  6   "REINDEX i1"        {}
           38  +  7   "REINDEX main.i1"   {}
    39     39   }
    40     40   
    41     41   # EVIDENCE-OF: R-52173-44778 The REINDEX command is used to delete and
    42     42   # recreate indices from scratch.
    43     43   #
    44     44   #    Test this by corrupting some database indexes, running REINDEX, and
    45     45   #    observing that the corruption is gone.

Changes to test/e_select.test.

    74     74     }
    75     75   }
    76     76   
    77     77   #-------------------------------------------------------------------------
    78     78   # The following tests check that all paths on the syntax diagrams on
    79     79   # the lang_select.html page may be taken.
    80     80   #
    81         -# EVIDENCE-OF: R-18428-22111 -- syntax diagram join-constraint
           81  +# EVIDENCE-OF: R-11353-33501 -- syntax diagram join-constraint
    82     82   #
    83     83   do_join_test e_select-0.1.1 {
    84     84     SELECT count(*) FROM t1 %JOIN% t2 ON (t1.a=t2.a)
    85     85   } {3}
    86     86   do_join_test e_select-0.1.2 {
    87     87     SELECT count(*) FROM t1 %JOIN% t2 USING (a)
    88     88   } {3}
................................................................................
    92     92   do_catchsql_test e_select-0.1.4 {
    93     93     SELECT count(*) FROM t1, t2 ON (t1.a=t2.a) USING (a)
    94     94   } {1 {cannot have both ON and USING clauses in the same join}}
    95     95   do_catchsql_test e_select-0.1.5 {
    96     96     SELECT count(*) FROM t1, t2 USING (a) ON (t1.a=t2.a)
    97     97   } {1 {near "ON": syntax error}}
    98     98   
    99         -# EVIDENCE-OF: R-44854-11739 -- syntax diagram select-core
           99  +# EVIDENCE-OF: R-40919-40941 -- syntax diagram select-core
   100    100   #
   101    101   #   0: SELECT ...
   102    102   #   1: SELECT DISTINCT ...
   103    103   #   2: SELECT ALL ...
   104    104   #
   105    105   #   0: No FROM clause
   106    106   #   1: Has FROM clause
................................................................................
   217    217       1 a 1 c
   218    218     }
   219    219     2112.2  "SELECT ALL count(*), max(a) FROM t1 
   220    220              WHERE 0 GROUP BY b HAVING count(*)=2" { }
   221    221   }
   222    222   
   223    223   
   224         -# EVIDENCE-OF: R-23316-20169 -- syntax diagram result-column
          224  +# EVIDENCE-OF: R-41378-26734 -- syntax diagram result-column
   225    225   #
   226    226   do_select_tests e_select-0.3 {
   227    227     1  "SELECT * FROM t1" {a one b two c three}
   228    228     2  "SELECT t1.* FROM t1" {a one b two c three}
   229    229     3  "SELECT 'x'||a||'x' FROM t1" {xax xbx xcx}
   230    230     4  "SELECT 'x'||a||'x' alias FROM t1" {xax xbx xcx}
   231    231     5  "SELECT 'x'||a||'x' AS alias FROM t1" {xax xbx xcx}
   232    232   }
   233    233   
   234         -# EVIDENCE-OF: R-41233-21397 -- syntax diagram join-source
          234  +# EVIDENCE-OF: R-43129-35648 -- syntax diagram join-source
   235    235   #
   236         -# EVIDENCE-OF: R-45040-11121 -- syntax diagram join-op
          236  +# EVIDENCE-OF: R-36683-37460 -- syntax diagram join-op
   237    237   #
   238    238   do_select_tests e_select-0.4 {
   239    239     1  "SELECT t1.rowid FROM t1" {1 2 3}
   240    240     2  "SELECT t1.rowid FROM t1,t2" {1 1 1 2 2 2 3 3 3}
   241    241     3  "SELECT t1.rowid FROM t1,t2,t3" {1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3}
   242    242   
   243    243     4  "SELECT t1.rowid FROM t1" {1 2 3}
................................................................................
   254    254     12 "SELECT t1.rowid FROM t1 JOIN t3" {1 1 2 2 3 3}
   255    255     13 "SELECT t1.rowid FROM t1 LEFT OUTER JOIN t3" {1 1 2 2 3 3}
   256    256     14 "SELECT t1.rowid FROM t1 LEFT JOIN t3" {1 1 2 2 3 3}
   257    257     15 "SELECT t1.rowid FROM t1 INNER JOIN t3" {1 1 2 2 3 3}
   258    258     16 "SELECT t1.rowid FROM t1 CROSS JOIN t3" {1 1 2 2 3 3}
   259    259   }
   260    260   
   261         -# EVIDENCE-OF: R-56911-63533 -- syntax diagram compound-operator
          261  +# EVIDENCE-OF: R-28308-37813 -- syntax diagram compound-operator
   262    262   #
   263    263   do_select_tests e_select-0.5 {
   264    264     1  "SELECT rowid FROM t1 UNION ALL SELECT rowid+2 FROM t4" {1 2 3 3 4}
   265    265     2  "SELECT rowid FROM t1 UNION     SELECT rowid+2 FROM t4" {1 2 3 4}
   266    266     3  "SELECT rowid FROM t1 INTERSECT SELECT rowid+2 FROM t4" {3}
   267    267     4  "SELECT rowid FROM t1 EXCEPT    SELECT rowid+2 FROM t4" {1 2}
   268    268   }
   269    269   
   270         -# EVIDENCE-OF: R-60388-27458 -- syntax diagram ordering-term
          270  +# EVIDENCE-OF: R-06480-34950 -- syntax diagram ordering-term
   271    271   #
   272    272   do_select_tests e_select-0.6 {
   273    273     1  "SELECT b||a FROM t1 ORDER BY b||a"                  {onea threec twob}
   274    274     2  "SELECT b||a FROM t1 ORDER BY (b||a) COLLATE nocase" {onea threec twob}
   275    275     3  "SELECT b||a FROM t1 ORDER BY (b||a) ASC"            {onea threec twob}
   276    276     4  "SELECT b||a FROM t1 ORDER BY (b||a) DESC"           {twob threec onea}
   277    277   }
   278    278   
   279         -# EVIDENCE-OF: R-36494-33519 -- syntax diagram select-stmt
          279  +# EVIDENCE-OF: R-23926-36668 -- syntax diagram select-stmt
   280    280   #
   281    281   do_select_tests e_select-0.7 {
   282    282     1  "SELECT * FROM t1" {a one b two c three}
   283    283     2  "SELECT * FROM t1 ORDER BY b" {a one c three b two}
   284    284     3  "SELECT * FROM t1 ORDER BY b, a" {a one c three b two}
   285    285   
   286    286     4  "SELECT * FROM t1 LIMIT 10" {a one b two c three}

Changes to test/e_update.test.

    45     45     CREATE TABLE aux.t5(a, b);
    46     46   } {}
    47     47   
    48     48   proc do_update_tests {args} {
    49     49     uplevel do_select_tests $args
    50     50   }
    51     51   
    52         -# EVIDENCE-OF: R-05685-44205 -- syntax diagram update-stmt
           52  +# EVIDENCE-OF: R-62337-45828 -- syntax diagram update-stmt
    53     53   #
    54     54   do_update_tests e_update-0 {
    55     55     1    "UPDATE t1 SET a=10" {}
    56     56     2    "UPDATE t1 SET a=10, b=5" {}
    57     57     3    "UPDATE t1 SET a=10 WHERE b=5" {}
    58     58     4    "UPDATE t1 SET b=5,a=10 WHERE 1" {}
    59     59     5    "UPDATE main.t1 SET a=10" {}
................................................................................
   491    491   }
   492    492   
   493    493   # EVIDENCE-OF: R-59581-44104 If SQLite is built with the
   494    494   # SQLITE_ENABLE_UPDATE_DELETE_LIMIT compile-time option then the syntax
   495    495   # of the UPDATE statement is extended with optional ORDER BY and LIMIT
   496    496   # clauses
   497    497   #
   498         -# EVIDENCE-OF: R-08948-01887 -- syntax diagram update-stmt-limited
          498  +# EVIDENCE-OF: R-45169-39597 -- syntax diagram update-stmt-limited
   499    499   #
   500    500   do_update_tests e_update-3.0 {
   501    501     1   "UPDATE t1 SET a=b LIMIT 5"                                    {}
   502    502     2   "UPDATE t1 SET a=b LIMIT 5-1 OFFSET 2+2"                       {}
   503    503     3   "UPDATE t1 SET a=b LIMIT 2+2, 16/4"                            {}
   504    504     4   "UPDATE t1 SET a=b ORDER BY a LIMIT 5"                         {}
   505    505     5   "UPDATE t1 SET a=b ORDER BY a LIMIT 5-1 OFFSET 2+2"            {}

Changes to test/e_vacuum.test.

    61     61       set prevpageno $pageno
    62     62     }
    63     63     execsql { DROP TABLE temp.stat }
    64     64     set nFrag
    65     65   }
    66     66   
    67     67   
    68         -# EVIDENCE-OF: R-63707-33375 -- syntax diagram vacuum-stmt
           68  +# EVIDENCE-OF: R-45173-45977 -- syntax diagram vacuum-stmt
    69     69   #
    70     70   do_execsql_test e_vacuum-0.1 { VACUUM } {}
    71     71   
    72     72   # EVIDENCE-OF: R-51469-36013 Unless SQLite is running in
    73     73   # "auto_vacuum=FULL" mode, when a large amount of data is deleted from
    74     74   # the database file it leaves behind empty space, or "free" database
    75     75   # pages.