home *** CD-ROM | disk | FTP | other *** search
/ PC World 2002 July & August / PCWorld_2002-07-08_cd.bin / Komunik / MySQL / mysql / data1.cab / Development / bench / test-create < prev    next >
Text File  |  2002-02-21  |  7KB  |  268 lines
  1. #!/usr/bin/perl
  2. # Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3. #
  4. # This library is free software; you can redistribute it and/or
  5. # modify it under the terms of the GNU Library General Public
  6. # License as published by the Free Software Foundation; either
  7. # version 2 of the License, or (at your option) any later version.
  8. #
  9. # This library is distributed in the hope that it will be useful,
  10. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12. # Library General Public License for more details.
  13. #
  14. # You should have received a copy of the GNU Library General Public
  15. # License along with this library; if not, write to the Free
  16. # Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  17. # MA 02111-1307, USA
  18. #
  19. # This test is for testing how long it takes to create tables,
  20. # make a count(*) from them and finally drop the tables. These
  21. # commands will be done in different ways in this test.
  22. # Using option --fast will drop all the tables in the end
  23. # of this test with one command instead of making own
  24. # 'drop' command for each and every table.
  25. # By changing the variable '$table_amount' value you can make
  26. # this test a lot harder/easier for your computer to drive.
  27. # Note that when using value bigger than 64 for this variable
  28. # will do 'drop table'-command    in totally different way because of that
  29. # how MySQL handles these commands.
  30.  
  31. ##################### Standard benchmark inits ##############################
  32.  
  33. use DBI;
  34. use Benchmark;
  35.  
  36. $opt_loop_count=10000; # Change this to make test harder/easier
  37. # This is the default value for the amount of tables used in this test.
  38.  
  39. chomp($pwd = `pwd`); $pwd = "." if ($pwd eq '');
  40. require "$pwd/bench-init.pl" || die "Can't read Configuration file: $!\n";
  41.  
  42. $create_loop_count=$opt_loop_count;
  43. if ($opt_small_test)
  44. {
  45.   $opt_loop_count/=100;
  46.   $create_loop_count/=1000;
  47. }
  48.  
  49. $max_tables=min($limits->{'max_tables'},$opt_loop_count);
  50.  
  51. if ($opt_small_test)
  52. {
  53.   $max_tables=10;
  54. }
  55.  
  56.  
  57. print "Testing the speed of creating and droping tables\n";
  58. print "Testing with $max_tables tables and $opt_loop_count loop count\n\n";
  59.  
  60. ####
  61. ####  Connect and start timeing
  62. ####
  63.  
  64. $dbh = $server->connect();
  65.  
  66. ### Test how the database can handle many tables
  67. ### Create $max_tables ; Access all off them with a simple query
  68. ### and then drop the tables
  69.  
  70. if ($opt_force) # If tables used in this test exist, drop 'em
  71. {
  72.   print "Okay..Let's make sure that our tables don't exist yet.\n\n";
  73.   for ($i=1 ; $i <= $max_tables ; $i++)
  74.   {
  75.     $dbh->do("drop table bench_$i" . $server->{'drop_attr'});
  76.   }
  77. }
  78.  
  79. if ($opt_fast && defined($server->{vacuum}))
  80. {
  81.   $server->vacuum(1,\$dbh);
  82. }
  83.  
  84. print "Testing create of tables\n";
  85.  
  86. $loop_time=$start_time=new Benchmark;
  87.  
  88. for ($i=1 ; $i <= $max_tables ; $i++)
  89. {
  90.   if (do_many($dbh,$server->create("bench_$i",
  91.                    ["i int NOT NULL",
  92.                     "d double",
  93.                     "f float",
  94.                     "s char(10)",
  95.                     "v varchar(100)"],
  96.                    ["primary key (i)"])))
  97.   {
  98.     # Got an error; Do cleanup
  99.     for ($i=1 ; $i <= $max_tables ; $i++)
  100.     {
  101.       $dbh->do("drop table bench_$i" . $server->{'drop_attr'});
  102.     }
  103.     die "Test aborted";
  104.   }
  105. }
  106.  
  107. $end_time=new Benchmark;
  108. print "Time for create_MANY_tables ($max_tables): " .
  109.   timestr(timediff($end_time, $loop_time),"all") . "\n\n";
  110.  
  111. if ($opt_fast && defined($server->{vacuum}))
  112. {
  113.   $server->vacuum(1,\$dbh);
  114. }
  115.  
  116. #### Here comes $max_tables couples of cont(*) to the tables.
  117. #### We'll check how long it will take...
  118. ####
  119.  
  120. print "Accessing tables\n";
  121.  
  122. if ($limits->{'group_functions'})
  123. {
  124.   $query="select count(*) from ";
  125.   $type="select_group_when_MANY_tables";
  126. }
  127. else
  128. {
  129.   $query="select * from ";
  130.   $type="select_when_MANY_tables";
  131. }
  132.  
  133. $loop_time=new Benchmark;
  134. for ($i=1 ; $i <= $max_tables ; $i++)
  135. {
  136.   $sth = $dbh->do("$query bench_$i") or die $DBI::errstr;
  137. }
  138.  
  139. $end_time=new Benchmark;
  140. print "Time to $type ($max_tables): " .
  141.     timestr(timediff($end_time, $loop_time),"all") . "\n\n";
  142.  
  143. ####
  144. #### Now we are going to drop $max_tables tables;
  145. ####
  146.  
  147. print "Testing drop\n";
  148.  
  149. $loop_time=new Benchmark;
  150.  
  151. if ($opt_fast && $server->{'limits'}->{'multi_drop'} &&
  152.     $server->{'limits'}->{'query_size'} > 11+$max_tables*10)
  153. {
  154.   my $query="drop table bench_1";
  155.   for ($i=2 ; $i <= $max_tables ; $i++)
  156.   {
  157.     $query.=",bench_$i";
  158.   }
  159.   $sth = $dbh->do($query . $server->{'drop_attr'}) or die $DBI::errstr;
  160. }
  161. else
  162. {
  163.   for ($i=1 ; $i <= $max_tables ; $i++)
  164.   {
  165.     $sth = $dbh->do("drop table bench_$i" . $server->{'drop_attr'})
  166.       or die $DBI::errstr;
  167.   }
  168. }
  169.  
  170.  
  171. $end_time=new Benchmark;
  172. print "Time for drop_table_when_MANY_tables ($max_tables): " .
  173.     timestr(timediff($end_time, $loop_time),"all") . "\n\n";
  174.  
  175. if ($opt_fast && defined($server->{vacuum}))
  176. {
  177.   $server->vacuum(1,\$dbh);
  178. }
  179.  
  180. #### We'll do first one 'create table' and then we'll drop it
  181. #### away immediately. This loop shall be executed $opt_loop_count
  182. #### times.
  183.  
  184. print "Testing create+drop\n";
  185.  
  186. $loop_time=new Benchmark;
  187.  
  188. for ($i=1 ; $i <= $create_loop_count ; $i++)
  189. {
  190.   do_many($dbh,$server->create("bench_$i",
  191.                    ["i int NOT NULL",
  192.                 "d double",
  193.                 "f float",
  194.                 "s char(10)",
  195.                 "v varchar(100)"],
  196.                    ["primary key (i)"]));
  197.   $sth = $dbh->do("drop table bench_$i" . $server->{'drop_attr'}) or die $DBI::errstr;
  198. }
  199.  
  200. $end_time=new Benchmark;
  201. print "Time for create+drop ($create_loop_count): " .
  202.     timestr(timediff($end_time, $loop_time),"all") . "\n";
  203.  
  204. if ($opt_fast && defined($server->{vacuum}))
  205. {
  206.   $server->vacuum(1,\$dbh);
  207. }
  208.  
  209. #
  210. # Same test, but with a table with many keys
  211. #
  212.  
  213. my @fields=(); my @keys=();
  214. $keys=min($limits->{'max_index'},16);        # 16 is more than enough
  215. $seg= min($limits->{'max_index_parts'},$keys,16);    # 16 is more than enough
  216.  
  217. # Make keys on the most important types
  218. @types=(0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,1,1);    # A 1 for each char field
  219. push(@fields,"field1 tinyint not null");
  220. push(@fields,"field2 mediumint not null");
  221. push(@fields,"field3 smallint not null");
  222. push(@fields,"field4 char(16) not null");
  223. push(@fields,"field5 integer not null");
  224. push(@fields,"field6 float not null");
  225. push(@fields,"field7 double not null");
  226. for ($i=8 ; $i <= $keys ; $i++)
  227. {
  228.   push(@fields,"field$i char(5) not null");    # Should be relatively fair
  229. }
  230.  
  231. # Let first key contain many segments
  232. my $query="primary key (";
  233. for ($i= 1 ; $i <= $seg ; $i++)
  234. {
  235.   $query.= "field$i,";
  236. }
  237. substr($query,-1)=")";
  238. push (@keys,$query);
  239.  
  240. #Create other keys
  241. for ($i=2 ; $i <= $keys ; $i++)
  242. {
  243.   push(@keys,"index index$i (field$i)");
  244. }
  245.  
  246. $loop_time=new Benchmark;
  247. for ($i=1 ; $i <= $opt_loop_count ; $i++)
  248. {
  249.   do_many($dbh,$server->create("bench_$i", \@fields, \@index));
  250.   $dbh->do("drop table bench_$i" . $server->{'drop_attr'}) or die $DBI::errstr;
  251. }
  252.  
  253. $end_time=new Benchmark;
  254. print "Time for create_key+drop ($opt_loop_count): " .
  255.     timestr(timediff($end_time, $loop_time),"all") . "\n";
  256.  
  257. if ($opt_fast && defined($server->{vacuum}))
  258. {
  259.   $server->vacuum(1,\$dbh);
  260. }
  261.  
  262. ####
  263. #### End of benchmark
  264. ####
  265.  
  266. $dbh->disconnect;                # close connection
  267. end_benchmark($start_time);
  268.