| OLD | NEW | 
 | (Empty) | 
|    1 # 2008 October 9 |  | 
|    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 # This file generates SQL text used for performance testing. |  | 
|   12 # |  | 
|   13 # $Id: mkspeedsql.tcl,v 1.1 2008/10/09 17:57:34 drh Exp $ |  | 
|   14 # |  | 
|   15  |  | 
|   16 # Set a uniform random seed |  | 
|   17 expr srand(0) |  | 
|   18  |  | 
|   19 # The number_name procedure below converts its argment (an integer) |  | 
|   20 # into a string which is the English-language name for that number. |  | 
|   21 # |  | 
|   22 # Example: |  | 
|   23 # |  | 
|   24 #     puts [number_name 123]   ->  "one hundred twenty three" |  | 
|   25 # |  | 
|   26 set ones {zero one two three four five six seven eight nine |  | 
|   27           ten eleven twelve thirteen fourteen fifteen sixteen seventeen |  | 
|   28           eighteen nineteen} |  | 
|   29 set tens {{} ten twenty thirty forty fifty sixty seventy eighty ninety} |  | 
|   30 proc number_name {n} { |  | 
|   31   if {$n>=1000} { |  | 
|   32     set txt "[number_name [expr {$n/1000}]] thousand" |  | 
|   33     set n [expr {$n%1000}] |  | 
|   34   } else { |  | 
|   35     set txt {} |  | 
|   36   } |  | 
|   37   if {$n>=100} { |  | 
|   38     append txt " [lindex $::ones [expr {$n/100}]] hundred" |  | 
|   39     set n [expr {$n%100}] |  | 
|   40   } |  | 
|   41   if {$n>=20} { |  | 
|   42     append txt " [lindex $::tens [expr {$n/10}]]" |  | 
|   43     set n [expr {$n%10}] |  | 
|   44   } |  | 
|   45   if {$n>0} { |  | 
|   46     append txt " [lindex $::ones $n]" |  | 
|   47   } |  | 
|   48   set txt [string trim $txt] |  | 
|   49   if {$txt==""} {set txt zero} |  | 
|   50   return $txt |  | 
|   51 } |  | 
|   52  |  | 
|   53 # Create a database schema. |  | 
|   54 # |  | 
|   55 puts { |  | 
|   56   PRAGMA page_size=1024; |  | 
|   57   PRAGMA cache_size=8192; |  | 
|   58   PRAGMA locking_mode=EXCLUSIVE; |  | 
|   59   CREATE TABLE t1(a INTEGER, b INTEGER, c TEXT); |  | 
|   60   CREATE TABLE t2(a INTEGER, b INTEGER, c TEXT); |  | 
|   61   CREATE INDEX i2a ON t2(a); |  | 
|   62   CREATE INDEX i2b ON t2(b); |  | 
|   63   SELECT name FROM sqlite_master ORDER BY 1; |  | 
|   64 } |  | 
|   65  |  | 
|   66  |  | 
|   67 # 50000 INSERTs on an unindexed table |  | 
|   68 # |  | 
|   69 set t1c_list {} |  | 
|   70 puts {BEGIN;} |  | 
|   71 for {set i 1} {$i<=50000} {incr i} { |  | 
|   72   set r [expr {int(rand()*500000)}] |  | 
|   73   set x [number_name $r] |  | 
|   74   lappend t1c_list $x |  | 
|   75   puts "INSERT INTO t1 VALUES($i,$r,'$x');" |  | 
|   76 } |  | 
|   77 puts {COMMIT;} |  | 
|   78  |  | 
|   79 # 50000 INSERTs on an indexed table |  | 
|   80 # |  | 
|   81 puts {BEGIN;} |  | 
|   82 for {set i 1} {$i<=50000} {incr i} { |  | 
|   83   set r [expr {int(rand()*500000)}] |  | 
|   84   puts "INSERT INTO t2 VALUES($i,$r,'[number_name $r]');" |  | 
|   85 } |  | 
|   86 puts {COMMIT;} |  | 
|   87  |  | 
|   88  |  | 
|   89 # 50 SELECTs on an integer comparison.  There is no index so |  | 
|   90 # a full table scan is required. |  | 
|   91 # |  | 
|   92 for {set i 0} {$i<50} {incr i} { |  | 
|   93   set lwr [expr {$i*100}] |  | 
|   94   set upr [expr {($i+10)*100}] |  | 
|   95   puts "SELECT count(*), avg(b) FROM t1 WHERE b>=$lwr AND b<$upr;" |  | 
|   96 } |  | 
|   97  |  | 
|   98 # 50 SELECTs on an LIKE comparison.  There is no index so a full |  | 
|   99 # table scan is required. |  | 
|  100 # |  | 
|  101 for {set i 0} {$i<50} {incr i} { |  | 
|  102   puts "SELECT count(*), avg(b) FROM t1 WHERE c LIKE '%[number_name $i]%';" |  | 
|  103 } |  | 
|  104  |  | 
|  105 # Create indices |  | 
|  106 # |  | 
|  107 puts {BEGIN;} |  | 
|  108 puts { |  | 
|  109   CREATE INDEX i1a ON t1(a); |  | 
|  110   CREATE INDEX i1b ON t1(b); |  | 
|  111   CREATE INDEX i1c ON t1(c); |  | 
|  112 } |  | 
|  113 puts {COMMIT;} |  | 
|  114  |  | 
|  115 # 5000 SELECTs on an integer comparison where the integer is |  | 
|  116 # indexed. |  | 
|  117 # |  | 
|  118 set sql {} |  | 
|  119 for {set i 0} {$i<5000} {incr i} { |  | 
|  120   set lwr [expr {$i*100}] |  | 
|  121   set upr [expr {($i+10)*100}] |  | 
|  122   puts "SELECT count(*), avg(b) FROM t1 WHERE b>=$lwr AND b<$upr;" |  | 
|  123 } |  | 
|  124  |  | 
|  125 # 100000 random SELECTs against rowid. |  | 
|  126 # |  | 
|  127 for {set i 1} {$i<=100000} {incr i} { |  | 
|  128   set id [expr {int(rand()*50000)+1}] |  | 
|  129   puts "SELECT c FROM t1 WHERE rowid=$id;" |  | 
|  130 } |  | 
|  131  |  | 
|  132 # 100000 random SELECTs against a unique indexed column. |  | 
|  133 # |  | 
|  134 for {set i 1} {$i<=100000} {incr i} { |  | 
|  135   set id [expr {int(rand()*50000)+1}] |  | 
|  136   puts "SELECT c FROM t1 WHERE a=$id;" |  | 
|  137 } |  | 
|  138  |  | 
|  139 # 50000 random SELECTs against an indexed column text column |  | 
|  140 # |  | 
|  141 set nt1c [llength $t1c_list] |  | 
|  142 for {set i 0} {$i<50000} {incr i} { |  | 
|  143   set r [expr {int(rand()*$nt1c)}] |  | 
|  144   set c [lindex $t1c_list $i] |  | 
|  145   puts "SELECT c FROM t1 WHERE c='$c';" |  | 
|  146 } |  | 
|  147  |  | 
|  148  |  | 
|  149 # Vacuum |  | 
|  150 puts {VACUUM;} |  | 
|  151  |  | 
|  152 # 5000 updates of ranges where the field being compared is indexed. |  | 
|  153 # |  | 
|  154 puts {BEGIN;} |  | 
|  155 for {set i 0} {$i<5000} {incr i} { |  | 
|  156   set lwr [expr {$i*2}] |  | 
|  157   set upr [expr {($i+1)*2}] |  | 
|  158   puts "UPDATE t1 SET b=b*2 WHERE a>=$lwr AND a<$upr;" |  | 
|  159 } |  | 
|  160 puts {COMMIT;} |  | 
|  161  |  | 
|  162 # 50000 single-row updates.  An index is used to find the row quickly. |  | 
|  163 # |  | 
|  164 puts {BEGIN;} |  | 
|  165 for {set i 0} {$i<50000} {incr i} { |  | 
|  166   set r [expr {int(rand()*500000)}] |  | 
|  167   puts "UPDATE t1 SET b=$r WHERE a=$i;" |  | 
|  168 } |  | 
|  169 puts {COMMIT;} |  | 
|  170  |  | 
|  171 # 1 big text update that touches every row in the table. |  | 
|  172 # |  | 
|  173 puts { |  | 
|  174   UPDATE t1 SET c=a; |  | 
|  175 } |  | 
|  176  |  | 
|  177 # Many individual text updates.  Each row in the table is |  | 
|  178 # touched through an index. |  | 
|  179 # |  | 
|  180 puts {BEGIN;} |  | 
|  181 for {set i 1} {$i<=50000} {incr i} { |  | 
|  182   set r [expr {int(rand()*500000)}] |  | 
|  183   puts "UPDATE t1 SET c='[number_name $r]' WHERE a=$i;" |  | 
|  184 } |  | 
|  185 puts {COMMIT;} |  | 
|  186  |  | 
|  187 # Delete all content in a table. |  | 
|  188 # |  | 
|  189 puts {DELETE FROM t1;} |  | 
|  190  |  | 
|  191 # Copy one table into another |  | 
|  192 # |  | 
|  193 puts {INSERT INTO t1 SELECT * FROM t2;} |  | 
|  194  |  | 
|  195 # Delete all content in a table, one row at a time. |  | 
|  196 # |  | 
|  197 puts {DELETE FROM t1 WHERE 1;} |  | 
|  198  |  | 
|  199 # Refill the table yet again |  | 
|  200 # |  | 
|  201 puts {INSERT INTO t1 SELECT * FROM t2;} |  | 
|  202  |  | 
|  203 # Drop the table and recreate it without its indices. |  | 
|  204 # |  | 
|  205 puts {BEGIN;} |  | 
|  206 puts { |  | 
|  207    DROP TABLE t1; |  | 
|  208    CREATE TABLE t1(a INTEGER, b INTEGER, c TEXT); |  | 
|  209 } |  | 
|  210 puts {COMMIT;} |  | 
|  211  |  | 
|  212 # Refill the table yet again.  This copy should be faster because |  | 
|  213 # there are no indices to deal with. |  | 
|  214 # |  | 
|  215 puts {INSERT INTO t1 SELECT * FROM t2;} |  | 
|  216  |  | 
|  217 # Select 20000 rows from the table at random. |  | 
|  218 # |  | 
|  219 puts { |  | 
|  220   SELECT rowid FROM t1 ORDER BY random() LIMIT 20000; |  | 
|  221 } |  | 
|  222  |  | 
|  223 # Delete 20000 random rows from the table. |  | 
|  224 # |  | 
|  225 puts { |  | 
|  226   DELETE FROM t1 WHERE rowid IN |  | 
|  227     (SELECT rowid FROM t1 ORDER BY random() LIMIT 20000); |  | 
|  228 } |  | 
|  229 puts {SELECT count(*) FROM t1;} |  | 
|  230      |  | 
|  231 # Delete 20000 more rows at random from the table. |  | 
|  232 # |  | 
|  233 puts { |  | 
|  234   DELETE FROM t1 WHERE rowid IN |  | 
|  235     (SELECT rowid FROM t1 ORDER BY random() LIMIT 20000); |  | 
|  236 } |  | 
|  237 puts {SELECT count(*) FROM t1;} |  | 
| OLD | NEW |