Fixed some reported bugs

BUILD/compile-alpha-cxx

@@ -4,7 +4,8 @@ make -k clean
 /bin/rm -f config.cache mysql-*.tar.gz
 aclocal; autoheader; aclocal; automake; autoconf
 
-CC=ccc CFLAGS="-fast" CXX=cxx CXXFLAGS="-fast -noexceptions -nortti" ./configure --prefix=/usr/local/mysql --disable-shared --with-extra-charsets=complex --enable-thread-safe-client --with-mysqld-ldflags=-all-static
+CC=ccc CFLAGS="-fast" CXX=cxx CXXFLAGS="-fast -noexceptions -nortti" ./configure --prefix=/usr/local/mysql --disable-shared --with-extra-charsets=complex --enable-thread-safe-client --with-mysqld-ldflags=-non_shared --with-client-ldflags=-non_shared
+
 make
 rm */.deps/*
 make

Docs/manual.texi

@@ -1972,6 +1972,9 @@ Apart from the following links, you can find and download a lot of
 @c @item @uref{http://www.devshed.com/resource/advanced/mysql/index.html, A
 @c beginner's tutorial of how to start using @strong{MySQL}}
 
+@item @uref{http://www.4t2.com/mysql. German MySQL maling list}
+Information about the German MySQL mailing list.
+
 @item @uref{http://www.analysisandsolutions.com/code/mybasic.htm}@*
 Beginners @strong{MySQL} Tutorial on how to install and set up
 @strong{MySQL} on a Windows machine.
@@ -2069,7 +2072,6 @@ organization.
 @item @uref{http://www.xnot.com/kmysql}@*
 KDE @strong{MySQL} client.
 
-
 @c EMAIL: bilhaut_f@mail.cpod.fr (Frédérik Bilhaut)
 @item @uref{http://www.penguinpowered.com/~kmysql}@*
 KMySQL is a database client for KDE that primarily supports @strong{MySQL}.
@@ -2090,6 +2092,14 @@ A free report writer in Java
 @item @uref{http://www.javaframework.de}@*
 MySQLExport - Export of @strong{MySQL} create statements and data in a lot of
 different formats (SQL, HTML, CVS, text, ZIP, GZIP...)
+
+@item @uref{http://dlabs.4t2.com, M2D}
+A MySQL-ADmin-client for windows. It supports administration of
+MySQL-Databases, creating of new DBs and tables, editing etc.
+
+@item @uref{http://www.scibit.com/Products/Software/Utils/Mascon.asp,
+Mascon home page}.
+Mascon is a powerful Win32 GUI for the administering MySQL server databases. 
 @end itemize
 
 @subheading Distributions that Include MySQL
@@ -2629,6 +2639,9 @@ unsubscribe from the @code{myodbc} list, send a message to
 @email{myodbc-subscribe@@lists.mysql.com} or
 @email{myodbc-unsubscribe@@lists.mysql.com}.
 
+There is also a german mailing list. You can find information about this
+at: @uref{http://www.4t2.com/mysql}.
+
 @cindex net etiquette
 @cindex mailing lists, archive location
 @cindex searching, MySQL webpages
@@ -6896,59 +6909,40 @@ We have tested @strong{MySQL} on Alpha with our benchmarks + test suite and
 it appears to work nicely.  The main thing we haven't yet had time to test
 is how things works with many concurrent users.
 
-When we compiled @strong{MySQL} we where using SuSE 6.3, kernel 2.2.13-SMP,
-egcs 1.1.2, and libc-2.1.2-28.
+When we compiled the standard @strong{MySQL} binary we are using SuSE 6.4,
+kernel 2.2.13-SMP, Compaq C compiler (V6.2-504) and Compaq C++ compiler
+(V6.3-005) on a Comaq DS20 machine with an Alpha EV6 processor
 
-We used the following configure line:
+You can find the above compilers at
+@uref{http://www.support.compaq.com/alpha-tools}). By using these compilers,
+instead of gcc, we get about 9-14 % better performance with @strong{MySQL}.
+
+Note that the configure line optimized the binary for the current CPU; This
+means you can only use our binary if you have an Alpha EV6 processor.
+We also compile staticly to avoid library problems.
 
 @example
-CFLAGS="-O6 -fomit-frame-pointer" CXX=gcc CXXFLAGS="-O6 -fomit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --disable-shared
+CC=ccc CFLAGS="-fast" CXX=cxx CXXFLAGS="-fast -noexceptions -nortti" ./configure --prefix=/usr/local/mysql --disable-shared --with-extra-charsets=complex --enable-thread-safe-client --with-mysqld-ldflags=-non_shared --with-client-ldflags=-non_shared
 @end example
 
-If you have access to Compaq's C compiler, the following configure line
-will give you about 9 % more performance:
+If you want to use egcs the following configure line worked for us:
+
 @example
-CC=ccc CFLAGS="-fast -O3 -fomit-frame-pointer" CXX=gcc CXXFLAGS="-O6 -fomit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti -mcpu=ev6 -Wa,-mev6" CXXLDFLAGS='/usr/lib/compaq/libots-2.2.7/libots.so /usr/lib/compaq/cpml-5.0.0/libcpml_ev6.a' ./configure --prefix=/usr/local/mysql --disable-shared
+CFLAGS="-O6 -fomit-frame-pointer" CXX=gcc CXXFLAGS="-O6 -fomit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --disable-shared
 @end example
 
-Note that the last example assumes your are using an Alpha EV6 processor.
-
 Some known problems when running @strong{MySQL} on Linux-Alpha:
 
 @itemize @bullet
 @item
-If you create many files ( > 10000) in one directory (as done by the
-@code{test-create} in the @strong{MySQL} benchmarks, mysqld may report
-the error @code{Can't create/write to file '...' (Errcode: 12)}. This
-is probably a bug in the Linux-Alpha kernel.
-@item
 Debugging threaded applications like @strong{MySQL} will not work with
 @code{gdb 4.18}.  You should download and use gdb 5.0 instead!
 @item
-If you try linking mysqld staticly, the resulting image will core dump
-at start.  In other words, @strong{DON'T} use
-@code{--with-mysqld-ldflags=-all-static}
+If you try linking mysqld staticly when using gcc, the resulting image
+will core dump at start.  In other words, @strong{DON'T} use
+@code{--with-mysqld-ldflags=-all-static} with gcc
 @end itemize
 
-We don't yet know if the following old information is still relevant, so we
-leave this here until we have had time to test Linux-Alpha properly.
-
-If you have problems with signals (@strong{MySQL} dies unexpectedly
-under high load) you may have found an OS bug with threads and
-signals. In this case you can tell @strong{MySQL} not to use signals by
-configuring with:
-
-@example
-shell> CFLAGS=-DDONT_USE_THR_ALARM \
-       CXXFLAGS=-DDONT_USE_THR_ALARM \
-       ./configure ...
-@end example
-
-This doesn't affect the performance of @strong{MySQL}, but has the side
-effect that you can't kill clients that are ``sleeping'' on a connection with
-@code{mysqladmin kill} or @code{mysqladmin shutdown}.  Instead, the client
-will die when it issues its next command.
-
 @node MKLinux, Qube2, Linux-Alpha, Linux
 @subsubsection MkLinux Notes
 
@@ -30808,13 +30802,32 @@ problems if you have values > 127 in the column!
 
 @cindex ADO program
 @item ADO
-When you access @strong{MyODBC} through ADO, @strong{MyODBC} doesn't
-return a result for @code{SQLRowCount} for a query.  We have tried to
-track this down and according to ODBC logs, @strong{MyODBC} returns the
-correct answer but the ADO client only gets -1 back from the ODBC
-manager.  Because of this we can only assume this is a bug in ADO.
+When you are coding with the ADO API and @strong{MyODBC} you need to put
+attention in some default properties that aren't supported by the
+@strong{MySQL} server.  For example using the @code{CursorLocation
+Property} as @code{adUseServer} will return for the @code{RecordCount
+Property} a result of -1. To have the right value, you need to set this
+property to @code{adUseClient}, like is showing in the VB code below:
 
-The only known workaround is to use a @code{SELECT COUNT(*)} statement
+@example
+Dim myconn As New ADODB.Connection
+Dim myrs As New Recordset
+Dim mySQL As String
+Dim myrows As Long
+
+myconn.Open "DSN=MyODBCsample"
+mySQL = "SELECT * from user"
+myrs.Source = mySQL
+Set myrs.ActiveConnection = myconn
+myrs.CursorLocation = adUseClient
+myrs.Open
+myrows = myrs.RecordCount
+
+myrs.Close
+myconn.Close
+@end example
+
+Another workaround is to use a @code{SELECT COUNT(*)} statement
 for a similar query to get the correct row count.
 
 @cindex Borland Buidler 4 program
@@ -37705,7 +37718,7 @@ Fernandez Herrero.
 @itemize @bullet
 @item Graphical clients
 @itemize @bullet
-@item @uref{http://www.ideit.com/products/dbvis: DbVisualizer}
+@item @uref{http://www.ideit.com/products/dbvis, DbVisualizer}
 Freeware JDBC client to graphically visualize the data and structure
 of several databases simultaneously. By Innovative-IT Development AB.
 
@@ -38531,6 +38544,17 @@ though, so Version 3.23 is not released as a stable version yet.
 @appendixsubsec Changes in release 3.23.28
 @itemize @bullet
 @item
+Fixed bug when using a multi-part keys where the first part was of type
+@code{TEXT} or @code{BLOB}.
+@item
+@code{DROP} of temporary tables wasn't stored in the update/binary log.
+@item
+Fixed bug where @code{SELECT DISTINCT * ... LIMIT #} only returned 1 row.
+@item
+Fixed a bug in the assembler code in strstr for sparc and cleaned up
+the global.h header file to avoid a problem with bad aliasing with
+the compiler submitted with RedHat 7.0. (Reported by Trond Eivind Glomsrød)
+@item
 Fixed the @code{--skip-networking} works properly on NT.
 @item
 Fixed long outstanding bug in the @code{ISAM} tables when a row with a length
@@ -43045,6 +43069,9 @@ Allow users to change startup options without taking down the server.
 Help for all commands from the client.
 @item
 Secure connections (with SSL).
+@item
+Extend the optimizer to be able to optimize some
+@code{ORDER BY key_name DESC} queries.
 @end itemize
 
 @node TODO future, TODO sometime, TODO MySQL 4.0, TODO
@@ -43185,8 +43212,7 @@ Function @code{CASE}.
 Many more variables for @code{show status}.  Counts for:
 @code{INSERT}/@code{DELETE}/@code{UPDATE} statements. Records reads and
 updated.  Selects on 1 table and selects with joins.  Mean number of
-tables in select. Key buffer read/write hits (logical and real).
-@code{ORDER BY}, @code{GROUP BY}, temporary tables created.
+tables in select. Number of @code{ORDER BY} and @code{GROUP BY} queries.
 @item
 If you abort @code{mysql} in the middle of a query, you should open
 another connection and kill the old running query.

myisam/mi_key.c

@@ -181,10 +181,14 @@ uint _mi_pack_key(register MI_INFO *info, uint keynr, uchar *key, uchar *old,
     }
     else if (keyseg->flag & (HA_VAR_LENGTH | HA_BLOB_PART))
     {
-      uint tmp_length=uint2korr(pos); pos+=2;
+      /* Length of key-part used with mi_rkey() always 2 */
+      uint tmp_length=uint2korr(pos);
+      k_length-= 2+length;
       set_if_smaller(length,tmp_length);
       store_key_length_inc(key,length);
-      k_length-=2;
+      memcpy((byte*) key, pos+2,(size_t) length);
+      key+= length;
+      continue;
     }
     else if (keyseg->flag & HA_SWAP_KEY)
     {						/* Numerical column */

mysys/Makefile.am

@@ -61,7 +61,7 @@ DEFS =			-DDEFAULT_BASEDIR=\"$(prefix)\" \
 			-DSHAREDIR="\"$(MYSQLSHAREdir)\"" \
                         @DEFS@
 
-#getopt1.o:		@THREAD_LOBJECTS@
+libmysys_a_DEPENDENCIES= @THREAD_LOBJECTS@
 
 OMIT_DEPENDENCIES =	pthread.h stdio.h __stdio.h stdlib.h __stdlib.h math.h\
 			__math.h time.h __time.h unistd.h __unistd.h types.h \
@@ -75,11 +75,25 @@ OMIT_DEPENDENCIES =	pthread.h stdio.h __stdio.h stdlib.h __stdlib.h math.h\
 # I hope this always does the right thing. Otherwise this is only test programs
 FLAGS=$(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
 
+#
+# The CP .. RM stuff is to avoid problems with some compilers (like alpha ccc)
+# which automaticly removes the object files you use to compile a final program
+#
+
 test_thr_alarm: thr_alarm.c $(LIBRARIES)
-	$(LINK) $(FLAGS) -DMAIN $(srcdir)/thr_alarm.c $(LDADD) $(LIBS)
+	$(CP) $(srcdir)/thr_alarm.c ./test_thr_alarm.c
+	$(LINK) $(FLAGS) -DMAIN ./test_thr_alarm.c $(LDADD) $(LIBS)
+	$(RM) ./test_thr_alarm.*
 
 test_thr_lock: thr_lock.c $(LIBRARIES)
-	$(LINK) $(FLAGS) -DMAIN $(srcdir)/thr_lock.c $(LDADD) $(LIBS)
+	$(CP) $(srcdir)/thr_lock.c test_thr_lock.c
+	$(LINK) $(FLAGS) -DMAIN ./test_thr_lock.c $(LDADD) $(LIBS)
+	$(RM) ./test_thr_lock.*
+
+test_vsnprintf: my_vsnprintf.c $(LIBRARIES)
+	$(CP) $(srcdir)/my_vsnprintf.c test_vsnprintf.c
+	$(LINK) $(FLAGS) -DMAIN ./test_vsnprintf.c $(LDADD) $(LIBS)
+	$(RM) test_vsnprintf.*
 
 test_dir: test_dir.c $(LIBRARIES)
 	$(LINK) $(FLAGS) -DMAIN $(srcdir)/test_dir.c $(LDADD) $(LIBS)
@@ -87,9 +101,6 @@ test_dir: test_dir.c $(LIBRARIES)
 test_charset: test_charset.c $(LIBRARIES)
 	$(LINK) $(FLAGS) -DMAIN $(srcdir)/test_charset.c $(LDADD) $(LIBS)
 
-test_vsnprintf: my_vsnprintf.c $(LIBRARIES)
-	$(LINK) $(FLAGS) -DMAIN $(srcdir)/my_vsnprintf.c $(LDADD) $(LIBS)
-
 test_hash: test_hash.c $(LIBRARIES)
 	$(LINK) $(FLAGS) -DMAIN $(srcdir)/test_dir.c $(LDADD) $(LIBS)
 

sql-bench/Results/ATIS-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  0:30:52
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 15:05:04
 
 ATIS table test
 
@@ -6,14 +6,14 @@ Creating tables
 Time for create_table (28):  0 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Inserting data
-Time to insert (9768):  4 wallclock secs ( 0.66 usr  0.60 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to insert (9768):  3 wallclock secs ( 0.68 usr  0.60 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Retrieving data
-Time for select_simple_join (500):  2 wallclock secs ( 0.64 usr  0.38 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_join (200): 13 wallclock secs ( 4.22 usr  3.17 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_distinct (800): 11 wallclock secs ( 1.68 usr  1.02 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_group (2800): 10 wallclock secs ( 1.54 usr  0.65 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_simple_join (500):  2 wallclock secs ( 0.62 usr  0.39 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_join (200): 12 wallclock secs ( 4.31 usr  3.11 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_distinct (800): 11 wallclock secs ( 1.72 usr  0.95 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_group (2800): 10 wallclock secs ( 1.58 usr  0.66 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Removing tables
 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: 40 wallclock secs ( 8.74 usr  5.83 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 38 wallclock secs ( 8.93 usr  5.72 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/alter-table-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  0:31:33
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 15:05:42
 
 Testing of ALTER TABLE
 Testing with 1000 columns and 1000 rows in 20 steps
 Insert data into the table
-Time for insert (1000) 0 wallclock secs ( 0.06 usr  0.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for insert (1000) 1 wallclock secs ( 0.06 usr  0.04 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Time for alter_table_add (992): 238 wallclock secs ( 0.17 usr  0.07 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for alter_table_add (992): 205 wallclock secs ( 0.17 usr  0.07 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Time for create_index (8):  4 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Time for drop_index (8):  4 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Time for alter_table_drop (496): 189 wallclock secs ( 0.06 usr  0.04 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for alter_table_drop (496): 161 wallclock secs ( 0.07 usr  0.03 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Total time: 435 wallclock secs ( 0.29 usr  0.17 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 375 wallclock secs ( 0.30 usr  0.15 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/big-tables-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  0:38:49
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 15:11:57
 
 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): 11 wallclock secs ( 3.96 usr  5.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to select_many_fields(1000): 12 wallclock secs ( 4.18 usr  5.43 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): 16 wallclock secs ( 4.05 usr  5.09 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to select_many_fields(1000): 16 wallclock secs ( 4.55 usr  5.42 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing insert VALUES()
-Time to insert_many_fields(1000):  5 wallclock secs ( 0.31 usr  0.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to insert_many_fields(1000):  5 wallclock secs ( 0.30 usr  0.08 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing insert (all_fields) VALUES()
-Time to insert_many_fields(1000):  9 wallclock secs ( 0.03 usr  0.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to insert_many_fields(1000):  9 wallclock secs ( 0.04 usr  0.08 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Total time: 41 wallclock secs ( 8.36 usr 10.28 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 42 wallclock secs ( 9.09 usr 11.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/connect-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  0:39:31
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 15:12:39
 
 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): 13 wallclock secs ( 7.52 usr  2.74 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to connect (10000): 14 wallclock secs ( 8.15 usr  2.36 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Test connect/simple select/disconnect
-Time for connect+select_simple (10000): 16 wallclock secs ( 7.94 usr  3.21 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for connect+select_simple (10000): 16 wallclock secs ( 8.31 usr  3.17 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Test simple select
-Time for select_simple (10000):  2 wallclock secs ( 0.28 usr  0.79 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_simple (10000):  2 wallclock secs ( 0.29 usr  0.75 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): 16 wallclock secs ( 7.90 usr  3.25 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to connect+select_1_row (10000): 17 wallclock secs ( 8.55 usr  3.39 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing select 1 row from table
-Time to select_1_row (10000):  3 wallclock secs ( 0.38 usr  1.04 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to select_1_row (10000):  3 wallclock secs ( 0.41 usr  1.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing select 2 rows from table
-Time to select_2_rows (10000):  3 wallclock secs ( 0.35 usr  0.96 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to select_2_rows (10000):  3 wallclock secs ( 0.38 usr  0.89 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Test select with aritmetic (+)
-Time for select_column+column (10000):  3 wallclock secs ( 0.32 usr  0.73 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_column+column (10000):  3 wallclock secs ( 0.27 usr  0.75 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing retrieval of big records (65000 bytes)
-Time to select_big (10000): 20 wallclock secs ( 9.73 usr  0.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to select_big (10000): 19 wallclock secs ( 7.84 usr  5.67 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Total time: 76 wallclock secs (34.42 usr 12.79 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 77 wallclock secs (34.21 usr 17.98 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/create-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  0:40:47
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 15:13:56
 
 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): 91 wallclock secs ( 1.80 usr  0.61 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for create_MANY_tables (10000): 91 wallclock secs ( 1.85 usr  0.61 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Accessing tables
-Time to select_group_when_MANY_tables (10000):  7 wallclock secs ( 0.95 usr  0.90 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to select_group_when_MANY_tables (10000):  6 wallclock secs ( 0.92 usr  0.90 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing drop
-Time for drop_table_when_MANY_tables (10000):  7 wallclock secs ( 0.69 usr  0.60 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for drop_table_when_MANY_tables (10000):  7 wallclock secs ( 0.63 usr  0.62 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing create+drop
-Time for create+drop (10000): 13 wallclock secs ( 2.72 usr  1.19 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for create_key+drop (10000): 17 wallclock secs ( 4.20 usr  1.25 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Total time: 135 wallclock secs (10.37 usr  4.56 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for create+drop (10000): 13 wallclock secs ( 2.86 usr  0.85 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for create_key+drop (10000): 17 wallclock secs ( 4.39 usr  1.33 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 134 wallclock secs (10.66 usr  4.31 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/insert-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  0:43:02
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 15:16:11
 
 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,72 +8,78 @@ Creating tables
 Inserting 100000 rows in order
 Inserting 100000 rows in reverse order
 Inserting 100000 rows in random order
-Time for insert (300000): 110 wallclock secs (19.18 usr 17.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for insert (300000): 116 wallclock secs (23.42 usr 16.99 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing insert of duplicates
-Time for insert_duplicates (100000): 40 wallclock secs ( 6.20 usr  6.19 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for insert_duplicates (100000): 39 wallclock secs ( 5.58 usr  6.03 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Retrieving data from the table
-Time for select_big (10:3000000): 35 wallclock secs (20.45 usr 14.85 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for order_by_key (10:3000000): 36 wallclock secs (20.39 usr 14.82 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for order_by (10:3000000): 51 wallclock secs (21.06 usr 22.46 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_diff_key (500:1000): 175 wallclock secs ( 0.24 usr  0.05 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_range_prefix (5010:42084): 11 wallclock secs ( 2.81 usr  0.93 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_range_key2 (5010:42084): 10 wallclock secs ( 2.78 usr  1.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_key_prefix (200000): 146 wallclock secs (76.59 usr 19.98 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_key (200000): 141 wallclock secs (74.40 usr 21.54 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_key2 (200000): 146 wallclock secs (76.95 usr 20.42 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_big (10:3000000): 37 wallclock secs (22.33 usr 14.93 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_big_key (10:3000000): 37 wallclock secs (22.01 usr 14.79 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_big_key_desc (10:3000000): 37 wallclock secs (22.03 usr 14.87 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_big_key2 (10:3000000): 37 wallclock secs (22.02 usr 14.86 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_big_key_diff (10:3000000): 52 wallclock secs (23.11 usr 21.71 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_big (10:3000000): 54 wallclock secs (22.86 usr 21.67 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_range (500:125750):  5 wallclock secs ( 1.17 usr  0.65 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_key (500:125750):  3 wallclock secs ( 1.17 usr  0.64 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for order_by_key2_diff (500:250500):  5 wallclock secs ( 2.05 usr  1.25 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_diff_key (500:1000): 154 wallclock secs ( 0.23 usr  0.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_range_prefix (5010:42084): 10 wallclock secs ( 2.79 usr  0.99 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_range_key2 (5010:42084): 11 wallclock secs ( 2.80 usr  1.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_key_prefix (200000): 144 wallclock secs (76.89 usr 20.33 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_key (200000): 137 wallclock secs (75.62 usr 20.87 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_key2 (200000): 144 wallclock secs (76.78 usr 20.52 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Test of compares with simple ranges
-Time for select_range_prefix (20000:43500):  9 wallclock secs ( 3.73 usr  1.36 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_range_key2 (20000:43500):  9 wallclock secs ( 3.69 usr  1.36 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_group (111): 41 wallclock secs ( 0.05 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for min_max_on_key (15000): 10 wallclock secs ( 4.68 usr  1.32 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for min_max (60): 23 wallclock secs ( 0.03 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count_on_key (100): 38 wallclock secs ( 0.04 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count (100): 53 wallclock secs ( 0.04 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_range_prefix (20000:43500):  8 wallclock secs ( 3.67 usr  1.34 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_range_key2 (20000:43500):  9 wallclock secs ( 3.70 usr  1.29 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_group (111): 42 wallclock secs ( 0.04 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for min_max_on_key (15000):  9 wallclock secs ( 4.71 usr  1.26 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for min_max (60): 21 wallclock secs ( 0.02 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_on_key (100): 41 wallclock secs ( 0.04 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count (100): 49 wallclock secs ( 0.03 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 Time for count_distinct_big (20): 58 wallclock secs ( 0.00 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing update of keys with functions
-Time for update_of_key (50000):  22 wallclock secs ( 2.91 usr  2.54 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for update_of_key_big (501): 19 wallclock secs ( 0.04 usr  0.03 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for update_of_key (50000):  26 wallclock secs ( 3.38 usr  2.96 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for update_of_key_big (501): 18 wallclock secs ( 0.04 usr  0.04 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing update with key
-Time for update_with_key (300000):  139 wallclock secs (23.06 usr 19.06 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for update_with_key (300000):  134 wallclock secs (21.08 usr 18.70 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing update of all rows
-Time for update_big (10):  28 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for update_big (10):  25 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing left outer join
-Time for outer_join_on_key (10:10):  42 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for outer_join (10:10):  65 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for outer_join_found (10:10):  60 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for outer_join_not_found (500:10):  38 wallclock secs ( 0.01 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for outer_join_on_key (10:10):  40 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for outer_join (10:10):  61 wallclock secs ( 0.01 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for outer_join_found (10:10):  55 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for outer_join_not_found (500:10):  35 wallclock secs ( 0.01 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing INSERT INTO ... SELECT
-Time for insert_select_1_key (1):   5 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for insert_select_1_key (1):   4 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 Time for insert_select_2_keys (1):   7 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 Time for drop table(2):  0 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing delete
-Time for delete_key (10000):  5 wallclock secs ( 0.68 usr  0.58 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for delete_key (10000):  4 wallclock secs ( 0.65 usr  0.54 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 Time for delete_all (12): 11 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): 95 wallclock secs ( 8.49 usr  5.48 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for insert_key (100000): 93 wallclock secs ( 8.08 usr  5.73 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing update of keys
-Time for update_of_key (256): 22 wallclock secs ( 0.02 usr  0.02 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for update_of_key (256): 21 wallclock secs ( 0.03 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): 49 wallclock secs ( 0.01 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for delete_big_many_keys (128): 49 wallclock secs ( 0.01 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Deleting everything from table
-Time for delete_all_many_keys (1): 49 wallclock secs ( 0.01 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for delete_all_many_keys (1): 49 wallclock secs ( 0.01 usr  0.01 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Inserting 100000 rows with multiple values
-Time for multiple_value_insert (100000):  7 wallclock secs ( 2.08 usr  0.05 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for multiple_value_insert (100000):  7 wallclock secs ( 2.19 usr  0.05 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Time for drop table(1):  0 wallclock secs ( 0.00 usr  0.00 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Total time: 1756 wallclock secs (370.65 usr 171.18 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 1851 wallclock secs (450.58 usr 224.15 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/select-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  1:12:21
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 17:02:47
 
 Testing the speed of selecting on keys that consist of many parts
 The test-table has 10000 rows and the test is done with 500 ranges.
 
 Creating table
 Inserting 10000 rows
-Time to insert (10000):  3 wallclock secs ( 0.72 usr  0.58 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to insert (10000):  3 wallclock secs ( 0.76 usr  0.64 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
 Testing big selects on the table
-Time for select_big (70:17207):  1 wallclock secs ( 0.14 usr  0.09 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for select_range (410:1057904): 269 wallclock secs ( 9.47 usr  5.61 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for min_max_on_key (70000): 178 wallclock secs (20.97 usr  6.44 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count_on_key (50000): 414 wallclock secs (15.80 usr  4.56 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_big (70:17207):  1 wallclock secs ( 0.13 usr  0.10 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for select_range (410:1057904): 228 wallclock secs ( 8.51 usr  5.59 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for min_max_on_key (70000): 177 wallclock secs (20.71 usr  6.35 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_on_key (50000): 413 wallclock secs (15.79 usr  4.45 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Time for count_group_on_key_parts (1000:0): 44 wallclock secs ( 1.15 usr  0.58 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_group_on_key_parts (1000:100000): 39 wallclock secs ( 0.99 usr  0.61 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 Testing count(distinct) on the table
-Time for count_distinct (1000:2000): 94 wallclock secs ( 0.64 usr  0.20 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count_distinct_group_on_key (1000:6000): 48 wallclock secs ( 0.37 usr  0.16 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count_distinct_group_on_key_parts (1000:100000): 69 wallclock secs ( 1.10 usr  0.62 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count_distinct_group (1000:100000): 69 wallclock secs ( 1.13 usr  0.58 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Time for count_distinct_big (1000:10000000): 793 wallclock secs (79.09 usr 89.49 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
-Total time: 1982 wallclock secs (130.60 usr 108.91 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_distinct (2000:2000): 86 wallclock secs ( 0.71 usr  0.21 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_distinct_group_on_key (1000:6000): 42 wallclock secs ( 0.45 usr  0.15 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_distinct_group_on_key_parts (1000:100000): 72 wallclock secs ( 1.08 usr  0.62 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_distinct_group (1000:100000): 72 wallclock secs ( 1.07 usr  0.63 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for count_distinct_big (100:1000000): 82 wallclock secs ( 7.24 usr  8.68 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 1215 wallclock secs (57.43 usr 28.03 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/Results/wisconsin-mysql-Linux_2.2.13_SMP_alpha

-Testing server 'MySQL 3.23.25 beta' at 2000-10-13  1:45:23
+Testing server 'MySQL 3.23.28 gamma' at 2000-11-18 16:16:05
 
 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)
 
 Inserting data
-Time to insert (31000): 15 wallclock secs ( 1.91 usr  1.77 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time to insert (31000): 15 wallclock secs ( 1.85 usr  1.84 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):  4 wallclock secs ( 1.75 usr  0.93 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Time for wisc_benchmark (114):  4 wallclock secs ( 1.92 usr  0.94 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
 
-Total time: 19 wallclock secs ( 3.67 usr  2.69 sys +  0.00 cusr  0.00 csys =  0.00 CPU)
+Total time: 19 wallclock secs ( 3.77 usr  2.78 sys +  0.00 cusr  0.00 csys =  0.00 CPU)

sql-bench/test-select.sh

@@ -338,13 +338,14 @@ if ($limits->{'group_functions'})
 
   $loop_time=new Benchmark;
   $rows=$estimated=$count=0;
-  for ($i=0 ; $i < $opt_medium_loop_count ; $i++)
+  $test_count=$opt_medium_loop_count/10;
+  for ($i=0 ; $i < $test_count ; $i++)
   {
     $count++;
     $rows+=fetch_all_rows($dbh,"select idn,count(distinct region) from bench1 group by idn");
     $end_time=new Benchmark;
     last if ($estimated=predict_query_time($loop_time,$end_time,\$count,$i+1,
-					   $opt_medium_loop_count));
+					   $test_count));
   }
   print_time($estimated);
   print " for count_distinct_big ($count:$rows): " .

sql/log.cc

@@ -703,7 +703,7 @@ void MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
 	VOID(pthread_mutex_unlock(&LOCK_log));
 	return;
       }
-      if (specialflag & SPECIAL_LONG_LOG_FORMAT)
+      if ((specialflag & SPECIAL_LONG_LOG_FORMAT) || query_start)
       {
 	current_time=time(NULL);
 	if (current_time != last_time)
@@ -724,28 +724,26 @@ void MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
 	  if (my_b_write(&log_file, (byte*) buff,24))
 	    error=errno;
 	}
-	if (my_b_printf(&log_file, "# User@Host: %s [%s] @ %s [%s]\n",
+	if (my_b_printf(&log_file, "# User@Host: %s[%s] @ %s [%s]\n",
 			thd->priv_user,
 			thd->user,
 			thd->host ? thd->host : "",
-			thd->ip ? thd->ip : ""))
+			thd->ip ? thd->ip : "") == (uint) -1)
 	  error=errno;
       }
       if (query_start)
       {
 	/* For slow query log */
-	if (!(specialflag & SPECIAL_LONG_LOG_FORMAT))
-	  current_time=time(NULL);
 	if (my_b_printf(&log_file,
 			"# Time: %lu  Lock_time: %lu  Rows_sent: %lu\n",
 			(ulong) (current_time - query_start),
 			(ulong) (thd->time_after_lock - query_start),
-			(ulong) thd->sent_row_count))
+			(ulong) thd->sent_row_count) == (uint) -1)
 	    error=errno;
       }
       if (thd->db && strcmp(thd->db,db))
       {						// Database changed
-	if (my_b_printf(&log_file,"use %s;\n",thd->db))
+	if (my_b_printf(&log_file,"use %s;\n",thd->db) == (uint) -1)
 	  error=errno;
 	strmov(db,thd->db);
       }

sql/mysqld.cc

@@ -172,7 +172,7 @@ static char **defaults_argv,time_zone[30];
 static const char *default_table_type_name;
 
 #ifdef HAVE_OPENSSL
-static bool opt_use_ssl = false;
+static bool opt_use_ssl = FALSE;
 static char *opt_ssl_key = 0;
 static char *opt_ssl_cert = 0;
 static char *opt_ssl_ca = 0;

sql/share/german/errmsg.txt

@@ -166,35 +166,35 @@
 "Timeout beim Lesen eines Communication-Packets",
 "Fehler beim Schreiben eines Communication-Packets",
 "Timeout beim Schreiben eines Communication-Packets",
-"Result string is longer than max_allowed_packet",
-"The used table type doesn't support BLOB/TEXT columns",
-"The used table type doesn't support AUTO_INCREMENT columns",
-"INSERT DELAYED can't be used with table '%-.64s', because it is locked with LOCK TABLES",
-"Incorrect column name '%-.100s'",
-"The used table handler can't index column '%-.64s'",
-"All tables in the MERGE table are not defined identically",
-"Can't write, because of unique constraint, to table '%-.64s'",
-"BLOB column '%-.64s' used in key specification without a key length",
-"All parts of a PRIMARY KEY must be NOT NULL;  If you need NULL in a key, use UNIQUE instead",
-"Result consisted of more than one row",
-"This table type requires a primary key",
-"This version of MySQL is not compiled with RAID support",
-"You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column",
-"Key '%-.64s' doesn't exist in table '%-.64s'",
-"Can't open table",
-"The handler for the table doesn't support check/repair",
-"You are not allowed to execute this command in a transaction",
-"Got error %d during COMMIT",
-"Got error %d during ROLLBACK",
-"Got error %d during FLUSH_LOGS",
-"Got error %d during CHECKPOINT",
-"Aborted connection %ld to db: '%-.64s' user: '%-.32s' host: `%-.64s' (%-.64s)",
-"The handler for the table does not support binary table dump",
-"Binlog closed while trying to FLUSH MASTER",
-"Failed rebuilding the index of dumped table '%-.64s'",
-"Error from master: '%-.64s'",
-"Net error reading from master",
-"Net error writing to master",
-"Can't find FULLTEXT index matching the column list",
+"Ergebnisstring ist länger als max_allowed_packet",
+"Der verwendete Tabellentyp unterstützt keine BLOB/TEXT Spalten",
+"Der verwendete Tabellentyp unterstützt keine AUTO_INCREMENT Spalte",
+"INSERT DELAYED kann nicht auf Tabelle '%-.64s' angewendet werden, da diese mit LOCK TABLES gesperrt ist",
+"Falscher Spaltenname '%-.100s'",
+"Der verwendete Tabellen-Handler kann die Spalte '%-.64s' nicht indizieren",
+"Alle Tabelle in der MERGE-Tabelle sind nicht gleich definiert",
+"Schreiben in Tabelle '%-.64s' nicht möglich wegen eines Unique Constraint",
+"BLOB Spalte '%-.64s' wird in der Key-Definition ohne Längenangabe verwendet",
+"Alle Teile eines PRIMARY KEY müssen als NOT NULL definiert sein; Wenn NULL benötigt wird sollte ein UNIQUE Key verwendet werden",
+"Ergebnis besteht aus mehr als einer Reihe",
+"Dieser Tabellentyp verlangt nach einem PRIMARY KEY",
+"Diese MySQL-Version ist nicht mit RAID-Unterstützung kompiliert",
+"Unter Verwendung des Sicheren Updatemodes wurde versucht eine Tabelle zu updaten ohne eine KEY-Spalte in der WHERE-Klausel",
+"Schlüssel '%-.64s' existiert nicht in der Tabelle '%-.64s'",
+"Kann Tabelle nicht öffnen",
+"Der Tabellen-Handler für diese Tabelle unterstützt kein check/repair",
+"Keine Berechtigung dieses Kommando in einer Transaktion auszuführen",
+"Fehler %d wärend COMMIT",
+"Fehler %d wärend ROLLBACK",
+"Fehler %d wärend FLUSH_LOGS",
+"Fehler %d wärend CHECKPOINT",
+"Verbindungsabbruch  %ld zu db: '%-.64s' user: '%-.32s' host: `%-.64s' (%-.64s)",
+"Der Tabellenhandler für die Tabelle unterstützt kein Binary Tabellendump",
+"Binlog wurde beendet wärend FLUSH MASTER",
+"Neubau des Index der gedumpten Tabelle '%-.64s' fehlgeschlagen",
+"Fehler vom Master: '%-.64s'",
+"Netzfehler beim Lesen vom Master",
+"Netzfehler beim Schreiben zum Master",
+"Kann keinen FULLTEXT-Index finden der der Spaltenliste entspricht",
 "Can't execute the given command because you have active locked tables or an active transaction",
 "Unknown system variable '%-.64'",

sql/sql_base.cc

@@ -1687,6 +1687,7 @@ insert_fields(THD *thd,TABLE_LIST *tables, const char *table_name,
     if (!table_name || !strcmp(table_name,tables->name))
     {
       Field **ptr=table->field,*field;
+      thd->used_tables|=table->map;
       while ((field = *ptr++))
       {
 	Item_field *item= new Item_field(field);

sql/sql_insert.cc

@@ -118,11 +118,10 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list, List<Item> &fields,
     if we are told to replace duplicates, the insert cannot be concurrent
     delayed insert changed to regular in slave thread
    */
-  if (lock_type == TL_WRITE_DELAYED &&
-      ((specialflag & (SPECIAL_NO_NEW_FUNC | SPECIAL_SAFE_MODE)) ||
-       thd->slave_thread
-       ) ||
-      lock_type == TL_WRITE_CONCURRENT_INSERT && duplic == DUP_REPLACE)
+  if ((lock_type == TL_WRITE_DELAYED &&
+       ((specialflag & (SPECIAL_NO_NEW_FUNC | SPECIAL_SAFE_MODE)) ||
+	thd->slave_thread)) ||
+      (lock_type == TL_WRITE_CONCURRENT_INSERT && duplic == DUP_REPLACE))
     lock_type=TL_WRITE;
 
   if (lock_type == TL_WRITE_DELAYED)

sql/sql_table.cc

@@ -79,7 +79,10 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists)
   {
     char *db=table->db ? table->db : thd->db;
     if (!close_temporary_table(thd, db, table->real_name))
+    {
+      some_tables_deleted=1;			// Log query
       continue;					// removed temporary table
+    }
 
     abort_locked_tables(thd,db,table->real_name);
     while (remove_table_from_cache(thd,db,table->real_name) && !thd->killed)

vio/VioFd.cc

@@ -82,13 +82,13 @@ VioFd::keepalive(boolonoff)
 bool
 VioFd::fcntl() const
 {
-  return false;
+  return FALSE;
 }
 
 bool
 VioFd::should_retry() const
 {
-  return false;
+  return FALSE;
 }
 
 int

vio/VioSSL.cc

@@ -48,7 +48,7 @@ report_errors()
 VioSSL::VioSSL(int fd,
 	       vio_ptr	ssl_context,
 	       int state)
-  : bio_(0), ssl_con_(0), open_(false), sd_(new VioSocket(fd))
+  : bio_(0), ssl_con_(0), open_(FALSE), sd_(new VioSocket(fd))
 {
   DBUG_ENTER("VioSSL::VioSSL");
   DBUG_PRINT("enter", ("this=%p, fd=%d, ssl_context=%p, state=%d",
@@ -66,7 +66,7 @@ VioSSL::VioSSL(int fd,
 VioSSL::VioSSL(VioSocket* sd,
 	       vio_ptr	 ssl_context,
 	       int state)
-  :bio_(0), ssl_con_(0), open_(false), sd_(sd)
+  :bio_(0), ssl_con_(0), open_(FALSE), sd_(sd)
 {
   DBUG_ENTER("VioSSL::VioSSL");
   DBUG_PRINT("enter",

vio/VioSSLFactoriesFd.cc

@@ -24,8 +24,8 @@ VIO_NS_BEGIN
 #define this_ssl_context	my_static_cast(SSL_CTX*)(this->ssl_context_)
 typedef unsigned char*		ssl_data_ptr_t;
 
-static bool	ssl_algorithms_added	= false;
-static bool	ssl_error_strings_loaded= false;
+static bool	ssl_algorithms_added	= FALSE;
+static bool	ssl_error_strings_loaded= FALSE;
 static int	verify_depth = 0;
 static int	verify_error = X509_V_OK;
 

vio/VioSocket.cc

@@ -73,7 +73,7 @@ VIO_NS_BEGIN
 
 VioSocket::VioSocket(vio_socket	sd, enum_vio_type type, bool localhost)
 :sd_(sd), localhost_(localhost), fcntl_(0),
- fcntl_set_(false), cipher_description_(0)
+ fcntl_set_(FALSE), cipher_description_(0)
 {
   DBUG_ENTER("VioSocket::VioSocket");
   DBUG_PRINT("enter", ("sd=%d", sd));