Lots of fixes for BDB tables

Change DROP TABLE to first drop the data, then the .frm file


Docs/manual.texi:
  Updated TODO and Changelog
include/Makefile.am:
  Portability fix
mysql-test/misc/select.res:
  ***MISSING WEAVE***
mysys/mf_iocache2.c:
  cleanup
scripts/mysqlhotcopy.sh:
  Fixed --noindices
sql-bench/Results/ATIS-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/RUN-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/alter-table-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/big-tables-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/connect-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/create-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/insert-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/select-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/Results/wisconsin-pg-Linux_2.2.14_my_SMP_i686-cmp-mysql,pg:
  Updated benchmarks
sql-bench/limits/pg.cfg:
  Updated to new crash-me
sql-bench/server-cfg.sh:
  Fixes for pg 7.0.2
sql/ha_berkeley.cc:
  Lots of BDB table fixes
sql/ha_berkeley.h:
  Lots of BDB table fixes
sql/handler.cc:
  Change DROP TABLE to first drop the data, then the .frm file
sql/hostname.cc:
  Fixes for empty hostnames
sql/log.cc:
  Fixed transaction logging
sql/share/swedish/errmsg.OLD:
  cleanup
sql/sql_delete.cc:
  Fixes for logging
sql/sql_insert.cc:
  Fixes for logging
sql/sql_select.cc:
  Fixes for BDB tables
sql/sql_table.cc:
  Change DROP TABLE to first drop the data, then the .frm file
sql/sql_update.cc:
  Fixes for logging
BitKeeper/etc/ignore:
  Added scripts/mysqld_multi to the ignore list
BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted

1 files changed, 159 insertions, 74 deletions

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);