mirror of
https://github.com/MariaDB/server.git
synced 2025-01-19 13:32:33 +01:00
f0ae3ce9b9
Fixed compile-pentium64 scripts Fixed wrong estimate of update_with_key_prefix in sql-bench Merge bk-internal.mysql.com:/home/bk/mysql-5.1 into mysql.com:/home/my/mysql-5.1 Fixed unsafe define of uint4korr() Fixed that --extern works with mysql-test-run.pl Small trivial cleanups This also fixes a bug in counting number of rows that are updated when we have many simultanous queries Move all connection handling and command exectuion main loop from sql_parse.cc to sql_connection.cc Split handle_one_connection() into reusable sub functions. Split create_new_thread() into reusable sub functions. Added thread_scheduler; Preliminary interface code for future thread_handling code. Use 'my_thread_id' for internal thread id's Make thr_alarm_kill() to depend on thread_id instead of thread Make thr_abort_locks_for_thread() depend on thread_id instead of thread In store_globals(), set my_thread_var->id to be thd->thread_id. Use my_thread_var->id as basis for my_thread_name() The above changes makes the connection we have between THD and threads more soft. Added a lot of DBUG_PRINT() and DBUG_ASSERT() functions Fixed compiler warnings Fixed core dumps when running with --debug Removed setting of signal masks (was never used) Made event code call pthread_exit() (portability fix) Fixed that event code doesn't call DBUG_xxx functions before my_thread_init() is called. Made handling of thread_id and thd->variables.pseudo_thread_id uniform. Removed one common 'not freed memory' warning from mysqltest Fixed a couple of usage of not initialized warnings (unlikely cases) Suppress compiler warnings from bdb and (for the moment) warnings from ndb
1801 lines
49 KiB
Bash
1801 lines
49 KiB
Bash
#!@PERL@
|
|
# Copyright (C) 2000-2003 MySQL AB
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Library General Public
|
|
# License as published by the Free Software Foundation; version 2
|
|
# of the License.
|
|
#
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Library General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Library General Public
|
|
# License along with this library; if not, write to the Free
|
|
# Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
|
|
# MA 02111-1307, USA
|
|
#
|
|
# Test of creating a simple table and inserting $record_count records in it,
|
|
# $opt_loop_count rows in order, $opt_loop_count rows in reverse order and
|
|
# $opt_loop_count rows in random order
|
|
#
|
|
# changes made for Oracle compatibility
|
|
# - $limits->{'func_odbc_mod'} is OK from crash-me, but it fails here so set we
|
|
# set it to 0 in server-cfg
|
|
# - the default server config runs out of rollback segments, so we added a
|
|
# couple of disconnect/connects to reset
|
|
#
|
|
##################### Standard benchmark inits ##############################
|
|
|
|
use Cwd;
|
|
use DBI;
|
|
use Benchmark;
|
|
use Data::Dumper;
|
|
|
|
$opt_loop_count=100000; # number of rows/3
|
|
$small_loop_count=10; # Loop for full table retrieval
|
|
$range_loop_count=$small_loop_count*50;
|
|
$many_keys_loop_count=$opt_loop_count;
|
|
$opt_read_key_loop_count=$opt_loop_count;
|
|
|
|
$pwd = cwd(); $pwd = "." if ($pwd eq '');
|
|
require "$pwd/bench-init.pl" || die "Can't read Configuration file: $!\n";
|
|
|
|
if ($opt_small_test)
|
|
{
|
|
$opt_loop_count/=100;
|
|
$many_keys_loop_count=$opt_loop_count/10;
|
|
$range_loop_count=10;
|
|
$opt_read_key_loop_count=10;
|
|
}
|
|
elsif ($opt_small_tables)
|
|
{
|
|
$opt_loop_count=10000; # number of rows/3
|
|
$many_keys_loop_count=$opt_loop_count;
|
|
$opt_read_key_loop_count=10;
|
|
}
|
|
elsif ($opt_small_key_tables)
|
|
{
|
|
$many_keys_loop_count/=10;
|
|
}
|
|
|
|
if ($opt_loop_count < 100)
|
|
{
|
|
$opt_loop_count=100; # Some tests must have some data to work!
|
|
}
|
|
$range_loop_count=min($opt_loop_count,$range_loop_count);
|
|
|
|
|
|
print "Testing the speed of inserting data into 1 table and do some selects on it.\n";
|
|
print "The tests are done with a table that has $opt_loop_count rows.\n\n";
|
|
|
|
####
|
|
#### Generating random keys
|
|
####
|
|
|
|
print "Generating random keys\n";
|
|
$random[$opt_loop_count]=0;
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$random[$i]=$i+$opt_loop_count;
|
|
}
|
|
|
|
my $tmpvar=1;
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
|
|
$swap=$tmpvar % $opt_loop_count;
|
|
$tmp=$random[$i]; $random[$i]=$random[$swap]; $random[$swap]=$tmp;
|
|
}
|
|
|
|
$total_rows=$opt_loop_count*3;
|
|
|
|
####
|
|
#### Connect and start timeing
|
|
####
|
|
$start_time=new Benchmark;
|
|
$dbh = $server->connect();
|
|
####
|
|
#### Create needed tables
|
|
####
|
|
|
|
goto keys_test if ($opt_stage == 2);
|
|
goto select_test if ($opt_skip_create);
|
|
|
|
print "Creating tables\n";
|
|
$dbh->do("drop table bench1" . $server->{'drop_attr'});
|
|
$dbh->do("drop table bench2" . $server->{'drop_attr'});
|
|
$dbh->do("drop table bench3" . $server->{'drop_attr'});
|
|
do_many($dbh,$server->create("bench1",
|
|
["id int NOT NULL",
|
|
"id2 int NOT NULL",
|
|
"id3 int NOT NULL",
|
|
"dummy1 char(30)"],
|
|
["primary key (id,id2)",
|
|
"index ix_id3 (id3)"]));
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
|
|
####
|
|
#### Insert $total_rows records in order, in reverse order and random.
|
|
####
|
|
|
|
$loop_time=new Benchmark;
|
|
|
|
if ($opt_fast_insert)
|
|
{
|
|
$query="insert into bench1 values ";
|
|
}
|
|
else
|
|
{
|
|
$query="insert into bench1 (id,id2,id3,dummy1) values ";
|
|
}
|
|
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->{AutoCommit} = 0;
|
|
print "Transactions enabled\n" if ($opt_debug);
|
|
}
|
|
|
|
if (($opt_fast || $opt_fast_insert) && $server->{'limits'}->{'insert_multi_value'})
|
|
{
|
|
$query_size=$server->{'limits'}->{'query_size'};
|
|
|
|
print "Inserting $opt_loop_count multiple-value rows in order\n";
|
|
$res=$query;
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$tmp= "($i,$i,$i,'ABCDEFGHIJ'),";
|
|
if (length($tmp)+length($res) < $query_size)
|
|
{
|
|
$res.= $tmp;
|
|
}
|
|
else
|
|
{
|
|
$sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
|
|
$res=$query . $tmp;
|
|
}
|
|
}
|
|
print "Inserting $opt_loop_count multiple-value rows in reverse order\n";
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$tmp= "(" . ($total_rows-1-$i) . "," .($total_rows-1-$i) .
|
|
"," .($total_rows-1-$i) . ",'BCDEFGHIJK'),";
|
|
if (length($tmp)+length($res) < $query_size)
|
|
{
|
|
$res.= $tmp;
|
|
}
|
|
else
|
|
{
|
|
$sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
|
|
$res=$query . $tmp;
|
|
}
|
|
}
|
|
print "Inserting $opt_loop_count multiple-value rows in random order\n";
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$tmp= "(" . $random[$i] . "," . $random[$i] . "," . $random[$i] .
|
|
",'CDEFGHIJKL')," or die $DBI::errstr;
|
|
if (length($tmp)+length($res) < $query_size)
|
|
{
|
|
$res.= $tmp;
|
|
}
|
|
else
|
|
{
|
|
$sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
|
|
$res=$query . $tmp;
|
|
}
|
|
}
|
|
$sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
|
|
}
|
|
else
|
|
{
|
|
print "Inserting $opt_loop_count rows in order\n";
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$sth = $dbh->do($query . "($i,$i,$i,'ABCDEFGHIJ')") or die $DBI::errstr;
|
|
}
|
|
|
|
print "Inserting $opt_loop_count rows in reverse order\n";
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$sth = $dbh->do($query . "(" . ($total_rows-1-$i) . "," .
|
|
($total_rows-1-$i) . "," .
|
|
($total_rows-1-$i) . ",'BCDEFGHIJK')")
|
|
or die $DBI::errstr;
|
|
}
|
|
|
|
print "Inserting $opt_loop_count rows in random order\n";
|
|
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$sth = $dbh->do($query . "(". $random[$i] . "," . $random[$i] .
|
|
"," . $random[$i] . ",'CDEFGHIJKL')") or die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->commit;
|
|
$dbh->{AutoCommit} = 1;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for insert (" . ($total_rows) . "): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
|
|
}
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
$server->vacuum(1,\$dbh,"bench1");
|
|
}
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
|
|
####
|
|
#### insert $opt_loop_count records with duplicate id
|
|
####
|
|
|
|
if ($limits->{'unique_index'})
|
|
{
|
|
print "Testing insert of duplicates\n";
|
|
$loop_time=new Benchmark;
|
|
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->{AutoCommit} = 0;
|
|
}
|
|
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
$tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
|
|
$tmp=$tmpvar % ($total_rows);
|
|
$tmpquery = "$query ($tmp,$tmp,2,'D')";
|
|
if ($dbh->do($tmpquery))
|
|
{
|
|
die "Didn't get an error when inserting duplicate record $tmp\n";
|
|
}
|
|
}
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->commit;
|
|
$dbh->{AutoCommit} = 1;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for insert_duplicates (" . ($opt_loop_count) . "): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
}
|
|
|
|
|
|
####
|
|
#### Do some selects on the table
|
|
####
|
|
|
|
select_test:
|
|
|
|
# ----------------- prepared+executed/prepared*executed tests
|
|
|
|
print "Test of prepared+execute/once prepared many execute selects\n";
|
|
$loop_time=new Benchmark;
|
|
|
|
for ($i=1 ; $i <= $opt_loop_count ; $i++)
|
|
{
|
|
my ($key_value)=$random[$i];
|
|
my ($query)= "select * from bench1 where id=$key_value";
|
|
print "$query\n" if ($opt_debug);
|
|
$sth = $dbh->prepare($query);
|
|
if (! $sth)
|
|
{
|
|
die "error in prepare select with id = $key_value : $DBI::errstr";
|
|
};
|
|
if (! $sth->execute)
|
|
{
|
|
die "cannot execute prepare select with id = $key_value : $DBI::errstr";
|
|
}
|
|
while ($sth->fetchrow_arrayref) { };
|
|
$sth->finish;
|
|
};
|
|
$end_time=new Benchmark;
|
|
print "Time for prepared_select ($opt_loop_count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$query= "select * from bench1 where id=?";
|
|
$sth = $dbh->prepare($query);
|
|
if (! $sth)
|
|
{
|
|
die "cannot prepare select: $DBI::errstr";
|
|
};
|
|
|
|
for ($i=1 ; $i <= $opt_loop_count ; $i++)
|
|
{
|
|
my ($key_value)=$random[$i];
|
|
$sth->bind_param(1,$key_value);
|
|
print "$query , id = $key_value\n" if ($opt_debug);
|
|
if (! $sth->execute)
|
|
{
|
|
die "cannot execute prepare select with id = $key_value : $DBI::errstr";
|
|
}
|
|
while ($sth->fetchrow_arrayref) { };
|
|
};
|
|
$sth->finish;
|
|
$end_time=new Benchmark;
|
|
print "Time for once_prepared_select ($opt_loop_count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
print "Retrieving data from the table\n";
|
|
$loop_time=new Benchmark;
|
|
$error=0;
|
|
|
|
# It's really a small table, so we can try a select on everything
|
|
|
|
$count=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
if (($found_rows=fetch_all_rows($dbh,"select id from bench1")) !=
|
|
$total_rows)
|
|
{
|
|
if (!$error++)
|
|
{
|
|
print "Warning: Got $found_rows rows when selecting a whole table of " . ($total_rows) . " rows\nContact the database or DBD author!\n";
|
|
}
|
|
}
|
|
$count+=$found_rows;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for select_big ($small_loop_count:$count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
#
|
|
# Do a lot of different ORDER BY queries
|
|
#
|
|
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$rows+=fetch_all_rows($dbh,"select id,id2 from bench1 order by id,id2",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_big_key ($small_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$rows+=fetch_all_rows($dbh,"select id,id2 from bench1 order by id desc, id2 desc",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_big_key_desc ($small_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$rows+=fetch_all_rows($dbh,"select id from bench1 order by id desc",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_big_key_prefix ($small_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$rows+=fetch_all_rows($dbh,"select id3 from bench1 order by id3",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_big_key2 ($small_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
$sel=$limits->{'order_by_unused'} ? "id2" : "*";
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$rows+=fetch_all_rows($dbh,"select $sel from bench1 order by id3",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_big_key_diff ($small_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
$sel=$limits->{'order_by_unused'} ? "id" : "*";
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$rows+=fetch_all_rows($dbh,"select $sel from bench1 order by id2,id3",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_big ($small_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
$sel=$limits->{'order_by_unused'} ? "dummy1" : "dummy1,id3";
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $range_loop_count ; $i++)
|
|
{
|
|
$start=$opt_loop_count/$range_loop_count*$i;
|
|
$end=$start+$i;
|
|
$rows+=fetch_all_rows($dbh,"select $sel from bench1 where id>=$start and id <= $end order by id3",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_range ($range_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$sel=$limits->{'order_by_unused'} ? "dummy1" : "dummy1,id";
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $range_loop_count ; $i++)
|
|
{
|
|
$start=$opt_loop_count/$range_loop_count*$i;
|
|
$end=$start+$i;
|
|
$rows+=fetch_all_rows($dbh,"select $sel from bench1 where id>=$start and id <= $end order by id",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_key_prefix ($range_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$sel=$limits->{'order_by_unused'} ? "id2" : "id2,id3";
|
|
$loop_time=new Benchmark;
|
|
$estimated=$rows=0;
|
|
for ($i=1 ; $i <= $range_loop_count ; $i++)
|
|
{
|
|
$start=$opt_loop_count/$range_loop_count*$i;
|
|
$end=$start+$range_loop_count;
|
|
$rows+=fetch_all_rows($dbh,"select $sel from bench1 where id3>=$start and id3 <= $end order by id3",1);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,$i,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for order_by_key2_diff ($range_loop_count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
#
|
|
# Test of select on 2 different keys with or
|
|
# (In this case database can only use keys if they do an automatic union).
|
|
#
|
|
|
|
$loop_time=new Benchmark;
|
|
$estimated=0;
|
|
$rows=0;
|
|
$count=0;
|
|
for ($i=1 ; $i <= $range_loop_count ; $i++)
|
|
{
|
|
my $rnd=$i;
|
|
my $rnd2=$random[$i];
|
|
$rows+=fetch_all_rows($dbh,"select id2 from bench1 where id=$rnd or id3=$rnd2",1);
|
|
$count++;
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$count,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for select_diff_key ($count:$rows): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
# Test select that is very popular when using ODBC
|
|
|
|
check_or_range("id","select_range_prefix");
|
|
check_or_range("id3","select_range_key2");
|
|
|
|
# Check reading on direct key on id and id3
|
|
|
|
check_select_key("*","id","select_key_prefix");
|
|
check_select_key2("*","id","id2","select_key");
|
|
check_select_key2("id,id2","id","id2","select_key_return_key");
|
|
check_select_key("*","id3","select_key2");
|
|
check_select_key("id3","id3","select_key2_return_key");
|
|
check_select_key("id,id2","id3","select_key2_return_prim");
|
|
|
|
####
|
|
#### A lot of simple selects on ranges
|
|
####
|
|
|
|
@Q=("select * from bench1 where !id!=3 or !id!=2 or !id!=1 or !id!=4 or !id!=16 or !id!=10",
|
|
6,
|
|
"select * from bench1 where !id!>=" . ($total_rows-1) ." or !id!<1",
|
|
2,
|
|
"select * from bench1 where !id!>=1 and !id!<=2",
|
|
2,
|
|
"select * from bench1 where (!id!>=1 and !id!<=2) or (!id!>=1 and !id!<=2)",
|
|
2,
|
|
"select * from bench1 where !id!>=1 and !id!<=10 and !id!<=5",
|
|
5,
|
|
"select * from bench1 where (!id!>0 and !id!<2) or !id!>=" . ($total_rows-1),
|
|
2,
|
|
"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),
|
|
5,
|
|
"select * from bench1 where (!id!>=5 and !id!<=10) or (!id!>=1 and !id!<=4)",
|
|
10,
|
|
"select * from bench1 where (!id!=1 or !id!=2) and (!id!=3 or !id!=4)",
|
|
0,
|
|
"select * from bench1 where (!id!=1 or !id!=2) and (!id!=2 or !id!=3)",
|
|
1,
|
|
"select * from bench1 where (!id!=1 or !id!=5 or !id!=20 or !id!=40) and (!id!=1 or !id!>=20 or !id!=4)",
|
|
3,
|
|
"select * from bench1 where ((!id!=1 or !id!=3) or (!id!>1 and !id!<3)) and !id!<=2",
|
|
2,
|
|
"select * from bench1 where (!id! >= 0 and !id! < 4) or (!id! >=4 and !id! < 6)",
|
|
6,
|
|
"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)",
|
|
9,
|
|
"select * from bench1 where (!id!>=1 and !id!<=2 or !id!>=4 and !id!<=5) or (!id!>=0 and !id! <=10)",
|
|
11,
|
|
"select * from bench1 where (!id!>=1 and !id!<=2 or !id!>=4 and !id!<=5) or (!id!>2 and !id! <=10)",
|
|
10,
|
|
"select * from bench1 where (!id!>1 or !id! <1) and !id!<=2",
|
|
2,
|
|
"select * from bench1 where !id! <= 2 and (!id!>1 or !id! <=1)",
|
|
3,
|
|
"select * from bench1 where (!id!>=1 or !id! <1) and !id!<=2",
|
|
3,
|
|
"select * from bench1 where (!id!>=1 or !id! <=2) and !id!<=2",
|
|
3
|
|
);
|
|
|
|
print "\nTest of compares with simple ranges\n";
|
|
check_select_range("id","select_range_prefix");
|
|
check_select_range("id3","select_range_key2");
|
|
|
|
####
|
|
#### Some group queries
|
|
####
|
|
|
|
if ($limits->{'group_functions'})
|
|
{
|
|
$loop_time=new Benchmark;
|
|
$count=1;
|
|
|
|
$estimated=0;
|
|
for ($tests=0 ; $tests < $small_loop_count ; $tests++)
|
|
{
|
|
$sth=$dbh->prepare($query="select count(*) from bench1") or die $DBI::errstr;
|
|
$sth->execute or die $sth->errstr;
|
|
if (($sth->fetchrow_array)[0] != $total_rows)
|
|
{
|
|
print "Warning: '$query' returned wrong result\n";
|
|
}
|
|
$sth->finish;
|
|
|
|
# min, max in keys are very normal
|
|
$count+=7;
|
|
fetch_all_rows($dbh,"select min(id) from bench1");
|
|
fetch_all_rows($dbh,"select max(id) from bench1");
|
|
fetch_all_rows($dbh,"select sum(id+0.0) from bench1");
|
|
fetch_all_rows($dbh,"select min(id3),max(id3),sum(id3-0.0) from bench1");
|
|
if ($limits->{'group_func_sql_min_str'})
|
|
{
|
|
fetch_all_rows($dbh,"select min(dummy1),max(dummy1) from bench1");
|
|
}
|
|
$count++;
|
|
$sth=$dbh->prepare($query="select count(*) from bench1 where id >= " .
|
|
($opt_loop_count*2)) or die $DBI::errstr;
|
|
$sth->execute or die $DBI::errstr;
|
|
if (($sth->fetchrow_array)[0] != $opt_loop_count)
|
|
{
|
|
print "Warning: '$query' returned wrong result\n";
|
|
}
|
|
$sth->finish;
|
|
|
|
$count++;
|
|
$sth=$dbh->prepare($query="select count(*),sum(id+0.0),min(id),max(id),avg(id-0.0) from bench1") or die $DBI::errstr;
|
|
$sth->execute or die $DBI::errstr;
|
|
@row=$sth->fetchrow_array;
|
|
if ($row[0] != $total_rows ||
|
|
int($row[1]+0.5) != int((($total_rows-1)/2*$total_rows)+0.5) ||
|
|
$row[2] != 0 ||
|
|
$row[3] != $total_rows-1 ||
|
|
1-$row[4]/(($total_rows-1)/2) > 0.001)
|
|
{
|
|
# PostgreSQL 6.3 fails here
|
|
print "Warning: '$query' returned wrong result: @row\n";
|
|
}
|
|
$sth->finish;
|
|
|
|
if ($limits->{'func_odbc_mod'})
|
|
{
|
|
$tmp="mod(id,10)";
|
|
if ($limits->{'func_extra_%'})
|
|
{
|
|
$tmp="id % 10"; # For postgreSQL
|
|
}
|
|
$count++;
|
|
if ($limits->{'group_by_alias'}) {
|
|
if (fetch_all_rows($dbh,$query=$server->query("select $tmp as last_digit,count(*) from bench1 group by last_digit")) != 10)
|
|
{
|
|
print "Warning: '$query' returned wrong number of rows\n";
|
|
}
|
|
} elsif ($limits->{'group_by_position'}) {
|
|
if (fetch_all_rows($dbh,$query=$server->query("select $tmp,count(*) from bench1 group by 1")) != 10)
|
|
{
|
|
print "Warning: '$query' returned wrong number of rows\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($limits->{'order_by_position'} && $limits->{'group_by_position'})
|
|
{
|
|
$count++;
|
|
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)
|
|
{
|
|
print "Warning: '$query' returned wrong number of rows\n";
|
|
}
|
|
}
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$tests,
|
|
$small_loop_count));
|
|
}
|
|
print_time($estimated);
|
|
print " for select_group ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=$estimated=0;
|
|
for ($tests=1 ; $tests <= $range_loop_count*5 ; $tests++)
|
|
{
|
|
$count+=6;
|
|
fetch_all_rows($dbh,"select min(id) from bench1");
|
|
fetch_all_rows($dbh,"select max(id) from bench1");
|
|
fetch_all_rows($dbh,"select min(id2) from bench1 where id=$tests");
|
|
fetch_all_rows($dbh,"select max(id2) from bench1 where id=$tests");
|
|
if ($limits->{'group_func_sql_min_str'})
|
|
{
|
|
fetch_all_rows($dbh,"select min(dummy1) from bench1 where id=$tests");
|
|
fetch_all_rows($dbh,"select max(dummy1) from bench1 where id=$tests");
|
|
}
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$tests,
|
|
$range_loop_count*5));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for min_max_on_key ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=$estimated=0;
|
|
for ($tests=1 ; $tests <= $small_loop_count ; $tests++)
|
|
{
|
|
$count+=6;
|
|
fetch_all_rows($dbh,"select min(id2) from bench1");
|
|
fetch_all_rows($dbh,"select max(id2) from bench1");
|
|
fetch_all_rows($dbh,"select min(id3) from bench1 where id2=$tests");
|
|
fetch_all_rows($dbh,"select max(id3) from bench1 where id2=$tests");
|
|
if ($limits->{'group_func_sql_min_str'})
|
|
{
|
|
fetch_all_rows($dbh,"select min(dummy1) from bench1 where id2=$tests");
|
|
fetch_all_rows($dbh,"select max(dummy1) from bench1 where id2=$tests");
|
|
}
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$tests,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for min_max ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
$total=$opt_loop_count*3;
|
|
for ($tests=0 ; $tests < $total ; $tests+=$total/100)
|
|
{
|
|
$count+=1;
|
|
fetch_all_rows($dbh,"select count(id) from bench1 where id < $tests");
|
|
}
|
|
$end_time=new Benchmark;
|
|
print "Time for count_on_key ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($tests=0 ; $tests < $total ; $tests+=$total/100)
|
|
{
|
|
$count+=1;
|
|
fetch_all_rows($dbh,"select count(dummy1) from bench1 where id2 < $tests");
|
|
}
|
|
$end_time=new Benchmark;
|
|
print "Time for count ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
if ($limits->{'group_distinct_functions'})
|
|
{
|
|
$loop_time=new Benchmark;
|
|
$count=$estimated=0;
|
|
for ($tests=1 ; $tests <= $small_loop_count ; $tests++)
|
|
{
|
|
$count+=2;
|
|
fetch_all_rows($dbh,"select count(distinct dummy1) from bench1");
|
|
fetch_all_rows($dbh,"select dummy1,count(distinct id) from bench1 group by dummy1");
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$tests,
|
|
$small_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for count_distinct_big ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
}
|
|
}
|
|
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
####
|
|
#### Some updates on the table
|
|
####
|
|
|
|
$loop_time=new Benchmark;
|
|
|
|
if ($limits->{'functions'})
|
|
{
|
|
print "\nTesting update of keys with functions\n";
|
|
my $update_loop_count=$opt_loop_count/2;
|
|
for ($i=0 ; $i < $update_loop_count ; $i++)
|
|
{
|
|
my $tmp=$opt_loop_count+$random[$i]; # $opt_loop_count*2 <= $tmp < $total_rows
|
|
$sth = $dbh->do("update bench1 set id3=-$tmp where id3=$tmp") or die $DBI::errstr;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for update_of_key ($update_loop_count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
do_query($dbh,"UNLOCK TABLES");
|
|
}
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
$server->vacuum(1,\$dbh,"bench1");
|
|
}
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
$step=int($opt_loop_count/$range_loop_count+1);
|
|
for ($i= 0 ; $i < $opt_loop_count ; $i+= $step)
|
|
{
|
|
$count++;
|
|
$sth=$dbh->do("update bench1 set id3= 0-id3 where id3 >= 0 and id3 <= $i") or die $DBI::errstr;
|
|
}
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
$count++;
|
|
$sth=$dbh->do("update bench1 set id3= 0-id3 where id3 >= 0 and id3 < $opt_loop_count") or die $DBI::errstr;
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
$count++;
|
|
$sth=$dbh->do("update bench1 set id3= 0-id3 where id3 >= $opt_loop_count and id3 < ". ($opt_loop_count*2)) or die $DBI::errstr;
|
|
|
|
#
|
|
# Check that everything was updated
|
|
# In principle we shouldn't time this in the update loop..
|
|
#
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
$row_count=0;
|
|
if (($sth=$dbh->prepare("select count(*) from bench1 where id3>=0"))
|
|
&& $sth->execute)
|
|
{
|
|
($row_count)=$sth->fetchrow;
|
|
}
|
|
$result=1 + $opt_loop_count-$update_loop_count;
|
|
if ($row_count != $result)
|
|
{
|
|
print "Warning: Update check returned $row_count instead of $result\n";
|
|
}
|
|
|
|
$sth->finish;
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
#restore id3 to 0 <= id3 < $total_rows/10 or 0<= id3 < $total_rows
|
|
|
|
my $func=($limits->{'func_odbc_floor'}) ? "floor((0-id3)/20)" : "0-id3";
|
|
$count++;
|
|
$sth=$dbh->do($query="update bench1 set id3=$func where id3<0") or die $DBI::errstr;
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for update_of_key_big ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
}
|
|
else
|
|
{
|
|
print "\nTesting update of keys in loops\n";
|
|
#
|
|
# This is for mSQL that doesn't have functions. Do we really need this ????
|
|
#
|
|
|
|
$sth=$dbh->prepare("select id3 from bench1 where id3 >= 0") or die $DBI::errstr;
|
|
$sth->execute or die $DBI::errstr;
|
|
$count=0;
|
|
while (@tmp = $sth->fetchrow_array)
|
|
{
|
|
my $tmp1 = "-$tmp[0]";
|
|
my $sth1 = $dbh->do("update bench1 set id3 = $tmp1 where id3 = $tmp[0]");
|
|
$count++;
|
|
$end_time=new Benchmark;
|
|
if (($end_time->[0] - $loop_time->[0]) > $opt_time_limit)
|
|
{
|
|
print "note: Aborting update loop because of timeout\n";
|
|
last;
|
|
}
|
|
}
|
|
$sth->finish;
|
|
# Check that everything except id3=0 was updated
|
|
# In principle we shouldn't time this in the update loop..
|
|
#
|
|
if (fetch_all_rows($dbh,$query="select * from bench1 where id3>=0") != 1)
|
|
{
|
|
if ($count == $total_rows)
|
|
{
|
|
print "Warning: Wrong information after update: Found '$row_count' rows, but should have been: 1\n";
|
|
}
|
|
}
|
|
#restore id3 to 0 <= id3 < $total_rows
|
|
$sth=$dbh->prepare("select id3 from bench1 where id3 < 0") or die $DBI::errstr;
|
|
$sth->execute or die $DBI::errstr;
|
|
while (@tmp = $sth->fetchrow_array)
|
|
{
|
|
$count++;
|
|
my $tmp1 = floor((0-$tmp[0])/10);
|
|
my $sth1 = $dbh->do("update bench1 set id3 = $tmp1 where id3 = $tmp[0]");
|
|
}
|
|
$sth->finish;
|
|
$end_time=new Benchmark;
|
|
$estimated=predict_query_time($loop_time,$end_time,\$count,$count,
|
|
$opt_loop_count*6);
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for update_of_key ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
}
|
|
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
if ($opt_lock_tables)
|
|
{
|
|
do_query($dbh,"UNLOCK TABLES");
|
|
}
|
|
$server->vacuum(1,\$dbh,"bench1");
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
#
|
|
# Testing some simple updates
|
|
#
|
|
|
|
print "Testing update with key\n";
|
|
$loop_time=new Benchmark;
|
|
for ($i=0 ; $i < $opt_loop_count*3 ; $i++)
|
|
{
|
|
$sth = $dbh->do("update bench1 set dummy1='updated' where id=$i and id2=$i") or die $DBI::errstr;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for update_with_key (" . ($opt_loop_count*3) . "): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($i=1 ; $i < $opt_loop_count*3 ; $i+=3)
|
|
{
|
|
$sth = $dbh->do("update bench1 set dummy1='updated' where id=$i") or die $DBI::errstr;
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$i,($i-1)/3,
|
|
$opt_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for update_with_key_prefix (" . ($opt_loop_count) . "): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
print "\nTesting update of all rows\n";
|
|
$loop_time=new Benchmark;
|
|
for ($i=0 ; $i < $small_loop_count ; $i++)
|
|
{
|
|
$sth = $dbh->do("update bench1 set dummy1='updated $i'") or die $DBI::errstr;
|
|
}
|
|
$end_time=new Benchmark;
|
|
print "Time for update_big ($small_loop_count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
|
|
#
|
|
# Testing left outer join
|
|
#
|
|
|
|
if ($limits->{'func_odbc_floor'} && $limits->{'left_outer_join'})
|
|
{
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 a READ, bench1 b READ") || die $DBI::errstr;
|
|
}
|
|
print "\nTesting left outer join\n";
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($i=0 ; $i < $small_loop_count ; $i++)
|
|
{
|
|
$count+=fetch_all_rows($dbh,"select count(*) from bench1 as a left outer join bench1 as b on (a.id2=b.id3)");
|
|
}
|
|
$end_time=new Benchmark;
|
|
print "Time for outer_join_on_key ($small_loop_count:$count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($i=0 ; $i < $small_loop_count ; $i++)
|
|
{
|
|
$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)");
|
|
}
|
|
$end_time=new Benchmark;
|
|
print "Time for outer_join ($small_loop_count:$count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$count=0;
|
|
$loop_time=new Benchmark;
|
|
for ($i=0 ; $i < $small_loop_count ; $i++)
|
|
{
|
|
$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");
|
|
}
|
|
$end_time=new Benchmark;
|
|
print "Time for outer_join_found ($small_loop_count:$count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
$count=$estimated=0;
|
|
$loop_time=new Benchmark;
|
|
for ($i=1 ; $i <= $small_loop_count ; $i++)
|
|
{
|
|
$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");
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,
|
|
\$count,$i,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for outer_join_not_found ($range_loop_count:$count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
###
|
|
### Test speed of IN( value list)
|
|
###
|
|
|
|
if ($limits->{'left_outer_join'})
|
|
{
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
|
|
}
|
|
print "\n";
|
|
do_many($dbh,$server->create("bench2",
|
|
["id int NOT NULL"],
|
|
["primary key (id)"]));
|
|
|
|
$max_tests=min(($limits->{'query_size'}-50)/6, $opt_loop_count);
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 READ, bench2 WRITE") ||
|
|
die $DBI::errstr;
|
|
}
|
|
test_where_in("bench1","bench2","id",1,10);
|
|
test_where_in("bench1","bench2","id",11,min(100,$max_tests));
|
|
test_where_in("bench1","bench2","id",101,min(1000,$max_tests));
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
|
|
}
|
|
$sth = $dbh->do("DROP TABLE bench2" . $server->{'drop_attr'}) ||
|
|
die $DBI::errstr;
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
####
|
|
#### Test INSERT INTO ... SELECT
|
|
####
|
|
|
|
if ($limits->{'insert_select'})
|
|
{
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
|
|
}
|
|
print "\nTesting INSERT INTO ... SELECT\n";
|
|
do_many($dbh,$server->create("bench2",
|
|
["id int NOT NULL",
|
|
"id2 int NOT NULL",
|
|
"id3 int NOT NULL",
|
|
"dummy1 char(30)"],
|
|
["primary key (id,id2)"]));
|
|
do_many($dbh,$server->create("bench3",
|
|
["id int NOT NULL",
|
|
"id2 int NOT NULL",
|
|
"id3 int NOT NULL",
|
|
"dummy1 char(30)"],
|
|
["primary key (id,id2)",
|
|
"index index_id3 (id3)"]));
|
|
$loop_time=new Benchmark;
|
|
$sth = $dbh->do("INSERT INTO bench2 SELECT * from bench1") ||
|
|
die $DBI::errstr;
|
|
$end_time=new Benchmark;
|
|
print "Time for insert_select_1_key (1): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
$loop_time=new Benchmark;
|
|
$sth = $dbh->do("INSERT INTO bench3 SELECT * from bench1") ||
|
|
die $DBI::errstr;
|
|
$end_time=new Benchmark;
|
|
print "Time for insert_select_2_keys (1): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
$loop_time=new Benchmark;
|
|
$sth = $dbh->do("DROP TABLE bench2" . $server->{'drop_attr'}) ||
|
|
die $DBI::errstr;
|
|
$sth = $dbh->do("DROP TABLE bench3" . $server->{'drop_attr'}) ||
|
|
die $DBI::errstr;
|
|
$end_time=new Benchmark;
|
|
print "Time for drop table(2): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
$server->vacuum(1,\$dbh);
|
|
}
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
####
|
|
#### Do some deletes on the table
|
|
####
|
|
|
|
if (!$opt_skip_delete)
|
|
{
|
|
print "\nTesting delete\n";
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($i=0 ; $i < $opt_loop_count ; $i+=10)
|
|
{
|
|
$count++;
|
|
$tmp=$opt_loop_count+$random[$i]; # $opt_loop_count*2 <= $tmp < $total_rows
|
|
$dbh->do("delete from bench1 where id3=$tmp") or die $DBI::errstr;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for delete_key ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
$count=0;
|
|
$loop_time=new Benchmark;
|
|
for ($i= 0 ; $i < $opt_loop_count ; $i+=$opt_loop_count/10)
|
|
{
|
|
$sth=$dbh->do("delete from bench1 where id3 >= 0 and id3 <= $i") or die $DBI::errstr;
|
|
$count++;
|
|
}
|
|
$count+=2;
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
$sth=$dbh->do("delete from bench1 where id3 >= 0 and id3 <= $opt_loop_count") or die $DBI::errstr;
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
$sth=$dbh->do("delete from bench1 where id >= $opt_loop_count and id <= " . ($opt_loop_count*2) ) or die $DBI::errstr;
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
if ($opt_fast)
|
|
{
|
|
$sth=$dbh->do("delete from bench1") or die $DBI::errstr;
|
|
}
|
|
else
|
|
{
|
|
$sth = $dbh->do("delete from bench1 where id3 < " . ($total_rows)) or die $DBI::errstr;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for delete_range ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
|
|
}
|
|
$sth = $dbh->do("drop table bench1" . $server->{'drop_attr'}) or die $DBI::errstr;
|
|
}
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
$server->vacuum(1,\$dbh);
|
|
}
|
|
|
|
|
|
keys_test:
|
|
#
|
|
# Test of insert in table with many keys
|
|
# This test assumes that the server really create the keys!
|
|
#
|
|
|
|
my @fields=(); my @keys=();
|
|
$keys=min($limits->{'max_index'},16); # 16 is more than enough
|
|
$seg= min($limits->{'max_index_parts'},$keys,16); # 16 is more than enough
|
|
|
|
print "Insert into table with $keys keys and with a primary key with $seg parts\n";
|
|
|
|
# Make keys on the most important types
|
|
@types=(0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,1,1); # A 1 for each char field
|
|
push(@fields,"field1 tinyint not null");
|
|
push(@fields,"field_search tinyint not null");
|
|
push(@fields,"field2 mediumint not null");
|
|
push(@fields,"field3 smallint not null");
|
|
push(@fields,"field4 char(16) not null");
|
|
push(@fields,"field5 integer not null");
|
|
push(@fields,"field6 float not null");
|
|
push(@fields,"field7 double not null");
|
|
for ($i=8 ; $i <= $keys ; $i++)
|
|
{
|
|
push(@fields,"field$i char(6) not null"); # Should be relatively fair
|
|
}
|
|
|
|
# First key contains many segments
|
|
$query="primary key (";
|
|
for ($i= 1 ; $i <= $seg ; $i++)
|
|
{
|
|
$query.= "field$i,";
|
|
}
|
|
substr($query,-1)=")";
|
|
push (@keys,$query);
|
|
push (@keys,"index index2 (field_search)");
|
|
|
|
#Create other keys
|
|
for ($i=3 ; $i <= $keys ; $i++)
|
|
{
|
|
push(@keys,"index index$i (field$i)");
|
|
}
|
|
|
|
do_many($dbh,$server->create("bench1",\@fields,\@keys));
|
|
if ($opt_lock_tables)
|
|
{
|
|
$dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
$loop_time=new Benchmark;
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->{AutoCommit} = 0;
|
|
}
|
|
|
|
$fields=$#fields;
|
|
if (($opt_fast || $opt_fast_insert) && $server->{'limits'}->{'insert_multi_value'})
|
|
{
|
|
$query_size=$server->{'limits'}->{'query_size'};
|
|
$query="insert into bench1 values ";
|
|
$res=$query;
|
|
for ($i=0; $i < $many_keys_loop_count; $i++)
|
|
{
|
|
$id= $i & 127;
|
|
$rand=$random[$i];
|
|
$tmp="($id,$id,$rand," . ($i & 32766) . ",'ABCDEF$rand',0,$rand,$rand.0,";
|
|
|
|
for ($j=8; $j <= $fields ; $j++)
|
|
{
|
|
$tmp.= ($types[$j] == 0) ? "$rand," : "'$rand',";
|
|
}
|
|
substr($tmp,-1)=")";
|
|
if (length($tmp)+length($res) < $query_size)
|
|
{
|
|
$res.= $tmp . ",";
|
|
}
|
|
else
|
|
{
|
|
$sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
|
|
$res=$query . $tmp . ",";
|
|
}
|
|
}
|
|
$sth = $dbh->do(substr($res,0,length($res)-1)) or die $DBI::errstr;
|
|
}
|
|
else
|
|
{
|
|
for ($i=0; $i < $many_keys_loop_count; $i++)
|
|
{
|
|
$id= $i & 127;
|
|
$rand=$random[$i];
|
|
$query="insert into bench1 values ($id,$id,$rand," . ($i & 32767) .
|
|
",'ABCDEF$rand',0,$rand,$rand.0,";
|
|
|
|
for ($j=8; $j <= $fields ; $j++)
|
|
{
|
|
$query.= ($types[$j] == 0) ? "$rand," : "'$rand',";
|
|
}
|
|
substr($query,-1)=")";
|
|
print "query1: $query\n" if ($opt_debug);
|
|
$dbh->do($query) or die "Got error $DBI::errstr with query: $query\n";
|
|
}
|
|
}
|
|
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->commit;
|
|
$dbh->{AutoCommit} = 1;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for insert_key ($many_keys_loop_count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
if ($opt_lock_tables)
|
|
{
|
|
do_query($dbh,"UNLOCK TABLES");
|
|
}
|
|
$server->vacuum(1,\$dbh,"bench1");
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
#
|
|
# update one key of the above
|
|
#
|
|
|
|
print "Testing update of keys\n";
|
|
$loop_time=new Benchmark;
|
|
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->{AutoCommit} = 0;
|
|
}
|
|
|
|
for ($i=0 ; $i< 256; $i++)
|
|
{
|
|
$dbh->do("update bench1 set field5=1 where field_search=$i")
|
|
or die "Got error $DBI::errstr with query: update bench1 set field5=1 where field_search=$i\n";
|
|
}
|
|
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->commit;
|
|
$dbh->{AutoCommit} = 1;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for update_of_primary_key_many_keys (256): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
if ($opt_lock_tables)
|
|
{
|
|
do_query($dbh,"UNLOCK TABLES");
|
|
}
|
|
$server->vacuum(1,\$dbh,"bench1");
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 WRITE") || die $DBI::errstr;
|
|
}
|
|
}
|
|
|
|
if ($server->small_rollback_segment())
|
|
{
|
|
$dbh->disconnect; # close connection
|
|
$dbh = $server->connect();
|
|
}
|
|
|
|
#
|
|
# Delete everything from table
|
|
#
|
|
|
|
print "Deleting rows from the table\n";
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
|
|
for ($i=0 ; $i < 128 ; $i++)
|
|
{
|
|
$count++;
|
|
$dbh->do("delete from bench1 where field_search = $i") or die $DBI::errstr;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for delete_big_many_keys ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES") || die $DBI::errstr;
|
|
}
|
|
|
|
print "Deleting everything from table\n";
|
|
$count=1;
|
|
if ($opt_fast)
|
|
{
|
|
$query= ($limits->{'truncate_table'} ? "truncate table bench1" :
|
|
"delete from bench1");
|
|
$dbh->do($query) or die $DBI::errstr;
|
|
}
|
|
else
|
|
{
|
|
$dbh->do("delete from bench1 where field1 > 0") or die $DBI::errstr;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for delete_all_many_keys ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
$sth = $dbh->do("drop table bench1" . $server->{'drop_attr'}) or die $DBI::errstr;
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
$server->vacuum(1,\$dbh);
|
|
}
|
|
|
|
#
|
|
# Test multi value inserts if the server supports it
|
|
#
|
|
|
|
if ($limits->{'insert_multi_value'})
|
|
{
|
|
$query_size=$limits->{'query_size'}; # Same limit for all databases
|
|
|
|
$sth = $dbh->do("drop table bench1" . $server->{'drop_attr'});
|
|
do_many($dbh,$server->create("bench1",
|
|
["id int NOT NULL",
|
|
"id2 int NOT NULL",
|
|
"id3 int NOT NULL",
|
|
"dummy1 char(30)"],
|
|
["primary key (id,id2)",
|
|
"index index_id3 (id3)"]));
|
|
|
|
$loop_time=new Benchmark;
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("LOCK TABLES bench1 write") || die $DBI::errstr;
|
|
}
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->{AutoCommit} = 0;
|
|
}
|
|
|
|
print "Inserting $opt_loop_count rows with multiple values\n";
|
|
$query="insert into bench1 values ";
|
|
$res=$query;
|
|
for ($i=0 ; $i < $opt_loop_count ; $i++)
|
|
{
|
|
my $tmp= "($i,$i,$i,'EFGHIJKLM'),";
|
|
if (length($i)+length($res) < $query_size)
|
|
{
|
|
$res.= $tmp;
|
|
}
|
|
else
|
|
{
|
|
do_query($dbh,substr($res,0,length($res)-1));
|
|
$res=$query .$tmp;
|
|
}
|
|
}
|
|
do_query($dbh,substr($res,0,length($res)-1));
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES ") || die $DBI::errstr;
|
|
}
|
|
if ($opt_fast && $server->{transactions})
|
|
{
|
|
$dbh->commit;
|
|
$dbh->{AutoCommit} = 1;
|
|
}
|
|
|
|
$end_time=new Benchmark;
|
|
print "Time for multiple_value_insert (" . ($opt_loop_count) . "): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
|
|
if ($opt_lock_tables)
|
|
{
|
|
$sth = $dbh->do("UNLOCK TABLES ") || die $DBI::errstr;
|
|
}
|
|
|
|
# A big table may take a while to drop
|
|
$loop_time=new Benchmark;
|
|
$sth = $dbh->do("drop table bench1" . $server->{'drop_attr'}) or die $DBI::errstr;
|
|
$end_time=new Benchmark;
|
|
print "Time for drop table(1): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n\n";
|
|
}
|
|
|
|
####
|
|
#### End of benchmark
|
|
####
|
|
|
|
$dbh->disconnect; # close connection
|
|
|
|
end_benchmark($start_time);
|
|
|
|
###
|
|
### Some help functions
|
|
###
|
|
|
|
|
|
# Do some sample selects on direct key
|
|
# First select finds a row, the second one doesn't find.
|
|
|
|
sub check_select_key
|
|
{
|
|
my ($sel_columns,$column,$check)= @_;
|
|
my ($loop_time,$end_time,$i,$tmp_var,$tmp,$count,$row_count,$estimated);
|
|
|
|
$estimated=0;
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($i=1 ; $i <= $opt_read_key_loop_count; $i++)
|
|
{
|
|
$count+=2;
|
|
$tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
|
|
$tmp=$tmpvar % ($total_rows);
|
|
fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp")
|
|
or die $DBI::errstr;
|
|
$tmp+=$total_rows;
|
|
defined($row_count=fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp")) or die $DBI::errstr;
|
|
die "Found $row_count rows on impossible id: $tmp\n" if ($row_count);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$i,
|
|
$opt_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for $check ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
}
|
|
|
|
# Same as above, but select on 2 columns
|
|
|
|
sub check_select_key2
|
|
{
|
|
my ($sel_columns,$column,$column2,$check)= @_;
|
|
my ($loop_time,$end_time,$i,$tmp_var,$tmp,$count,$row_count,$estimated);
|
|
|
|
$estimated=0;
|
|
$loop_time=new Benchmark;
|
|
$count=0;
|
|
for ($i=1 ; $i <= $opt_read_key_loop_count; $i++)
|
|
{
|
|
$count+=2;
|
|
$tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
|
|
$tmp=$tmpvar % ($total_rows);
|
|
fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp and $column2=$tmp")
|
|
or die $DBI::errstr;
|
|
$tmp+=$total_rows;
|
|
defined($row_count=fetch_all_rows($dbh,"select $sel_columns from bench1 where $column=$tmp and $column2=$tmp")) or die $DBI::errstr;
|
|
die "Found $row_count rows on impossible id: $tmp\n" if ($row_count);
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$i,
|
|
$opt_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for $check ($count): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
}
|
|
|
|
#
|
|
# Search using some very simple queries
|
|
#
|
|
|
|
sub check_select_range
|
|
{
|
|
my ($column,$check)= @_;
|
|
my ($loop_time,$end_time,$i,$tmp_var,$tmp,$query,$rows,$estimated);
|
|
|
|
$estimated=0;
|
|
$loop_time=new Benchmark;
|
|
$found=$count=0;
|
|
for ($test=1 ; $test <= $range_loop_count; $test++)
|
|
{
|
|
$count+=$#Q+1;
|
|
for ($i=0 ; $i < $#Q ; $i+=2)
|
|
{
|
|
$query=$Q[$i];
|
|
$rows=$Q[$i+1];
|
|
$query =~ s/!id!/$column/g;
|
|
if (($row_count=fetch_all_rows($dbh,$query)) != $rows)
|
|
{
|
|
if ($row_count == undef())
|
|
{
|
|
die "Got error: $DBI::errstr when executing $query\n";
|
|
}
|
|
die "'$query' returned wrong number of rows: $row_count instead of $rows\n";
|
|
}
|
|
$found+=$row_count;
|
|
}
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$test,
|
|
$range_loop_count));
|
|
}
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for $check ($count:$found): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
}
|
|
|
|
|
|
#
|
|
# SELECT * from bench where col=x or col=x or col=x ...
|
|
|
|
|
|
sub check_or_range
|
|
{
|
|
my ($column,$check)= @_;
|
|
my ($loop_time,$end_time,$i,$tmp_var,$tmp,$columns,$estimated,$found,
|
|
$or_part,$count,$loop_count);
|
|
|
|
$columns=min($limits->{'max_columns'},50,($limits->{'query_size'}-50)/13);
|
|
$columns=$columns- ($columns % 4); # Make Divisible by 4
|
|
|
|
$estimated=0;
|
|
$loop_time=new Benchmark;
|
|
$found=0;
|
|
# The number of tests must be divisible by the following
|
|
$tmp= $limits->{'func_extra_in_num'} ? 15 : 10;
|
|
# We need to calculate the exact number of test to make 'Estimated' right
|
|
$loop_count=$range_loop_count*10+$tmp-1;
|
|
$loop_count=$loop_count- ($loop_count % $tmp);
|
|
|
|
for ($count=0 ; $count < $loop_count ; )
|
|
{
|
|
for ($rowcnt=0; $rowcnt <= $columns; $rowcnt+= $columns/4)
|
|
{
|
|
my $query="select * from bench1 where ";
|
|
my $or_part= "$column = 1";
|
|
$count+=2;
|
|
|
|
for ($i=1 ; $i < $rowcnt ; $i++)
|
|
{
|
|
$tmpvar^= ((($tmpvar + 63) + $i)*3 % $opt_loop_count);
|
|
$tmp=$tmpvar % ($opt_loop_count*4);
|
|
$or_part.=" or $column=$tmp";
|
|
}
|
|
print $query . $or_part . "\n" if ($opt_debug);
|
|
($rows=fetch_all_rows($dbh,$query . $or_part)) or die $DBI::errstr;
|
|
$found+=$rows;
|
|
|
|
if ($limits->{'func_extra_in_num'})
|
|
{
|
|
my $in_part=$or_part; # Same query, but use 'func_extra_in_num' instead.
|
|
$in_part=~ s/ = / IN \(/;
|
|
$in_part=~ s/ or $column=/,/g;
|
|
$in_part.= ")";
|
|
fetch_all_rows($dbh,$query . $in_part) or die $DBI::errstr;
|
|
$count++;
|
|
}
|
|
# Do it a little harder by setting a extra range
|
|
defined(($rows=fetch_all_rows($dbh,"$query($or_part) and $column < 10"))) or die $DBI::errstr;
|
|
$found+=$rows;
|
|
}
|
|
$end_time=new Benchmark;
|
|
last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$count,
|
|
$loop_count));
|
|
}
|
|
|
|
if ($estimated)
|
|
{ print "Estimated time"; }
|
|
else
|
|
{ print "Time"; }
|
|
print " for $check ($count:$found): " .
|
|
timestr(timediff($end_time, $loop_time),"all") . "\n";
|
|
}
|
|
|
|
#
|
|
# General test of SELECT ... WHERE id in(value-list)
|
|
#
|
|
|
|
sub test_where_in
|
|
{
|
|
my ($t1,$t2,$id,$from,$to)= @_;
|
|
|
|
return if ($from >= $to);
|
|
|
|
$query="SELECT $t1.* FROM $t1 WHERE $id IN (";
|
|
for ($i=1 ; $i <= $to ; $i++)
|
|
{
|
|
$query.="$i,";
|
|
}
|
|
$query=substr($query,0,length($query)-1) . ")";
|
|
|
|
# Fill join table to have the same id's as 'query'
|
|
for ($i= $from ; $i <= $to ; $i++)
|
|
{
|
|
$dbh->do("insert into $t2 values($i)") or die $DBI::errstr;
|
|
}
|
|
if ($opt_fast && defined($server->{vacuum}))
|
|
{
|
|
$server->vacuum(1,\$dbh,"bench1");
|
|
}
|
|
|
|
time_fetch_all_rows("Testing SELECT ... WHERE id in ($to values)",
|
|
"select_in", $query, $dbh,
|
|
$range_loop_count);
|
|
time_fetch_all_rows(undef, "select_join_in",
|
|
"SELECT $t1.* FROM $t2 left outer join $t1 on ($t1.$id=$t2.$id)",
|
|
$dbh, $range_loop_count);
|
|
}
|