开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
test-insert
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：48k
源码类别：

模拟服务器

开发平台：

C/C++

test-insert：源码内容
  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. # Test of creating a simple table and inserting $record_count records in it,
  20. # $opt_loop_count rows in order, $opt_loop_count rows in reverse order and
  21. # $opt_loop_count rows in random order
  22. #
  23. # changes made for Oracle compatibility
  24. # - $limits{'func_odbc_mod'} is OK from crash-me, but it fails here so set we
  25. #   set it to 0 in server-cfg
  26. # - the default server config runs out of rollback segments, so I added a couple
  27. #   of disconnect/connects to reset
  28. ##################### Standard benchmark inits ##############################
  30. use DBI;
  31. use Benchmark;
  33. $opt_loop_count=100000; # number of rows/3
  34. $small_loop_count=10; # Loop for full table retrieval
  35. $range_loop_count=$small_loop_count*50;
  36. $many_keys_loop_count=$opt_loop_count;
  37. $opt_read_key_loop_count=$opt_loop_count;
  39. chomp($pwd = `pwd`); $pwd = "." if ($pwd eq '');
  40. require "$pwd/bench-init.pl" || die "Can't read Configuration file: $!n";
  42. if ($opt_small_test)
  43. {
  44.   $opt_loop_count/=100;
  45.   $many_keys_loop_count=$opt_loop_count/10;
  46.   $range_loop_count=10;
  47.   $opt_read_key_loop_count=10;
  48. }
  49. elsif ($opt_small_tables)
  50. {
  51.   $opt_loop_count=10000; # number of rows/3
  52.   $many_keys_loop_count=$opt_loop_count;
  53.   $opt_read_key_loop_count=10;
  54. }
  55. elsif ($opt_small_key_tables)
  56. {
  57.   $many_keys_loop_count/=10;
  58. }
  60. if ($opt_loop_count < 100)
  61. {
  62.   $opt_loop_count=100; # Some tests must have some data to work!
  63. }
  64. $range_loop_count=min($opt_loop_count,$range_loop_count);
  67. print "Testing the speed of inserting data into 1 table and do some selects on it.n";
  68. print "The tests are done with a table that has $opt_loop_count rows.nn";
  70. ####
  71. #### Generating random keys
  72. ####
  74. print "Generating random keysn";
  75. $random[$opt_loop_count]=0;
  76. for ($i=0 ; $i < $opt_loop_count ; $i++)
  77. {
  78.   $random[$i]=$i+$opt_loop_count;
  79. }
  81. my $tmpvar=1;
  82. for ($i=0 ; $i < $opt_loop_count ; $i++)
  83. {
  84.   $tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
  85.   $swap=$tmpvar % $opt_loop_count;
  86.   $tmp=$random[$i]; $random[$i]=$random[$swap]; $random[$swap]=$tmp;
  87. }
  89. $total_rows=$opt_loop_count*3;
  91. ####
  92. ####  Connect and start timeing
  93. ####
  94. $start_time=new Benchmark;
  95. $dbh = $server->connect();
  96. ####
  97. #### Create needed tables
  98. ####
  100. goto keys_test if ($opt_stage == 2);
  101. goto select_test if ($opt_skip_create);
  103. print "Creating tablesn";
  104. $dbh->do("drop table bench1" . $server->{'drop_attr'});
  105. $dbh->do("drop table bench2" . $server->{'drop_attr'});
  106. $dbh->do("drop table bench3" . $server->{'drop_attr'});
  107. do_many($dbh,$server->create("bench1",
  108.      ["id int NOT NULL",
  109.       "id2 int NOT NULL",
  110.       "id3 int NOT NULL",
  111.       "dummy1 char(30)"],
  112.      ["primary key (id,id2)",
  113.      "index index_id3 (id3)"]));
  115. if ($opt_lock_tables)
  116. {
  117.   $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  118. }
  120. ####
  121. #### Insert $total_rows records in order, in reverse order and random.
  122. ####
  124. $loop_time=new Benchmark;
  126. if ($opt_fast_insert)
  127. {
  128.   $query="insert into bench1 values ";
  129. }
  130. else
  131. {
  132.   $query="insert into bench1 (id,id2,id3,dummy1) values ";
  133. }
  135. if (($opt_fast || $opt_fast_insert) && $server->{'limits'}->{'insert_multi_value'})
  136. {
  137.   $query_size=$server->{'limits'}->{'query_size'};
  139.   print "Inserting $opt_loop_count multiple-value rows in ordern";
  140.   $res=$query;
  141.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  142.   {
  143.     $tmp= "($i,$i,$i,'ABCDEFGHIJ'),";
  144.     if (length($tmp)+length($res) < $query_size)
  145.     {
  146.       $res.= $tmp;
  147.     }
  148.     else
  149.     {
  150.       $sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
  151.       $res=$query . $tmp;
  152.     }
  153.   }
  154.   print "Inserting $opt_loop_count multiple-value rows in reverse ordern";
  155.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  156.   {
  157.     $tmp= "(" . ($total_rows-1-$i) . "," .($total_rows-1-$i) .
  158.       "," .($total_rows-1-$i) . ",'BCDEFGHIJK'),";
  159.     if (length($tmp)+length($res) < $query_size)
  160.     {
  161.       $res.= $tmp;
  162.     }
  163.     else
  164.     {
  165.       $sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
  166.       $res=$query . $tmp;
  167.     }
  168.   }
  169.   print "Inserting $opt_loop_count multiple-value rows in random ordern";
  170.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  171.   {
  172.     $tmp= "(" . $random[$i] . "," . $random[$i] . "," . $random[$i] .
  173.       ",'CDEFGHIJKL')," or die $DBI::errstr;
  174.     if (length($tmp)+length($res) < $query_size)
  175.     {
  176.       $res.= $tmp;
  177.     }
  178.     else
  179.     {
  180.       $sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
  181.       $res=$query . $tmp;
  182.     }
  183.   }
  184.   $sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
  185. }
  186. else
  187. {
  188.   print "Inserting $opt_loop_count rows in ordern";
  189.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  190.   {
  191.     $sth = $dbh->do($query . "($i,$i,$i,'ABCDEFGHIJ')") or die $DBI::errstr;
  192.   }
  194.   print "Inserting $opt_loop_count rows in reverse ordern";
  195.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  196.   {
  197.     $sth = $dbh->do($query . "(" . ($total_rows-1-$i) . "," .
  198.     ($total_rows-1-$i) . "," .
  199.     ($total_rows-1-$i) . ",'BCDEFGHIJK')")
  200.       or die $DBI::errstr;
  201.   }
  203.   print "Inserting $opt_loop_count rows in random ordern";
  205.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  206.   {
  207.     $sth = $dbh->do($query . "(". $random[$i] . "," . $random[$i] .
  208.     "," . $random[$i] . ",'CDEFGHIJKL')") or die $DBI::errstr;
  209.   }
  210. }
  212. $end_time=new Benchmark;
  213. print "Time for insert (" . ($total_rows) . "): " .
  214.   timestr(timediff($end_time, $loop_time),"all") . "nn";
  216. if ($opt_lock_tables)
  217. {
  218.   $sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
  219. }
  220. if ($opt_fast && defined($server->{vacuum}))
  221. {
  222.   $server->vacuum(1,$dbh,"bench1");
  223. }
  224. if ($opt_lock_tables)
  225. {
  226.   $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  227. }
  229. ####
  230. #### insert $opt_loop_count records with duplicate id
  231. ####
  233. if ($limits->{'unique_index'})
  234. {
  235.   print "Testing insert of duplicatesn";
  236.   $loop_time=new Benchmark;
  237.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  238.   {
  239.     $tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
  240.     $tmp=$tmpvar % ($total_rows);
  241.     $tmpquery = "$query ($tmp,$tmp,2,'D')";
  242.     if ($dbh->do($tmpquery))
  243.     {
  244.       die "Didn't get an error when inserting duplicate record $tmpn";
  245.     }
  246.   }
  248.   $end_time=new Benchmark;
  249.   print "Time for insert_duplicates (" . ($opt_loop_count) . "): " .
  250.   timestr(timediff($end_time, $loop_time),"all") . "nn";
  251. }
  254. ####
  255. #### Do some selects on the table
  256. ####
  258. select_test:
  260. print "Retrieving data from the tablen";
  261. $loop_time=new Benchmark;
  262. $error=0;
  264. # It's really a small table, so we can try a select on everything
  266. $count=0;
  267. for ($i=1 ; $i <= $small_loop_count ; $i++)
  268. {
  269.   if (($found_rows=fetch_all_rows($dbh,"select id from bench1")) !=
  270.       $total_rows)
  271.   {
  272.     if (!$error++)
  273.     {
  274.       print "Warning: Got $found_rows rows when selecting a whole table of " . ($total_rows) . " rowsnContact the database or DBD author!n";
  275.     }
  276.   }
  277.   $count+=$found_rows;
  278. }
  280. $end_time=new Benchmark;
  281. print "Time for select_big ($small_loop_count:$count): " .
  282.     timestr(timediff($end_time, $loop_time),"all") . "n";
  284. #
  285. # Do a lot of different ORDER BY queries
  286. #
  288. $loop_time=new Benchmark;
  289. $estimated=$rows=0;
  290. for ($i=1 ; $i <= $small_loop_count ; $i++)
  291. {
  292.   $rows+=fetch_all_rows($dbh,"select id,id2 from bench1 order by id,id2",1);
  293.   $end_time=new Benchmark;
  294.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  295.  $small_loop_count));
  296. }
  297. if ($estimated)
  298. { print "Estimated time"; }
  299. else
  300. { print "Time"; }
  301. print " for order_by_big_key ($small_loop_count:$rows): " .
  302.   timestr(timediff($end_time, $loop_time),"all") . "n";
  305. $loop_time=new Benchmark;
  306. $estimated=$rows=0;
  307. for ($i=1 ; $i <= $small_loop_count ; $i++)
  308. {
  309.   $rows+=fetch_all_rows($dbh,"select id,id2 from bench1 order by id desc, id2 desc",1);
  310.   $end_time=new Benchmark;
  311.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  312.  $small_loop_count));
  313. }
  314. if ($estimated)
  315. { print "Estimated time"; }
  316. else
  317. { print "Time"; }
  318. print " for order_by_big_key_desc ($small_loop_count:$rows): " .
  319.   timestr(timediff($end_time, $loop_time),"all") . "n";
  322. $loop_time=new Benchmark;
  323. $estimated=$rows=0;
  324. for ($i=1 ; $i <= $small_loop_count ; $i++)
  325. {
  326.   $rows+=fetch_all_rows($dbh,"select id from bench1 order by id desc",1);
  327.   $end_time=new Benchmark;
  328.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  329.  $small_loop_count));
  330. }
  331. if ($estimated)
  332. { print "Estimated time"; }
  333. else
  334. { print "Time"; }
  335. print " for order_by_big_key_prefix ($small_loop_count:$rows): " .
  336.   timestr(timediff($end_time, $loop_time),"all") . "n";
  339. $loop_time=new Benchmark;
  340. $estimated=$rows=0;
  341. for ($i=1 ; $i <= $small_loop_count ; $i++)
  342. {
  343.   $rows+=fetch_all_rows($dbh,"select id3 from bench1 order by id3",1);
  344.   $end_time=new Benchmark;
  345.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  346.  $small_loop_count));
  347. }
  348. if ($estimated)
  349. { print "Estimated time"; }
  350. else
  351. { print "Time"; }
  352. print " for order_by_big_key2 ($small_loop_count:$rows): " .
  353.   timestr(timediff($end_time, $loop_time),"all") . "n";
  356. $sel=$limits->{'order_by_unused'} ? "id2" : "*";
  357. $loop_time=new Benchmark;
  358. $estimated=$rows=0;
  359. for ($i=1 ; $i <= $small_loop_count ; $i++)
  360. {
  361.   $rows+=fetch_all_rows($dbh,"select $sel from bench1 order by id3",1);
  362.   $end_time=new Benchmark;
  363.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  364.  $small_loop_count));
  365. }
  366. if ($estimated)
  367. { print "Estimated time"; }
  368. else
  369. { print "Time"; }
  370. print " for order_by_big_key_diff ($small_loop_count:$rows): " .
  371.   timestr(timediff($end_time, $loop_time),"all") . "n";
  374. $sel=$limits->{'order_by_unused'} ? "id" : "*";
  375. $loop_time=new Benchmark;
  376. $estimated=$rows=0;
  377. for ($i=1 ; $i <= $small_loop_count ; $i++)
  378. {
  379.   $rows+=fetch_all_rows($dbh,"select $sel from bench1 order by id2,id3",1);
  380.   $end_time=new Benchmark;
  381.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  382.  $small_loop_count));
  383. }
  384. if ($estimated)
  385. { print "Estimated time"; }
  386. else
  387. { print "Time"; }
  388. print " for order_by_big ($small_loop_count:$rows): " .
  389.   timestr(timediff($end_time, $loop_time),"all") . "n";
  392. $sel=$limits->{'order_by_unused'} ? "dummy1" : "dummy1,id3";
  393. $loop_time=new Benchmark;
  394. $estimated=$rows=0;
  395. for ($i=1 ; $i <= $range_loop_count ; $i++)
  396. {
  397.   $start=$opt_loop_count/$range_loop_count*$i;
  398.   $end=$start+$i;
  399.   $rows+=fetch_all_rows($dbh,"select $sel from bench1 where id>=$start and id <= $end order by id3",1);
  400.   $end_time=new Benchmark;
  401.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  402.  $range_loop_count));
  403. }
  404. if ($estimated)
  405. { print "Estimated time"; }
  406. else
  407. { print "Time"; }
  408. print " for order_by_range ($range_loop_count:$rows): " .
  409.   timestr(timediff($end_time, $loop_time),"all") . "n";
  411. $sel=$limits->{'order_by_unused'} ? "dummy1" : "dummy1,id";
  412. $loop_time=new Benchmark;
  413. $estimated=$rows=0;
  414. for ($i=1 ; $i <= $range_loop_count ; $i++)
  415. {
  416.   $start=$opt_loop_count/$range_loop_count*$i;
  417.   $end=$start+$i;
  418.   $rows+=fetch_all_rows($dbh,"select $sel from bench1 where id>=$start and id <= $end order by id",1);
  419.   $end_time=new Benchmark;
  420.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  421.  $range_loop_count));
  422. }
  423. if ($estimated)
  424. { print "Estimated time"; }
  425. else
  426. { print "Time"; }
  427. print " for order_by_key_prefix ($range_loop_count:$rows): " .
  428.   timestr(timediff($end_time, $loop_time),"all") . "n";
  430. $sel=$limits->{'order_by_unused'} ? "id2" : "id2,id3";
  431. $loop_time=new Benchmark;
  432. $estimated=$rows=0;
  433. for ($i=1 ; $i <= $range_loop_count ; $i++)
  434. {
  435.   $start=$opt_loop_count/$range_loop_count*$i;
  436.   $end=$start+$range_loop_count;
  437.   $rows+=fetch_all_rows($dbh,"select $sel from bench1 where id3>=$start and id3 <= $end order by id3",1);
  438.   $end_time=new Benchmark;
  439.   last if ($estimated=predict_query_time($loop_time,$end_time,$i,$i,
  440.  $range_loop_count));
  441. }
  442. if ($estimated)
  443. { print "Estimated time"; }
  444. else
  445. { print "Time"; }
  446. print " for order_by_key2_diff ($range_loop_count:$rows): " .
  447.   timestr(timediff($end_time, $loop_time),"all") . "n";
  449. #
  450. # Test of select on 2 different keys with or
  451. # (In this case database can only use keys if they do an automatic union).
  452. #
  454. $loop_time=new Benchmark;
  455. $estimated=0;
  456. $rows=0;
  457. $count=0;
  458. for ($i=1 ; $i <= $range_loop_count ; $i++)
  459. {
  460.   my $rnd=$i;
  461.   my $rnd2=$random[$i];
  462.   $rows+=fetch_all_rows($dbh,"select id2 from bench1 where id=$rnd or id3=$rnd2",1);
  463.   $count++;
  464.   $end_time=new Benchmark;
  465.   last if ($estimated=predict_query_time($loop_time,$end_time,$count,$count,
  466.  $range_loop_count));
  467. }
  468. if ($estimated)
  469. { print "Estimated time"; }
  470. else
  471. { print "Time"; }
  472. print " for select_diff_key ($count:$rows): " .
  473.   timestr(timediff($end_time, $loop_time),"all") . "n";
  476. # Test select that is very popular when using ODBC
  478. check_or_range("id","select_range_prefix");
  479. check_or_range("id3","select_range_key2");
  481. # Check reading on direct key on id and id3
  483. check_select_key("*","id","select_key_prefix");
  484. check_select_key2("*","id","id2","select_key");
  485. check_select_key2("id,id2","id","id2","select_key_return_key");
  486. check_select_key("*","id3","select_key2");
  487. check_select_key("id3","id3","select_key2_return_key");
  488. check_select_key("id,id2","id3","select_key2_return_prim");
  490. ####
  491. #### A lot of simple selects on ranges
  492. ####
  494. @Q=("select * from bench1 where !id!=3 or !id!=2 or !id!=1 or !id!=4 or !id!=16 or !id!=10",
  495.     6,
  496.     "select * from bench1 where !id!>=" . ($total_rows-1) ." or !id!<1",
  497.     2,
  498.     "select * from bench1 where !id!>=1 and !id!<=2",
  499.     2,
  500.     "select * from bench1 where (!id!>=1 and !id!<=2) or (!id!>=1 and !id!<=2)",
  501.     2,
  502.     "select * from bench1 where !id!>=1 and !id!<=10 and !id!<=5",
  503.     5,
  504.     "select * from bench1 where (!id!>0 and !id!<2) or !id!>=" . ($total_rows-1),
  505.     2,
  506.     "select * from bench1 where (!id!>0 and !id!<2) or (!id!>= " . ($opt_loop_count/2) . " and !id! <= " . ($opt_loop_count/2+2) . ") or !id! = " . ($opt_loop_count/2-1),
  507.     5,
  508.     "select * from bench1 where (!id!>=5 and !id!<=10) or (!id!>=1 and !id!<=4)",
  509.     10,
  510.     "select * from bench1 where (!id!=1 or !id!=2) and (!id!=3 or !id!=4)",
  511.     0,
  512.     "select * from bench1 where (!id!=1 or !id!=2) and (!id!=2 or !id!=3)",
  513.     1,
  514.     "select * from bench1 where (!id!=1 or !id!=5 or !id!=20 or !id!=40) and (!id!=1 or !id!>=20 or !id!=4)",
  515.     3,
  516.     "select * from bench1 where ((!id!=1 or !id!=3) or (!id!>1 and !id!<3)) and !id!<=2",
  517.     2,
  518.     "select * from bench1 where (!id! >= 0 and !id! < 4) or (!id! >=4 and !id! < 6)",
  519.     6,
  520.     "select * from bench1 where !id! <= -1 or (!id! >= 0 and !id! <= 5) or (!id! >=4 and !id! < 6) or (!id! >=6 and !id! <=7) or (!id!>7 and !id! <= 8)",
  521.     9,
  522.     "select * from bench1 where (!id!>=1 and !id!<=2 or !id!>=4 and !id!<=5) or (!id!>=0 and !id! <=10)",
  523.     11,
  524.     "select * from bench1 where (!id!>=1 and !id!<=2 or !id!>=4 and !id!<=5) or (!id!>2 and !id! <=10)",
  525.     10,
  526.     "select * from bench1 where (!id!>1 or !id! <1) and !id!<=2",
  527.     2,
  528.     "select * from bench1 where !id! <= 2 and (!id!>1 or !id! <=1)",
  529.     3,
  530.     "select * from bench1 where (!id!>=1 or !id! <1) and !id!<=2",
  531.     3,
  532.     "select * from bench1 where (!id!>=1 or !id! <=2) and !id!<=2",
  533.     3
  534.     );
  536. print "nTest of compares with simple rangesn";
  537. check_select_range("id","select_range_prefix");
  538. check_select_range("id3","select_range_key2");
  540. ####
  541. #### Some group queries
  542. ####
  544. if ($limits->{'group_functions'})
  545. {
  546.   $loop_time=new Benchmark;
  547.   $count=1;
  549.   $estimated=0;
  550.   for ($tests=0 ; $tests < $small_loop_count ; $tests++)
  551.   {
  552.     $sth=$dbh->prepare($query="select count(*) from bench1") or die $DBI::errstr;
  553.     $sth->execute or die $sth->errstr;
  554.     if (($sth->fetchrow_array)[0] != $total_rows)
  555.     {
  556.       print "Warning: '$query' returned wrong resultn";
  557.     }
  558.     $sth->finish;
  560.     # min, max in keys are very normal
  561.     $count+=7;
  562.     fetch_all_rows($dbh,"select min(id) from bench1");
  563.     fetch_all_rows($dbh,"select max(id) from bench1");
  564.     fetch_all_rows($dbh,"select sum(id+0.0) from bench1");
  565.     fetch_all_rows($dbh,"select min(id3),max(id3),sum(id3-0.0) from bench1");
  566.     if ($limits->{'group_func_sql_min_str'})
  567.     {
  568.       fetch_all_rows($dbh,"select min(dummy1),max(dummy1) from bench1");
  569.     }
  570.     $count++;
  571.     $sth=$dbh->prepare($query="select count(*) from bench1 where id >= " .
  572.        ($opt_loop_count*2)) or die $DBI::errstr;
  573.     $sth->execute or die $DBI::errstr;
  574.     if (($sth->fetchrow_array)[0] != $opt_loop_count)
  575.     {
  576.       print "Warning: '$query' returned wrong resultn";
  577.     }
  578.     $sth->finish;
  581.     $count++;
  582.     $sth=$dbh->prepare($query="select count(*),sum(id+0.0),min(id),max(id),avg(id-0.0) from bench1") or die $DBI::errstr;
  583.     $sth->execute or die $DBI::errstr;
  584.     @row=$sth->fetchrow_array;
  585.     if ($row[0] != $total_rows ||
  586. int($row[1]+0.5) != int((($total_rows-1)/2*$total_rows)+0.5) ||
  587. $row[2] != 0 ||
  588. $row[3] != $total_rows-1 ||
  589. 1-$row[4]/(($total_rows-1)/2) > 0.001)
  590.     {
  591.       # PostgreSQL 6.3 fails here
  592.       print "Warning: '$query' returned wrong result: @rown";
  593.     }
  594.     $sth->finish;
  596.     if ($limits->{'func_odbc_mod'})
  597.     {
  598.       $tmp="mod(id,10)";
  599.       if ($limits->{'func_extra_%'})
  600.       {
  601. $tmp="id % 10"; # For postgreSQL
  602.       }
  603.       $count++;
  604.       if ($limits->{'group_by_alias'}) {
  605. if (fetch_all_rows($dbh,$query=$server->query("select $tmp as last_digit,count(*) from bench1 group by last_digit")) != 10)
  606. {
  607.   print "Warning: '$query' returned wrong number of rowsn";
  608. }
  609.       } elsif ($limits->{'group_by_position'}) {
  610. if (fetch_all_rows($dbh,$query=$server->query("select $tmp,count(*) from bench1 group by 1")) != 10)
  611. {
  612.   print "Warning: '$query' returned wrong number of rowsn";
  613. }
  614.       }
  615.     }
  617.     if ($limits->{'order_by_position'} && $limits->{'group_by_position'})
  618.     {
  619.       $count++;
  620.       if (fetch_all_rows($dbh, $query="select id,id3,dummy1 from bench1 where id < 100+$count-$count group by id,id3,dummy1 order by id desc,id3,dummy1") != 100)
  621.       {
  622. print "Warning: '$query' returned wrong number of rowsn";
  623.       }
  624.     }
  625.     $end_time=new Benchmark;
  626.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$tests,
  627.    $small_loop_count));
  628.   }
  629.   print_time($estimated);
  630.   print " for select_group ($count): " .
  631.       timestr(timediff($end_time, $loop_time),"all") . "n";
  633.   $loop_time=new Benchmark;
  634.   $count=$estimated=0;
  635.   for ($tests=1 ; $tests <= $range_loop_count*5 ; $tests++)
  636.   {
  637.     $count+=6;
  638.     fetch_all_rows($dbh,"select min(id) from bench1");
  639.     fetch_all_rows($dbh,"select max(id) from bench1");
  640.     fetch_all_rows($dbh,"select min(id2) from bench1 where id=$tests");
  641.     fetch_all_rows($dbh,"select max(id2) from bench1 where id=$tests");
  642.     if ($limits->{'group_func_sql_min_str'})
  643.     {
  644.       fetch_all_rows($dbh,"select min(dummy1) from bench1 where id=$tests");
  645.       fetch_all_rows($dbh,"select max(dummy1) from bench1 where id=$tests");
  646.     }
  647.     $end_time=new Benchmark;
  648.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$tests,
  649.    $range_loop_count*5));
  650.   }
  651.   if ($estimated)
  652.   { print "Estimated time"; }
  653.   else
  654.   { print "Time"; }
  655.   print " for min_max_on_key ($count): " .
  656.       timestr(timediff($end_time, $loop_time),"all") . "n";
  658.   $loop_time=new Benchmark;
  659.   $count=$estimated=0;
  660.   for ($tests=1 ; $tests <= $small_loop_count ; $tests++)
  661.   {
  662.     $count+=6;
  663.     fetch_all_rows($dbh,"select min(id2) from bench1");
  664.     fetch_all_rows($dbh,"select max(id2) from bench1");
  665.     fetch_all_rows($dbh,"select min(id3) from bench1 where id2=$tests");
  666.     fetch_all_rows($dbh,"select max(id3) from bench1 where id2=$tests");
  667.     if ($limits->{'group_func_sql_min_str'})
  668.     {
  669.       fetch_all_rows($dbh,"select min(dummy1) from bench1 where id2=$tests");
  670.       fetch_all_rows($dbh,"select max(dummy1) from bench1 where id2=$tests");
  671.     }
  672.     $end_time=new Benchmark;
  673.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$tests,
  674.    $range_loop_count));
  675.   }
  676.   if ($estimated)
  677.   { print "Estimated time"; }
  678.   else
  679.   { print "Time"; }
  680.   print " for min_max ($count): " .
  681.       timestr(timediff($end_time, $loop_time),"all") . "n";
  683.   $loop_time=new Benchmark;
  684.   $count=0;
  685.   $total=$opt_loop_count*3;
  686.   for ($tests=0 ; $tests < $total ; $tests+=$total/100)
  687.   {
  688.     $count+=1;
  689.     fetch_all_rows($dbh,"select count(id) from bench1 where id < $tests");
  690.   }
  691.   $end_time=new Benchmark;
  692.   print "Time for count_on_key ($count): " .
  693.       timestr(timediff($end_time, $loop_time),"all") . "n";
  695.   $loop_time=new Benchmark;
  696.   $count=0;
  697.   for ($tests=0 ; $tests < $total ; $tests+=$total/100)
  698.   {
  699.     $count+=1;
  700.     fetch_all_rows($dbh,"select count(dummy1) from bench1 where id2 < $tests");
  701.   }
  702.   $end_time=new Benchmark;
  703.   print "Time for count ($count): " .
  704.       timestr(timediff($end_time, $loop_time),"all") . "n";
  706.   if ($limits->{'group_distinct_functions'})
  707.   {
  708.     $loop_time=new Benchmark;
  709.     $count=$estimated=0;
  710.     for ($tests=1 ; $tests <= $small_loop_count ; $tests++)
  711.     {
  712.       $count+=2;
  713.       fetch_all_rows($dbh,"select count(distinct dummy1) from bench1");
  714.       fetch_all_rows($dbh,"select dummy1,count(distinct id) from bench1 group by dummy1");
  715.       $end_time=new Benchmark;
  716.       last if ($estimated=predict_query_time($loop_time,$end_time,$count,$tests,
  717.      $small_loop_count));
  718.     }
  719.     if ($estimated)
  720.     { print "Estimated time"; }
  721.     else
  722.     { print "Time"; }
  723.     print " for count_distinct_big ($count): " .
  724.     timestr(timediff($end_time, $loop_time),"all") . "n";
  725.   }
  726. }
  729. if ($server->small_rollback_segment())
  730. {
  731.   $dbh->disconnect; # close connection
  732.   $dbh = $server->connect();
  733. }
  735. ####
  736. #### Some updates on the table
  737. ####
  739. $loop_time=new Benchmark;
  741. if ($limits->{'functions'})
  742. {
  743.   print "nTesting update of keys with functionsn";
  744.   my $update_loop_count=$opt_loop_count/2;
  745.   for ($i=0 ; $i < $update_loop_count ; $i++)
  746.   {
  747.     my $tmp=$opt_loop_count+$random[$i]; # $opt_loop_count*2 <= $tmp < $total_rows
  748.     $sth = $dbh->do("update bench1 set id3=-$tmp where id3=$tmp") or die $DBI::errstr;
  749.   }
  751.   $end_time=new Benchmark;
  752.   print "Time for update_of_key ($update_loop_count):  " .
  753.     timestr(timediff($end_time, $loop_time),"all") . "n";
  755.   if ($opt_lock_tables)
  756.   {
  757.     do_query($dbh,"UNLOCK TABLES");
  758.   }
  759.   if ($opt_fast && defined($server->{vacuum}))
  760.   {
  761.     $server->vacuum(1,$dbh,"bench1");
  762.   }
  763.   if ($opt_lock_tables)
  764.   {
  765.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  766.   }
  768.   if ($server->small_rollback_segment())
  769.   {
  770.     $dbh->disconnect; # close connection
  771.     $dbh = $server->connect();
  772.   }
  774.   $loop_time=new Benchmark;
  775.   $count=0;
  776.   $step=int($opt_loop_count/$range_loop_count+1);
  777.   for ($i= 0 ; $i < $opt_loop_count ; $i+= $step)
  778.   {
  779.     $count++;
  780.     $sth=$dbh->do("update bench1 set id3= 0-id3 where id3 >= 0 and id3 <= $i") or die $DBI::errstr;
  781.   }
  783.   if ($server->small_rollback_segment())
  784.   {
  785.     $dbh->disconnect; # close connection
  786.     $dbh = $server->connect();
  787.   }
  788.   $count++;
  789.   $sth=$dbh->do("update bench1 set id3= 0-id3 where id3 >= 0 and id3 < $opt_loop_count") or die $DBI::errstr;
  791.   if ($server->small_rollback_segment())
  792.   {
  793.     $dbh->disconnect; # close connection
  794.     $dbh = $server->connect();
  795.   }
  796.   $count++;
  797.   $sth=$dbh->do("update bench1 set id3= 0-id3 where id3 >= $opt_loop_count and id3 < ". ($opt_loop_count*2)) or die $DBI::errstr;
  799.   #
  800.   # Check that everything was updated
  801.   # In principle we shouldn't time this in the update loop..
  802.   #
  804.   if ($server->small_rollback_segment())
  805.   {
  806.     $dbh->disconnect; # close connection
  807.     $dbh = $server->connect();
  808.   }
  809.   $row_count=0;
  810.   if (($sth=$dbh->prepare("select count(*) from bench1 where id3>=0"))
  811.       && $sth->execute)
  812.   {
  813.     ($row_count)=$sth->fetchrow;
  814.   }
  815.   $result=1 + $opt_loop_count-$update_loop_count;
  816.   if ($row_count != $result)
  817.   {
  818.     print "Warning: Update check returned $row_count instead of $resultn";
  819.   }
  821.   $sth->finish;
  822.   if ($server->small_rollback_segment())
  823.   {
  824.     $dbh->disconnect; # close connection
  825.     $dbh = $server->connect();
  826.   }
  827.   #restore id3 to 0 <= id3 < $total_rows/10 or 0<= id3 < $total_rows
  829.   my $func=($limits->{'func_odbc_floor'}) ? "floor((0-id3)/20)" : "0-id3";
  830.   $count++;
  831.   $sth=$dbh->do($query="update bench1 set id3=$func where id3<0") or die $DBI::errstr;
  833.   $end_time=new Benchmark;
  834.   print "Time for update_of_key_big ($count): " .
  835.     timestr(timediff($end_time, $loop_time),"all") . "nn";
  836. }
  837. else
  838. {
  839.   print "nTesting update of keys in loopsn";
  840.   #
  841.   # This is for mSQL that doesn't have functions. Do we really need this ????
  842.   #
  844.   $sth=$dbh->prepare("select id3 from bench1 where id3 >= 0") or die $DBI::errstr;
  845.   $sth->execute or die $DBI::errstr;
  846.   $count=0;
  847.   while (@tmp = $sth->fetchrow_array)
  848.   {
  849.     my $tmp1 = "-$tmp[0]";
  850.     my $sth1 = $dbh->do("update bench1 set id3 = $tmp1 where id3 = $tmp[0]");
  851.     $count++;
  852.     $end_time=new Benchmark;
  853.     if (($end_time->[0] - $loop_time->[0]) > $opt_time_limit)
  854.     {
  855.       print "note: Aborting update loop because of timeoutn";
  856.       last;
  857.     }
  858.   }
  859.   $sth->finish;
  860.   # Check that everything except id3=0 was updated
  861.   # In principle we shouldn't time this in the update loop..
  862.   #
  863.   if (fetch_all_rows($dbh,$query="select * from bench1 where id3>=0") != 1)
  864.   {
  865.     if ($count == $total_rows)
  866.     {
  867.       print "Warning: Wrong information after update: Found '$row_count' rows, but should have been: 1n";
  868.     }
  869.   }
  870.   #restore id3 to 0 <= id3 < $total_rows
  871.   $sth=$dbh->prepare("select id3 from bench1 where id3 < 0") or die $DBI::errstr;
  872.   $sth->execute or die $DBI::errstr;
  873.   while (@tmp = $sth->fetchrow_array)
  874.   {
  875.     $count++;
  876.     my $tmp1 = floor((0-$tmp[0])/10);
  877.     my $sth1 = $dbh->do("update bench1 set id3 = $tmp1 where id3 = $tmp[0]");
  878.   }
  879.   $sth->finish;
  880.   $end_time=new Benchmark;
  881.   $estimated=predict_query_time($loop_time,$end_time,$count,$count,
  882. $opt_loop_count*6);
  883.   if ($estimated)
  884.   { print "Estimated time"; }
  885.   else
  886.   { print "Time"; }
  887.   print " for update_of_key ($count): " .
  888.     timestr(timediff($end_time, $loop_time),"all") . "nn";
  889. }
  891. if ($opt_fast && defined($server->{vacuum}))
  892. {
  893.   if ($opt_lock_tables)
  894.   {
  895.     do_query($dbh,"UNLOCK TABLES");
  896.   }
  897.   $server->vacuum(1,$dbh,"bench1");
  898.   if ($opt_lock_tables)
  899.   {
  900.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  901.   }
  902. }
  904. #
  905. # Testing some simple updates
  906. #
  908. print "Testing update with keyn";
  909. $loop_time=new Benchmark;
  910. for ($i=0 ; $i < $opt_loop_count*3 ; $i++)
  911. {
  912.   $sth = $dbh->do("update bench1 set dummy1='updated' where id=$i and id2=$i") or die $DBI::errstr;
  913. }
  915. $end_time=new Benchmark;
  916. print "Time for update_with_key (" . ($opt_loop_count*3) . "):  " .
  917.   timestr(timediff($end_time, $loop_time),"all") . "n";
  919. $loop_time=new Benchmark;
  920. for ($i=0 ; $i < $opt_loop_count*3 ; $i+=3)
  921. {
  922.   $sth = $dbh->do("update bench1 set dummy1='updated' where id=$i") or die $DBI::errstr;
  923. }
  925. $end_time=new Benchmark;
  926. print "Time for update_with_key_prefix (" . ($opt_loop_count) . "):  " .
  927.   timestr(timediff($end_time, $loop_time),"all") . "n";
  929. print "nTesting update of all rowsn";
  930. $loop_time=new Benchmark;
  931. for ($i=0 ; $i < $small_loop_count ; $i++)
  932. {
  933.   $sth = $dbh->do("update bench1 set dummy1='updated $i'") or die $DBI::errstr;
  934. }
  935. $end_time=new Benchmark;
  936. print "Time for update_big ($small_loop_count):  " .
  937.   timestr(timediff($end_time, $loop_time),"all") . "n";
  940. #
  941. # Testing left outer join
  942. #
  944. if ($limits->{'func_odbc_floor'} && $limits->{'left_outer_join'})
  945. {
  946.   if ($opt_lock_tables)
  947.   {
  948.     $sth = $dbh->do("LOCK TABLES bench1 a READ, bench1 b READ") || die $DBI::errstr;
  949.   }
  950.   print "nTesting left outer joinn";
  951.   $loop_time=new Benchmark;
  952.   $count=0;
  953.   for ($i=0 ; $i < $small_loop_count ; $i++)
  954.   {
  955.     $count+=fetch_all_rows($dbh,"select count(*) from bench1 as a left outer join bench1 as b on (a.id2=b.id3)");
  956.   }
  957.   $end_time=new Benchmark;
  958.   print "Time for outer_join_on_key ($small_loop_count:$count):  " .
  959.     timestr(timediff($end_time, $loop_time),"all") . "n";
  961.   $loop_time=new Benchmark;
  962.   $count=0;
  963.   for ($i=0 ; $i < $small_loop_count ; $i++)
  964.   {
  965.     $count+=fetch_all_rows($dbh,"select count(a.dummy1),count(b.dummy1) from bench1 as a left outer join bench1 as b on (a.id2=b.id3)");
  966.   }
  967.   $end_time=new Benchmark;
  968.   print "Time for outer_join ($small_loop_count:$count):  " .
  969.     timestr(timediff($end_time, $loop_time),"all") . "n";
  971.   $count=0;
  972.   $loop_time=new Benchmark;
  973.   for ($i=0 ; $i < $small_loop_count ; $i++)
  974.   {
  975.     $count+=fetch_all_rows($dbh,"select count(a.dummy1),count(b.dummy1) from bench1 as a left outer join bench1 as b on (a.id2=b.id3) where b.id3 is not null");
  976.   }
  977.   $end_time=new Benchmark;
  978.   print "Time for outer_join_found ($small_loop_count:$count):  " .
  979.     timestr(timediff($end_time, $loop_time),"all") . "n";
  981.   $count=$estimated=0;
  982.   $loop_time=new Benchmark;
  983.   for ($i=1 ; $i <= $small_loop_count ; $i++)
  984.   {
  985.     $count+=fetch_all_rows($dbh,"select count(a.dummy1),count(b.dummy1) from bench1 as a left outer join bench1 as b on (a.id2=b.id3) where b.id3 is null");
  986.     $end_time=new Benchmark;
  987.     last if ($estimated=predict_query_time($loop_time,$end_time,
  988.    $count,$i,
  989.    $range_loop_count));
  990.   }
  991.   if ($estimated)
  992.   { print "Estimated time"; }
  993.   else
  994.   { print "Time"; }
  995.   print " for outer_join_not_found ($range_loop_count:$count):  " .
  996.     timestr(timediff($end_time, $loop_time),"all") . "n";
  998.   if ($opt_lock_tables)
  999.   {
  1000.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  1001.   }
  1002. }
  1004. if ($server->small_rollback_segment())
  1005. {
  1006.   $dbh->disconnect; # close connection
  1007.   $dbh = $server->connect();
  1008. }
  1010. ###
  1011. ### Test speed of IN( value list)
  1012. ###
  1014. if ($limits->{'left_outer_join'})
  1015. {
  1016.   if ($opt_lock_tables)
  1017.   {
  1018.     $sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
  1019.   }
  1020.   print "n";
  1021.   do_many($dbh,$server->create("bench2",
  1022.        ["id int NOT NULL"],
  1023.        ["primary key (id)"]));
  1025.   $max_tests=min(($limits->{'query_size'}-50)/6, $opt_loop_count);
  1027.   if ($opt_lock_tables)
  1028.   {
  1029.     $sth = $dbh->do("LOCK TABLES bench1 READ, bench2 WRITE") ||
  1030.       die $DBI::errstr;
  1031.   }
  1032.   test_where_in("bench1","bench2","id",1,10);
  1033.   test_where_in("bench1","bench2","id",11,min(100,$max_tests));
  1034.   test_where_in("bench1","bench2","id",101,min(1000,$max_tests));
  1035.   if ($opt_lock_tables)
  1036.   {
  1037.     $sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
  1038.   }
  1039.   $sth = $dbh->do("DROP TABLE bench2" . $server->{'drop_attr'}) ||
  1040.     die $DBI::errstr;
  1041.   if ($opt_lock_tables)
  1042.   {
  1043.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  1044.   }
  1045. }
  1047. ####
  1048. #### Test INSERT INTO ... SELECT
  1049. ####
  1051. if ($limits->{'insert_select'})
  1052. {
  1053.   if ($opt_lock_tables)
  1054.   {
  1055.     $sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
  1056.   }
  1057.   print "nTesting INSERT INTO ... SELECTn";
  1058.   do_many($dbh,$server->create("bench2",
  1059.        ["id int NOT NULL",
  1060. "id2 int NOT NULL",
  1061. "id3 int NOT NULL",
  1062. "dummy1 char(30)"],
  1063.        ["primary key (id,id2)"]));
  1064.   do_many($dbh,$server->create("bench3",
  1065.        ["id int NOT NULL",
  1066. "id2 int NOT NULL",
  1067. "id3 int NOT NULL",
  1068. "dummy1 char(30)"],
  1069.        ["primary key (id,id2)",
  1070. "index index_id3 (id3)"]));
  1071.   $loop_time=new Benchmark;
  1072.   $sth = $dbh->do("INSERT INTO bench2 SELECT * from bench1") ||
  1073.     die $DBI::errstr;
  1074.   $end_time=new Benchmark;
  1075.   print "Time for insert_select_1_key (1):  " .
  1076.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1077.   $loop_time=new Benchmark;
  1078.   $sth = $dbh->do("INSERT INTO bench3 SELECT * from bench1") ||
  1079.     die $DBI::errstr;
  1080.   $end_time=new Benchmark;
  1081.   print "Time for insert_select_2_keys (1):  " .
  1082.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1083.   $loop_time=new Benchmark;
  1084.   $sth = $dbh->do("DROP TABLE bench2" . $server->{'drop_attr'}) ||
  1085.     die $DBI::errstr;
  1086.   $sth = $dbh->do("DROP TABLE bench3" . $server->{'drop_attr'}) ||
  1087.     die $DBI::errstr;
  1088.   $end_time=new Benchmark;
  1089.   print "Time for drop table(2): " .
  1090.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1092.   if ($opt_fast && defined($server->{vacuum}))
  1093.   {
  1094.     $server->vacuum(1,$dbh);
  1095.   }
  1096.   if ($server->small_rollback_segment())
  1097.   {
  1098.     $dbh->disconnect; # close connection
  1099.     $dbh = $server->connect();
  1100.   }
  1101.   if ($opt_lock_tables)
  1102.   {
  1103.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  1104.   }
  1105. }
  1107. ####
  1108. #### Do some deletes on the table
  1109. ####
  1111. if (!$opt_skip_delete)
  1112. {
  1113.   print "nTesting deleten";
  1114.   $loop_time=new Benchmark;
  1115.   $count=0;
  1116.   for ($i=0 ; $i < $opt_loop_count ; $i+=10)
  1117.   {
  1118.     $count++;
  1119.     $tmp=$opt_loop_count+$random[$i]; # $opt_loop_count*2 <= $tmp < $total_rows
  1120.     $dbh->do("delete from bench1 where id3=$tmp") or die $DBI::errstr;
  1121.   }
  1123.   $end_time=new Benchmark;
  1124.   print "Time for delete_key ($count): " .
  1125.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1127.   if ($server->small_rollback_segment())
  1128.   {
  1129.     $dbh->disconnect; # close connection
  1130.     $dbh = $server->connect();
  1131.   }
  1133.   $count=0;
  1134.   $loop_time=new Benchmark;
  1135.   for ($i= 0 ; $i < $opt_loop_count ; $i+=$opt_loop_count/10)
  1136.   {
  1137.     $sth=$dbh->do("delete from bench1 where id3 >= 0 and id3 <= $i") or die $DBI::errstr;
  1138.     $count++;
  1139.   }
  1140.   $count+=2;
  1141.   if ($server->small_rollback_segment())
  1142.   {
  1143.     $dbh->disconnect; # close connection
  1144.     $dbh = $server->connect();
  1145.   }
  1146.   $sth=$dbh->do("delete from bench1 where id3 >= 0 and id3 <= $opt_loop_count") or die $DBI::errstr;
  1147.   if ($server->small_rollback_segment())
  1148.   {
  1149.     $dbh->disconnect; # close connection
  1150.     $dbh = $server->connect();
  1151.   }
  1153.   $sth=$dbh->do("delete from bench1 where id >= $opt_loop_count and id <= " . ($opt_loop_count*2) ) or die $DBI::errstr;
  1155.   if ($server->small_rollback_segment())
  1156.   {
  1157.     $dbh->disconnect; # close connection
  1158.     $dbh = $server->connect();
  1159.   }
  1160.   if ($opt_fast)
  1161.   {
  1162.     $sth=$dbh->do("delete from bench1") or die $DBI::errstr;
  1163.   }
  1164.   else
  1165.   {
  1166.     $sth = $dbh->do("delete from bench1 where id3 < " . ($total_rows)) or die $DBI::errstr;
  1167.   }
  1169.   $end_time=new Benchmark;
  1170.   print "Time for delete_all ($count): " .
  1171.     timestr(timediff($end_time, $loop_time),"all") . "nn";
  1173.   if ($opt_lock_tables)
  1174.   {
  1175.     $sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
  1176.   }
  1177.   $sth = $dbh->do("drop table bench1" . $server->{'drop_attr'}) or die $DBI::errstr;
  1178. }
  1180. if ($server->small_rollback_segment())
  1181. {
  1182.   $dbh->disconnect; # close connection
  1183.   $dbh = $server->connect();
  1184. }
  1185. if ($opt_fast && defined($server->{vacuum}))
  1186. {
  1187.   $server->vacuum(1,$dbh);
  1188. }
  1191. keys_test:
  1192. #
  1193. # Test of insert in table with many keys
  1194. # This test assumes that the server really create the keys!
  1195. #
  1197. my @fields=(); my @keys=();
  1198. $keys=min($limits->{'max_index'},16);   # 16 is more than enough
  1199. $seg= min($limits->{'max_index_parts'},$keys,16); # 16 is more than enough
  1201. print "Insert into table with $keys keys and with a primary key with $seg partsn";
  1203. # Make keys on the most important types
  1204. @types=(0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,1,1); # A 1 for each char field
  1205. push(@fields,"field1 tinyint not null");
  1206. push(@fields,"field2 mediumint not null");
  1207. push(@fields,"field3 smallint not null");
  1208. push(@fields,"field4 char(16) not null");
  1209. push(@fields,"field5 integer not null");
  1210. push(@fields,"field6 float not null");
  1211. push(@fields,"field7 double not null");
  1212. for ($i=8 ; $i <= $keys ; $i++)
  1213. {
  1214.   push(@fields,"field$i char(6) not null"); # Should be relatively fair
  1215. }
  1217. # First key contains many segments
  1218. $query="primary key (";
  1219. for ($i= 1 ; $i <= $seg ; $i++)
  1220. {
  1221.   $query.= "field$i,";
  1222. }
  1223. substr($query,-1)=")";
  1224. push (@keys,$query);
  1226. #Create other keys
  1227. for ($i=2 ; $i <= $keys ; $i++)
  1228. {
  1229.   push(@keys,"index index$i (field$i)");
  1230. }
  1232. do_many($dbh,$server->create("bench1",@fields,@keys));
  1233. if ($opt_lock_tables)
  1234. {
  1235.   $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  1236. }
  1238. if ($server->small_rollback_segment())
  1239. {
  1240.   $dbh->disconnect; # close connection
  1241.   $dbh = $server->connect();
  1242. }
  1244. $loop_time=new Benchmark;
  1245. $fields=$#fields;
  1246. if (($opt_fast || $opt_fast_insert) && $server->{'limits'}->{'insert_multi_value'})
  1247. {
  1248.   $query_size=$server->{'limits'}->{'query_size'};
  1249.   $query="insert into bench1 values ";
  1250.   $res=$query;
  1251.   for ($i=0; $i < $many_keys_loop_count; $i++)
  1252.   {
  1253.     $rand=$random[$i];
  1254.     $tmp="(" . ($i & 127) . ",$rand," . ($i & 32766) .
  1255.       ",'ABCDEF$rand',0,";
  1257.     for ($j=5; $j <= $fields ; $j++)
  1258.     {
  1259.       $tmp.= ($types[$j] == 0) ? "$rand," : "'$rand',";
  1260.     }
  1261.     substr($tmp,-1)=")";
  1262.     if (length($tmp)+length($res) < $query_size)
  1263.     {
  1264.       $res.= $tmp . ",";
  1265.     }
  1266.     else
  1267.     {
  1268.       $sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
  1269.       $res=$query . $tmp . ",";
  1270.     }
  1271.   }
  1272.   $sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
  1273. }
  1274. else
  1275. {
  1276.   for ($i=0; $i < $many_keys_loop_count; $i++)
  1277.   {
  1278.     $rand=$random[$i];
  1279.     $query="insert into bench1 values (" . ($i & 127) . ",$rand," . ($i & 32767) .
  1280.       ",'ABCDEF$rand',0,";
  1282.     for ($j=5; $j <= $fields ; $j++)
  1283.     {
  1284.       $query.= ($types[$j] == 0) ? "$rand," : "'$rand',";
  1285.     }
  1286.     substr($query,-1)=")";
  1287.     print "query1: $queryn" if ($opt_debug);
  1288.     $dbh->do($query) or die "Got error $DBI::errstr with query: $queryn";
  1289.   }
  1290. }
  1291. $end_time=new Benchmark;
  1292. print "Time for insert_key ($many_keys_loop_count): " .
  1293.   timestr(timediff($end_time, $loop_time),"all") . "nn";
  1295. if ($server->small_rollback_segment())
  1296. {
  1297.   $dbh->disconnect; # close connection
  1298.   $dbh = $server->connect();
  1299. }
  1300. if ($opt_fast && defined($server->{vacuum}))
  1301. {
  1302.   if ($opt_lock_tables)
  1303.   {
  1304.     do_query($dbh,"UNLOCK TABLES");
  1305.   }
  1306.   $server->vacuum(1,$dbh,"bench1");
  1307.   if ($opt_lock_tables)
  1308.   {
  1309.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  1310.   }
  1311. }
  1313. #
  1314. # update one key of the above
  1315. #
  1317. print "Testing update of keysn";
  1318. $loop_time=new Benchmark;
  1319. for ($i=0 ; $i< 256; $i++)
  1320. {
  1321.   $dbh->do("update bench1 set field5=1 where field1=$i")
  1322.     or die "Got error $DBI::errstr with query: update bench1 set field5=1 where field1=$in";
  1323. }
  1324. $end_time=new Benchmark;
  1325. print "Time for update_of_primary_key_many_keys (256): " .
  1326.   timestr(timediff($end_time, $loop_time),"all") . "nn";
  1328. if ($server->small_rollback_segment())
  1329. {
  1330.   $dbh->disconnect; # close connection
  1331.   $dbh = $server->connect();
  1332. }
  1333. if ($opt_fast && defined($server->{vacuum}))
  1334. {
  1335.   if ($opt_lock_tables)
  1336.   {
  1337.     do_query($dbh,"UNLOCK TABLES");
  1338.   }
  1339.   $server->vacuum(1,$dbh,"bench1");
  1340.   if ($opt_lock_tables)
  1341.   {
  1342.     $sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
  1343.   }
  1344. }
  1346. if ($server->small_rollback_segment())
  1347. {
  1348.   $dbh->disconnect; # close connection
  1349.   $dbh = $server->connect();
  1350. }
  1352. #
  1353. # Delete everything from table
  1354. #
  1356. print "Deleting rows from the tablen";
  1357. $loop_time=new Benchmark;
  1358. $count=0;
  1360. for ($i=0 ; $i < 128 ; $i++)
  1361. {
  1362.   $count++;
  1363.   $dbh->do("delete from bench1 where field1 = $i") or die $DBI::errstr;
  1364. }
  1366. $end_time=new Benchmark;
  1367. print "Time for delete_big_many_keys ($count): " .
  1368. timestr(timediff($end_time, $loop_time),"all") . "nn";
  1370. print "Deleting everything from tablen";
  1371. $count=1;
  1372. if ($opt_fast)
  1373. {
  1374.   $dbh->do("delete from bench1") or die $DBI::errstr;
  1375. }
  1376. else
  1377. {
  1378.   $dbh->do("delete from bench1 where field1 > 0") or die $DBI::errstr;
  1379. }
  1381. if ($opt_lock_tables)
  1382. {
  1383.   $sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
  1384. }
  1386. $end_time=new Benchmark;
  1387. print "Time for delete_all_many_keys ($count): " .
  1388.   timestr(timediff($end_time, $loop_time),"all") . "nn";
  1390. $sth = $dbh->do("drop table bench1" . $server->{'drop_attr'}) or die $DBI::errstr;
  1391. if ($opt_fast && defined($server->{vacuum}))
  1392. {
  1393.   $server->vacuum(1,$dbh);
  1394. }
  1396. #
  1397. # Test multi value inserts if the server supports it
  1398. #
  1400. if ($limits->{'insert_multi_value'})
  1401. {
  1402.   $query_size=$limits->{'query_size'}; # Same limit for all databases
  1404.   $sth = $dbh->do("drop table bench1" . $server->{'drop_attr'});
  1405.   do_many($dbh,$server->create("bench1",
  1406.        ["id int NOT NULL",
  1407. "id2 int NOT NULL",
  1408. "id3 int NOT NULL",
  1409. "dummy1 char(30)"],
  1410.        ["primary key (id,id2)",
  1411.        "index index_id3 (id3)"]));
  1412.   if ($opt_lock_tables)
  1413.   {
  1414.     $sth = $dbh->do("LOCK TABLES bench1 write") || die $DBI::errstr;
  1415.   }
  1417.   $loop_time=new Benchmark;
  1418.   print "Inserting $opt_loop_count rows with multiple valuesn";
  1419.   $query="insert into bench1 values ";
  1420.   $res=$query;
  1421.   for ($i=0 ; $i < $opt_loop_count ; $i++)
  1422.   {
  1423.     my $tmp= "($i,$i,$i,'EFGHIJKLM'),";
  1424.     if (length($i)+length($res) < $query_size)
  1425.     {
  1426.       $res.= $tmp;
  1427.     }
  1428.     else
  1429.     {
  1430.       do_query($dbh,substr($res,0,length($res)-1));
  1431.       $res=$query .$tmp;
  1432.     }
  1433.   }
  1434.   do_query($dbh,substr($res,0,length($res)-1));
  1436.   if ($opt_lock_tables)
  1437.   {
  1438.     $sth = $dbh->do("UNLOCK TABLES ") || die $DBI::errstr;
  1439.   }
  1441.   $end_time=new Benchmark;
  1442.   print "Time for multiple_value_insert (" . ($opt_loop_count) . "): " .
  1443.     timestr(timediff($end_time, $loop_time),"all") . "nn";
  1445.   if ($opt_lock_tables)
  1446.   {
  1447.     $sth = $dbh->do("UNLOCK TABLES ") || die $DBI::errstr;
  1448.   }
  1450.   # A big table may take a while to drop
  1451.   $loop_time=new Benchmark;
  1452.   $sth = $dbh->do("drop table bench1" . $server->{'drop_attr'}) or die $DBI::errstr;
  1453.   $end_time=new Benchmark;
  1454.   print "Time for drop table(1): " .
  1455.     timestr(timediff($end_time, $loop_time),"all") . "nn";
  1456. }
  1458. ####
  1459. #### End of benchmark
  1460. ####
  1462. $dbh->disconnect; # close connection
  1464. end_benchmark($start_time);
  1466. ###
  1467. ### Some help functions
  1468. ###
  1471. # Do some sample selects on direct key
  1472. # First select finds a row, the second one doesn't find.
  1474. sub check_select_key
  1475. {
  1476.   my ($sel_columns,$column,$check)= @_;
  1477.   my ($loop_time,$end_time,$i,$tmp_var,$tmp,$count,$row_count,$estimated);
  1479.   $estimated=0;
  1480.   $loop_time=new Benchmark;
  1481.   $count=0;
  1482.   for ($i=1 ; $i <= $opt_read_key_loop_count; $i++)
  1483.   {
  1484.     $count+=2;
  1485.     $tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
  1486.     $tmp=$tmpvar % ($total_rows);
  1487.     fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp")
  1488.       or die $DBI::errstr;
  1489.     $tmp+=$total_rows;
  1490.     defined($row_count=fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp")) or die $DBI::errstr;
  1491.     die "Found $row_count rows on impossible id: $tmpn" if ($row_count);
  1492.     $end_time=new Benchmark;
  1493.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$i,
  1494.    $opt_loop_count));
  1495.   }
  1496.   if ($estimated)
  1497.   { print "Estimated time"; }
  1498.   else
  1499.   { print "Time"; }
  1500.   print " for $check ($count): " .
  1501.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1502. }
  1504. # Same as above, but select on 2 columns
  1506. sub check_select_key2
  1507. {
  1508.   my ($sel_columns,$column,$column2,$check)= @_;
  1509.   my ($loop_time,$end_time,$i,$tmp_var,$tmp,$count,$row_count,$estimated);
  1511.   $estimated=0;
  1512.   $loop_time=new Benchmark;
  1513.   $count=0;
  1514.   for ($i=1 ; $i <= $opt_read_key_loop_count; $i++)
  1515.   {
  1516.     $count+=2;
  1517.     $tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
  1518.     $tmp=$tmpvar % ($total_rows);
  1519.     fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp and $column2=$tmp")
  1520.       or die $DBI::errstr;
  1521.     $tmp+=$total_rows;
  1522.     defined($row_count=fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp and $column2=$tmp")) or die $DBI::errstr;
  1523.     die "Found $row_count rows on impossible id: $tmpn" if ($row_count);
  1524.     $end_time=new Benchmark;
  1525.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$i,
  1526.    $opt_loop_count));
  1527.   }
  1528.   if ($estimated)
  1529.   { print "Estimated time"; }
  1530.   else
  1531.   { print "Time"; }
  1532.   print " for $check ($count): " .
  1533.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1534. }
  1536. #
  1537. # Search using some very simple queries
  1538. #
  1540. sub check_select_range
  1541. {
  1542.   my ($column,$check)= @_;
  1543.   my ($loop_time,$end_time,$i,$tmp_var,$tmp,$query,$rows,$estimated);
  1545.   $estimated=0;
  1546.   $loop_time=new Benchmark;
  1547.   $found=$count=0;
  1548.   for ($test=1 ; $test <= $range_loop_count; $test++)
  1549.   {
  1550.     $count+=$#Q+1;
  1551.     for ($i=0 ; $i < $#Q ; $i+=2)
  1552.     {
  1553.       $query=$Q[$i];
  1554.       $rows=$Q[$i+1];
  1555.       $query =~ s/!id!/$column/g;
  1556.       if (($row_count=fetch_all_rows($dbh,$query)) != $rows)
  1557.       {
  1558. if ($row_count == undef())
  1559. {
  1560.   die "Got error: $DBI::errstr when executing $queryn";
  1561. }
  1562. die "'$query' returned wrong number of rows: $row_count instead of $rowsn";
  1563.       }
  1564.       $found+=$row_count;
  1565.     }
  1566.     $end_time=new Benchmark;
  1567.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$test,
  1568.    $range_loop_count));
  1569.   }
  1570.   if ($estimated)
  1571.   { print "Estimated time"; }
  1572.   else
  1573.   { print "Time"; }
  1574.   print " for $check ($count:$found): " .
  1575.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1576. }
  1579. #
  1580. # SELECT * from bench where col=x or col=x or col=x ...
  1583. sub check_or_range
  1584. {
  1585.   my ($column,$check)= @_;
  1586.   my ($loop_time,$end_time,$i,$tmp_var,$tmp,$columns,$estimated,$found,
  1587.       $or_part,$count,$loop_count);
  1589.   $columns=min($limits->{'max_columns'},50,($limits->{'query_size'}-50)/13);
  1590.   $columns=$columns- ($columns % 4); # Make Divisible by 4
  1592.   $estimated=0;
  1593.   $loop_time=new Benchmark;
  1594.   $found=0;
  1595.   # The number of tests must be divisible by the following
  1596.   $tmp= $limits->{'func_extra_in_num'} ? 15 : 10; 
  1597.   # We need to calculate the exact number of test to make 'Estimated' right
  1598.   $loop_count=$range_loop_count*10+$tmp-1;
  1599.   $loop_count=$loop_count- ($loop_count % $tmp);
  1600.   
  1601.   for ($count=0 ; $count < $loop_count ; )
  1602.   {
  1603.     for ($rowcnt=0; $rowcnt <= $columns; $rowcnt+= $columns/4)
  1604.     {
  1605.       my $query="select * from bench1 where ";
  1606.       my $or_part= "$column = 1";
  1607.       $count+=2;
  1609.       for ($i=1 ; $i < $rowcnt ; $i++)
  1610.       {
  1611. $tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
  1612. $tmp=$tmpvar % ($opt_loop_count*4);
  1613. $or_part.=" or $column=$tmp";
  1614.       }
  1615.       print $query . $or_part . "n" if ($opt_debug);
  1616.       ($rows=fetch_all_rows($dbh,$query . $or_part)) or die $DBI::errstr;
  1617.       $found+=$rows;
  1619.       if ($limits->{'func_extra_in_num'})
  1620.       {
  1621. my $in_part=$or_part; # Same query, but use 'func_extra_in_num' instead.
  1622. $in_part=~ s/ = / IN (/;
  1623. $in_part=~ s/ or $column=/,/g;
  1624. $in_part.= ")";
  1625. fetch_all_rows($dbh,$query . $in_part) or die $DBI::errstr;
  1626. $count++;
  1627.       }
  1628.       # Do it a little harder by setting a extra range
  1629.       defined(($rows=fetch_all_rows($dbh,"$query($or_part) and $column < 10"))) or die $DBI::errstr;
  1630.       $found+=$rows;
  1631.     }
  1632.     $end_time=new Benchmark;
  1633.     last if ($estimated=predict_query_time($loop_time,$end_time,$count,$count,
  1634.    $loop_count));
  1635.   }
  1637.   if ($estimated)
  1638.   { print "Estimated time"; }
  1639.   else
  1640.   { print "Time"; }
  1641.   print " for $check ($count:$found): " .
  1642.     timestr(timediff($end_time, $loop_time),"all") . "n";
  1643. }
  1645. #
  1646. # General test of SELECT ... WHERE id in(value-list)
  1647. #
  1649. sub test_where_in
  1650. {
  1651.   my ($t1,$t2,$id,$from,$to)= @_;
  1653.   return if ($from >= $to);
  1655.   $query="SELECT $t1.* FROM $t1 WHERE $id IN (";
  1656.   for ($i=1 ; $i <= $to ; $i++)
  1657.   {
  1658.     $query.="$i,";
  1659.   }
  1660.   $query=substr($query,0,length($query)-1) . ")";
  1662.   # Fill join table to have the same id's as 'query'
  1663.   for ($i= $from ; $i <= $to ; $i++)
  1664.   {
  1665.     $dbh->do("insert into $t2 values($i)") or die $DBI::errstr;
  1666.   }
  1667.   if ($opt_fast && defined($server->{vacuum}))
  1668.   {
  1669.     $server->vacuum(1,$dbh,"bench1");
  1670.   }
  1672.   time_fetch_all_rows("Testing SELECT ... WHERE id in ($to values)",
  1673.       "select_in", $query, $dbh,
  1674.       $range_loop_count);
  1675.   time_fetch_all_rows(undef, "select_join_in",
  1676.       "SELECT $t1.* FROM $t2 left outer join $t1 on ($t1.$id=$t2.$id)",
  1677.        $dbh, $range_loop_count);
  1678. }