Merge

BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted
Docs/manual.texi:
  merged

BitKeeper/etc/logging_ok

 monty@donna.mysql.com
 sasha@mysql.sashanet.com
+serg@serg.mysql.com

Docs/manual.texi

@@ -1807,6 +1807,13 @@ is as tested as the other table types.
 This only affects the new code that checks if the table was closed properly
 on open and executes an automatic check/repair of the table if it wasn't.
 
+@item MERGE tables -- Alpha / Beta
+The usage of keys on @code{MERGE} tables is still not that tested.  The
+other part of the @code{MERGE} code is quite well tested.
+
+@item FULLTEXT -- Alpha / Beta
+Text search seams to work, but is still not widely used.
+
 @end table
 
 MySQL AB provides e-mail support for paying customers, but the @strong{MySQL}
@@ -9029,9 +9036,9 @@ priority in one thread.
 @item --memlock
 Lock the @code{mysqld} process in memory.  This works only if your system
 supports the @code{mlockall()} system call.  This may help if you have
-a problem where the opearting system is causing @code{mysqld} to swap on disk.
+a problem where the operating system is causing @code{mysqld} to swap on disk.
 
-@item --myisam-recover [=option[,option...]]] where option is one of DEFAULT, BACKUP or FORCE.
+@item --myisam-recover [=option[,option...]]] where option is one of DEFAULT, BACKUP, FORCE or QUICK.
 If this option is used, @code{mysqld} will on open check if the table is
 marked as crashed or if if the table wasn't closed properly
 (The last option only works if you are running with @code{--skip-locking}).
@@ -9044,10 +9051,15 @@ The following options affects how the repair works.
 @item DEFAULT @tab The same as not giving any option to @code{--myisam-recover}.
 @item BACKUP @tab If the data table was changed during recover, save a backup of the @file{table_name.MYD} data file as @file{table_name-datetime.BAK}.
 @item FORCE @tab Run recover even if we will loose more than one row from the .MYD file.
+@item QUICK @tab Don't check the rows in the table if there isn't any delete blocks.
 @end multitable
 
-Before a table is automaticly repaired, mysqld will add a note about this
-in the error log.
+Before a table is automaticly repaired, mysqld will add a note about
+this in the error log.  If you want to be able to recover from most
+things without user intervention, you should use the options
+@code{BACKUP,FORCE}.  This will force a repair of a table even if some rows
+would be deleted, but it will keep the old data file as a backup so that
+you can later examine what happened.
 
 @item --pid-file=path
 Path to pid file used by @code{safe_mysqld}.
@@ -16312,7 +16324,8 @@ Version 3.22.  @code{ADDDATE()} and @code{SUBDATE()} are synonyms for
 @code{DATE_ADD()} and @code{DATE_SUB()}.
 
 In @strong{MySQL} Version 3.23, you can use @code{+} and @code{-} instead of
-@code{DATE_ADD()} and @code{DATE_SUB()}. (See example)
+@code{DATE_ADD()} and @code{DATE_SUB()} if the expression on the right side is
+a date or datetime column. (See example)
 
 @code{date} is a @code{DATETIME} or @code{DATE} value specifying the starting
 date.  @code{expr} is an expression specifying the interval value to be added
@@ -20214,7 +20227,9 @@ this join type is good.
 
 @item range
 Only rows that are in a given range will be retrieved, using an index to
-select the rows.  The @code{ref} column indicates which index is used.
+select the rows.  The @code{key} column indicates which index is used.
+The @code{key_len} contains the longest key part that was used.
+The @code{ref} column will be NULL for this type.
 
 @item index
 This is the same as @code{ALL}, except that only the index tree is
@@ -21256,7 +21271,7 @@ of both worlds.
 
 @menu
 * MyISAM::                      MyISAM tables
-* MERGE::
+* MERGE::			MERGE tables
 * ISAM::                        ISAM tables
 * HEAP::                        HEAP tables
 * BDB::                         BDB or Berkeley_db tables
@@ -21368,11 +21383,37 @@ The following options to @code{mysqld} can be used to change the behavior of
 
 @multitable @columnfractions .40 .60
 @item @strong{Option} @tab @strong{Meaning}
-@item @code{--myisam-recover} @tab Automatic recover of crashed tables.
+@item @code{--myisam-recover=#} @tab Automatic recover of crashed tables.
 @item @code{-O myisam_sort_buffer_size=#} @tab Buffer used when recovering tables.
 @item @code{--delay-key-write-for-all-tables} @tab Don't flush key buffers between writes for any MyISAM table
 @end multitable
 
+The automatic recovery is activated if you start mysqld with
+@code{--myisam-recover=#}. @xref{Command-line options}.
+On open, the table is checked if it's marked as crashed or if the open
+count variable for the table is not 0 and you are running with
+@code{--skip-locking}.  If either of the above is true the following happens.
+
+@itemize @bullet
+@item
+The table is checked for errors.
+@item
+If we found an error, try to do a fast repair (with sorting and without
+recreating the data file) of the table.
+@item
+If the repair fails because of an error in the data file (for example a
+duplicate key error), we try again, but this time we recreate the data file.
+@item
+If the repair fails, retry once more with the old repair option method
+(write row by row without sorting) which should be able to repair any
+type of error with little disk requirements..
+@end itemize
+
+Note that if you run automatic recover with the @code{BACKUP} option,
+you should have a cron script that automaticly moves file with names
+like @file{tablename-datetime.BAK} from the database directories to a
+backup media.
+
 @xref{Command-line options}.
 
 @menu
@@ -21903,6 +21944,9 @@ properly locked if one another thread issues a table lock.
 @item
 Internal locking in @code{BDB} tables are done on page level.
 @item
+@code{SELECT COUNT(*) FROM table_name} is slow as @code{BDB} tables doesn't
+maintain a count of the number of rows in the table.
+@item
 Scanning is slower than with @code{MyISAM} tables as one has data in BDB
 tables is stored in B-trees and not in a separate data file.
 @item
@@ -37037,7 +37081,7 @@ This listing.
 Perl @code{Data-Dumper} module.  Useful with @code{DBI}/@code{DBD} support for
 older perl installations.
 
-@item @uref{http://www.mysql.com/Downloads/Contrib/DBI-1.13.tar.gz, DBI-1.13.tar.gz}
+@item @uref{http://www.mysql.com/Downloads/Contrib/DBI-1.14.tar.gz, DBI-1.14.tar.gz}
 Perl @code{DBI} module.
 
 @item @uref{http://www.mysql.com/Downloads/Contrib/KAMXbase1.0.tar.gz,KAMXbase1.0.tar.gz}
@@ -37046,7 +37090,7 @@ module written by Pratap Pereira @email{pereira@@ee.eng.ohio-state.edu},
 extened by Kevin A. McGrail @email{kmcgrail@@digital1.peregrinehw.com}.
 This converter can handle MEMO fields.
 
-@item @uref{http://www.mysql.com/Downloads/Contrib/Msql-Mysql-modules-1.2214.tar.gz, Msql-Mysql-modules-1.2214.tar.gz}
+@item @uref{http://www.mysql.com/Downloads/Contrib/Msql-Mysql-modules-1.2215.tar.gz, Msql-Mysql-modules-1.2215.tar.gz}
 Perl @code{DBD} module to access mSQL and @strong{MySQL} databases..
 
 @item @uref{http://www.mysql.com/Downloads/Contrib/Data-ShowTable-3.3.tar.gz,  Data-ShowTable-3.3.tar.gz}
@@ -38003,6 +38047,12 @@ though, so 3.23 is not released as a stable version yet.
 @appendixsubsec Changes in release 3.23.26
 @itemize @bullet
 @item
+Fixed problem with @code{SUBSTRING_INDEX()} and @code{REPLACE()}.
+(Patch by Alexander Igonitchev)
+@item
+@code{CREATE TEMPORARY TABLE IF NOT EXISTS} doesn't anymore give an error
+if the table existed.
+@item
 If one don't create a @code{PRIMARY KEY} in a BDB table, a hidden
 @code{PRIMARY KEY} will be created.
 @item

include/Makefile.am

@@ -30,16 +30,14 @@ noinst_HEADERS =	global.h config-win.h \
 			my_tree.h hash.h thr_alarm.h thr_lock.h \
 			getopt.h t_ctype.h violite.h \
 			mysql_version.h.in
-EXTRA_DIST=		my_config.h
 
 # mysql_version.h are generated
-SUPERCLEANFILES =	mysql_version.h my_global.h
+SUPERCLEANFILES =	mysql_version.h my_global.h my_config.h
 
 # Some include files that may be moved and patched by configure
 DISTCLEANFILES =	sched.h
-CLEANFILES =		my_config.h
 
-all-local:		my_global.h
+all-local:		my_global.h my_config.h
 
 # Since we include my_config.h it better exist from the beginning
 link_sources:

include/my_pthread.h

@@ -57,8 +57,8 @@ struct timespec {		/* For pthread_cond_timedwait() */
 
 typedef int pthread_mutexattr_t;
 #define win_pthread_self my_thread_var->pthread_self
-#define pthread_handler_decl(A,B) unsigned __cdecl A(void *B)
-typedef unsigned (__cdecl *pthread_handler)(void *);
+#define pthread_handler_decl(A,B) void * __cdecl A(void *B)
+typedef void * (__cdecl *pthread_handler)(void *);
 
 void win_pthread_init(void);
 int win_pthread_setspecific(void *A,void *B,uint length);

myisam/mi_check.c

@@ -504,7 +504,8 @@ static int chk_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
 
   if (used_length > keyinfo->block_length)
   {
-    mi_check_print_error(param,"Wrong pageinfo at page: %s", llstr(page,llbuff));
+    mi_check_print_error(param,"Wrong pageinfo at page: %s",
+			 llstr(page,llbuff));
     goto err;
   }
   for ( ;; )
@@ -1172,9 +1173,9 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
       if (my_errno != HA_ERR_FOUND_DUPP_KEY) goto err;
       DBUG_DUMP("record",(byte*) sort_info->record,share->base.pack_reclength);
       mi_check_print_info(param,"Duplicate key %2d for record at %10s against new record at %10s",
-		 info->errkey+1,
-		 llstr(sort_info->start_recpos,llbuff),
-		 llstr(info->lastpos,llbuff2));
+			  info->errkey+1,
+			  llstr(sort_info->start_recpos,llbuff),
+			  llstr(info->dupp_key_pos,llbuff2));
       if (param->testflag & T_VERBOSE)
       {
 	VOID(_mi_make_key(info,(uint) info->errkey,info->lastkey,
@@ -1185,7 +1186,7 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
       sort_info->dupp++;
       if (rep_quick == 1)
       {
-	param->error_printed=1;
+	param->error_printed=param->retry_without_quick=1;
 	goto err;
       }
       continue;
@@ -1217,6 +1218,16 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
     param->retry_repair=param->retry_without_quick=1;
     goto err;
   }
+  if (param->testflag & T_SAFE_REPAIR)
+  {
+    /* Don't repair if we loosed more than one row */
+    if (info->state->records+1 < start_records)
+    {
+      info->state->records=start_records;
+      got_error=1;
+      goto err;
+    }
+  }
 
   if (!rep_quick)
   {
@@ -1225,7 +1236,6 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
     info->state->data_file_length=sort_info->filepos;
     /* Only whole records */
     share->state.split=info->state->records+info->state->del;
-    param->out_flag|=O_NEW_DATA;			/* Data in new file */
     share->state.version=(ulong) time((time_t*) 0);	/* Force reopen */
   }
   else
@@ -1247,6 +1257,21 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
     memcpy( &share->state.state, info->state, sizeof(*info->state));
 
 err:
+  if (!got_error)
+  {
+    /* Replace the actual file with the temporary file */
+    if (new_file >= 0)
+    {
+      my_close(new_file,MYF(0));
+      info->dfile=new_file= -1;
+      if (change_to_newfile(share->filename,MI_NAME_DEXT,
+			    DATA_TMP_EXT, share->base.raid_chunks,
+			    (param->testflag & T_BACKUP_DATA ?
+			     MYF(MY_REDEL_MAKE_BACKUP): MYF(0))) ||
+	  mi_open_datafile(info,share))
+	got_error=1;
+    }
+  }
   if (got_error)
   {
     if (! param->error_printed)
@@ -1274,7 +1299,8 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
     share->pack.header_length=0;
     share->data_file_type=sort_info->new_data_file_type;
   }
-  share->state.changed|=STATE_NOT_OPTIMIZED_KEYS | STATE_NOT_SORTED_PAGES;
+  share->state.changed|= (STATE_NOT_OPTIMIZED_KEYS | STATE_NOT_SORTED_PAGES |
+			  STATE_NOT_ANALYZED);
   DBUG_RETURN(got_error);
 }
 
@@ -1453,14 +1479,17 @@ int mi_sort_index(MI_CHECK *param, register MI_INFO *info, my_string name)
   flush_key_blocks(info->s->kfile, FLUSH_IGNORE_CHANGED);
 
 	/* Put same locks as old file */
-  if (lock_file(param,new_file,0L,F_WRLCK,"tempfile",param->temp_filename))
-    goto err;
   info->s->state.version=(ulong) time((time_t*) 0);
   VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
   VOID(my_close(info->s->kfile,MYF(MY_WME)));
-  param->out_flag|=O_NEW_INDEX;			/* Data in new file */
+  info->s->kfile = -1;
+  VOID(my_close(new_file,MYF(MY_WME)));
+  if (change_to_newfile(info->s->filename,MI_NAME_IEXT,INDEX_TMP_EXT,0,
+			MYF(0)) ||
+      mi_open_keyfile(info->s))
+    goto err2;
+  _mi_readinfo(info,F_WRLCK,0);
 
-  info->s->kfile=new_file;
   info->state->key_file_length=param->new_file_pos;
   info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
   for (key=0 ; key < info->s->base.keys ; key++)
@@ -1473,6 +1502,7 @@ int mi_sort_index(MI_CHECK *param, register MI_INFO *info, my_string name)
 
 err:
   VOID(my_close(new_file,MYF(MY_WME)));
+err2:
   VOID(my_delete(param->temp_filename,MYF(MY_WME)));
   DBUG_RETURN(-1);
 } /* sort_index */
@@ -1842,7 +1872,6 @@ int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
       /* Only whole records */
       share->state.split=info->state->records+info->state->del;
       share->state.version=(ulong) time((time_t*) 0);
-      param->out_flag|=O_NEW_DATA;		/* Data in new file */
       my_close(info->dfile,MYF(0));
       info->dfile=new_file;
       share->data_file_type=sort_info->new_data_file_type;
@@ -1909,18 +1938,34 @@ int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
     memcpy( &share->state.state, info->state, sizeof(*info->state));
 
 err:
+  got_error|= flush_blocks(param,share->kfile);
+  VOID(end_io_cache(&info->rec_cache));
+  if (!got_error)
+  {
+    /* Replace the actual file with the temporary file */
+    if (new_file >= 0)
+    {
+      my_close(new_file,MYF(0));
+      info->dfile=new_file= -1;
+      if (change_to_newfile(share->filename,MI_NAME_DEXT,
+			    DATA_TMP_EXT, share->base.raid_chunks,
+			    (param->testflag & T_BACKUP_DATA ?
+			     MYF(MY_REDEL_MAKE_BACKUP): MYF(0))) ||
+	  mi_open_datafile(info,share))
+	got_error=1;
+    }
+  }
   if (got_error)
   {
     if (! param->error_printed)
       mi_check_print_error(param,"%d when fixing table",my_errno);
     if (new_file >= 0)
     {
-      VOID(end_io_cache(&info->rec_cache));
       VOID(my_close(new_file,MYF(0)));
-      VOID(my_raid_delete(param->temp_filename,info->s->base.raid_chunks,
+      VOID(my_raid_delete(param->temp_filename,share->base.raid_chunks,
 			  MYF(MY_WME)));
       if (info->dfile == new_file)
-	info->dfile=0;
+	info->dfile= -1;
     }
     mi_mark_crashed_on_repair(info);
   }
@@ -1932,7 +1977,6 @@ int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
   my_free(sort_info->record,MYF(MY_ALLOW_ZERO_PTR));
   my_free(sort_info->buff,MYF(MY_ALLOW_ZERO_PTR));
   VOID(end_io_cache(&param->read_cache));
-  VOID(end_io_cache(&info->rec_cache));
   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
   if (!got_error && (param->testflag & T_UNPACK))
   {
@@ -2350,8 +2394,8 @@ int sort_write_record(SORT_INFO *sort_info)
 	if (sort_info->buff_length < reclength)
 	{
 	  if (!(sort_info->buff=my_realloc(sort_info->buff, (uint) reclength,
-					  MYF(MY_FREE_ON_ERROR |
-					      MY_ALLOW_ZERO_PTR))))
+					   MYF(MY_FREE_ON_ERROR |
+					       MY_ALLOW_ZERO_PTR))))
 	    DBUG_RETURN(1);
 	  sort_info->buff_length=reclength;
 	}
@@ -2440,6 +2484,7 @@ static int sort_key_write(SORT_INFO *sort_info, const void *a)
 						    sort_info->key_block->
 						    lastkey),
 				 llbuff2));
+    param->error_printed=param->retry_without_quick=1;
     if (sort_info->param->testflag & T_VERBOSE)
       _mi_print_key(stdout,sort_info->keyseg,(uchar*) a, USE_WHOLE_KEY);
     return (sort_delete_record(param));
@@ -2474,7 +2519,7 @@ static int sort_insert_key(MI_CHECK *param,
 			   my_off_t prev_block)
 {
   uint a_length,t_length,nod_flag;
-  my_off_t filepos;
+  my_off_t filepos,key_file_length;
   uchar *anc_buff,*lastkey;
   MI_KEY_PARAM s_temp;
   MI_INFO *info;
@@ -2525,11 +2570,20 @@ static int sort_insert_key(MI_CHECK *param,
   mi_putint(anc_buff,key_block->last_length,nod_flag);
   bzero((byte*) anc_buff+key_block->last_length,
 	sort_info->keyinfo->block_length- key_block->last_length);
+  key_file_length=info->state->key_file_length;
   if ((filepos=_mi_new(info,sort_info->keyinfo)) == HA_OFFSET_ERROR)
-    return 1;
-  if (my_pwrite(info->s->kfile,(byte*) anc_buff,
-		(uint) sort_info->keyinfo->block_length,filepos,
-		param->myf_rw))
+    DBUG_RETURN(1);
+
+  /* If we read the page from the key cache, we have to write it back to it */
+  if (key_file_length == info->state->key_file_length)
+  {
+    if (_mi_write_keypage(info, sort_info->keyinfo, filepos,
+			  anc_buff))
+      DBUG_RETURN(1);
+  }
+  else if (my_pwrite(info->s->kfile,(byte*) anc_buff,
+		     (uint) sort_info->keyinfo->block_length,filepos,
+		     param->myf_rw))
     DBUG_RETURN(1);
   DBUG_DUMP("buff",(byte*) anc_buff,mi_getint(anc_buff));
 
@@ -2607,7 +2661,7 @@ static int sort_delete_record(MI_CHECK *param)
 static int flush_pending_blocks(MI_CHECK *param)
 {
   uint nod_flag,length;
-  my_off_t filepos;
+  my_off_t filepos,key_file_length;
   MI_INFO *info;
   SORT_KEY_BLOCKS *key_block;
   SORT_INFO *sort_info= &param->sort_info;
@@ -2622,18 +2676,27 @@ static int flush_pending_blocks(MI_CHECK *param)
     length=mi_getint(key_block->buff);
     if (nod_flag)
       _mi_kpointer(info,key_block->end_pos,filepos);
-    if ((filepos=_mi_new(info,sort_info->keyinfo)) == HA_OFFSET_ERROR)
-      DBUG_RETURN(1);
+    key_file_length=info->state->key_file_length;
     bzero((byte*) key_block->buff+length,
 	  sort_info->keyinfo->block_length-length);
-    if (my_pwrite(info->s->kfile,(byte*) key_block->buff,
-		 (uint) sort_info->keyinfo->block_length,filepos,
-                 param->myf_rw))
+    if ((filepos=_mi_new(info,sort_info->keyinfo)) == HA_OFFSET_ERROR)
+      DBUG_RETURN(1);
+
+    /* If we read the page from the key cache, we have to write it back */
+    if (key_file_length == info->state->key_file_length)
+    {
+      if (_mi_write_keypage(info, sort_info->keyinfo, filepos,
+			    key_block->buff))
+	DBUG_RETURN(1);
+    }
+    else if (my_pwrite(info->s->kfile,(byte*) key_block->buff,
+		       (uint) sort_info->keyinfo->block_length,filepos,
+		       param->myf_rw))
       DBUG_RETURN(1);
     DBUG_DUMP("buff",(byte*) key_block->buff,length);
     nod_flag=1;
   }
-  info->s->state.key_root[sort_info->key]=filepos;	/* Last is root for tree */
+  info->s->state.key_root[sort_info->key]=filepos; /* Last is root for tree */
   DBUG_RETURN(0);
 } /* flush_pending_blocks */
 

myisam/mi_open.c

@@ -101,6 +101,7 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
 	  (kfile=my_open(name_buff,(open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0)
 	goto err;
     }
+    share->mode=open_mode;
     errpos=1;
     if (my_read(kfile,(char*) share->state.header.file_version,head_length,
 		MYF(MY_NABP)))
@@ -343,28 +344,11 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
       lock_error=1;			/* Database unlocked */
     }
 
-#ifdef USE_RAID
-    if (share->base.raid_type)
-    {
-      if ((info.dfile=my_raid_open(fn_format(name_buff,name,"",MI_NAME_DEXT,
-					     2+4),
-				   mode | O_SHARE,
-				   share->base.raid_type,
-				   share->base.raid_chunks,
-				   share->base.raid_chunksize,
-				   MYF(MY_WME | MY_RAID))) < 0)
+    if (mi_open_datafile(&info, share))
       goto err;
-    }
-    else
-#endif
-      if ((info.dfile=my_open(fn_format(name_buff,name,"",MI_NAME_DEXT,2+4),
-			      mode | O_SHARE,
-			      MYF(MY_WME))) < 0)
-	goto err;
     errpos=5;
 
     share->kfile=kfile;
-    share->mode=open_mode;
     share->this_process=(ulong) getpid();
     share->rnd= (int)	 share->this_process;	/* rnd-counter for splits */
 #ifndef DBUG_OFF
@@ -433,27 +417,8 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
       my_errno=EACCES;				/* Can't open in write mode */
       goto err;
     }
-#ifdef USE_RAID
-    if (share->base.raid_type)
-    {
-      if ((info.dfile=my_raid_open(fn_format(name_buff,old_info->filename,"",
-					     MI_NAME_DEXT, 2+4),
-				   mode | O_SHARE,
-				   share->base.raid_type,
-				   share->base.raid_chunks,
-				   share->base.raid_chunksize,
-				   MYF(MY_WME | MY_RAID))) < 0)
+    if (mi_open_datafile(&info, share))
       goto err;
-    }
-    else
-#endif
-      if ((info.dfile=my_open(fn_format(name_buff,old_info->filename,"",
-					MI_NAME_DEXT,2+4),
-			      mode | O_SHARE,MYF(MY_WME))) < 0)
-	{
-	  my_errno=errno;
-	  goto err;
-	}
     errpos=5;
   }
 
@@ -1009,3 +974,40 @@ char *mi_recinfo_read(char *ptr, MI_COLUMNDEF *recinfo)
    recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
    return ptr;
 }
+
+/**************************************************************************
+ ** Help functions for recover
+ *************************************************************************/
+
+int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share)
+{
+  char name_buff[FN_REFLEN];
+  (void) fn_format(name_buff, share->filename,"",MI_NAME_DEXT, 2+4);
+
+#ifdef USE_RAID
+  if (share->base.raid_type)
+  {
+    if ((info->dfile=my_raid_open(name_buff,
+				  share->mode | O_SHARE,
+				  share->base.raid_type,
+				  share->base.raid_chunks,
+				  share->base.raid_chunksize,
+				  MYF(MY_WME | MY_RAID))) < 0)
+      return 1;
+  }
+  else
+#endif
+    if ((info->dfile=my_open(name_buff, share->mode | O_SHARE,
+			     MYF(MY_WME))) < 0)
+      return 1;
+  return 0;
+}
+
+
+int mi_open_keyfile(MYISAM_SHARE *share)
+{
+  if ((share->kfile=my_open(share->filename, share->mode | O_SHARE,
+			    MYF(MY_WME))) < 0)
+    return 1;
+  return 0;
+}

myisam/mi_page.c

@@ -99,6 +99,7 @@ int _mi_dispose(register MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos)
   my_off_t old_link;
   char buff[8];
   DBUG_ENTER("_mi_dispose");
+  DBUG_PRINT("enter",("pos: %ld", (long) pos));
 
   old_link=info->s->state.key_del[keyinfo->block_size];
   info->s->state.key_del[keyinfo->block_size]=pos;
@@ -141,6 +142,6 @@ my_off_t _mi_new(register MI_INFO *info, MI_KEYDEF *keyinfo)
       info->s->state.key_del[keyinfo->block_size]=mi_sizekorr(buff);
   }
   info->s->state.changed|= STATE_NOT_SORTED_PAGES;
-  DBUG_PRINT("exit",("Pos: %d",pos));
+  DBUG_PRINT("exit",("Pos: %ld",(long) pos));
   DBUG_RETURN(pos);
 } /* _mi_new */

myisam/myisamchk.c

@@ -196,7 +196,7 @@ static struct option long_options[] =
 
 static void print_version(void)
 {
-  printf("%s  Ver 1.34 for %s at %s\n",my_progname,SYSTEM_TYPE,
+  printf("%s  Ver 1.35 for %s at %s\n",my_progname,SYSTEM_TYPE,
 	 MACHINE_TYPE);
 }
 
@@ -481,6 +481,7 @@ static int myisamchk(MI_CHECK *param, my_string filename)
   File datafile;
   char fixed_name[FN_REFLEN];
   char llbuff[22],llbuff2[22];
+  my_bool state_updated=0;
   MYISAM_SHARE *share;
   DBUG_ENTER("myisamchk");
 
@@ -665,43 +666,32 @@ static int myisamchk(MI_CHECK *param, my_string filename)
 	    (share->state.key_map ||
 	     (rep_quick && !param->keys_in_use && !recreate)) &&
 	    mi_test_if_sort_rep(info, info->state->records, 1))
+	{
 	  error=mi_repair_by_sort(&check_param,info,fixed_name,rep_quick);
+	  state_updated=1;
+	}
 	else if (param->testflag & (T_REP | T_REP_BY_SORT))
 	  error=mi_repair(&check_param, info,fixed_name,rep_quick);
       }
       if (!error && param->testflag & T_SORT_RECORDS)
       {
+	/*
+	  The data file is nowadays reopened in the repair code so we should
+	  soon remove the following reopen-code
+	*/
+#ifndef TO_BE_REMOVED
 	if (param->out_flag & O_NEW_DATA)
 	{			/* Change temp file to org file */
 	  VOID(my_close(info->dfile,MYF(MY_WME))); /* Close new file */
 	  error|=change_to_newfile(fixed_name,MI_NAME_DEXT,DATA_TMP_EXT,
 				   raid_chunks,
 				   MYF(0));
-#ifdef USE_RAID
-	  if (share->base.raid_type)
-	  {
-	    mi_check_print_info(&check_param,"Opening as RAID-ed table\n");
-	    info->dfile=my_raid_open(fn_format(param->temp_filename,
-					       fixed_name,"",
-					       MI_NAME_DEXT, 2+4),
-				     O_RDWR | O_SHARE,
-				     share->base.raid_type,
-				     raid_chunks,
-				     share->base.raid_chunksize,
-				     MYF(MY_WME | MY_RAID));
-	  }
-	  else
-#endif
-	    info->dfile=my_open(fn_format(param->temp_filename,
-					  fixed_name,"",
-					  MI_NAME_DEXT,2+4),
-				O_RDWR | O_SHARE,
-				MYF(MY_WME));
-	  if (info->dfile < 0)
+	  if (mi_open_datafile(info,info->s))
 	    error=1;
 	  param->out_flag&= ~O_NEW_DATA; /* We are using new datafile */
 	  param->read_cache.file=info->dfile;
 	}
+#endif
 	if (! error)
 	{
 	  uint key;
@@ -757,7 +747,11 @@ static int myisamchk(MI_CHECK *param, my_string filename)
       {
 	error|=chk_key(param, info);
 	if (!error && (param->testflag & (T_STATISTICS | T_AUTO_INC)))
-	  error=update_state_info(param, info, UPDATE_STAT);
+	  error=update_state_info(param, info,
+				  ((param->testflag & T_STATISTICS) ?
+				   UPDATE_STAT : 0) |
+				  ((param->testflag & T_AUTO_INC) ?
+				   UPDATE_AUTO_INC : 0));
       }
       if ((!rep_quick && !error) ||
 	  !(param->testflag & (T_FAST | T_FORCE_CREATE)))
@@ -808,7 +802,8 @@ static int myisamchk(MI_CHECK *param, my_string filename)
       error|=update_state_info(param, info,
 			       UPDATE_OPEN_COUNT |
 			       (((param->testflag & (T_REP | T_REP_BY_SORT)) ?
-				 UPDATE_TIME | UPDATE_STAT : 0) |
+				 UPDATE_TIME : 0) |
+				(state_updated ? UPDATE_STAT : 0) |
 				((param->testflag & T_SORT_RECORDS) ?
 				 UPDATE_SORT : 0)));
     VOID(lock_file(param, share->kfile,0L,F_UNLCK,"indexfile",filename));
@@ -1142,7 +1137,8 @@ static int mi_sort_records(MI_CHECK *param,
   SORT_INFO *sort_info= &param->sort_info;
   DBUG_ENTER("sort_records");
 
-  bzero((char*) sort_info,sizeof(sort_info));
+  bzero((char*) sort_info,sizeof(*sort_info));
+  sort_info->param=param;
   keyinfo= &share->keyinfo[sort_key];
   got_error=1;
   temp_buff=0;
@@ -1263,7 +1259,7 @@ static int mi_sort_records(MI_CHECK *param,
   {
     VOID(end_io_cache(&info->rec_cache));
     (void) my_close(new_file,MYF(MY_WME));
-    (void) my_raid_delete(param->temp_filename, share->base.raid_chunksize,
+    (void) my_raid_delete(param->temp_filename, share->base.raid_chunks,
 			  MYF(MY_WME));
   }
   if (temp_buff)

myisam/myisamdef.h

@@ -575,6 +575,10 @@ enum myisam_log_commands {
 #define myisam_log_command(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_command(a,b,c,d,e)
 #define myisam_log_record(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_record(a,b,c,d,e)
 
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
 extern uint _mi_get_block_info(MI_BLOCK_INFO *,File, my_off_t);
 extern uint _mi_rec_pack(MI_INFO *info,byte *to,const byte *from);
 extern uint _mi_pack_get_block_info(MI_INFO *mysql, MI_BLOCK_INFO *, File,
@@ -626,11 +630,10 @@ int _mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
 	     enum ha_rkey_function search_flag, bool raw_key);
 
 my_bool check_table_is_closed(const char *name, const char *where);
+int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share);
+int mi_open_keyfile(MYISAM_SHARE *share);
 
 /* Functions needed by mi_check */
-#ifdef	__cplusplus
-extern "C" {
-#endif
 void mi_check_print_error _VARARGS((MI_CHECK *param, const char *fmt,...));
 void mi_check_print_warning _VARARGS((MI_CHECK *param, const char *fmt,...));
 void mi_check_print_info _VARARGS((MI_CHECK *param, const char *fmt,...));

mysys/mf_tempfile.c

@@ -100,7 +100,7 @@ File create_temp_file(char *to, const char *dir, const char *prefix,
       return 1;
     }
     strmov(to,dir);
-    strmov(convert_dirname(to),prefix);
+    strmov(convert_dirname(to),prefix_buff);
     file=mkstemp(to);
   }
 #elif defined(HAVE_TEMPNAM)

mysys/my_winthread.c

@@ -83,7 +83,7 @@ int pthread_create(pthread_t *thread_id, pthread_attr_t *attr,
 			       attr->dwStackSize ? attr->dwStackSize :
 			       65535, (void*) map);
 #else
-  hThread=(HANDLE)_beginthread(pthread_start,
+  hThread=(HANDLE)_beginthread((void( __cdecl *)(void *)) pthread_start,
 			       attr->dwStackSize ? attr->dwStackSize :
 			       65535, (void*) map);
 #endif

sql-bench/bench-init.pl.sh

@@ -51,7 +51,7 @@ $log_prog_args=join(" ", skip_arguments(\@ARGV,"comments","cmp","server",
 					"user", "host", "database", "password",
 					"use-old-results","skip-test",
 					"machine", "dir", "suffix", "log"));
-GetOptions("skip-test=s","comments=s","cmp=s","server=s","user=s","host=s","database=s","password=s","loop-count=i","row-count=i","skip-create","skip-delete","verbose","fast-insert","lock-tables","debug","fast","force","field-count=i","regions=i","groups=i","time-limit=i","log","use-old-results","machine=s","dir=s","suffix=s","help","odbc","small-test","small-tables","small-key-tables","stage=i","old-headers","die-on-errors","create-options","hires") || usage();
+GetOptions("skip-test=s","comments=s","cmp=s","server=s","user=s","host=s","database=s","password=s","loop-count=i","row-count=i","skip-create","skip-delete","verbose","fast-insert","lock-tables","debug","fast","force","field-count=i","regions=i","groups=i","time-limit=i","log","use-old-results","machine=s","dir=s","suffix=s","help","odbc","small-test","small-tables","small-key-tables","stage=i","old-headers","die-on-errors","create-options=s","hires") || usage();
 
 usage() if ($opt_help);
 $server=get_server($opt_server,$opt_host,$opt_database,$opt_odbc,
@@ -400,6 +400,11 @@ All benchmarks takes the following options:
   with the same --cmp, you will get a test that is comparable between
   the different sql servers.
 
+--create-options=#
+  Extra argument to all create statements.  If you for example want to
+  create all MySQL tables as BDB tables use:
+  --create-options=TYPE=BDB
+
 --database (Default $opt_database)
   In which database the test tables are created.
 

sql-bench/test-insert.sh

@@ -572,7 +572,7 @@ if ($limits->{'group_functions'})
 
   $loop_time=new Benchmark;
   $count=$estimated=0;
-  for ($tests=0 ; $tests < $small_loop_count ; $tests++)
+  for ($tests=1 ; $tests <= $small_loop_count ; $tests++)
   {
     $count+=2;
     fetch_all_rows($dbh,"select count(distinct dummy1) from bench1");
@@ -834,7 +834,7 @@ if ($limits->{'func_odbc_floor'} && $limits->{'left_outer_join'})
 
   $count=$estimated=0;
   $loop_time=new Benchmark;
-  for ($i=0 ; $i < $small_loop_count ; $i++)
+  for ($i=1 ; $i <= $small_loop_count ; $i++)
   {
     $count+=fetch_all_rows($dbh,"select count(a.dummy1),count(b.dummy1) from bench1 as a left outer join bench1 as b on (a.id2=b.id3) where b.id3 is null");
     $end_time=new Benchmark;

sql/field.cc

@@ -4574,6 +4574,7 @@ create_field::create_field(Field *old_field,Field *orig_field)
     interval= ((Field_enum*) old_field)->typelib;
   else
     interval=0;
+  def=0;
   if (!old_field->is_real_null() && ! (flags & BLOB_FLAG) &&
       old_field->type() != FIELD_TYPE_TIMESTAMP && old_field->ptr &&
       orig_field)
@@ -4584,15 +4585,14 @@ create_field::create_field(Field *old_field,Field *orig_field)
     /* Get the value from record[2] (the default value row) */
     my_ptrdiff_t diff= (my_ptrdiff_t) (orig_field->table->rec_buff_length*2);
     orig_field->move_field(diff);		// Points now at record[2]
+    bool is_null=orig_field->is_real_null();
     res=orig_field->val_str(&tmp,&tmp);
     orig_field->move_field(-diff);		// Back to record[0]
-    if (res)					// If not NULL value
+    if (!is_null)
     {
       pos= (char*) sql_memdup(tmp.ptr(),tmp.length()+1);
       pos[tmp.length()]=0;
       def=new Item_string(pos,tmp.length());
     }
   }
-  else
-    def=0;
 }

sql/ha_berkeley.cc

@@ -1472,11 +1472,11 @@ ha_rows ha_berkeley::records_in_range(int keynr,
   DB_KEY_RANGE start_range, end_range;
   double start_pos,end_pos,rows;
   DBUG_ENTER("records_in_range");
-  if ((start_key && file->key_range(file,transaction,
+  if ((start_key && file->key_range(key_file[keynr],transaction,
 				    pack_key(&key, keynr, key_buff, start_key,
 					     start_key_len),
 				    &start_range,0)) ||
-      (end_key && file->key_range(file,transaction,
+      (end_key && file->key_range(key_file[keynr],transaction,
 				  pack_key(&key, keynr, key_buff, end_key,
 					   end_key_len),
 				  &end_range,0)))

sql/ha_myisam.cc

@@ -35,7 +35,7 @@ ulong myisam_recover_options= HA_RECOVER_NONE;
 
 /* bits in myisam_recover_options */
 const char *myisam_recover_names[] =
-{ "DEFAULT", "BACKUP", "FORCE"};
+{ "DEFAULT", "BACKUP", "FORCE", "QUICK"};
 TYPELIB myisam_recover_typelib= {array_elements(myisam_recover_names),"",
 				 myisam_recover_names};
 
@@ -57,6 +57,8 @@ static void mi_check_print_msg(MI_CHECK *param,	const char* msg_type,
   my_vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
   msgbuf[sizeof(msgbuf) - 1] = 0; // healthy paranoia
 
+  DBUG_PRINT(msg_type,("message: %s",msgbuf));
+
   if (thd->net.vio == 0)
   {
     sql_print_error(msgbuf);
@@ -409,29 +411,44 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt)
   int error;
   if (!file) return HA_ADMIN_INTERNAL_ERROR;
   MI_CHECK param;
+  ha_rows start_records;
 
   myisamchk_init(&param);
   param.thd = thd;
   param.op_name = (char*) "repair";
-  param.testflag = (check_opt->flags | T_SILENT | T_FORCE_CREATE |
-		    T_REP_BY_SORT);
+  param.testflag = ((check_opt->flags | T_SILENT | T_FORCE_CREATE) |
+		    (check_opt->flags & T_EXTEND ? T_REP : T_REP_BY_SORT));
   if (check_opt->quick)
     param.opt_rep_quick++;
   param.sort_buffer_length=  check_opt->sort_buffer_size;
-  while ((error=repair(thd,param,0)))
+  start_records=file->state->records;
+  while ((error=repair(thd,param,0)) && param.retry_repair)
   {
+    param.retry_repair=0;
     if (param.retry_without_quick && param.opt_rep_quick)
     {
       param.opt_rep_quick=0;
+      sql_print_error("Warning: Retrying recover of:  %s without quick",
+		      table->path);
       continue;
     }
     if ((param.testflag & T_REP_BY_SORT))
     {
-      param.testflag= (param.testflag & ~T_REP_BY_SORT) | T_REP;      
+      param.testflag= (param.testflag & ~T_REP_BY_SORT) | T_REP;
+      sql_print_error("Warning: Retrying recover of:  %s with keycache",
+		      table->path);
       continue;
     }
     break;
   }
+  if (!error && start_records != file->state->records)
+  {
+    char llbuff[22],llbuff2[22];
+    sql_print_error("Warning:  Found %s of %s rows from %s",
+		    llstr(file->state->records, llbuff),
+		    llstr(start_records, llbuff2),
+		    table->path);
+  }    
   return error;
 }
 
@@ -455,17 +472,18 @@ int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt)
 int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
 {
   int error=0;
-  bool optimize_done= !optimize;
+  bool optimize_done= !optimize, statistics_done=0;
   char fixed_name[FN_REFLEN];
   const char *old_proc_info=thd->proc_info;
   MYISAM_SHARE* share = file->s;
+  DBUG_ENTER("ha_myisam::repair");
 
   param.table_name = table->table_name;
   param.tmpfile_createflag = O_RDWR | O_TRUNC;
   param.using_global_keycache = 1;
   param.thd=thd;
   param.tmpdir=mysql_tmpdir;
-    
+  param.out_flag=0;
   VOID(fn_format(fixed_name,file->filename,"",MI_NAME_IEXT,
 		     4+ (param.opt_follow_links ? 16 : 0)));
 
@@ -475,15 +493,18 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
 	!(share->state.changed & STATE_NOT_OPTIMIZED_KEYS))))
   {
     optimize_done=1;
-    if (mi_test_if_sort_rep(file,file->state->records,0))
+    if (mi_test_if_sort_rep(file,file->state->records,0) &&
+	(param.testflag & T_REP_BY_SORT))
     {
       param.testflag|= T_STATISTICS;		// We get this for free
-      thd->proc_info="Repairing by sorting";
+      thd->proc_info="Repair by sorting";
+      statistics_done=1;
       error = mi_repair_by_sort(&param, file, fixed_name, param.opt_rep_quick);
     }
     else
     {
-      thd->proc_info="Repairing";
+      thd->proc_info="Repair with keycache";
+      param.testflag &= ~T_REP_BY_SORT;
       error=  mi_repair(&param, file, fixed_name, param.opt_rep_quick);
     }
   }
@@ -496,7 +517,7 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
       thd->proc_info="Sorting index";
       error=mi_sort_index(&param,file,fixed_name);
     }
-    if ((param.testflag & T_STATISTICS) &&
+    if (!statistics_done && (param.testflag & T_STATISTICS) &&
 	(share->state.changed & STATE_NOT_ANALYZED))
     {
       optimize_done=1;
@@ -517,7 +538,7 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
     if (file->s->base.auto_key)
       update_auto_increment_key(&param, file, 1);
     error = update_state_info(&param, file,
-			      UPDATE_TIME |
+			      UPDATE_TIME | UPDATE_OPEN_COUNT |
 			      (param.testflag & T_STATISTICS ?
 			       UPDATE_STAT : 0));
     info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE |
@@ -528,33 +549,9 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
     mi_mark_crashed(file);
     file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
   }
-  if (!error)
-  {
-    if (param.out_flag & (O_NEW_DATA | O_NEW_INDEX))
-    {
-      /*
-	We have to close all instances of this file to ensure that we can
-	do the rename safely on all operating system and to ensure that
-	all threads are using the new version.
-      */
-      thd->proc_info="renaming file";
-      VOID(pthread_mutex_lock(&LOCK_open));
-      if (close_cached_table(thd,table))
-	error=1;
-
-      if (param.out_flag & O_NEW_DATA)
-	error|=change_to_newfile(fixed_name,MI_NAME_DEXT,
-				 DATA_TMP_EXT, 0, MYF(0));
-
-      if (param.out_flag & O_NEW_INDEX)
-	error|=change_to_newfile(fixed_name,MI_NAME_IEXT,
-				 INDEX_TMP_EXT, 0, MYF(0));
-      VOID(pthread_mutex_unlock(&LOCK_open));
-    }
-  }
   thd->proc_info=old_proc_info;
-  return (error ? HA_ADMIN_FAILED :
-          !optimize_done ? HA_ADMIN_ALREADY_DONE : HA_ADMIN_OK);
+  DBUG_RETURN(error ? HA_ADMIN_FAILED :
+	      !optimize_done ? HA_ADMIN_ALREADY_DONE : HA_ADMIN_OK);
 }
 
 
@@ -600,16 +597,19 @@ bool ha_myisam::check_and_repair(THD *thd)
   DBUG_ENTER("ha_myisam::auto_check_and_repair");
 
   check_opt.init();
-  check_opt.flags= T_MEDIUM;
-  check_opt.quick= !file->state->del;	// Don't use quick if deleted rows
+  check_opt.flags= T_MEDIUM | T_AUTO_REPAIR;
+  // Don't use quick if deleted rows
+  if (!file->state->del && (myisam_recover_options & HA_RECOVER_QUICK))
+    check_opt.quick=1;
+  sql_print_error("Warning: Checking table:  %s",table->path);
   if (mi_is_crashed(file) || check(thd, &check_opt))
   {
-    if (check_opt.retry_without_quick)
-      check_opt.quick=0;
+    sql_print_error("Warning: Recovering table: %s",table->path);
+    check_opt.quick= !check_opt.retry_without_quick;
     check_opt.flags=(((myisam_recover_options & HA_RECOVER_BACKUP) ? 
 		      T_BACKUP_DATA : 0) |
 		     (!(myisam_recover_options & HA_RECOVER_FORCE) ? 
-		      T_SAFE_REPAIR : 0));
+		      T_SAFE_REPAIR : 0)) | T_AUTO_REPAIR;
     if (repair(thd, &check_opt))
       error=1;
   }

sql/ha_myisam.h

@@ -28,6 +28,7 @@
 #define HA_RECOVER_DEFAULT	1	// Automatic recover active
 #define HA_RECOVER_BACKUP	2	// Make a backupfile on recover
 #define HA_RECOVER_FORCE	4	// Recover even if we loose rows
+#define HA_RECOVER_QUICK	8	// Don't check rows in data file
 
 extern ulong myisam_sort_buffer_size;
 extern TYPELIB myisam_recover_typelib;

sql/handler.cc

@@ -32,6 +32,9 @@
 #ifdef HAVE_BERKELEY_DB
 #include "ha_berkeley.h"
 #endif
+#ifdef HAVE_INNOBASE_DB
+#include "ha_innobase.h"
+#endif
 #include <myisampack.h>
 #include <errno.h>
 
@@ -46,7 +49,7 @@ ulong ha_read_count, ha_write_count, ha_delete_count, ha_update_count,
 
 const char *ha_table_type[] = {
   "", "DIAB_ISAM","HASH","MISAM","PISAM","RMS_ISAM","HEAP", "ISAM",
-  "MRG_ISAM","MYISAM", "MRG_MYISAM", "BERKELEY_DB?", "?", "?",NullS
+  "MRG_ISAM","MYISAM", "MRG_MYISAM", "BDB", "INNOBASE", "?", "?",NullS
 };
 
 const char *ha_row_type[] = {
@@ -66,6 +69,10 @@ enum db_type ha_checktype(enum db_type database_type)
   case DB_TYPE_BERKELEY_DB:
     return(berkeley_skip ? DB_TYPE_MYISAM : database_type);
 #endif
+#ifdef HAVE_INNOBASE_DB
+  case DB_TYPE_INNOBASE:
+    return(innobase_skip ? DB_TYPE_MYISAM : database_type);
+#endif
 #ifndef NO_HASH
   case DB_TYPE_HASH:
 #endif
@@ -103,6 +110,10 @@ handler *get_new_handler(TABLE *table, enum db_type db_type)
 #ifdef HAVE_BERKELEY_DB
   case DB_TYPE_BERKELEY_DB:
     return new ha_berkeley(table);
+#endif
+#ifdef HAVE_INNOBASE_DB
+  case DB_TYPE_INNOBASE_DB:
+    return new ha_innobase(table);
 #endif
   case DB_TYPE_HEAP:
     return new ha_heap(table);
@@ -123,6 +134,14 @@ int ha_init()
     if ((error=berkeley_init()))
       return error;
   }
+#endif
+#ifdef HAVE_INNOBASE_DB
+  if (!innobase_skip)
+  {
+    int error;
+    if ((error=innobase_init()))
+      return error;
+  }
 #endif
   return 0;
 }
@@ -146,6 +165,10 @@ int ha_panic(enum ha_panic_function flag)
 #ifdef HAVE_BERKELEY_DB
   if (!berkeley_skip)
     error|=berkeley_end();
+#endif
+#ifdef HAVE_INNOBASE_DB
+  if (!innobase_skip)
+    error|=innobase_end();
 #endif
   return error;
 } /* ha_panic */
@@ -154,7 +177,7 @@ int ha_panic(enum ha_panic_function flag)
 int ha_autocommit_or_rollback(THD *thd, int error)
 {
   DBUG_ENTER("ha_autocommit_or_rollback");
-#ifdef HAVE_BERKELEY_DB
+#if defined(HAVE_BERKELEY_DB) || defined(HAVE_INNOBASE_DB)
   if ((thd->options & OPTION_AUTO_COMMIT) && !thd->locked_tables)
   {
     if (!error)
@@ -183,6 +206,17 @@ int ha_commit(THD *thd)
       error=1;
     }
   }
+#endif
+#ifdef HAVE_INNOBASE_DB
+  if (thd->transaction.innobase_tid)
+  {
+    int error=innobase_commit(thd);
+    if (error)
+    {
+      my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
+      error=1;
+    }
+  }
 #endif
   DBUG_RETURN(error);
 }
@@ -201,6 +235,17 @@ int ha_rollback(THD *thd)
       error=1;
     }
   }
+#endif
+#ifdef HAVE_INNOBASE_DB
+  if (thd->transaction.innobase_tid)
+  {
+    int error=innobase_rollback(thd);
+    if (error)
+    {
+      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), error);
+      error=1;
+    }
+  }
 #endif
   DBUG_RETURN(error);
 }
@@ -212,6 +257,10 @@ bool ha_flush_logs()
 #ifdef HAVE_BERKELEY_DB
   if (!berkeley_skip && berkeley_flush_logs())
     result=1;
+#endif
+#ifdef HAVE_INNOBASE_DB
+  if (!innobase_skip && innobase_flush_logs())
+    result=1;
 #endif
   return result;
 }

sql/item_strfunc.cc

@@ -448,7 +448,7 @@ String *Item_func_replace::val_str(String *str)
       res->replace((uint) offset,from_length,*res3);
       offset+=(int) to_length;
     }
-    while ((offset=res->strstr(*res2,(uint) offset)) >0);
+    while ((offset=res->strstr(*res2,(uint) offset)) >= 0);
   return res;
 
 null:
@@ -768,7 +768,7 @@ String *Item_func_substr_index::val_str(String *str)
     }
     else
     {					// Start counting at end
-      for (offset=res->length() ; ; offset-=delimeter_length)
+      for (offset=res->length() ; ; offset-=delimeter_length-1)
       {
 	if ((int) (offset=res->strrstr(*delimeter,offset)) < 0)
 	  return res;			// Didn't find, return org string

sql/log_event.h

@@ -308,7 +308,7 @@ class Start_log_event: public Log_event
   
   Start_log_event() :Log_event(time(NULL)),binlog_version(BINLOG_VERSION)
   {
-    created = when;
+    created = (uint32) when;
     memcpy(server_version, ::server_version, sizeof(server_version));
   }
   Start_log_event(FILE* file, time_t when_arg, uint32 server_id) :

sql/mysqld.cc

@@ -21,6 +21,9 @@
 #ifdef HAVE_BERKELEY_DB
 #include "ha_berkeley.h"
 #endif
+#ifdef HAVE_INNOBASE_DB
+#include "ha_innobase.h"
+#endif
 #include "ha_myisam.h"
 #include <nisam.h>
 #include <thr_alarm.h>
@@ -147,8 +150,7 @@ static ulong opt_specialflag=SPECIAL_ENGLISH;
 static my_socket unix_sock= INVALID_SOCKET,ip_sock= INVALID_SOCKET;
 static ulong back_log,connect_timeout,concurrency;
 static my_string opt_logname=0,opt_update_logname=0,
-  opt_binlog_index_name = 0,opt_slow_logname=0;
-my_string opt_bin_logname = 0; // this one needs to be seen in sql_parse.cc
+       opt_binlog_index_name = 0,opt_slow_logname=0;
 static char mysql_home[FN_REFLEN],pidfile_name[FN_REFLEN];
 static pthread_t select_thread;
 static pthread_t flush_thread;			// Used when debugging
@@ -231,9 +233,11 @@ char mysql_real_data_home[FN_REFLEN],
      default_charset[LIBLEN],mysql_charsets_dir[FN_REFLEN], *charsets_list,
      blob_newline,f_fyllchar,max_sort_char,*mysqld_user,*mysqld_chroot,
      *opt_init_file;
+char *opt_bin_logname = 0; // this one needs to be seen in sql_parse.cc
 char server_version[50]=MYSQL_SERVER_VERSION;
 const char *first_keyword="first";
 const char **errmesg;			/* Error messages */
+const char *myisam_recover_options_str="OFF";
 byte last_ref[MAX_REFLENGTH];		/* Index ref of keys */
 my_string mysql_unix_port=NULL,mysql_tmpdir=NULL;
 ulong my_bind_addr;			/* the address we bind to */
@@ -2219,7 +2223,8 @@ enum options {
                OPT_LOG_SLAVE_UPDATES,    OPT_BINLOG_DO_DB, 
                OPT_BINLOG_IGNORE_DB,     OPT_WANT_CORE,
 	       OPT_SKIP_CONCURRENT_INSERT, OPT_MEMLOCK, OPT_MYISAM_RECOVER,
-	       OPT_REPLICATE_REWRITE_DB, OPT_SERVER_ID, OPT_SKIP_SLAVE_START
+	       OPT_REPLICATE_REWRITE_DB, OPT_SERVER_ID, OPT_SKIP_SLAVE_START,
+	       OPT_SKIP_INNOBASE
 };
 
 static struct option long_options[] = {
@@ -2292,6 +2297,9 @@ static struct option long_options[] = {
   {"set-variable",          required_argument, 0, 'O'},
 #ifdef HAVE_BERKELEY_DB
   {"skip-bdb",              no_argument,       0, (int) OPT_BDB_SKIP},
+#endif
+#ifdef HAVE_INNOBASE_DB
+  {"skip-innobase",         no_argument,       0, (int) OPT_INNOBASE_SKIP},
 #endif
   {"skip-concurrent-insert", no_argument,      0, (int) OPT_SKIP_CONCURRENT_INSERT},
   {"skip-delay-key-write",  no_argument,       0, (int) OPT_SKIP_DELAY_KEY_WRITE},
@@ -2443,6 +2451,7 @@ struct show_var_st init_vars[]= {
   {"max_sort_length",         (char*) &max_item_sort_length,        SHOW_LONG},
   {"max_tmp_tables",          (char*) &max_tmp_tables,              SHOW_LONG},
   {"max_write_lock_count",    (char*) &max_write_lock_count,        SHOW_LONG},
+  {"myisam_recover_options",  (char*) &myisam_recover_options_str,  SHOW_CHAR_PTR},
   {"myisam_sort_buffer_size", (char*) &myisam_sort_buffer_size,     SHOW_LONG},
   {"net_buffer_length",       (char*) &net_buffer_length,           SHOW_LONG},
   {"net_retry_count",         (char*) &mysqld_net_retry_count,      SHOW_LONG},
@@ -2647,6 +2656,11 @@ static void usage(void)
   --bdb-tmpdir=directory  Berkeley DB tempfile name\n\
   --skip-bdb		  Don't use berkeley db (will save memory)\n\
 ");
+#endif
+#ifdef HAVE_INNOBASE_DB
+  puts("\
+  --skip-innobase	  Don't use innobase (will save memory)\n\
+");
 #endif
   print_defaults("my",load_default_groups);
   puts("");
@@ -2917,11 +2931,13 @@ static void get_options(int argc,char **argv)
       myisam_delay_key_write=0;
       myisam_concurrent_insert=0;
       myisam_recover_options= HA_RECOVER_NONE;
+      ha_open_options&= ~HA_OPEN_ABORT_IF_CRASHED;
       break;
     case (int) OPT_SAFE:
       opt_specialflag|= SPECIAL_SAFE_MODE;
       myisam_delay_key_write=0;
       myisam_recover_options= HA_RECOVER_NONE;	// To be changed
+      ha_open_options&= ~HA_OPEN_ABORT_IF_CRASHED;
       break;
     case (int) OPT_SKIP_CONCURRENT_INSERT:
       myisam_concurrent_insert=0;
@@ -3085,17 +3101,30 @@ static void get_options(int argc,char **argv)
     case OPT_BDB_SKIP:
       berkeley_skip=1;
       break;
+#endif
+#ifdef HAVE_INNOBASE_DB
+    case OPT_INNOBASE_SKIP:
+      innobase_skip=1;
+      break;
 #endif
     case OPT_MYISAM_RECOVER:
     {
       if (!optarg || !optarg[0])
-	myisam_recover_options=HA_RECOVER_DEFAULT;
-      else if ((myisam_recover_options=
-		find_bit_type(optarg, &myisam_recover_typelib)) == ~(ulong) 0)
       {
-	fprintf(stderr, "Unknown option to myisam-recover: %s\n",optarg);
-	exit(1);
+	myisam_recover_options=    HA_RECOVER_DEFAULT;
+	myisam_recover_options_str= myisam_recover_typelib.type_names[0];
+      }
+      else
+      {
+	myisam_recover_options_str=optarg;
+	if ((myisam_recover_options=
+		find_bit_type(optarg, &myisam_recover_typelib)) == ~(ulong) 0)
+	{
+	  fprintf(stderr, "Unknown option to myisam-recover: %s\n",optarg);
+	  exit(1);
+	}
       }
+      ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
       break;
     }
     case OPT_MASTER_HOST:

sql/sql_base.cc

@@ -706,7 +706,7 @@ TABLE *open_table(THD *thd,const char *db,const char *table_name,
     /* make a new table */
     if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
       DBUG_RETURN(NULL);
-    if (open_unireg_entry(thd, table,db,table_name,alias,0) ||
+    if (open_unireg_entry(thd, table,db,table_name,alias,1) ||
 	!(table->table_cache_key=memdup_root(&table->mem_root,(char*) key,
 					     key_length)))
     {
@@ -1157,7 +1157,6 @@ static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
     thd->net.last_error[0]=0;				// Clear error message
     thd->net.last_errno=0;
     error=0;
-    sql_print_error("Warning: Repairing table: %s.%s",db,name);
     if (openfrm(path,alias,
 		(uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE | HA_GET_INDEX |
 			 HA_TRY_READ_ONLY),
@@ -1166,12 +1165,22 @@ static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
 		entry) ||
 	(entry->file->is_crashed() && entry->file->check_and_repair(thd)))
     {
+      /* Give right error message */
+      thd->net.last_error[0]=0;
+      thd->net.last_errno=0;
+      entry->file->print_error(HA_ERR_CRASHED,MYF(0));
       sql_print_error("Error: Couldn't repair table: %s.%s",db,name);
+      closefrm(entry);
       error=1;
     }
+    else
+    {
+      thd->net.last_error[0]=0;				// Clear error message
+      thd->net.last_errno=0;
+    }
     unlock_table_name(thd,&table_list);
     if (locked)
-      pthread_mutex_lock(&LOCK_open);      // Get back old lock
+      pthread_mutex_lock(&LOCK_open);      // Get back original lock
     if (error)
       goto err;
   }

sql/sql_table.cc

@@ -501,6 +501,8 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
   if ((create_info->options & HA_LEX_CREATE_TMP_TABLE)
       && find_temporary_table(thd,db,table_name))
   {
+    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
+      DBUG_RETURN(0);
     my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
     DBUG_RETURN(-1);
   }
@@ -887,6 +889,24 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
       continue;
     }
 
+    /* Close all instances of the table to allow repair to rename files */
+    if (open_for_modify && table->table->version)
+    {
+      pthread_mutex_lock(&LOCK_open);
+      mysql_lock_abort(thd,table->table);
+      while (remove_table_from_cache(thd, table->table->table_cache_key,
+				     table->table->real_name) &&
+	     ! thd->killed)
+      {
+	dropping_tables++;
+	(void) pthread_cond_wait(&COND_refresh,&LOCK_open);
+	dropping_tables--;
+      }
+      pthread_mutex_unlock(&LOCK_open);
+      if (thd->killed)
+	goto err;
+    }
+
     int result_code = (table->table->file->*operator_func)(thd, check_opt);
     packet->length(0);
     net_store_data(packet, table_name);
@@ -931,7 +951,7 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
       break;
     }
     if (fatal_error)
-      table->table->flush_version=0;	// Force close of table
+      table->table->version=0;			// Force close of table
     close_thread_tables(thd);
     if (my_net_write(&thd->net, (char*) packet->ptr(),
 		     packet->length()))