Merge ua141d10.elisa.omakaista.fi:/home/my/bk/mysql-4.1-main

into  ua141d10.elisa.omakaista.fi:/home/my/bk/mysql-5.0-marvel

client/mysqlbinlog.cc

@@ -1105,7 +1105,7 @@ could be out of memory");
     }
     if (len < 8 && net->read_pos[0] == 254)
       break; // end of data
-    DBUG_PRINT("info",( "len: %lu, net->read_pos[5]: %d\n",
+    DBUG_PRINT("info",( "len: %lu  net->read_pos[5]: %d\n",
 			len, net->read_pos[5]));
     if (!(ev= Log_event::read_log_event((const char*) net->read_pos + 1 ,
                                         len - 1, &error_msg,

include/raid.h

@@ -140,7 +140,7 @@ class RaidFd {
     inline void Calculate()
     {
       DBUG_ENTER("RaidFd::_Calculate");
-      DBUG_PRINT("info",("_position: %lu _raid_chunksize: %d, _size: %lu",
+      DBUG_PRINT("info",("_position: %lu  _raid_chunksize: %lu  _size: %lu",
 			 (ulong) _position, _raid_chunksize, (ulong) _size));
 
       _total_block = (ulong) (_position / _raid_chunksize);
@@ -148,7 +148,7 @@ class RaidFd {
       _remaining_bytes = (uint) (_raid_chunksize -
 				 (_position - _total_block * _raid_chunksize));
       DBUG_PRINT("info",
-		 ("_total_block: %d  this_block: %d  _remaining_bytes:%d",
+		 ("_total_block: %lu  this_block: %d  _remaining_bytes: %d",
 		  _total_block, _this_block, _remaining_bytes));
       DBUG_VOID_RETURN;
     }

mysys/my_handler.c

@@ -557,4 +557,3 @@ HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a)
   }
   return keyseg;
 }
-

mysys/my_lib.c

@@ -627,7 +627,7 @@ int my_fstat(int Filedes, MY_STAT *stat_area,
              myf MyFlags __attribute__((unused)))
 {
   DBUG_ENTER("my_fstat");
-  DBUG_PRINT("my",("fd: %d MyFlags: %d",Filedes,MyFlags));
+  DBUG_PRINT("my",("fd: %d  MyFlags: %d", Filedes, MyFlags));
   DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
 }
 
@@ -636,7 +636,7 @@ MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags)
 {
   int m_used;
   DBUG_ENTER("my_stat");
-  DBUG_PRINT("my", ("path: '%s', stat_area: 0x%lx, MyFlags: %d", path,
+  DBUG_PRINT("my", ("path: '%s'  stat_area: 0x%lx  MyFlags: %d", path,
                     (long) stat_area, my_flags));
 
   if ((m_used= (stat_area == NULL)))

mysys/my_seek.c

@@ -60,7 +60,7 @@ my_off_t my_seek(File fd, my_off_t pos, int whence,
   if (newpos == (os_off_t) -1)
   {
     my_errno=errno;
-    DBUG_PRINT("error",("lseek: %lu, errno: %d", (ulong) newpos,errno));
+    DBUG_PRINT("error",("lseek: %lu  errno: %d", (ulong) newpos,errno));
     DBUG_RETURN(MY_FILEPOS_ERROR);
   }
   if ((my_off_t) newpos != pos)

mysys/raid.cc

@@ -232,7 +232,7 @@ extern "C" {
   {
     DBUG_ENTER("my_raid_pwrite");
     DBUG_PRINT("enter",
-               ("Fd: %d  Buffer: 0x %lx  Count: %u offset: %u  MyFlags: %d",
+               ("Fd: %d  Buffer: 0x%lx  Count: %u  offset: %u  MyFlags: %d",
                 Filedes, Buffer, Count, offset, MyFlags));
      if (is_raid(Filedes))
      {
@@ -251,8 +251,8 @@ extern "C" {
 		   myf MyFlags)
   {
     DBUG_ENTER("my_raid_lock");
-    DBUG_PRINT("enter",("Fd: %d  start: %u  length: %u  MyFlags: %d",
-		      fd, start, length, MyFlags));
+    DBUG_PRINT("enter",("Fd: %d  start: %lu  length: %lu  MyFlags: %d",
+                        fd, (ulong) start, (ulong) length, MyFlags));
     if (my_disable_locking)
       DBUG_RETURN(0);
     if (is_raid(fd))
@@ -285,8 +285,8 @@ extern "C" {
   int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
   {
     DBUG_ENTER("my_raid_chsize");
-    DBUG_PRINT("enter",("Fd: %d  newlength: %u  MyFlags: %d",
-		      fd, newlength, MyFlags));
+    DBUG_PRINT("enter",("Fd: %d  newlength: %lu  MyFlags: %d",
+                        fd, (ulong) newlength, MyFlags));
    if (is_raid(fd))
    {
      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
@@ -414,7 +414,7 @@ RaidFd(uint raid_type, uint raid_chunks, ulong raid_chunksize)
    _fd_vector(0)
 {
   DBUG_ENTER("RaidFd::RaidFd");
-  DBUG_PRINT("enter",("RaidFd_type: %u  Disks: %u  Chunksize: %d",
+  DBUG_PRINT("enter",("RaidFd_type: %u  Disks: %u  Chunksize: %lu",
 		   raid_type, raid_chunks, raid_chunksize));
 
   /* TODO: Here we should add checks if the malloc fails */
@@ -623,7 +623,7 @@ Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags)
 {
   DBUG_ENTER("RaidFd::Lock");
   DBUG_PRINT("enter",("locktype: %d  start: %lu  length: %lu  MyFlags: %d",
-		      locktype, start, length, MyFlags));
+		      locktype, (ulong) start, (ulong) length, MyFlags));
   my_off_t bufptr = start;
   // Loop until all data is locked
   while(length)
@@ -733,8 +733,8 @@ my_off_t RaidFd::
 Tell(myf MyFlags)
 {
   DBUG_ENTER("RaidFd::Tell");
-  DBUG_PRINT("enter",("MyFlags: %d _position %d",
-		   MyFlags,_position));
+  DBUG_PRINT("enter",("MyFlags: %d  _position: %lu",
+                      MyFlags, (ulong) _position));
   DBUG_RETURN(_position);
 }
 
@@ -742,8 +742,8 @@ int RaidFd::
 Chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
 {
   DBUG_ENTER("RaidFd::Chsize");
-  DBUG_PRINT("enter",("Fd: %d, newlength: %d, MyFlags: %d",
-		   fd, newlength,MyFlags));
+  DBUG_PRINT("enter",("Fd: %d  newlength: %lu  MyFlags: %d",
+                      fd, (ulong) newlength, MyFlags));
   _position = newlength;
   Calculate();
   uint _rounds = _total_block / _raid_chunks;	     // INT() assumed

mysys/thr_lock.c

@@ -658,7 +658,7 @@ thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner,
 	  goto end;
 	}
       }
-      DBUG_PRINT("lock",("write locked by thread: %ld, type: %d",
+      DBUG_PRINT("lock",("write locked by thread: %ld  type: %d",
 			 lock->read.data->owner->info->thread_id, data->type));
     }
     wait_queue= &lock->write_wait;

sql/ha_ndbcluster.cc

@@ -755,7 +755,7 @@ int ha_ndbcluster::set_ndb_value(NdbOperation *ndb_op, Field *field,
         blob_ptr= (char*)"";
       }
 
-      DBUG_PRINT("value", ("set blob ptr=%p len=%u",
+      DBUG_PRINT("value", ("set blob ptr: %p  len: %u",
                            blob_ptr, blob_len));
       DBUG_DUMP("value", (char*)blob_ptr, min(blob_len, 26));
 
@@ -4387,7 +4387,7 @@ int ha_ndbcluster::create(const char *name,
   for (i= 0; i < form->s->fields; i++) 
   {
     Field *field= form->field[i];
-    DBUG_PRINT("info", ("name: %s, type: %u, pack_length: %d", 
+    DBUG_PRINT("info", ("name: %s  type: %u  pack_length: %d", 
                         field->field_name, field->real_type(),
                         field->pack_length()));
     if ((my_errno= create_ndb_column(col, field, create_info)))
@@ -5968,7 +5968,7 @@ static int packfrm(const void *data, uint len,
   uint blob_len;
   frm_blob_struct* blob;
   DBUG_ENTER("packfrm");
-  DBUG_PRINT("enter", ("data: 0x%lx, len: %d", (long) data, len));
+  DBUG_PRINT("enter", ("data: 0x%lx  len: %d", (long) data, len));
   
   error= 1;
   org_len= len;
@@ -5995,7 +5995,8 @@ static int packfrm(const void *data, uint len,
   *pack_len= blob_len;
   error= 0;
   
-  DBUG_PRINT("exit", ("pack_data: 0x%lx, pack_len: %d", (long) *pack_data, *pack_len));
+  DBUG_PRINT("exit", ("pack_data: 0x%lx  pack_len: %d", (long) *pack_data,
+                      *pack_len));
 err:
   DBUG_RETURN(error);
   
@@ -6034,7 +6035,8 @@ static int unpackfrm(const void **unpack_data, uint *unpack_len,
    *unpack_data= data;
    *unpack_len= complen;
 
-   DBUG_PRINT("exit", ("frmdata: 0x%lx, len: %d", (long) *unpack_data, *unpack_len));
+   DBUG_PRINT("exit", ("frmdata: 0x%lx  len: %d", (long) *unpack_data,
+                       *unpack_len));
 
    DBUG_RETURN(0);
 }

sql/item_cmpfunc.cc

@@ -2367,7 +2367,7 @@ byte *in_row::get_value(Item *item)
 void in_row::set(uint pos, Item *item)
 {
   DBUG_ENTER("in_row::set");
-  DBUG_PRINT("enter", ("pos %u item 0x%lx", pos, (ulong) item));
+  DBUG_PRINT("enter", ("pos: %u  item: 0x%lx", pos, (ulong) item));
   ((cmp_item_row*) base)[pos].store_value_by_template(&tmp, item);
   DBUG_VOID_RETURN;
 }

sql/net_serv.cc

@@ -818,7 +818,7 @@ my_real_read(NET *net, ulong *complen)
         {
           my_bool interrupted = vio_should_retry(net->vio);
 
-	  DBUG_PRINT("info",("vio_read returned %ld,  errno: %d",
+	  DBUG_PRINT("info",("vio_read returned %ld  errno: %d",
 			     length, vio_errno(net->vio)));
 #if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2)) || defined(MYSQL_SERVER)
 	  /*

sql/sql_cache.cc

@@ -381,7 +381,7 @@ inline Query_cache_block * Query_cache_block_table::block()
 void Query_cache_block::init(ulong block_length)
 {
   DBUG_ENTER("Query_cache_block::init");
-  DBUG_PRINT("qcache", ("init block 0x%lx  length: %lu", (ulong) this,
+  DBUG_PRINT("qcache", ("init block: 0x%lx  length: %lu", (ulong) this,
 			block_length));
   length = block_length;
   used = 0;
@@ -3675,7 +3675,7 @@ void Query_cache::queries_dump()
       Query_cache_query_flags flags;
       memcpy(&flags, str+len, QUERY_CACHE_FLAGS_SIZE);
       str[len]= 0; // make zero ending DB name
-      DBUG_PRINT("qcache", ("F:%u C:%u L:%lu T:'%s' (%u) '%s' '%s'",
+      DBUG_PRINT("qcache", ("F: %u  C: %u L: %lu  T: '%s' (%u)  '%s'  '%s'",
 			    flags.client_long_flag,
 			    flags.character_set_client_num, 
                             (ulong)flags.limit,
@@ -3998,7 +3998,7 @@ my_bool Query_cache::check_integrity(bool locked)
       } while (block != bins[i].free_blocks);
       if (count != bins[i].number)
       {
-	DBUG_PRINT("error", ("bins[%d].number = %d, but bin have %d blocks",
+	DBUG_PRINT("error", ("bins[%d].number= %d, but bin have %d blocks",
 			     i, bins[i].number,  count));
 	result = 1;
       }

sql/sql_class.cc

@@ -748,7 +748,8 @@ void THD::add_changed_table(const char *key, long key_length)
     {
       list_include(prev_changed, curr, changed_table_dup(key, key_length));
       DBUG_PRINT("info", 
-		 ("key_length %ld %u", key_length, (*prev_changed)->key_length));
+		 ("key_length: %ld  %u", key_length,
+                  (*prev_changed)->key_length));
       DBUG_VOID_RETURN;
     }
     else if (cmp == 0)
@@ -758,7 +759,7 @@ void THD::add_changed_table(const char *key, long key_length)
       {
 	list_include(prev_changed, curr, changed_table_dup(key, key_length));
 	DBUG_PRINT("info", 
-		   ("key_length %ld %u", key_length,
+		   ("key_length:  %ld  %u", key_length,
 		    (*prev_changed)->key_length));
 	DBUG_VOID_RETURN;
       }
@@ -770,7 +771,7 @@ void THD::add_changed_table(const char *key, long key_length)
     }
   }
   *prev_changed = changed_table_dup(key, key_length);
-  DBUG_PRINT("info", ("key_length %ld %u", key_length,
+  DBUG_PRINT("info", ("key_length: %ld  %u", key_length,
 		      (*prev_changed)->key_length));
   DBUG_VOID_RETURN;
 }

sql/sql_prepare.cc

@@ -1668,7 +1668,7 @@ static bool check_prepared_statement(Prepared_statement *stmt,
   enum enum_sql_command sql_command= lex->sql_command;
   int res= 0;
   DBUG_ENTER("check_prepared_statement");
-  DBUG_PRINT("enter",("command: %d, param_count: %u",
+  DBUG_PRINT("enter",("command: %d  param_count: %u",
                       sql_command, stmt->param_count));
 
   lex->first_lists_tables_same();