diff options
28 files changed, 590 insertions, 399 deletions
diff --git a/.bzrignore b/.bzrignore index eff6aeb4967..6c3860cf3d6 100644 --- a/.bzrignore +++ b/.bzrignore @@ -425,3 +425,4 @@ mysql-test/var/slave-data/mysql-bin.012 mysql-test/var/slave-data/mysql-bin.013 mysql-test/var/slave-data/mysql-bin.014 mysql-test/var/slave-data/mysql-bin.index +scripts/mysqld_multi diff --git a/BitKeeper/etc/logging_ok b/BitKeeper/etc/logging_ok index fb7d3b9d9c5..84bd71dbd9f 100644 --- a/BitKeeper/etc/logging_ok +++ b/BitKeeper/etc/logging_ok @@ -1,5 +1 @@ -jani@prima.mysql.com -sasha@mysql.sashanet.com -sasha@work.mysql.com -serg@serg.mysql.com -jani@prima.mysql.fi +monty@donna.mysql.com diff --git a/Docs/manual.texi b/Docs/manual.texi index a4bd3f7f30a..e2cbf7fb3c2 100644 --- a/Docs/manual.texi +++ b/Docs/manual.texi @@ -31688,9 +31688,9 @@ for a similar query to get the correct row count. @cindex Borland Buidler 4 program @item Borland Builder 4 When you start a query you can use the property @code{Active} or use the -method @code{Open}. Note that @code{Active} will start by automatically issuing -a @code{SELECT * FROM ...} query that may not be a good thing if your tables -are big! +method @code{Open}. Note that @code{Active} will start by automatically +issuing a @code{SELECT * FROM ...} query that may not be a good thing if +your tables are big! @item ColdFusion (On Unix) The following information is taken from the ColdFusion documentation: @@ -31702,11 +31702,16 @@ newer version should also work.) You can download @strong{MyODBC} at @uref{http://www.mysql.com/downloads/api-myodbc.html} @cindex ColdFusion program -ColdFusion Version 4.5.1 allows you to us the ColdFusion Administrator to add -the @strong{MySQL} data source. However, the driver is not included with -ColdFusion Version 4.5.1. Before the @strong{MySQL} driver will appear in the ODBC -datasources drop-down list, you must build and copy the @strong{MyODBC} driver -to @file{/opt/coldfusion/lib/libmyodbc.so}. +ColdFusion Version 4.5.1 allows you to us the ColdFusion Administrator +to add the @strong{MySQL} data source. However, the driver is not +included with ColdFusion Version 4.5.1. Before the @strong{MySQL} driver +will appear in the ODBC datasources drop-down list, you must build and +copy the @strong{MyODBC} driver to +@file{/opt/coldfusion/lib/libmyodbc.so}. + +The Contrib directory contains the program mydsn-xxx.zip which allows +you to build and remove the DSN registry file for the MyODBC driver +on Coldfusion applications. @cindex DataJunction @item DataJunction @@ -38643,13 +38648,18 @@ databases. By Hal Roberts. Interface for Stk. Stk is the Tk widgets with Scheme underneath instead of Tcl. By Terry Jones. -@item @uref{http://www.mysql.com/Downloads/Contrib/eiffel-wrapper-1.0.tar.gz,eiffel-wrapper-1.0.tar.gz}. +@item @uref{http://www.mysql.com/Downloads/Contrib/eiffel-wrapper-1.0.tar.gz,eiffel-wrapper-1.0.tar.gz} Eiffel wrapper by Michael Ravits. -@item @uref{http://www.mysql.com/Downloads/Contrib/SQLmy0.06.tgz,SQLmy0.06.tgz}. +@item @uref{http://www.mysql.com/Downloads/Contrib/SQLmy0.06.tgz,SQLmy0.06.tgz} FlagShip Replaceable Database Driver (RDD) for MySQL. By Alejandro Fernandez Herrero. @uref{http://www.fship.com/rdds.html, Flagship RDD home page} + +@item @uref{http://www.mysql.com/Downloads/Contrib/mydsn-1.0.zip,mydsn-1.0.zip} +Binary and source for @code{mydsn.dll}. mydsn should be used to build +and remove the DSN registry file for the MyODBC driver in Coldfusion +applications. By Miguel Angel Solórzano. @end itemize @appendixsec Clients @@ -39603,36 +39613,49 @@ though, so Version 3.23 is not released as a stable version yet. @appendixsubsec Changes in release 3.23.29 @itemize @bullet @item +Changed drop table to first drop the tables and then the @code{.frm} file. +@item +Fixed a bug in the hostname cache which caused @code{mysqld} to report the +hostname as '' in some error messages. +@item Fixed a bug with @code{HEAP} type tables; the variable @code{max_heap_table_size} wasn't used. Now either @code{MAX_ROWS} or @code{max_heap_table_size} can be used to limit the size of a @code{HEAP} type table. @item -Renamed variable @code{bdb_lock_max} to @code{bdb_max_lock}. -@item Changed the default server-id to 1 for masters and 2 for slaves to make it easier to use the binary log. @item -Added @code{CHECK}, @code{ANALYZE} and @code{OPTIMIZE} of BDB tables. +Renamed variable @code{bdb_lock_max} to @code{bdb_max_lock}. +@item +Added support for @code{auto_increment} on sub fields for BDB tables. +@item +Added @code{ANALYZE} of BDB tables. @item Store in BDB tables the number of rows; This helps to optimize queries when we need an approximation of the number of row. @item -Made @code{DROP TABLE}, @code{RENAME TABLE}, @code{CREATE INDEX} and -@code{DROP INDEX} are now transaction endpoints. +If we get an error in a multi-row statement, we now only rollback the +last statement, not the entire transaction. +@item +If you do a @code{ROLLBACK} when you have updated a non-transactional table +you will get an error as a warning. @item Added option @code{--bdb-shared-data} to @code{mysqld}. @item +Added status variable @code{Slave_open_temp_tables}. +@item Added variables @code{binlog_cache_size} and @code{max_binlog_cache_size} to @code{mysqld}. @item +Made @code{DROP TABLE}, @code{RENAME TABLE}, @code{CREATE INDEX} and +@code{DROP INDEX} are now transaction endpoints. +@item If you do a @code{DROP DATABASE} on a symbolic linked database, both the link and the original database is deleted. @item Fixed that @code{DROP DATABASE} works on OS/2. @item -New client @code{mysqld_multi}. @xref{mysqld_multi}. -@item Fixed bug when doing a @code{SELECT DISTINCT ... table1 LEFT JOIN table2..} when table2 was empty. @item @@ -39640,13 +39663,13 @@ Added @code{--abort-slave-event-count} and @code{--disconnect-slave-event-count} options to @code{mysqld} for debugging and testing of replication. @item -added @code{Slave_open_temp_tables} status variable. -@item Fixed replication of temporary tables. Handles everything except slave server restart. @item @code{SHOW KEYS} now shows whether or not key is @code{FULLTEXT}. @item +New script @code{mysqld_multi}. @xref{mysqld_multi}. +@item Added new script, @file{mysql-multi.server.sh}. Thanks to Tim Bunce @email{Tim.Bunce@@ig.co.uk} for modifying @file{mysql.server} to easily handle hosts running many @code{mysqld} processes. @@ -39682,12 +39705,6 @@ with FrontBase. Allow @code{RESTRICT} and @code{CASCADE} after @code{DROP TABLE} to make porting easier. @item -If we get an error we now only rollback the statement (for BDB tables), -not the entire transaction. -@item -If you do a @code{ROLLBACK} when you have updated a non-transactional table -you will get an error as a warning. -@item Reset status variable which could cause problem if one used @code{--slow-log}. @item Added variable @code{connect_timeout} to @code{mysql} and @code{mysqladmin}. @@ -44053,6 +44070,32 @@ Fixed @code{DISTINCT} with calculated columns. @node Bugs, TODO, News, Top @appendix Known errors and design deficiencies in MySQL +The following problems are known and have a very high priority to get +fixed: + +@itemize @bullet +@item +@code{ANALYZE TABLE} on a BDB table may in some case make the table +unusable until one has restarted @code{mysqld}. When this happens you will +see errors like the following in the @strong{MySQL} error file: + +@example +001207 22:07:56 bdb: log_flush: LSN past current end-of-log +@end example + +@item +Don't execute @code{ALTER TABLE} on a @code{BDB} table on which you are +running not completed multi-statement transactions. (The transaction +will probably be ignored). + +@item +Doing a @code{LOCK TABLE ..} and @code{FLUSH TABLES ..} doesn't +guarantee that there isn't a half-finished transaction in progress on the +table. +@end itemize + +The following problems are known and will be fixed in due time: + @itemize @bullet @item @code{mysqldump} on a @code{MERGE} table doesn't include the current @@ -44120,7 +44163,7 @@ you a nice speed increase as it allows @strong{MySQL} to do some optimizations that otherwise would be very hard to do. If you set a column to a wrong value, @strong{MySQL} will, instead of doing -a rollback, store the @code{best possible value} in the column. +a rollback, store the @code{best possible value} in the column: @itemize @bullet @item @@ -44144,6 +44187,7 @@ If the date is totally wrong, @strong{MySQL} will store the special If you set an @code{enum} to an unsupported value, it will be set to the error value 'empty string', with numeric value 0. @end itemize + @item If you execute a @code{PROCEDURE} on a query that returns an empty set, in some cases the @code{PROCEDURE} will not transform the columns. diff --git a/include/Makefile.am b/include/Makefile.am index f5f290e35da..83ba47dc219 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -51,7 +51,7 @@ my_global.h: global.h # These files should not be included in distributions since they are # generated by configure from the .h.in files dist-hook: - rm -f $(distdir)/mysql_version.h $(distdir)/my_config.h + $(RM) -f $(distdir)/mysql_version.h $(distdir)/my_config.h # Don't update the files from bitkeeper %::SCCS/s.% diff --git a/mysys/mf_iocache2.c b/mysys/mf_iocache2.c index f6e686e0378..4e44a632156 100644 --- a/mysys/mf_iocache2.c +++ b/mysys/mf_iocache2.c @@ -32,20 +32,19 @@ void my_b_seek(IO_CACHE *info,my_off_t pos) { - if(info->type == READ_CACHE) - { - info->rc_pos=info->rc_end=info->buffer; - } - else if(info->type == WRITE_CACHE) - { - byte* try_rc_pos; - try_rc_pos = info->rc_pos + (pos - info->pos_in_file); - if(try_rc_pos >= info->buffer && try_rc_pos <= info->rc_end) - info->rc_pos = try_rc_pos; - else - flush_io_cache(info); - } - + if (info->type == READ_CACHE) + { + info->rc_pos=info->rc_end=info->buffer; + } + else if (info->type == WRITE_CACHE) + { + byte* try_rc_pos; + try_rc_pos = info->rc_pos + (pos - info->pos_in_file); + if (try_rc_pos >= info->buffer && try_rc_pos <= info->rc_end) + info->rc_pos = try_rc_pos; + else + flush_io_cache(info); + } info->pos_in_file=pos; info->seek_not_done=1; } diff --git a/scripts/mysqlhotcopy.sh b/scripts/mysqlhotcopy.sh index 735fbdcf2aa..c8c62a88ccb 100644 --- a/scripts/mysqlhotcopy.sh +++ b/scripts/mysqlhotcopy.sh @@ -37,10 +37,12 @@ WARNING: THIS IS VERY MUCH A FIRST-CUT ALPHA. Comments/patches welcome. # Documentation continued at end of file my $VERSION = "1.9"; -my $opt_tmpdir= $main::env{TMPDIR}; +my $opt_tmpdir= $main::ENV{TMPDIR}; my $OPTIONS = <<"_OPTIONS"; +$0 Ver $VERSION + Usage: $0 db_name [new_db_name | directory] -?, --help display this helpscreen and exit @@ -115,6 +117,8 @@ GetOptions( \%opt, my @db_desc = (); my $tgt_name = undef; +usage("") if ($opt{help}); + if ( $opt{regexp} || $opt{suffix} || @ARGV > 2 ) { $tgt_name = pop @ARGV unless ( exists $opt{suffix} ); @db_desc = map { s{^([^\.]+)\./(.+)/$}{$1}; { 'src' => $_, 't_regex' => ( $2 ? $2 : '.*' ) } } @ARGV; @@ -133,10 +137,9 @@ else { } } -my $mysqld_help; my %mysqld_vars; my $start_time = time; -my $opt_tmpdir= $opt{tempdir} ? $opt{tmpdir} : $main::env{TMPDIR}; +my $opt_tmpdir= $opt{tmpdir} ? $opt{tmpdir} : $main::ENV{TMPDIR}; $0 = $1 if $0 =~ m:/([^/]+)$:; $opt{quiet} = 0 if $opt{debug}; $opt{allowold} = 1 if $opt{keepold}; @@ -310,15 +313,19 @@ print Dumper( \@db_desc ) if ( $opt{debug} ); die "No tables to hot-copy" unless ( length $hc_locks ); -# --- create target directories --- +# --- create target directories if we are using 'cp' --- my @existing = (); -foreach my $rdb ( @db_desc ) { + +if ($opt{method} =~ /^cp\b/) +{ + foreach my $rdb ( @db_desc ) { push @existing, $rdb->{target} if ( -d $rdb->{target} ); -} + } -die "Can't hotcopy to '", join( "','", @existing ), "' because already exist and --allowold option not given.\n" - if ( @existing && !$opt{allowold} ); + die "Can't hotcopy to '", join( "','", @existing ), "' because already exist and --allowold option not given.\n" + if ( @existing && !$opt{allowold} ); +} retire_directory( @existing ) if ( @existing ); @@ -385,54 +392,11 @@ foreach my $rdb ( @db_desc ) push @failed, "$rdb->{src} -> $rdb->{target} failed: $@" if ( $@ ); - @files = map { "$datadir/$rdb->{src}/$_" } @{$rdb->{index}}; + @files = @{$rdb->{index}}; if ($rdb->{index}) { - # - # Copy only the header of the index file - # - - my $tmpfile="$opt_tmpdir/mysqlhotcopy$$"; - foreach my $file ($rdb->{index}) - { - my $from="$datadir/$rdb->{src}/$file"; - my $to="$rdb->{target}/$file"; - my $buff; - open(INPUT, $from) || die "Can't open file $from: $!\n"; - my $length=read INPUT, $buff, 2048; - die "Can't read index header from $from\n" if ($length <= 1024); - close INPUT; - - if ( $opt{dryrun} ) - { - print '$opt{method}-header $from $to\n'; - } - elsif ($opt{method} eq 'cp') - { - !open(OUTPUT,$to) || die "Can\'t create file $to: $!\n"; - if (write(OUTPUT,$buff) != length($buff)) - { - die "Error when writing data to $to: $!\n"; - } - close OUTPUT || die "Error on close of $to: $!\n"; - } - elsif ($opt{method} eq 'scp') - { - my $tmp=$tmpfile; - open(OUTPUT,"$tmp") || die "Can\'t create file $tmp: $!\n"; - if (write(OUTPUT,$buff) != length($buff)) - { - die "Error when writing data to $tmp: $!\n"; - } - close OUTPUT || die "Error on close of $tmp: $!\n"; - safe_system('scp $tmp $to'); - } - else - { - die "Can't use unsupported method '$opt{method}'\n"; - } - } - unlink "$opt_tmpdir/mysqlhotcopy$$"; + copy_index($opt{method}, \@files, + "$datadir/$rdb->{src}", $rdb->{target} ); } if ( $opt{checkpoint} ) { @@ -534,9 +498,62 @@ sub copy_files { safe_system (@cmd); } +# +# Copy only the header of the index file +# + +sub copy_index +{ + my ($method, $files, $source, $target) = @_; + my $tmpfile="$opt_tmpdir/mysqlhotcopy$$"; + + print "Copying indices for ".@$files." files...\n" unless $opt{quiet}; + foreach my $file (@$files) + { + my $from="$source/$file"; + my $to="$target/$file"; + my $buff; + open(INPUT, "<$from") || die "Can't open file $from: $!\n"; + my $length=read INPUT, $buff, 2048; + die "Can't read index header from $from\n" if ($length < 1024); + close INPUT; + + if ( $opt{dryrun} ) + { + print "$opt{method}-header $from $to\n"; + } + elsif ($opt{method} eq 'cp') + { + open(OUTPUT,">$to") || die "Can\'t create file $to: $!\n"; + if (syswrite(OUTPUT,$buff) != length($buff)) + { + die "Error when writing data to $to: $!\n"; + } + close OUTPUT || die "Error on close of $to: $!\n"; + } + elsif ($opt{method} eq 'scp') + { + my $tmp=$tmpfile; + open(OUTPUT,">$tmp") || die "Can\'t create file $tmp: $!\n"; + if (syswrite(OUTPUT,$buff) != length($buff)) + { + die "Error when writing data to $tmp: $!\n"; + } + close OUTPUT || die "Error on close of $tmp: $!\n"; + safe_system("scp $tmp $to"); + } + else + { + die "Can't use unsupported method '$opt{method}'\n"; + } + } + unlink "$tmpfile" if ($opt{method} eq 'scp'); +} + + sub safe_system { - my @cmd=shift; + my @cmd= @_; if ( $opt{dryrun} ) { @@ -546,7 +563,7 @@ sub safe_system ## for some reason system fails but backticks works ok for scp... print "Executing '@cmd'\n" if $opt{debug}; - my $cp_status = system @cmd; + my $cp_status = system "@cmd > /dev/null"; if ($cp_status != 0) { warn "Burp ('scuse me). Trying backtick execution...\n" if $opt{debug}; #' ## try something else @@ -680,7 +697,9 @@ UNIX domain socket to use when connecting to local server =item --noindices -don't include index files in copy +Don\'t include index files in copy. Only up to the first 2048 bytes +are copied; You can restore the indexes with isamchk -r or myisamchk -r +on the backup. =item --method=# @@ -689,9 +708,10 @@ method for copy (only "cp" currently supported). Alpha support for will vary with your ability to understand how scp works. 'man scp' and 'man ssh' are your friends. -The destination directory _must exist_ on the target machine using -the scp method. Liberal use of the --debug option will help you figure -out what's really going on when you do an scp. +The destination directory _must exist_ on the target machine using the +scp method. --keepold and --allowold are meeningless with scp. +Liberal use of the --debug option will help you figure out what\'s +really going on when you do an scp. Note that using scp will lock your tables for a _long_ time unless your network connection is _fast_. If this is unacceptable to you, @@ -755,3 +775,4 @@ Ralph Corderoy - added synonyms for commands Scott Wiersdorf - added table regex and scp support Monty - working --noindex (copy only first 2048 bytes of index file) + Fixes for --method=scp diff --git a/sql-bench/Results/ATIS-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/ATIS-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index 5b70a172d91..a94e920b55d 100644 --- a/sql-bench/Results/ATIS-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/ATIS-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,19 +1,19 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-15 16:58:55 +Testing server 'PostgreSQL version ???' at 2000-12-05 5:18:45 ATIS table test Creating tables -Time for create_table (28): 1 wallclock secs ( 0.02 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for create_table (28): 0 wallclock secs ( 0.02 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Inserting data -Time to insert (9768): 9 wallclock secs ( 2.71 usr 0.43 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to insert (9768): 9 wallclock secs ( 2.88 usr 0.35 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Retrieving data -Time for select_simple_join (500): 3 wallclock secs ( 0.76 usr 0.04 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for select_join (200): 13 wallclock secs ( 4.80 usr 0.22 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for select_distinct (800): 17 wallclock secs ( 2.10 usr 0.03 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for select_group (2500): 44 wallclock secs ( 1.57 usr 0.13 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_simple_join (500): 3 wallclock secs ( 0.69 usr 0.04 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_join (200): 14 wallclock secs ( 5.18 usr 0.20 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_distinct (800): 17 wallclock secs ( 2.21 usr 0.07 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_group (2600): 45 wallclock secs ( 1.73 usr 0.10 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Removing tables -Time to drop_table (28): 1 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Total time: 88 wallclock secs (11.97 usr 0.85 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to drop_table (28): 0 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Total time: 89 wallclock secs (12.72 usr 0.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/RUN-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/RUN-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index f2ebd0c3b6f..c1bbaca36f9 100644 --- a/sql-bench/Results/RUN-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/RUN-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,75 +1,87 @@ -Benchmark DBD suite: 2.8 -Date of test: 2000-08-16 21:56:32 +Benchmark DBD suite: 2.10 +Date of test: 2000-12-05 5:18:45 Running tests on: Linux 2.2.14-my-SMP i686 Arguments: -Comments: Intel Xeon, 2x550 Mhz, 1G, pg started with -o -F +Comments: Intel Xeon, 2x550 Mhz 500 Mb, pg started with -o -F Limits from: mysql,pg -Server version: PostgreSQL version 7.0.2 +Server version: PostgreSQL version ??? -ATIS: Total time: 88 wallclock secs (11.97 usr 0.85 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -alter-table: Total time: 50 wallclock secs ( 0.67 usr 0.07 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -big-tables: Total time: 1244 wallclock secs ( 8.76 usr 0.69 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -connect: Total time: 482 wallclock secs (45.81 usr 18.33 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -create: Total time: 8745 wallclock secs (32.62 usr 4.94 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -insert: Estimated total time: 102579 wallclock secs (481.81 usr 72.29 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -select: Estimated total time: 8574 wallclock secs (124.45 usr 11.39 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -wisconsin: Total time: 810 wallclock secs (12.32 usr 1.94 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +ATIS: Total time: 89 wallclock secs (12.72 usr 0.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +alter-table: Total time: 29 wallclock secs ( 0.71 usr 0.09 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +big-tables: Total time: 1248 wallclock secs ( 9.27 usr 0.79 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +connect: Total time: 472 wallclock secs (48.80 usr 17.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +create: Total time: 8968 wallclock secs (35.76 usr 5.26 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +insert: Estimated total time: 110214 wallclock secs (659.27 usr 91.88 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +select: Estimated total time: 8255 wallclock secs (54.76 usr 6.93 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +wisconsin: Total time: 813 wallclock secs (12.05 usr 2.14 sys + 0.00 cusr 0.00 csys = 0.00 CPU) All 8 test executed successfully Tests with estimated time have a + at end of line Totals per operation: Operation seconds usr sys cpu tests -alter_table_add 46.00 0.32 0.01 0.00 992 -connect 129.00 8.57 4.58 0.00 10000 -connect+select_1_row 176.00 11.82 5.48 0.00 10000 -connect+select_simple 142.00 11.34 5.77 0.00 10000 -count 121.00 0.03 0.01 0.00 100 -count_distinct 232.00 0.39 0.08 0.00 1000 -count_distinct_big 691.00 82.24 2.83 0.00 1020 -count_distinct_group 268.00 1.09 0.06 0.00 1000 -count_distinct_group_on_key 169.00 0.37 0.07 0.00 1000 -count_distinct_group_on_key_parts 267.00 1.11 0.10 0.00 1000 -count_group_on_key_parts 238.00 1.01 0.03 0.00 1000 -count_on_key 2504.00 13.04 3.07 0.00 50100 + -create+drop 3022.00 10.18 1.71 0.00 10000 -create_MANY_tables 455.00 8.09 1.12 0.00 10000 +alter_table_add 28.00 0.41 0.03 0.00 992 +connect 125.00 9.11 3.79 0.00 10000 +connect+select_1_row 173.00 12.56 5.56 0.00 10000 +connect+select_simple 140.00 12.15 5.74 0.00 10000 +count 130.00 0.01 0.03 0.00 100 +count_distinct 235.00 0.76 0.12 0.00 2000 +count_distinct_big 200.00 8.26 0.30 0.00 120 +count_distinct_group 271.00 1.27 0.10 0.00 1000 +count_distinct_group_on_key 174.00 0.44 0.11 0.00 1000 +count_distinct_group_on_key_parts 270.00 1.43 0.07 0.00 1000 +count_group_on_key_parts 242.00 1.19 0.05 0.00 1000 +count_on_key 2544.00 16.73 2.42 0.00 50100 + +create+drop 2954.00 11.24 1.81 0.00 10000 +create_MANY_tables 448.00 7.42 0.95 0.00 10000 create_index 1.00 0.00 0.00 0.00 8 -create_key+drop 3752.00 8.40 1.09 0.00 10000 -create_table 1.00 0.02 0.00 0.00 31 -delete_big 1915.00 0.00 0.01 0.00 13 -delete_big_many_keys 10.00 0.00 0.00 0.00 2 -delete_key 256.00 3.10 0.66 0.00 10000 +create_key+drop 4055.00 10.98 1.30 0.00 10000 +create_table 1.00 0.03 0.01 0.00 31 +delete_all 341.00 0.00 0.00 0.00 12 +delete_all_many_keys 31.00 0.07 0.00 0.00 1 +delete_big 0.00 0.00 0.00 0.00 1 +delete_big_many_keys 30.00 0.07 0.00 0.00 128 +delete_key 283.00 2.91 0.52 0.00 10000 drop_index 0.00 0.00 0.00 0.00 8 -drop_table 1.00 0.00 0.00 0.00 28 -drop_table_when_MANY_tables 1328.00 2.91 0.56 0.00 10000 -insert 8783.00 110.09 19.24 0.00 350768 -insert_duplicates 55.00 29.54 3.69 0.00 300000 -insert_key 3825.00 33.55 6.09 0.00 100000 -insert_many_fields 357.00 1.00 0.17 0.00 2000 -min_max 55.00 0.01 0.00 0.00 60 -min_max_on_key 10785.00 26.27 4.98 0.00 85000 ++ -order_by 103.00 22.05 0.77 0.00 10 -order_by_key 118.00 22.03 0.69 0.00 10 -select_1_row 7.00 2.56 0.42 0.00 10000 -select_2_rows 7.00 2.76 0.42 0.00 10000 -select_big 64.00 26.10 1.44 0.00 10080 -select_column+column 8.00 2.28 0.49 0.00 10000 -select_diff_key 13.00 0.17 0.01 0.00 500 -select_distinct 17.00 2.10 0.03 0.00 800 -select_group 277.00 1.59 0.13 0.00 2611 -select_group_when_MANY_tables 188.00 3.03 0.46 0.00 10000 -select_join 13.00 4.80 0.22 0.00 200 -select_key 5051.00 66.15 11.60 0.00 200000 + -select_key_prefix 5061.00 67.04 11.03 0.00 200000 + -select_many_fields 886.00 7.75 0.52 0.00 2000 -select_range 24336.00 10.60 1.23 0.00 25410 ++ -select_range_prefix 24383.00 6.53 0.60 0.00 25000 ++ -select_simple 5.00 2.71 0.49 0.00 10000 -select_simple_join 3.00 0.76 0.04 0.00 500 -update_big 2330.00 0.00 0.00 0.00 500 -update_of_key 4738.00 14.09 2.44 0.00 756 -update_of_key_big 249.00 0.12 0.01 0.00 501 -update_with_key 15050.00 85.10 15.69 0.00 100000 -wisc_benchmark 16.00 3.11 0.27 0.00 114 -TOTALS 122507.00 717.92 110.41 0.00 1594122 +++++++++ +drop_table 0.00 0.00 0.00 0.00 28 +drop_table_when_MANY_tables 1324.00 3.41 0.51 0.00 10000 +insert 8542.00 109.96 19.42 0.00 350768 +insert_duplicates 3055.00 60.75 8.53 0.00 100000 +insert_key 3693.00 33.29 5.64 0.00 100000 +insert_many_fields 357.00 1.18 0.13 0.00 2000 +insert_select_1_key 49.00 0.00 0.00 0.00 1 +insert_select_2_keys 43.00 0.00 0.00 0.00 1 +min_max 58.00 0.02 0.01 0.00 60 +min_max_on_key 11172.00 24.56 3.60 0.00 85000 ++ +order_by_big 121.00 21.92 0.67 0.00 10 +order_by_big_key 115.00 22.06 0.67 0.00 10 +order_by_big_key2 118.00 22.07 0.53 0.00 10 +order_by_big_key_desc 116.00 22.15 0.66 0.00 10 +order_by_big_key_diff 126.00 22.20 0.79 0.00 10 +order_by_key 15.00 1.09 0.06 0.00 500 +order_by_key2_diff 19.00 2.00 0.06 0.00 500 +order_by_range 16.00 1.21 0.02 0.00 500 +select_1_row 7.00 3.10 0.50 0.00 10000 +select_2_rows 6.00 2.75 0.54 0.00 10000 +select_big 64.00 25.86 1.65 0.00 10080 +select_column+column 9.00 2.41 0.31 0.00 10000 +select_diff_key 13.00 0.24 0.01 0.00 500 +select_distinct 17.00 2.21 0.07 0.00 800 +select_group 285.00 1.76 0.11 0.00 2711 +select_group_when_MANY_tables 187.00 2.71 0.68 0.00 10000 +select_join 14.00 5.18 0.20 0.00 200 +select_key 4967.00 68.44 12.65 0.00 200000 + +select_key2 4933.00 67.48 11.08 0.00 200000 + +select_key_prefix 4938.00 67.63 10.85 0.00 200000 + +select_many_fields 891.00 8.07 0.66 0.00 2000 +select_range 35.00 0.87 0.02 0.00 410 +select_range_key2 26862.00 7.62 1.08 0.00 25000 ++ +select_range_prefix 24419.00 9.69 0.80 0.00 25000 ++ +select_simple 4.00 2.96 0.45 0.00 10000 +select_simple_join 3.00 0.69 0.04 0.00 500 +update_big 1894.00 0.02 0.00 0.00 10 +update_of_key 3624.00 15.41 3.10 0.00 50256 +update_of_key_big 444.00 0.20 0.00 0.00 501 +update_with_key 14806.00 89.73 16.29 0.00 300000 +wisc_benchmark 18.00 3.04 0.25 0.00 114 +TOTALS 130055.00 832.98 125.55 0.00 1844991 ++++++++++ diff --git a/sql-bench/Results/alter-table-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/alter-table-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index 5daea20e303..d225f1fddaa 100644 --- a/sql-bench/Results/alter-table-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/alter-table-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,14 +1,14 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-16 1:58:36 +Testing server 'PostgreSQL version ???' at 2000-12-05 5:20:15 Testing of ALTER TABLE Testing with 1000 columns and 1000 rows in 20 steps Insert data into the table -Time for insert (1000) 1 wallclock secs ( 0.35 usr 0.06 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for insert (1000) 0 wallclock secs ( 0.28 usr 0.06 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for alter_table_add (992): 46 wallclock secs ( 0.32 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for alter_table_add (992): 28 wallclock secs ( 0.41 usr 0.03 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Time for create_index (8): 1 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Time for drop_index (8): 0 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Total time: 50 wallclock secs ( 0.67 usr 0.07 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Total time: 29 wallclock secs ( 0.71 usr 0.09 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/big-tables-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/big-tables-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index 116a722b3ab..10e17dea64a 100644 --- a/sql-bench/Results/big-tables-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/big-tables-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,19 +1,19 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-16 1:59:26 +Testing server 'PostgreSQL version ???' at 2000-12-05 5:20:45 Testing of some unusual tables All tests are done 1000 times with 1000 fields Testing table with 1000 fields Testing select * from table with 1 record -Time to select_many_fields(1000): 389 wallclock secs ( 3.71 usr 0.29 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to select_many_fields(1000): 402 wallclock secs ( 3.75 usr 0.32 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing select all_fields from table with 1 record -Time to select_many_fields(1000): 497 wallclock secs ( 4.04 usr 0.23 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to select_many_fields(1000): 489 wallclock secs ( 4.32 usr 0.34 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing insert VALUES() -Time to insert_many_fields(1000): 143 wallclock secs ( 0.43 usr 0.07 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to insert_many_fields(1000): 144 wallclock secs ( 0.38 usr 0.08 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing insert (all_fields) VALUES() -Time to insert_many_fields(1000): 214 wallclock secs ( 0.57 usr 0.10 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to insert_many_fields(1000): 213 wallclock secs ( 0.80 usr 0.05 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Total time: 1244 wallclock secs ( 8.76 usr 0.69 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Total time: 1248 wallclock secs ( 9.27 usr 0.79 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/connect-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/connect-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index d8b9c049611..31a92939c56 100644 --- a/sql-bench/Results/connect-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/connect-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,30 +1,30 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-15 17:01:48 +Testing server 'PostgreSQL version ???' at 2000-12-05 5:41:34 Testing the speed of connecting to the server and sending of data All tests are done 10000 times Testing connection/disconnect -Time to connect (10000): 129 wallclock secs ( 8.57 usr 4.58 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to connect (10000): 125 wallclock secs ( 9.11 usr 3.79 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Test connect/simple select/disconnect -Time for connect+select_simple (10000): 142 wallclock secs (11.34 usr 5.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for connect+select_simple (10000): 140 wallclock secs (12.15 usr 5.74 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Test simple select -Time for select_simple (10000): 5 wallclock secs ( 2.71 usr 0.49 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_simple (10000): 4 wallclock secs ( 2.96 usr 0.45 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing connect/select 1 row from table/disconnect -Time to connect+select_1_row (10000): 176 wallclock secs (11.82 usr 5.48 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to connect+select_1_row (10000): 173 wallclock secs (12.56 usr 5.56 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing select 1 row from table -Time to select_1_row (10000): 7 wallclock secs ( 2.56 usr 0.42 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to select_1_row (10000): 7 wallclock secs ( 3.10 usr 0.50 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing select 2 rows from table -Time to select_2_rows (10000): 7 wallclock secs ( 2.76 usr 0.42 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to select_2_rows (10000): 6 wallclock secs ( 2.75 usr 0.54 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Test select with aritmetic (+) -Time for select_column+column (10000): 8 wallclock secs ( 2.28 usr 0.49 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_column+column (10000): 9 wallclock secs ( 2.41 usr 0.31 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing retrieval of big records (7000 bytes) -Time to select_big (10000): 8 wallclock secs ( 3.76 usr 0.68 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to select_big (10000): 8 wallclock secs ( 3.74 usr 0.88 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Total time: 482 wallclock secs (45.81 usr 18.33 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Total time: 472 wallclock secs (48.80 usr 17.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/create-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/create-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index c22ceeb6781..1272418baab 100644 --- a/sql-bench/Results/create-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/create-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,18 +1,18 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-15 17:09:50 +Testing server 'PostgreSQL version ???' at 2000-12-05 5:49:26 Testing the speed of creating and droping tables Testing with 10000 tables and 10000 loop count Testing create of tables -Time for create_MANY_tables (10000): 455 wallclock secs ( 8.09 usr 1.12 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for create_MANY_tables (10000): 448 wallclock secs ( 7.42 usr 0.95 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Accessing tables -Time to select_group_when_MANY_tables (10000): 188 wallclock secs ( 3.03 usr 0.46 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to select_group_when_MANY_tables (10000): 187 wallclock secs ( 2.71 usr 0.68 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing drop -Time for drop_table_when_MANY_tables (10000): 1328 wallclock secs ( 2.91 usr 0.56 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for drop_table_when_MANY_tables (10000): 1324 wallclock secs ( 3.41 usr 0.51 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing create+drop -Time for create+drop (10000): 3022 wallclock secs (10.18 usr 1.71 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for create_key+drop (10000): 3752 wallclock secs ( 8.40 usr 1.09 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Total time: 8745 wallclock secs (32.62 usr 4.94 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for create+drop (10000): 2954 wallclock secs (11.24 usr 1.81 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for create_key+drop (10000): 4055 wallclock secs (10.98 usr 1.30 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Total time: 8968 wallclock secs (35.76 usr 5.26 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/insert-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/insert-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index 7b13c383bbb..f05e4b8c64f 100644 --- a/sql-bench/Results/insert-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/insert-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,4 +1,4 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-16 2:20:11 +Testing server 'PostgreSQL version ???' at 2000-12-05 8:18:54 Testing the speed of inserting data into 1 table and do some selects on it. The tests are done with a table that has 100000 rows. @@ -8,73 +8,91 @@ Creating tables Inserting 100000 rows in order Inserting 100000 rows in reverse order Inserting 100000 rows in random order -Time for insert (300000): 7729 wallclock secs (94.80 usr 16.69 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for insert (300000): 7486 wallclock secs (94.98 usr 16.58 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing insert of duplicates -Time for insert_duplicates (300000): 55 wallclock secs (29.54 usr 3.69 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for insert_duplicates (100000): 3055 wallclock secs (60.75 usr 8.53 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Retrieving data from the table -Time for select_big (10:3000000): 53 wallclock secs (22.20 usr 0.75 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for order_by_key (10:3000000): 118 wallclock secs (22.03 usr 0.69 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for order_by (10:3000000): 103 wallclock secs (22.05 usr 0.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for select_diff_key (500:1000): 13 wallclock secs ( 0.17 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_big (10:3000000): 54 wallclock secs (21.95 usr 0.77 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_big_key (10:3000000): 115 wallclock secs (22.06 usr 0.67 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_big_key_desc (10:3000000): 116 wallclock secs (22.15 usr 0.66 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_big_key2 (10:3000000): 118 wallclock secs (22.07 usr 0.53 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_big_key_diff (10:3000000): 126 wallclock secs (22.20 usr 0.79 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_big (10:3000000): 121 wallclock secs (21.92 usr 0.67 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_range (500:125750): 16 wallclock secs ( 1.21 usr 0.02 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_key (500:125750): 15 wallclock secs ( 1.09 usr 0.06 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for order_by_key2_diff (500:250500): 19 wallclock secs ( 2.00 usr 0.06 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_diff_key (500:1000): 13 wallclock secs ( 0.24 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -165 queries in 165 loops of 5000 loops took 605 seconds -Estimated time for select_range_prefix (5000:1386): 18333 wallclock secs ( 3.03 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +180 queries in 180 loops of 5000 loops took 653 seconds +Estimated time for select_range_prefix (5000:1512): 18138 wallclock secs ( 5.00 usr 0.28 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -165 queries in 165 loops of 5000 loops took 603 seconds -Estimated time for select_range (5000:1386): 18272 wallclock secs ( 5.45 usr 0.91 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +165 queries in 165 loops of 5000 loops took 614 seconds +Estimated time for select_range_key2 (5000:1386): 18606 wallclock secs ( 3.03 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -23746 queries in 11873 loops of 100000 loops took 601 seconds -Estimated time for select_key_prefix (200000): 5061 wallclock secs (67.04 usr 11.03 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +24340 queries in 12170 loops of 100000 loops took 601 seconds +Estimated time for select_key_prefix (200000): 4938 wallclock secs (67.63 usr 10.85 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -23796 queries in 11898 loops of 100000 loops took 601 seconds -Estimated time for select_key (200000): 5051 wallclock secs (66.15 usr 11.60 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +24198 queries in 12099 loops of 100000 loops took 601 seconds +Estimated time for select_key (200000): 4967 wallclock secs (68.44 usr 12.65 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Note: Query took longer then time-limit: 600 +Estimating end time based on: +24362 queries in 12181 loops of 100000 loops took 601 seconds +Estimated time for select_key2 (200000): 4933 wallclock secs (67.48 usr 11.08 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Test of compares with simple ranges Note: Query took longer then time-limit: 600 Estimating end time based on: -2000 queries in 50 loops of 500 loops took 605 seconds -Estimated time for select_range_prefix (20000:4350): 6050 wallclock secs ( 3.50 usr 0.60 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +1920 queries in 48 loops of 500 loops took 603 seconds +Estimated time for select_range_prefix (20000:4176): 6281 wallclock secs ( 4.69 usr 0.52 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -2000 queries in 50 loops of 500 loops took 603 seconds -Estimated time for select_range (20000:4350): 6030 wallclock secs ( 4.30 usr 0.30 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for select_group (111): 233 wallclock secs ( 0.02 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +1480 queries in 37 loops of 500 loops took 611 seconds +Estimated time for select_range_key2 (20000:3219): 8256 wallclock secs ( 4.59 usr 1.08 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_group (111): 240 wallclock secs ( 0.03 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -1362 queries in 227 loops of 2500 loops took 601 seconds -Estimated time for min_max_on_key (15000): 6618 wallclock secs ( 5.40 usr 0.33 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for min_max (60): 55 wallclock secs ( 0.01 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_on_key (100): 116 wallclock secs ( 0.04 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count (100): 121 wallclock secs ( 0.03 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_distinct_big (20): 139 wallclock secs ( 0.02 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +1314 queries in 219 loops of 2500 loops took 603 seconds +Estimated time for min_max_on_key (15000): 6883 wallclock secs ( 4.00 usr 0.46 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for min_max (60): 58 wallclock secs ( 0.02 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_on_key (100): 120 wallclock secs ( 0.03 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count (100): 130 wallclock secs ( 0.01 usr 0.03 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_distinct_big (20): 143 wallclock secs ( 0.02 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing update of keys with functions -Time for update_of_key (500): 2520 wallclock secs (13.97 usr 2.44 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for update_of_key_big (501): 249 wallclock secs ( 0.12 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for update_of_key (50000): 2460 wallclock secs (15.33 usr 3.09 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for update_of_key_big (501): 444 wallclock secs ( 0.20 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing update with key -Time for update_with_key (100000): 15050 wallclock secs (85.10 usr 15.69 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for update_with_key (300000): 14806 wallclock secs (89.73 usr 16.29 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing update of all rows -Time for update_big (500): 2330 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for update_big (10): 1894 wallclock secs ( 0.02 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) + +Testing INSERT INTO ... SELECT +Time for insert_select_1_key (1): 49 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for insert_select_2_keys (1): 43 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for drop table(2): 20 wallclock secs ( 0.01 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing delete -Time for delete_key (10000): 256 wallclock secs ( 3.10 usr 0.66 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for delete_big (12): 1914 wallclock secs ( 0.00 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for delete_key (10000): 283 wallclock secs ( 2.91 usr 0.52 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for delete_all (12): 341 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Insert into table with 16 keys and with a primary key with 16 parts -Time for insert_key (100000): 3825 wallclock secs (33.55 usr 6.09 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for insert_key (100000): 3693 wallclock secs (33.29 usr 5.64 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing update of keys -Time for update_of_key (256): 2218 wallclock secs ( 0.12 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for update_of_key (256): 1164 wallclock secs ( 0.08 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) + +Deleting rows from the table +Time for delete_big_many_keys (128): 30 wallclock secs ( 0.07 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Deleting everything from table -Time for delete_big_many_keys (2): 10 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for delete_all_many_keys (1): 31 wallclock secs ( 0.07 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Estimated total time: 102579 wallclock secs (481.81 usr 72.29 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Estimated total time: 110214 wallclock secs (659.27 usr 91.88 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/select-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/select-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index d7df2ce91cf..60e5348568b 100644 --- a/sql-bench/Results/select-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/select-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,29 +1,29 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-16 13:49:53 +Testing server 'PostgreSQL version ???' at 2000-12-05 20:00:31 Testing the speed of selecting on keys that consist of many parts The test-table has 10000 rows and the test is done with 12 ranges. Creating table Inserting 10000 rows -Time to insert (10000): 254 wallclock secs ( 3.38 usr 0.46 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to insert (10000): 254 wallclock secs ( 3.11 usr 0.60 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing big selects on the table -Time for select_big (70:17207): 3 wallclock secs ( 0.14 usr 0.01 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for select_range (410:75949): 34 wallclock secs ( 0.85 usr 0.02 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_big (70:17207): 2 wallclock secs ( 0.17 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for select_range (410:75949): 35 wallclock secs ( 0.87 usr 0.02 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -10094 queries in 1442 loops of 10000 loops took 601 seconds -Estimated time for min_max_on_key (70000): 4167 wallclock secs (20.87 usr 4.65 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +9807 queries in 1401 loops of 10000 loops took 601 seconds +Estimated time for min_max_on_key (70000): 4289 wallclock secs (20.56 usr 3.14 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Note: Query took longer then time-limit: 600 Estimating end time based on: -12580 queries in 2516 loops of 10000 loops took 601 seconds -Estimated time for count_on_key (50000): 2388 wallclock secs (13.00 usr 3.06 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +12395 queries in 2479 loops of 10000 loops took 601 seconds +Estimated time for count_on_key (50000): 2424 wallclock secs (16.70 usr 2.42 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_group_on_key_parts (1000:0): 238 wallclock secs ( 1.01 usr 0.03 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_group_on_key_parts (1000:100000): 242 wallclock secs ( 1.19 usr 0.05 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Testing count(distinct) on the table -Time for count_distinct (1000:2000): 232 wallclock secs ( 0.39 usr 0.08 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_distinct_group_on_key (1000:6000): 169 wallclock secs ( 0.37 usr 0.07 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_distinct_group_on_key_parts (1000:100000): 267 wallclock secs ( 1.11 usr 0.10 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_distinct_group (1000:100000): 268 wallclock secs ( 1.09 usr 0.06 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time for count_distinct_big (1000:10000000): 552 wallclock secs (82.22 usr 2.83 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Estimated total time: 8574 wallclock secs (124.45 usr 11.39 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_distinct (2000:2000): 235 wallclock secs ( 0.76 usr 0.12 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_distinct_group_on_key (1000:6000): 174 wallclock secs ( 0.44 usr 0.11 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_distinct_group_on_key_parts (1000:100000): 270 wallclock secs ( 1.43 usr 0.07 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_distinct_group (1000:100000): 271 wallclock secs ( 1.27 usr 0.10 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for count_distinct_big (100:1000000): 57 wallclock secs ( 8.24 usr 0.30 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Estimated total time: 8255 wallclock secs (54.76 usr 6.93 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/Results/wisconsin-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg b/sql-bench/Results/wisconsin-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg index fa3940c1131..23f8f49f12c 100644 --- a/sql-bench/Results/wisconsin-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg +++ b/sql-bench/Results/wisconsin-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg @@ -1,14 +1,14 @@ -Testing server 'PostgreSQL version 7.0.2' at 2000-08-16 14:43:33 +Testing server 'PostgreSQL version ???' at 2000-12-05 20:46:15 Wisconsin benchmark test -Time for create_table (3): 0 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for create_table (3): 1 wallclock secs ( 0.01 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Inserting data -Time to insert (31000): 791 wallclock secs ( 9.20 usr 1.66 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Time to delete_big (1): 1 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to insert (31000): 793 wallclock secs ( 8.99 usr 1.89 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time to delete_big (1): 0 wallclock secs ( 0.00 usr 0.00 sys + 0.00 cusr 0.00 csys = 0.00 CPU) Running actual benchmark -Time for wisc_benchmark (114): 16 wallclock secs ( 3.11 usr 0.27 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Time for wisc_benchmark (114): 18 wallclock secs ( 3.04 usr 0.25 sys + 0.00 cusr 0.00 csys = 0.00 CPU) -Total time: 810 wallclock secs (12.32 usr 1.94 sys + 0.00 cusr 0.00 csys = 0.00 CPU) +Total time: 813 wallclock secs (12.05 usr 2.14 sys + 0.00 cusr 0.00 csys = 0.00 CPU) diff --git a/sql-bench/limits/pg.cfg b/sql-bench/limits/pg.cfg index 1675cff71ef..7e4d20b052a 100644 --- a/sql-bench/limits/pg.cfg +++ b/sql-bench/limits/pg.cfg @@ -1,4 +1,4 @@ -#This file is automaticly generated by crash-me 1.45 +#This file is automaticly generated by crash-me 1.54 NEG=yes # update of column= -column Need_cast_for_null=no # Need to cast NULL for arithmetic @@ -18,40 +18,44 @@ alter_drop_unique=no # Alter table drop unique alter_modify_col=no # Alter table modify column alter_rename_table=yes # Alter table rename table atomic_updates=no # atomic updates -automatic_rowid=no # Automatic rowid +automatic_rowid=no # Automatic row id binary_numbers=no # binary numbers (0b1001) binary_strings=yes # binary strings (b'0110') -case_insensitive_strings=no # case insensitive compare +case_insensitive_strings=no # Case insensitive compare char_is_space_filled=yes # char are space filled column_alias=yes # Column alias columns_in_group_by=+64 # number of columns in group by columns_in_order_by=+64 # number of columns in order by comment_#=no # # as comment -comment_--=yes # -- as comment +comment_--=yes # -- as comment (ANSI) comment_/**/=yes # /* */ as comment -comment_//=no # // as comment +comment_//=no # // as comment (ANSI) compute=no # Compute connections=32 # Simultaneous connections (installation default) constraint_check=yes # Column constraints constraint_check_table=yes # Table constraints constraint_null=yes # NULL constraint (SyBase style) crash_me_safe=yes # crash me safe -crash_me_version=1.45 # crash me version +crash_me_version=1.54 # crash me version create_default=yes # default value for column create_default_func=no # default value function for column create_if_not_exists=no # create table if not exists create_index=yes # create index create_schema=no # Create SCHEMA -create_table_select=no # create table from select +create_table_select=with AS # create table from select cross_join=yes # cross join (same as from a,b) +date_infinity=no # Supports 'infinity dates date_last=yes # Supports 9999-12-31 dates date_one=yes # Supports 0001-01-01 dates date_with_YY=yes # Supports YY-MM-DD 2000 compilant dates date_zero=no # Supports 0000-00-00 dates domains=no # Domains (ANSI SQL) +dont_require_cast_to_float=no # No need to cast from integer to float double_quotes=yes # Double '' as ' in strings drop_if_exists=no # drop table if exists drop_index=yes # drop index +drop_requires_cascade=no # drop table require cascade/restrict +drop_restrict=no # drop table with cascade/restrict end_colon=yes # allows end ';' except=yes # except except_all=no # except all @@ -158,6 +162,7 @@ func_extra_version=yes # Function VERSION func_extra_weekday=no # Function WEEKDAY func_extra_|=no # Function | (bitwise or) func_extra_||=no # Function OR as '||' +func_extra_~*=yes # Function ~* (case insensitive compare) func_odbc_abs=yes # Function ABS func_odbc_acos=yes # Function ACOS func_odbc_ascii=yes # Function ASCII @@ -178,7 +183,7 @@ func_odbc_dayofweek=no # Function DAYOFWEEK func_odbc_dayofyear=no # Function DAYOFYEAR func_odbc_degrees=yes # Function DEGREES func_odbc_difference=no # Function DIFFERENCE() -func_odbc_exp=no # Function EXP +func_odbc_exp=yes # Function EXP func_odbc_floor=yes # Function FLOOR func_odbc_fn_left=no # Function ODBC syntax LEFT & RIGHT func_odbc_hour=no # Function HOUR @@ -240,7 +245,8 @@ func_sql_extract_sql=yes # Function EXTRACT func_sql_localtime=no # Function LOCALTIME func_sql_localtimestamp=no # Function LOCALTIMESTAMP func_sql_lower=yes # Function LOWER -func_sql_nullif=no # Function NULLIF +func_sql_nullif_num=yes # Function NULLIF with numbers +func_sql_nullif_string=no # Function NULLIF with strings func_sql_octet_length=no # Function OCTET_LENGTH func_sql_position=yes # Function POSITION func_sql_searched_case=yes # Function searched CASE @@ -270,7 +276,7 @@ func_where_unique=no # Function UNIQUE functions=yes # Functions group_by=yes # Group by group_by_alias=yes # Group by alias -group_by_null=yes # group on column with null values +group_by_null=yes # Group on column with null values group_by_position=yes # Group by position group_distinct_functions=yes # Group functions with distinct group_func_extra_bit_and=no # Group function BIT_AND @@ -279,28 +285,33 @@ group_func_extra_count_distinct_list=no # Group function COUNT(DISTINCT expr,exp group_func_extra_std=no # Group function STD group_func_extra_stddev=no # Group function STDDEV group_func_extra_variance=no # Group function VARIANCE +group_func_sql_any=no # Group function ANY group_func_sql_avg=yes # Group function AVG group_func_sql_count_*=yes # Group function COUNT (*) group_func_sql_count_column=yes # Group function COUNT column name group_func_sql_count_distinct=yes # Group function COUNT(DISTINCT expr) +group_func_sql_every=no # Group function EVERY group_func_sql_max=yes # Group function MAX on numbers group_func_sql_max_str=yes # Group function MAX on strings group_func_sql_min=yes # Group function MIN on numbers group_func_sql_min_str=yes # Group function MIN on strings +group_func_sql_some=no # Group function SOME group_func_sql_sum=yes # Group function SUM group_functions=yes # Group functions +group_on_unused=yes # Group on unused column has_true_false=yes # TRUE and FALSE having=yes # Having having_with_alias=no # Having on alias having_with_group=yes # Having with group function hex_numbers=no # hex numbers (0x41) hex_strings=yes # hex strings (x'1ace') -ignore_end_space=yes # ignore end space in compare +ignore_end_space=yes # Ignore end space in compare index_in_create=no # index in create table index_namespace=no # different namespace for index index_parts=no # index on column part (extension) -inner_join=no # inner join +inner_join=yes # inner join insert_empty_string=yes # insert empty string +insert_multi_value=no # INSERT with Value lists insert_select=yes # insert INTO ... SELECT ... insert_with_set=no # INSERT with set syntax intersect=yes # intersect @@ -343,7 +354,6 @@ multi_null_in_unique=yes # null in unique index multi_strings=yes # Multiple line strings multi_table_delete=no # DELETE FROM table1,table2... multi_table_update=no # Update with many tables -insert_multi_value=no # Value lists in INSERT natural_join=yes # natural join natural_join_incompat=yes # natural join (incompatible lists) natural_left_outer_join=no # natural left outer join @@ -352,6 +362,7 @@ null_concat_expr=yes # Is 'a' || NULL = NULL null_in_index=yes # null in index null_in_unique=yes # null in unique index null_num_expr=yes # Is 1+NULL = NULL +nulls_in_unique=yes # null combination in unique index odbc_left_outer_join=no # left outer join odbc style operating_system=Linux 2.2.14-5.0 i686 # crash-me tested on order_by=yes # Order by @@ -359,6 +370,7 @@ order_by_alias=yes # Order by alias order_by_function=yes # Order by function order_by_position=yes # Order by position order_by_remember_desc=no # Order by DESC is remembered +order_on_unused=yes # Order by on unused column primary_key_in_create=yes # primary key in create table psm_functions=no # PSM functions (ANSI SQL) psm_modules=no # PSM modules (ANSI SQL) @@ -372,6 +384,7 @@ quote_with_"=no # Allows ' and " as string markers recursive_subqueries=+64 # recursive subqueries remember_end_space=no # Remembers end space in char() remember_end_space_varchar=yes # Remembers end space in varchar() +rename_table=no # rename table repeat_string_size=+8000000 # return string size from function right_outer_join=no # right outer join rowid=oid # Type for row id @@ -381,15 +394,16 @@ select_limit2=yes # SELECT with LIMIT #,# select_string_size=16777207 # constant string size in SELECT select_table_update=yes # Update with sub select select_without_from=yes # SELECT without FROM -server_version=PostgreSQL 7.0 # server version +server_version=PostgreSQL version 7.0.2 # server version simple_joins=yes # ANSI SQL simple joins storage_of_float=round # Storage of float values subqueries=yes # subqueries table_alias=yes # Table alias table_name_case=yes # case independent table names table_wildcard=yes # Select table_name.* -tempoary_table=yes # temporary tables +temporary_table=yes # temporary tables transactions=yes # transactions +truncate_table=yes # truncate type_extra_abstime=yes # Type abstime type_extra_bfile=no # Type bfile type_extra_blob=no # Type blob @@ -397,6 +411,7 @@ type_extra_bool=yes # Type bool type_extra_box=yes # Type box type_extra_byte=no # Type byte type_extra_char(1_arg)_binary=no # Type char(1 arg) binary +type_extra_cidr=yes # Type cidr type_extra_circle=yes # Type circle type_extra_clob=no # Type clob type_extra_datetime=yes # Type datetime @@ -406,6 +421,7 @@ type_extra_float(2_arg)=no # Type float(2 arg) type_extra_float4=yes # Type float4 type_extra_float8=yes # Type float8 type_extra_image=no # Type image +type_extra_inet=yes # Type inet type_extra_int(1_arg)_zerofill=no # Type int(1 arg) zerofill type_extra_int1=no # Type int1 type_extra_int2=yes # Type int2 @@ -422,6 +438,7 @@ type_extra_long_raw=no # Type long raw type_extra_long_varbinary=no # Type long varbinary type_extra_long_varchar(1_arg)=no # Type long varchar(1 arg) type_extra_lseg=yes # Type lseg +type_extra_macaddr=yes # Type macaddr type_extra_mediumint=no # Type mediumint type_extra_mediumtext=no # Type mediumtext type_extra_middleint=no # Type middleint @@ -457,6 +474,7 @@ type_odbc_varbinary(1_arg)=no # Type varbinary(1 arg) type_sql_bit=yes # Type bit type_sql_bit(1_arg)=yes # Type bit(1 arg) type_sql_bit_varying(1_arg)=yes # Type bit varying(1 arg) +type_sql_boolean=yes # Type boolean type_sql_char(1_arg)=yes # Type char(1 arg) type_sql_char_varying(1_arg)=yes # Type char varying(1 arg) type_sql_character(1_arg)=yes # Type character(1 arg) diff --git a/sql-bench/server-cfg.sh b/sql-bench/server-cfg.sh index 661a9766a2d..02dbb5dd712 100755 --- a/sql-bench/server-cfg.sh +++ b/sql-bench/server-cfg.sh @@ -581,7 +581,7 @@ sub new $limits{'table_wildcard'} = 1; $limits{'max_column_name'} = 32; # Is this true $limits{'max_columns'} = 1000; # 500 crashes pg 6.3 - $limits{'max_tables'} = 65000; # Should be big enough + $limits{'max_tables'} = 5000; # 10000 crashes pg 7.0.2 $limits{'max_conditions'} = 30; # This makes Pg real slow $limits{'max_index'} = 64; # Is this true ? $limits{'max_index_parts'} = 16; # Is this true ? diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc index 694823883ac..fc293c1e8af 100644 --- a/sql/ha_berkeley.cc +++ b/sql/ha_berkeley.cc @@ -1,15 +1,15 @@ /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB - + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - + This program 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 General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ @@ -64,7 +64,7 @@ #include <stdarg.h> #define HA_BERKELEY_ROWS_IN_TABLE 10000 /* to get optimization right */ -#define HA_BERKELEY_RANGE_COUNT 100 +#define HA_BERKELEY_RANGE_COUNT 100 #define HA_BERKELEY_MAX_ROWS 10000000 /* Max rows in table */ /* extra rows for estimate_number_of_rows() */ #define HA_BERKELEY_EXTRA_ROWS 100 @@ -99,6 +99,7 @@ static byte* bdb_get_key(BDB_SHARE *share,uint *length, my_bool not_used __attribute__((unused))); static BDB_SHARE *get_share(const char *table_name, TABLE *table); static void free_share(BDB_SHARE *share, TABLE *table); +static int write_status(DB *status_block, char *buff, uint length); static void update_status(BDB_SHARE *share, TABLE *table); static void berkeley_noticecall(DB_ENV *db_env, db_notices notice); @@ -131,7 +132,7 @@ bool berkeley_init(void) db_env->set_verbose(db_env, DB_VERB_CHKPOINT | DB_VERB_DEADLOCK | DB_VERB_RECOVERY, 1); - + db_env->set_cachesize(db_env, 0, berkeley_cache_size, 0); db_env->set_lk_detect(db_env, berkeley_lock_type); if (berkeley_max_lock) @@ -139,7 +140,7 @@ bool berkeley_init(void) if (db_env->open(db_env, berkeley_home, - berkeley_init_flags | DB_INIT_LOCK | + berkeley_init_flags | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_CREATE | DB_THREAD, 0666)) { @@ -271,7 +272,7 @@ berkeley_cmp_hidden_key(DB* file, const DBT *new_key, const DBT *saved_key) { ulonglong a=uint5korr((char*) new_key->data); ulonglong b=uint5korr((char*) saved_key->data); - return a < b ? -1 : (a > b ? 1 : 0); + return a < b ? -1 : (a > b ? 1 : 0); } static int @@ -338,7 +339,7 @@ static bool berkeley_key_cmp(TABLE *table, KEY *key_info, const char *key, uint key_length) { KEY_PART_INFO *key_part= key_info->key_part, - *end=key_part+key_info->key_parts; + *end=key_part+key_info->key_parts; for ( ; key_part != end && (int) key_length > 0; key_part++) { @@ -433,7 +434,6 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) DBUG_RETURN(1); } - info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST); transaction=0; cursor=0; key_read=0; @@ -485,6 +485,7 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) share->status|=STATUS_PRIMARY_KEY_INIT; } get_status(); + info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST); DBUG_RETURN(0); } @@ -611,7 +612,7 @@ void ha_berkeley::unpack_key(char *record, DBT *key, uint index) { KEY *key_info=table->key_info+index; KEY_PART_INFO *key_part= key_info->key_part, - *end=key_part+key_info->key_parts; + *end=key_part+key_info->key_parts; char *pos=(char*) key->data; for ( ; key_part != end; key_part++) @@ -712,7 +713,7 @@ DBT *ha_berkeley::pack_key(DBT *key, uint keynr, char *buff, continue; } key_ptr++; - } + } buff=key_part->field->keypack(buff,key_ptr+offset,key_part->length); key_ptr+=key_part->store_length; key_length-=key_part->store_length; @@ -817,7 +818,7 @@ int ha_berkeley::key_cmp(uint keynr, const byte * old_row, } if (key_part->key_part_flag & (HA_BLOB_PART | HA_VAR_LENGTH)) { - + if (key_part->field->cmp_binary(old_row + key_part->offset, new_row + key_part->offset, (ulong) key_part->length)) @@ -855,7 +856,7 @@ int ha_berkeley::update_primary_key(DB_TXN *trans, bool primary_key_changed, DBUG_RETURN(error); // This should always succeed if ((error=pack_row(&row, new_row, 0))) { - // Out of memory (this shouldn't happen!) + // Out of memory (this shouldn't happen!) (void) file->put(file, trans, &old_key, &row, key_type[primary_key]); DBUG_RETURN(error); @@ -906,7 +907,7 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row) else { create_key(&prim_key, primary_key, key_buff, new_row); - + if ((primary_key_changed=key_cmp(primary_key, old_row, new_row))) create_key(&old_prim_key, primary_key, primary_key_buff, old_row); else @@ -1007,10 +1008,10 @@ int ha_berkeley::remove_key(DB_TXN *sub_trans, uint keynr, const byte *record, if (!(error=file->cursor(key_file[keynr], sub_trans, &cursor, 0))) { if (!(error=cursor->c_get(cursor, - (keynr == primary_key ? + (keynr == primary_key ? prim_key : create_key(&key, keynr, key_buff2, record)), - (keynr == primary_key ? + (keynr == primary_key ? packed_record : prim_key), DB_GET_BOTH))) { // This shouldn't happen @@ -1055,7 +1056,7 @@ int ha_berkeley::delete_row(const byte * record) key_map keys=table->keys_in_use; DBUG_ENTER("delete_row"); statistic_increment(ha_delete_count,&LOCK_status); - + if ((error=pack_row(&row, record, 0))) DBUG_RETURN((error)); create_key(&prim_key, primary_key, key_buff, record); @@ -1106,7 +1107,7 @@ int ha_berkeley::index_init(uint keynr) dbug_assert(cursor == 0); if ((error=file->cursor(key_file[keynr], transaction, &cursor, table->reginfo.lock_type > TL_WRITE_ALLOW_READ ? - DB_RMW : 0))) + 0 : 0))) cursor=0; // Safety bzero((char*) &last_key,sizeof(last_key)); DBUG_RETURN(error); @@ -1269,7 +1270,7 @@ int ha_berkeley::index_prev(byte * buf) DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV), buf, active_index, &row, &last_key, 1)); } - + int ha_berkeley::index_first(byte * buf) { @@ -1469,7 +1470,7 @@ int ha_berkeley::external_lock(THD *thd, int lock_type) { if (thd->transaction.stmt.bdb_tid) { - /* + /* F_UNLOCK is done without a transaction commit / rollback. This happens if the thread didn't update any rows We must in this case commit the work to keep the row locks @@ -1481,7 +1482,7 @@ int ha_berkeley::external_lock(THD *thd, int lock_type) } } DBUG_RETURN(error); -} +} THR_LOCK_DATA **ha_berkeley::store_lock(THD *thd, THR_LOCK_DATA **to, @@ -1539,6 +1540,7 @@ int ha_berkeley::create(const char *name, register TABLE *form, char name_buff[FN_REFLEN]; char part[7]; uint index=1; + int error=1; DBUG_ENTER("ha_berkeley::create"); fn_format(name_buff,name,"", ha_berkeley_ext,2 | 4); @@ -1563,9 +1565,22 @@ int ha_berkeley::create(const char *name, register TABLE *form, /* Create the status block to save information from last status command */ /* Is DB_BTREE the best option here ? (QUEUE can't be used in sub tables) */ - if (create_sub_table(name_buff,"status",DB_BTREE,0)) - DBUG_RETURN(1); - DBUG_RETURN(0); + + DB *status_block; + if (!db_create(&status_block, db_env, 0)) + { + if (!status_block->open(status_block, name_buff, + "status", DB_BTREE, DB_CREATE, 0)) + { + char rec_buff[4+MAX_KEY*4]; + uint length= 4+ table->keys*4; + bzero(rec_buff, length); + if (!write_status(status_block, rec_buff, length)) + error=0; + status_block->close(status_block,0); + } + } + DBUG_RETURN(error); } @@ -1574,13 +1589,10 @@ int ha_berkeley::delete_table(const char *name) int error; char name_buff[FN_REFLEN]; if ((error=db_create(&file, db_env, 0))) - { my_errno=error; - file=0; - return 1; - } - error=file->remove(file,fn_format(name_buff,name,"",ha_berkeley_ext,2 | 4), - NULL,0); + else + error=file->remove(file,fn_format(name_buff,name,"",ha_berkeley_ext,2 | 4), + NULL,0); file=0; // Safety return error; } @@ -1659,23 +1671,22 @@ longlong ha_berkeley::get_auto_increment() table->next_number_key_offset); /* Store for compare */ memcpy(key_buff2, key_buff, (key_len=last_key.size)); - key_info->handler.bdb_return_if_eq= -1; - error=read_row(cursor->c_get(cursor, &last_key, &row, DB_SET_RANGE), - table->record[1], active_index, &row, (DBT*) 0, 0); + /* Modify the compare so that we will find the next key */ + key_info->handler.bdb_return_if_eq= 1; + /* We lock the next key as the new key will probl. be on the same page */ + error=cursor->c_get(cursor, &last_key, &row, DB_SET_RANGE | DB_RMW), key_info->handler.bdb_return_if_eq= 0; - if (!error && !berkeley_key_cmp(table, key_info, key_buff2, key_len)) + + if (!error || error == DB_NOTFOUND) { /* - Found matching key; Now search after next key, go one step back - and then we should have found the biggest key with the given - prefix + Now search go one step back and then we should have found the + biggest key with the given prefix */ - (void) read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT_NODUP), - table->record[1], active_index, &row, (DBT*) 0, 0); - if (read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV), + if (read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV | DB_RMW), table->record[1], active_index, &row, (DBT*) 0, 0) || berkeley_key_cmp(table, key_info, key_buff2, key_len)) - error=1; // Something went wrong + error=1; // Something went wrong or no such key } } nr=(longlong) @@ -1718,25 +1729,47 @@ static void print_msg(THD *thd, const char *table_name, const char *op_name, int ha_berkeley::analyze(THD* thd, HA_CHECK_OPT* check_opt) { - DB_BTREE_STAT stat; + DB_BTREE_STAT *stat=0; uint i; for (i=0 ; i < table->keys ; i++) { - file->stat(key_file[i], (void*) &stat, 0, 0); - share->rec_per_key[i]= stat.bt_ndata / stat.bt_nkeys; + if (stat) + { + free(stat); + stat=0; + } + if (file->stat(key_file[i], (void*) &stat, 0, 0)) + goto err; + share->rec_per_key[i]= (stat->bt_ndata / + (stat->bt_nkeys ? stat->bt_nkeys : 1)); } - /* If hidden primary key */ + /* A hidden primary key is not in key_file[] */ if (hidden_primary_key) - file->stat(file, (void*) &stat, 0, 0); + { + if (stat) + { + free(stat); + stat=0; + } + if (file->stat(file, (void*) &stat, 0, 0)) + goto err; + } pthread_mutex_lock(&share->mutex); - share->rows=stat.bt_ndata; + share->rows=stat->bt_ndata; share->status|=STATUS_BDB_ANALYZE; // Save status on close share->version++; // Update stat in table pthread_mutex_unlock(&share->mutex); - update_status(share,table); // Write status to file + update_status(share,table); // Write status to file + if (stat) + free(stat); return ((share->status & STATUS_BDB_ANALYZE) ? HA_ADMIN_FAILED : HA_ADMIN_OK); + +err: + if (stat) + free(stat); + return HA_ADMIN_FAILED; } int ha_berkeley::optimize(THD* thd, HA_CHECK_OPT* check_opt) @@ -1749,25 +1782,65 @@ int ha_berkeley::check(THD* thd, HA_CHECK_OPT* check_opt) { char name_buff[FN_REFLEN]; int error; + DB *tmp_file; + DBUG_ENTER("ha_berkeley::check"); + + DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED); + +#ifdef NOT_YET + /* + To get this to work we need to ensure that no running transaction is + using the table. We also need to create a new environment without + locking for this. + */ + + /* We must open the file again to be able to check it! */ + if ((error=db_create(&tmp_file, db_env, 0))) + { + print_msg(thd, table->real_name, "check", "error", + "Got error %d creating environment",error); + DBUG_RETURN(HA_ADMIN_FAILED); + } + + /* Compare the overall structure */ + tmp_file->set_bt_compare(tmp_file, + (hidden_primary_key ? berkeley_cmp_hidden_key : + berkeley_cmp_packed_key)); + file->app_private= (void*) (table->key_info+table->primary_key); fn_format(name_buff,share->table_name,"", ha_berkeley_ext, 2 | 4); - if ((error=file->verify(file, name_buff, NullS, (FILE*) 0, - hidden_primary_key ? 0 : DB_NOORDERCHK))) + if ((error=tmp_file->verify(tmp_file, name_buff, NullS, (FILE*) 0, + hidden_primary_key ? 0 : DB_NOORDERCHK))) { print_msg(thd, table->real_name, "check", "error", "Got error %d checking file structure",error); - return HA_ADMIN_CORRUPT; + tmp_file->close(tmp_file,0); + DBUG_RETURN(HA_ADMIN_CORRUPT); } - for (uint i=0 ; i < table->keys ; i++) + + /* Check each index */ + tmp_file->set_bt_compare(tmp_file, berkeley_cmp_packed_key); + for (uint index=0,i=0 ; i < table->keys ; i++) { - if ((error=file->verify(key_file[i], name_buff, NullS, (FILE*) 0, - DB_ORDERCHKONLY))) + char part[7]; + if (i == primary_key) + strmov(part,"main"); + else + sprintf(part,"key%02d",++index); + tmp_file->app_private= (void*) (table->key_info+i); + if ((error=tmp_file->verify(tmp_file, name_buff, part, (FILE*) 0, + DB_ORDERCHKONLY))) { print_msg(thd, table->real_name, "check", "error", - "Key %d was not in order",error); - return HA_ADMIN_CORRUPT; + "Key %d was not in order (Error: %d)", + index+ test(i >= primary_key), + error); + tmp_file->close(tmp_file,0); + DBUG_RETURN(HA_ADMIN_CORRUPT); } } - return HA_ADMIN_OK; + tmp_file->close(tmp_file,0); + DBUG_RETURN(HA_ADMIN_OK); +#endif } /**************************************************************************** @@ -1856,8 +1929,8 @@ void ha_berkeley::get_status() fn_format(name_buff, share->table_name,"", ha_berkeley_ext, 2 | 4); if (!db_create(&share->status_block, db_env, 0)) { - if (!share->status_block->open(share->status_block, name_buff, - "status", DB_BTREE, open_mode, 0)) + if (share->status_block->open(share->status_block, name_buff, + "status", DB_BTREE, open_mode, 0)) { share->status_block->close(share->status_block, 0); share->status_block=0; @@ -1871,15 +1944,16 @@ void ha_berkeley::get_status() if (!file->cursor(share->status_block, 0, &cursor, 0)) { DBT row; - char rec_buff[64],*pos=rec_buff; + char rec_buff[64]; bzero((char*) &row,sizeof(row)); bzero((char*) &last_key,sizeof(last_key)); row.data=rec_buff; - row.size=sizeof(rec_buff); + row.ulen=sizeof(rec_buff); row.flags=DB_DBT_USERMEM; if (!cursor->c_get(cursor, &last_key, &row, DB_FIRST)) { uint i; + uchar *pos=(uchar*) row.data; share->org_rows=share->rows=uint4korr(pos); pos+=4; for (i=0 ; i < table->keys ; i++) { @@ -1896,6 +1970,24 @@ void ha_berkeley::get_status() } +static int write_status(DB *status_block, char *buff, uint length) +{ + DB_TXN *trans; + DBT row,key; + int error; + const char *key_buff="status"; + + bzero((char*) &row,sizeof(row)); + bzero((char*) &key,sizeof(key)); + row.data=buff; + key.data=(void*) key_buff; + key.size=sizeof(key_buff); + row.size=length; + error=status_block->put(status_block, 0, &key, &row, 0); + return error; +} + + static void update_status(BDB_SHARE *share, TABLE *table) { DBUG_ENTER("update_status"); @@ -1922,25 +2014,18 @@ static void update_status(BDB_SHARE *share, TABLE *table) goto end; } { - uint i; - DBT row,key; - char rec_buff[4+MAX_KEY*sizeof(ulong)], *pos=rec_buff; + char rec_buff[4+MAX_KEY*4], *pos=rec_buff; const char *key_buff="status"; - - bzero((char*) &row,sizeof(row)); - bzero((char*) &key,sizeof(key)); - row.data=rec_buff; - key.data=(void*) key_buff; - key.size=sizeof(key_buff); - row.flags=key.flags=DB_DBT_USERMEM; int4store(pos,share->rows); pos+=4; - for (i=0 ; i < table->keys ; i++) + for (uint i=0 ; i < table->keys ; i++) { int4store(pos,share->rec_per_key[i]); pos+=4; } - row.size=(uint) (pos-rec_buff); - (void) share->status_block->put(share->status_block, 0, &key, &row, 0); + DBUG_PRINT("info",("updating status for %s",share->table_name)); + (void) write_status(share->status_block, rec_buff, + (uint) (pos-rec_buff)); share->status&= ~STATUS_BDB_ANALYZE; + share->org_rows=share->rows; } end: pthread_mutex_unlock(&share->mutex); diff --git a/sql/ha_berkeley.h b/sql/ha_berkeley.h index 4ee682664a5..b17d0f041ba 100644 --- a/sql/ha_berkeley.h +++ b/sql/ha_berkeley.h @@ -1,15 +1,15 @@ /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB - + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - + This program 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 General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ @@ -54,7 +54,7 @@ class ha_berkeley: public handler ulong changed_rows; uint primary_key,last_dup_key, hidden_primary_key, version; bool fixed_length_row, fixed_length_primary_key, key_read; - bool fix_rec_buff_for_blob(ulong length); + bool fix_rec_buff_for_blob(ulong length); byte current_ident[BDB_HIDDEN_PRIMARY_KEY_LENGTH]; ulong max_row_length(const byte *buf); @@ -82,7 +82,7 @@ class ha_berkeley: public handler HA_REC_NOT_IN_SEQ | HA_KEYPOS_TO_RNDPOS | HA_READ_ORDER | HA_LASTKEY_ORDER | HA_LONGLONG_KEYS | HA_NULL_KEY | HA_HAVE_KEY_READ_ONLY | - HA_BLOB_KEY | HA_NOT_EXACT_COUNT | + HA_BLOB_KEY | HA_NOT_EXACT_COUNT | HA_PRIMARY_KEY_IN_READ_INDEX | HA_DROP_BEFORE_CREATE | HA_AUTO_PART_KEY), last_dup_key((uint) -1),version(0) @@ -93,8 +93,8 @@ class ha_berkeley: public handler const char **bas_ext() const; ulong option_flag() const { return int_option_flag; } uint max_record_length() const { return HA_MAX_REC_LENGTH; } - uint max_keys() const { return MAX_KEY-1; } - uint max_key_parts() const { return MAX_REF_PARTS; } + uint max_keys() const { return MAX_KEY-1; } + uint max_key_parts() const { return MAX_REF_PARTS; } uint max_key_length() const { return MAX_KEY_LENGTH; } uint extra_rec_buf_length() { return BDB_HIDDEN_PRIMARY_KEY_LENGTH; } ha_rows estimate_number_of_rows(); diff --git a/sql/handler.cc b/sql/handler.cc index 7c6a3e32ff2..24bf16b3604 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -297,12 +297,16 @@ bool ha_flush_logs() return result; } +/* + This should return ENOENT if the file doesn't exists. + The .frm file will be deleted only if we return 0 or ENOENT +*/ int ha_delete_table(enum db_type table_type, const char *path) { handler *file=get_new_handler((TABLE*) 0, table_type); if (!file) - return -1; + return ENOENT; int error=file->delete_table(path); delete file; return error; @@ -620,12 +624,16 @@ uint handler::get_dup_key(int error) int handler::delete_table(const char *name) { + int error=0; for (const char **ext=bas_ext(); *ext ; ext++) { if (delete_file(name,*ext,2)) - return my_errno; + { + if ((error=errno) != ENOENT) + break; + } } - return 0; + return error; } diff --git a/sql/hostname.cc b/sql/hostname.cc index db8f8349446..1c52a5363d3 100644 --- a/sql/hostname.cc +++ b/sql/hostname.cc @@ -81,10 +81,12 @@ static void add_hostname(struct in_addr *in,const char *name) if ((entry=(host_entry*) malloc(sizeof(host_entry)+length+1))) { - char *new_name= (char *) (entry+1); + char *new_name; memcpy_fixed(&entry->ip, &in->s_addr, sizeof(in->s_addr)); - memcpy(new_name, name, length); // Should work even if name == NULL - new_name[length]=0; // End of string + if (length) + memcpy(new_name= (char *) (entry+1), name, length+1); + else + new_name=0; entry->hostname=new_name; entry->errors=0; (void) hostname_cache->add(entry); diff --git a/sql/log.cc b/sql/log.cc index d87fdd1b7e5..49e0faf4a7a 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -686,10 +686,9 @@ bool MYSQL_LOG::write(IO_CACHE *cache) uint length; my_off_t start_pos=my_b_tell(&log_file); - if (reinit_io_cache(cache, WRITE_CACHE, 0, 0, 0)) + if (reinit_io_cache(cache, READ_CACHE, 0, 0, 0)) { - if (!write_error) - sql_print_error(ER(ER_ERROR_ON_WRITE), cache->file_name, errno); + sql_print_error(ER(ER_ERROR_ON_WRITE), cache->file_name, errno); goto err; } while ((length=my_b_fill(cache))) @@ -710,8 +709,7 @@ bool MYSQL_LOG::write(IO_CACHE *cache) } if (cache->error) // Error on read { - if (!write_error) - sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno); + sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno); goto err; } } diff --git a/sql/share/swedish/errmsg.OLD b/sql/share/swedish/errmsg.OLD index ea8c2b78e3f..ee3d913e51a 100644 --- a/sql/share/swedish/errmsg.OLD +++ b/sql/share/swedish/errmsg.OLD @@ -198,5 +198,4 @@ "Tabell '%-.64s' är crashad och bör repareras med REPAIR TABLE", "Tabell '%-.64s' är crashad och senast (automatiska?) reparation misslyckades", "Warning: Några icke transaktionella tabeller kunde inte återställas vid ROLLBACK", -#ER_TRANS_CACHE_FULL "Transaktionen krävde mera än 'max_binlog_cache_size' minne. Utöka denna mysqld variabel och försök på nytt", diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc index dbcd2640dbc..eab67c835fd 100644 --- a/sql/sql_delete.cc +++ b/sql/sql_delete.cc @@ -215,7 +215,7 @@ int mysql_delete(THD *thd,TABLE_LIST *table_list,COND *conds,ha_rows limit, if (options & OPTION_QUICK) (void) table->file->extra(HA_EXTRA_NORMAL); using_transactions=table->file->has_transactions(); - if (deleted && (error == 0 || !using_transactions)) + if (deleted && (error <= 0 || !using_transactions)) { mysql_update_log.write(thd,thd->query, thd->query_length); if (mysql_bin_log.is_open()) diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index baaf65d4197..13da095607d 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -256,7 +256,7 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list, List<Item> &fields, else if (table->next_number_field) id=table->next_number_field->val_int(); // Return auto_increment value using_transactions=table->file->has_transactions(); - if ((info.copied || info.deleted) && (error == 0 || !using_transactions)) + if ((info.copied || info.deleted) && (error <= 0 || !using_transactions)) { mysql_update_log.write(thd, thd->query, thd->query_length); if (mysql_bin_log.is_open()) diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 31fc3f28099..1359551fcf1 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -863,7 +863,8 @@ make_join_statistics(JOIN *join,TABLE_LIST *tables,COND *conds, else s->dependent=(table_map) 0; s->key_dependent=(table_map) 0; - if ((table->system || table->file->records <= 1L) && ! s->dependent) + if ((table->system || table->file->records <= 1) && ! s->dependent && + !(table->file->option_flag() & HA_NOT_EXACT_COUNT)) { s->type=JT_SYSTEM; const_table_map|=table->map; @@ -924,7 +925,8 @@ make_join_statistics(JOIN *join,TABLE_LIST *tables,COND *conds, { if (s->dependent & ~(const_table_map)) // All dep. must be constants continue; - if (s->table->file->records <= 1L) + if (s->table->file->records <= 1L && + !(s->table->file->option_flag() & HA_NOT_EXACT_COUNT)) { // system table s->type=JT_SYSTEM; const_table_map|=s->table->map; diff --git a/sql/sql_table.cc b/sql/sql_table.cc index dc1ceb1112b..78b202e538c 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -110,24 +110,25 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists) table_type=get_table_type(path); - if (my_delete(path,MYF(0))) /* Delete the table definition file */ + if (access(path,F_OK)) { - if (errno != ENOENT || !if_exists) - { + if (!if_exists) error=1; - if (errno != ENOENT) - { - my_error(ER_CANT_DELETE_FILE,MYF(0),path,errno); - } - } } else { - some_tables_deleted=1; - *fn_ext(path)=0; // Remove extension; + char *end; + *(end=fn_ext(path))=0; // Remove extension error=ha_delete_table(table_type, path); if (error == ENOENT && if_exists) error = 0; + if (!error || error == ENOENT) + { + /* Delete the table definition file */ + strmov(end,reg_ext); + if (!(error=my_delete(path,MYF(MY_WME)))) + some_tables_deleted=1; + } } if (error) { @@ -1427,17 +1428,6 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name, thd->count_cuted_fields=0; /* Don`t calc cuted fields */ new_table->time_stamp=save_time_stamp; -#if defined( __WIN__) || defined( __EMX__) - /* - We must do the COMMIT here so that we can close and rename the - temporary table (as windows can't rename open tables) - */ - if (ha_commit_stmt(thd)) - error=1; - if (ha_commit(thd)) - error=1; -#endif - if (table->tmp_table) { /* We changed a temporary table */ @@ -1556,7 +1546,6 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name, } } -#if !(defined( __WIN__) || defined( __EMX__)) /* The ALTER TABLE is always in it's own transaction */ error = ha_commit_stmt(thd); if (ha_commit(thd)) @@ -1567,7 +1556,6 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name, VOID(pthread_mutex_unlock(&LOCK_open)); goto err; } -#endif thd->proc_info="end"; mysql_update_log.write(thd, thd->query,thd->query_length); diff --git a/sql/sql_update.cc b/sql/sql_update.cc index 54f85eb2ec7..c52370c02fd 100644 --- a/sql/sql_update.cc +++ b/sql/sql_update.cc @@ -238,7 +238,7 @@ int mysql_update(THD *thd,TABLE_LIST *table_list,List<Item> &fields, VOID(table->file->extra(HA_EXTRA_READCHECK)); table->time_stamp=save_time_stamp; // Restore auto timestamp pointer using_transactions=table->file->has_transactions(); - if (updated && (error == 0 || !using_transactions)) + if (updated && (error <= 0 || !using_transactions)) { mysql_update_log.write(thd,thd->query,thd->query_length); if (mysql_bin_log.is_open()) |