Temporary commit of 10.0-merge

28 files changed, 138 insertions, 100 deletions

diff --git a/storage/maria/ha_maria.cc b/storage/maria/ha_maria.cc
index 95f37ddb12f..092e1a8a79e 100644
--- a/storage/maria/ha_maria.cc
+++ b/storage/maria/ha_maria.cc
@@ -512,7 +512,7 @@ static int table2maria(TABLE *table_arg, data_file_type row_type,
     keydef[i].block_length= pos->block_size;
     keydef[i].seg= keyseg;
     keydef[i].keysegs= pos->key_parts;
-    for (j= 0; j < pos->key_parts; j++)
+    for (j= 0; j < pos->user_defined_key_parts; j++)
     {
       Field *field= pos->key_part[j].field;
       type= field->key_type();
@@ -574,7 +574,7 @@ static int table2maria(TABLE *table_arg, data_file_type row_type,
                                           (uchar*) table_arg->record[0]);
       }
     }
-    keyseg+= pos->key_parts;
+    keyseg+= pos->user_defined_key_parts;
   }
   if (table_arg->found_next_number_field)
     keydef[share->next_number_index].flag|= HA_AUTO_KEY;
@@ -1042,7 +1042,7 @@ ulong ha_maria::index_flags(uint inx, uint part, bool all_parts) const
 double ha_maria::scan_time()
 {
   if (file->s->data_file_type == BLOCK_RECORD)
-    return ulonglong2double(stats.data_file_length - file->s->block_size) / max(file->s->block_size / 2, IO_SIZE) + 2;
+    return ulonglong2double(stats.data_file_length - file->s->block_size) / MY_MAX(file->s->block_size / 2, IO_SIZE) + 2;
   return handler::scan_time();
 }
 
@@ -2464,18 +2464,18 @@ int ha_maria::info(uint flag)
     ref_length= maria_info.reflength;
     share->db_options_in_use= maria_info.options;
     stats.block_size= maria_block_size;
-    stats.mrr_length_per_rec= maria_info.reflength + 8; // 8 = max(sizeof(void *))
+    stats.mrr_length_per_rec= maria_info.reflength + 8; // 8 = MY_MAX(sizeof(void *))
 
     /* Update share */
     share->keys_in_use.set_prefix(share->keys);
     share->keys_in_use.intersect_extended(maria_info.key_map);
     share->keys_for_keyread.intersect(share->keys_in_use);
     share->db_record_offset= maria_info.record_offset;
-    if (share->key_parts)
+    if (share->user_defined_key_parts)
     {
       ulong *to= table->key_info[0].rec_per_key, *end;
       double *from= maria_info.rec_per_key;
-      for (end= to+ share->key_parts ; to < end ; to++, from++)
+      for (end= to+ share->user_defined_key_parts ; to < end ; to++, from++)
         *to= (ulong) (*from + 0.5);
     }
 
diff --git a/storage/maria/ma_bitmap.c b/storage/maria/ma_bitmap.c
index e3668d3c8d3..a351447cce3 100644
--- a/storage/maria/ma_bitmap.c
+++ b/storage/maria/ma_bitmap.c
@@ -319,7 +319,11 @@ my_bool _ma_bitmap_init(MARIA_SHARE *share, File file,
 my_bool _ma_bitmap_end(MARIA_SHARE *share)
 {
   my_bool res;
-  mysql_mutex_assert_owner(&share->close_lock);
+
+#ifndef DBUG_OFF
+  if (! share->internal_table)
+    mysql_mutex_assert_owner(&share->close_lock);
+#endif
   DBUG_ASSERT(share->bitmap.non_flushable == 0);
   DBUG_ASSERT(share->bitmap.flush_all_requested == 0);
   DBUG_ASSERT(share->bitmap.waiting_for_non_flushable == 0 &&
@@ -1393,7 +1397,7 @@ found:
   IMPLEMENTATION
     We will return the smallest area >= size.  If there is no such
     block, we will return the biggest area that satisfies
-    area_size >= min(BLOB_SEGMENT_MIN_SIZE*full_page_size, size)
+    area_size >= MY_MIN(BLOB_SEGMENT_MIN_SIZE*full_page_size, size)
 
     To speed up searches, we will only consider areas that has at least 16 free
     pages starting on an even boundary.  When finding such an area, we will
@@ -1501,7 +1505,7 @@ static ulong allocate_full_pages(MARIA_FILE_BITMAP *bitmap,
     DBUG_RETURN(0);                             /* No room on page */
 
   /*
-    Now allocate min(pages_needed, area_size), starting from
+    Now allocate MY_MIN(pages_needed, area_size), starting from
     best_start + best_prefix_area_size
   */
   if (best_area_size > pages_needed)
diff --git a/storage/maria/ma_blockrec.c b/storage/maria/ma_blockrec.c
index 55b9a137050..2fc30b880b4 100644
--- a/storage/maria/ma_blockrec.c
+++ b/storage/maria/ma_blockrec.c
@@ -1230,7 +1230,7 @@ static my_bool extend_directory(MARIA_HA *info, uchar *buff, uint block_size,
   }
 
   check_directory(buff, block_size,
-                  info ? min(info->s->base.min_block_length, length) : 0,
+                  info ? MY_MIN(info->s->base.min_block_length, length) : 0,
                   *empty_space);
   DBUG_RETURN(0);
 }
@@ -2126,7 +2126,7 @@ static my_bool write_full_pages(MARIA_HA *info,
     }
     lsn_store(buff, lsn);
     buff[PAGE_TYPE_OFFSET]= (uchar) BLOB_PAGE;
-    copy_length= min(data_size, length);
+    copy_length= MY_MIN(data_size, length);
     memcpy(buff + LSN_SIZE + PAGE_TYPE_SIZE, data, copy_length);
     length-= copy_length;
 
@@ -3504,7 +3504,7 @@ static my_bool allocate_and_write_block_record(MARIA_HA *info,
 
   /* page will be pinned & locked by get_head_or_tail_page */
   if (get_head_or_tail_page(info, blocks->block, info->buff,
-                            max(row->space_on_head_page,
+                            MY_MAX(row->space_on_head_page,
                                 info->s->base.min_block_length),
                             HEAD_PAGE,
                             PAGECACHE_LOCK_WRITE, &row_pos))
@@ -3952,7 +3952,7 @@ static my_bool _ma_update_at_original_place(MARIA_HA *info,
   */
 
   DBUG_ASSERT(blocks->count > 1 ||
-              max(new_row->total_length, share->base.min_block_length) <=
+              MY_MAX(new_row->total_length, share->base.min_block_length) <=
               length_on_head_page);
 
   /* Store same amount of data on head page as on original page */
diff --git a/storage/maria/ma_cache.c b/storage/maria/ma_cache.c
index 829189baeed..35926d37e03 100644
--- a/storage/maria/ma_cache.c
+++ b/storage/maria/ma_cache.c
@@ -61,7 +61,7 @@ my_bool _ma_read_cache(MARIA_HA *handler, IO_CACHE *info, uchar *buff,
       (my_off_t) (info->read_end - info->request_pos))
   {
     in_buff_pos=info->request_pos+(uint) offset;
-    in_buff_length= min(length,(size_t) (info->read_end-in_buff_pos));
+    in_buff_length= MY_MIN(length,(size_t) (info->read_end-in_buff_pos));
     memcpy(buff,info->request_pos+(uint) offset,(size_t) in_buff_length);
     if (!(length-=in_buff_length))
       DBUG_RETURN(0);
diff --git a/storage/maria/ma_check.c b/storage/maria/ma_check.c
index ab9080c40fb..e6907aabe27 100644
--- a/storage/maria/ma_check.c
+++ b/storage/maria/ma_check.c
@@ -2396,7 +2396,7 @@ static int initialize_variables_for_repair(HA_CHECK *param,
   else
   {
     ulong rec_length;
-    rec_length= max(share->base.min_pack_length,
+    rec_length= MY_MAX(share->base.min_pack_length,
                     share->base.min_block_length);
     sort_info->max_records= (ha_rows) (sort_info->filelength / rec_length);
   }
@@ -3600,7 +3600,7 @@ int maria_filecopy(HA_CHECK *param, File to,File from,my_off_t start,
   ulong buff_length;
   DBUG_ENTER("maria_filecopy");
 
-  buff_length=(ulong) min(param->write_buffer_length,length);
+  buff_length=(ulong) MY_MIN(param->write_buffer_length,length);
   if (!(buff=my_malloc(buff_length,MYF(0))))
   {
     buff=tmp_buff; buff_length=IO_SIZE;
@@ -5658,7 +5658,7 @@ word_init_ft_buf:
   ft_buf->buf=ft_buf->lastkey+a_len;
   /*
     32 is just a safety margin here
-    (at least max(val_len, sizeof(nod_flag)) should be there).
+    (at least MY_MAX(val_len, sizeof(nod_flag)) should be there).
     May be better performance could be achieved if we'd put
       (sort_info->keyinfo->block_length-32)/XXX
       instead.
@@ -6071,7 +6071,7 @@ int maria_recreate_table(HA_CHECK *param, MARIA_HA **org_info, char *filename)
   maria_close(*org_info);
 
   bzero((char*) &create_info,sizeof(create_info));
-  create_info.max_rows=max(max_records,share.base.records);
+  create_info.max_rows=MY_MAX(max_records,share.base.records);
   create_info.reloc_rows=share.base.reloc;
   create_info.old_options=(share.options |
 			   (unpack ? HA_OPTION_TEMP_COMPRESS_RECORD : 0));
@@ -6494,7 +6494,8 @@ static my_bool create_new_data_handle(MARIA_SORT_PARAM *param, File new_file)
   DBUG_ENTER("create_new_data_handle");
 
   if (!(sort_info->new_info= maria_open(info->s->open_file_name.str, O_RDWR,
-                                        HA_OPEN_COPY | HA_OPEN_FOR_REPAIR)))
+                                        HA_OPEN_COPY | HA_OPEN_FOR_REPAIR |
+                                        HA_OPEN_INTERNAL_TABLE)))
     DBUG_RETURN(1);
 
   new_info= sort_info->new_info;
@@ -6915,7 +6916,7 @@ static TrID max_trid_in_system(void)
 {
   TrID id= trnman_get_max_trid(); /* 0 if transac manager not initialized */
   /* 'id' may be far bigger, if last shutdown is old */
-  return max(id, max_trid_in_control_file);
+  return MY_MAX(id, max_trid_in_control_file);
 }
 
 
diff --git a/storage/maria/ma_checkpoint.c b/storage/maria/ma_checkpoint.c
index 304216a76d9..51494300172 100644
--- a/storage/maria/ma_checkpoint.c
+++ b/storage/maria/ma_checkpoint.c
@@ -563,7 +563,7 @@ pthread_handler_t ma_checkpoint_background(void *arg)
   DBUG_ASSERT(interval > 0);
 
 #ifdef HAVE_PSI_THREAD_INTERFACE
-  PSI_CALL(set_thread_user_host)(0,0,0,0);
+  PSI_THREAD_CALL(set_thread_user_host)(0,0,0,0);
 #endif
 
   /*
@@ -861,11 +861,11 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
     my_malloc(STATE_COPIES * sizeof(struct st_state_copy), MYF(MY_WME));
   dfiles= (PAGECACHE_FILE *)my_realloc((uchar *)dfiles,
                                        /* avoid size of 0 for my_realloc */
-                                       max(1, nb) * sizeof(PAGECACHE_FILE),
+                                       MY_MAX(1, nb) * sizeof(PAGECACHE_FILE),
                                        MYF(MY_WME | MY_ALLOW_ZERO_PTR));
   kfiles= (PAGECACHE_FILE *)my_realloc((uchar *)kfiles,
                                        /* avoid size of 0 for my_realloc */
-                                       max(1, nb) * sizeof(PAGECACHE_FILE),
+                                       MY_MAX(1, nb) * sizeof(PAGECACHE_FILE),
                                        MYF(MY_WME | MY_ALLOW_ZERO_PTR));
   if (unlikely((state_copies == NULL) ||
                (dfiles == NULL) || (kfiles == NULL)))
@@ -898,7 +898,7 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
         Collect and cache a bunch of states. We do this for many states at a
         time, to not lock/unlock the log's lock too often.
       */
-      uint j, bound= min(nb, i + STATE_COPIES);
+      uint j, bound= MY_MIN(nb, i + STATE_COPIES);
       state_copy= state_copies;
       /* part of the state is protected by log's lock */
       translog_lock();
diff --git a/storage/maria/ma_close.c b/storage/maria/ma_close.c
index c355f1f1def..dd3a034425a 100644
--- a/storage/maria/ma_close.c
+++ b/storage/maria/ma_close.c
@@ -27,6 +27,7 @@ int maria_close(register MARIA_HA *info)
   int error=0,flag;
   my_bool share_can_be_freed= FALSE;
   MARIA_SHARE *share= info->s;
+  my_bool internal_table= share->internal_table;
   DBUG_ENTER("maria_close");
   DBUG_PRINT("enter",("name: '%s'  base: 0x%lx  reopen: %u  locks: %u",
                       share->open_file_name.str,
@@ -49,9 +50,9 @@ int maria_close(register MARIA_HA *info)
       error= my_errno;
   }
 
-
   /* Ensure no one can open this file while we are closing it */
-  mysql_mutex_lock(&THR_LOCK_maria);
+  if (!internal_table)
+    mysql_mutex_lock(&THR_LOCK_maria);
   if (info->lock_type == F_EXTRA_LCK)
     info->lock_type=F_UNLCK;			/* HA_EXTRA_NO_USER_CHANGE */
 
@@ -60,8 +61,11 @@ int maria_close(register MARIA_HA *info)
     if (maria_lock_database(info,F_UNLCK))
       error=my_errno;
   }
-  mysql_mutex_lock(&share->close_lock);
-  mysql_mutex_lock(&share->intern_lock);
+  if (!internal_table)
+  {
+    mysql_mutex_lock(&share->close_lock);
+    mysql_mutex_lock(&share->intern_lock);
+  }
 
   if (share->options & HA_OPTION_READ_ONLY_DATA)
   {
@@ -75,7 +79,8 @@ int maria_close(register MARIA_HA *info)
     info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
   }
   flag= !--share->reopen;
-  maria_open_list=list_delete(maria_open_list,&info->open_list);
+  if (!internal_table)
+    maria_open_list=list_delete(maria_open_list,&info->open_list);
 
   my_free(info->rec_buff);
   (*share->end)(info);
@@ -159,7 +164,8 @@ int maria_close(register MARIA_HA *info)
         error= my_errno;
     }
     thr_lock_delete(&share->lock);
-    (void) mysql_mutex_destroy(&share->key_del_lock);
+    mysql_mutex_destroy(&share->key_del_lock);
+
     {
       int i,keys;
       keys = share->state.header.keys;
@@ -181,9 +187,11 @@ int maria_close(register MARIA_HA *info)
       We have to unlock share->intern_lock then lock it after
       LOCK_trn_list (trnman_lock()) to avoid dead locks.
     */
-    mysql_mutex_unlock(&share->intern_lock);
+    if (!internal_table)
+      mysql_mutex_unlock(&share->intern_lock);
     _ma_remove_not_visible_states_with_lock(share, TRUE);
-    mysql_mutex_lock(&share->intern_lock);
+    if (!internal_table)
+      mysql_mutex_lock(&share->intern_lock);
 
     if (share->in_checkpoint & MARIA_CHECKPOINT_LOOKS_AT_ME)
     {
@@ -220,9 +228,12 @@ int maria_close(register MARIA_HA *info)
       share->state_history= 0;
     }
   }
-  mysql_mutex_unlock(&THR_LOCK_maria);
-  mysql_mutex_unlock(&share->intern_lock);
-  mysql_mutex_unlock(&share->close_lock);
+  if (!internal_table)
+  {
+    mysql_mutex_unlock(&THR_LOCK_maria);
+    mysql_mutex_unlock(&share->intern_lock);
+    mysql_mutex_unlock(&share->close_lock);
+  }
   if (share_can_be_freed)
   {
     (void) mysql_mutex_destroy(&share->intern_lock);
diff --git a/storage/maria/ma_commit.c b/storage/maria/ma_commit.c
index 70bc668a220..46db3ca4ae5 100644
--- a/storage/maria/ma_commit.c
+++ b/storage/maria/ma_commit.c
@@ -39,11 +39,11 @@ int ma_commit(TRN *trn)
   /*
     - if COMMIT record is written before trnman_commit_trn():
     if Checkpoint comes in the middle it will see trn is not committed,
-    then if crash, Recovery might roll back trn (if min(rec_lsn) is after
+    then if crash, Recovery might roll back trn (if MY_MIN(rec_lsn) is after
     COMMIT record) and this is not an issue as
     * transaction's updates were not made visible to other transactions
     * "commit ok" was not sent to client
-    Alternatively, Recovery might commit trn (if min(rec_lsn) is before COMMIT
+    Alternatively, Recovery might commit trn (if MY_MIN(rec_lsn) is before COMMIT
     record), which is ok too. All in all it means that "trn committed" is not
     100% equal to "COMMIT record written".
     - if COMMIT record is written after trnman_commit_trn():
diff --git a/storage/maria/ma_create.c b/storage/maria/ma_create.c
index 28c3491730f..152302a5426 100644
--- a/storage/maria/ma_create.c
+++ b/storage/maria/ma_create.c
@@ -51,6 +51,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
        base_pos,long_varchar_count,varchar_length,
        unique_key_parts,fulltext_keys,offset, not_block_record_extra_length;
   uint max_field_lengths, extra_header_size, column_nr;
+  uint internal_table= flags & HA_CREATE_INTERNAL_TABLE;
   ulong reclength, real_reclength,min_pack_length;
   char filename[FN_REFLEN], linkname[FN_REFLEN], *linkname_ptr;
   ulong pack_reclength;
@@ -713,7 +714,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     got from MAI file header (see also mariapack.c:save_state)
   */
   share.base.key_reflength=
-    maria_get_pointer_length(max(ci->key_file_length,tmp),3);
+    maria_get_pointer_length(MY_MAX(ci->key_file_length,tmp),3);
   share.base.keys= share.state.header.keys= keys;
   share.state.header.uniques= uniques;
   share.state.header.fulltext_keys= fulltext_keys;
@@ -780,7 +781,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     share.base.min_block_length=
       (share.base.pack_reclength+3 < MARIA_EXTEND_BLOCK_LENGTH &&
        ! share.base.blobs) ?
-      max(share.base.pack_reclength,MARIA_MIN_BLOCK_LENGTH) :
+      MY_MAX(share.base.pack_reclength,MARIA_MIN_BLOCK_LENGTH) :
       MARIA_EXTEND_BLOCK_LENGTH;
   }
   else if (datafile_type == STATIC_RECORD)
@@ -789,7 +790,8 @@ int maria_create(const char *name, enum data_file_type datafile_type,
   if (! (flags & HA_DONT_TOUCH_DATA))
     share.state.create_time= time((time_t*) 0);
 
-  mysql_mutex_lock(&THR_LOCK_maria);
+  if (!internal_table)
+    mysql_mutex_lock(&THR_LOCK_maria);
 
   /*
     NOTE: For test_if_reopen() we need a real path name. Hence we need
@@ -854,7 +856,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     NOTE: The filename is compared against unique_file_name of every
     open table. Hence we need a real path here.
   */
-  if (_ma_test_if_reopen(filename))
+  if (!internal_table && _ma_test_if_reopen(filename))
   {
     my_printf_error(HA_ERR_TABLE_EXIST, "Aria table '%s' is in use "
                     "(most likely by a MERGE table). Try FLUSH TABLES.",
@@ -1171,7 +1173,8 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     if (mysql_file_close(dfile,MYF(0)))
       goto err;
   }
-  mysql_mutex_unlock(&THR_LOCK_maria);
+  if (!internal_table)
+    mysql_mutex_unlock(&THR_LOCK_maria);
   res= 0;
   my_free((char*) rec_per_key_part);
   errpos=0;
@@ -1180,7 +1183,8 @@ int maria_create(const char *name, enum data_file_type datafile_type,
   DBUG_RETURN(res);
 
 err:
-  mysql_mutex_unlock(&THR_LOCK_maria);
+  if (!internal_table)
+    mysql_mutex_unlock(&THR_LOCK_maria);
 
 err_no_lock:
   save_errno=my_errno;
diff --git a/storage/maria/ma_delete.c b/storage/maria/ma_delete.c
index 5b8d0e01677..50edb216a1c 100644
--- a/storage/maria/ma_delete.c
+++ b/storage/maria/ma_delete.c
@@ -987,7 +987,7 @@ static int underflow(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
         */
         if (_ma_log_add(anc_page, anc_length, keypos,
                         anc_key_inserted.move_length +
-                        max(anc_key_inserted.changed_length -
+                        MY_MAX(anc_key_inserted.changed_length -
                             anc_key_inserted.move_length,
                             key_deleted.changed_length),
                         anc_key_inserted.move_length -
@@ -1229,7 +1229,7 @@ static int underflow(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
       */
       if (_ma_log_add(anc_page, anc_length, keypos,
                       anc_key_inserted.move_length +
-                      max(anc_key_inserted.changed_length -
+                      MY_MAX(anc_key_inserted.changed_length -
                           anc_key_inserted.move_length,
                           key_deleted.changed_length),
                       anc_key_inserted.move_length -
@@ -1570,7 +1570,7 @@ my_bool _ma_log_delete(MARIA_PAGE *ma_page, const uchar *key_pos,
       current_size != share->max_index_block_size)
   {
     /* Append data that didn't fit on the page before */
-    uint length= (min(ma_page->size, share->max_index_block_size) -
+    uint length= (MY_MIN(ma_page->size, share->max_index_block_size) -
                   current_size);
     uchar *data= ma_page->buff + current_size;
 
diff --git a/storage/maria/ma_dynrec.c b/storage/maria/ma_dynrec.c
index c1c0a8e9729..4bb51d0dcf3 100644
--- a/storage/maria/ma_dynrec.c
+++ b/storage/maria/ma_dynrec.c
@@ -851,7 +851,7 @@ static my_bool update_dynamic_record(MARIA_HA *info, MARIA_RECORD_POS filepos,
 	uint tmp=MY_ALIGN(reclength - length + 3 +
 			  test(reclength >= 65520L),MARIA_DYN_ALIGN_SIZE);
 	/* Don't create a block bigger than MARIA_MAX_BLOCK_LENGTH */
-	tmp= min(length+tmp, MARIA_MAX_BLOCK_LENGTH)-length;
+	tmp= MY_MIN(length+tmp, MARIA_MAX_BLOCK_LENGTH)-length;
 	/* Check if we can extend this block */
 	if (block_info.filepos + block_info.block_len ==
 	    info->state->data_file_length &&
diff --git a/storage/maria/ma_extra.c b/storage/maria/ma_extra.c
index 0847f3c729c..66e7b4033c7 100644
--- a/storage/maria/ma_extra.c
+++ b/storage/maria/ma_extra.c
@@ -105,7 +105,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
       cache_size= (extra_arg ? *(ulong*) extra_arg :
 		   my_default_record_cache_size);
       if (!(init_io_cache(&info->rec_cache, info->dfile.file,
-			 (uint) min(share->state.state.data_file_length+1,
+			 (uint) MY_MIN(share->state.state.data_file_length+1,
 				    cache_size),
 			  READ_CACHE,0L,(pbool) (info->lock_type != F_UNLCK),
 			  MYF(share->write_flag & MY_WAIT_IF_FULL))))
diff --git a/storage/maria/ma_ft_boolean_search.c b/storage/maria/ma_ft_boolean_search.c
index c98c4b599fc..eb5813f84f1 100644
--- a/storage/maria/ma_ft_boolean_search.c
+++ b/storage/maria/ma_ft_boolean_search.c
@@ -46,9 +46,9 @@
     three subexpressions (including the top-level one),
     every one has its own max_docid, updated by its plus word.
     but for the search word6 uses
-    max(word1.max_docid, word3.max_docid, word5.max_docid),
+    MY_MAX(word1.max_docid, word3.max_docid, word5.max_docid),
     while word4 uses, accordingly,
-    max(word1.max_docid, word3.max_docid).
+    MY_MAX(word1.max_docid, word3.max_docid).
 */
 
 #define FT_CORE
diff --git a/storage/maria/ma_info.c b/storage/maria/ma_info.c
index 341ea147785..912ed0984a3 100644
--- a/storage/maria/ma_info.c
+++ b/storage/maria/ma_info.c
@@ -31,7 +31,7 @@ MARIA_RECORD_POS maria_position(MARIA_HA *info)
 uint maria_max_key_length()
 {
   uint tmp= (_ma_max_key_length() - 8 - HA_MAX_KEY_SEG*3);
-  return min(HA_MAX_KEY_LENGTH, tmp);
+  return MY_MIN(HA_MAX_KEY_LENGTH, tmp);
 }
 
 /* Get information about the table */
diff --git a/storage/maria/ma_key_recover.c b/storage/maria/ma_key_recover.c
index 502ac2b8809..ae9427981ea 100644
--- a/storage/maria/ma_key_recover.c
+++ b/storage/maria/ma_key_recover.c
@@ -506,7 +506,7 @@ my_bool _ma_log_add(MARIA_PAGE *ma_page,
                        move_length));
   DBUG_ASSERT(info->s->now_transactional);
   DBUG_ASSERT(move_length <= (int) changed_length);
-  DBUG_ASSERT(ma_page->org_size == min(org_page_length, max_page_size));
+  DBUG_ASSERT(ma_page->org_size == MY_MIN(org_page_length, max_page_size));
   DBUG_ASSERT(ma_page->size == org_page_length + move_length);
   DBUG_ASSERT(offset <= ma_page->org_size);
 
@@ -618,7 +618,7 @@ my_bool _ma_log_add(MARIA_PAGE *ma_page,
   DBUG_ASSERT(current_size <= max_page_size && current_size <= ma_page->size);
   if (current_size != ma_page->size && current_size != max_page_size)
   {
-    uint length= min(ma_page->size, max_page_size) - current_size;
+    uint length= MY_MIN(ma_page->size, max_page_size) - current_size;
     uchar *data= ma_page->buff + current_size;
 
     log_pos[0]= KEY_OP_ADD_SUFFIX;
@@ -641,7 +641,7 @@ my_bool _ma_log_add(MARIA_PAGE *ma_page,
     overflow!
   */
   ma_page->org_size= current_size;
-  DBUG_ASSERT(ma_page->org_size == min(ma_page->size, max_page_size));
+  DBUG_ASSERT(ma_page->org_size == MY_MIN(ma_page->size, max_page_size));
 
   if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
                             info->trn, info,
@@ -663,7 +663,7 @@ void _ma_log_key_changes(MARIA_PAGE *ma_page, LEX_CUSTRING *log_array,
                          uint *translog_parts)
 {
   MARIA_SHARE *share= ma_page->info->s;
-  int page_length= min(ma_page->size, share->max_index_block_size);
+  int page_length= MY_MIN(ma_page->size, share->max_index_block_size);
   uint org_length;
   ha_checksum crc;
 
@@ -1111,7 +1111,7 @@ uint _ma_apply_redo_index(MARIA_HA *info,
                           uint2korr(header), uint2korr(header+2)));
       DBUG_ASSERT(uint2korr(header) == page_length);
 #ifndef DBUG_OFF
-      new_page_length= min(uint2korr(header+2), max_page_size);
+      new_page_length= MY_MIN(uint2korr(header+2), max_page_size);
 #endif
       header+= 4;
       break;
@@ -1148,7 +1148,7 @@ uint _ma_apply_redo_index(MARIA_HA *info,
         from= uint2korr(header);
         header+= 2;
         /* "from" is a place in the existing page */
-        DBUG_ASSERT(max(from, to) < max_page_size);
+        DBUG_ASSERT(MY_MAX(from, to) < max_page_size);
         memcpy(buff + to, buff + from, full_length);
       }
       break;
diff --git a/storage/maria/ma_loghandler.c b/storage/maria/ma_loghandler.c
index 56926c048d8..2a2681c0844 100644
--- a/storage/maria/ma_loghandler.c
+++ b/storage/maria/ma_loghandler.c
@@ -4808,7 +4808,7 @@ static my_bool translog_advance_pointer(int pages, uint16 last_page_data)
     }
 #endif
 
-    min_offset= min(buffer_end_offset, file_end_offset);
+    min_offset= MY_MIN(buffer_end_offset, file_end_offset);
     /* TODO: check is it ptr or size enough */
     log_descriptor.bc.buffer->size+= min_offset;
     log_descriptor.bc.ptr+= min_offset;
@@ -6833,7 +6833,7 @@ translog_variable_length_header(uchar *page, translog_size_t page_offset,
     page_rest= (uint16) (TRANSLOG_PAGE_SIZE - (src - page));
 
     base_lsn= buff->lsn;
-    body_len= min(page_rest, buff->record_length);
+    body_len= MY_MIN(page_rest, buff->record_length);
   }
   else
   {
@@ -7396,7 +7396,7 @@ translog_size_t translog_read_record(LSN lsn,
                       data->scanner.fixed_horizon));
   if (offset < data->read_header)
   {
-    uint16 len= min(data->read_header, end) - offset;
+    uint16 len= MY_MIN(data->read_header, end) - offset;
     DBUG_PRINT("info",
                ("enter header offset: %lu  length: %lu",
                 (ulong) offset, (ulong) length));
diff --git a/storage/maria/ma_open.c b/storage/maria/ma_open.c
index 88422e3dc5f..0543f426af3 100644
--- a/storage/maria/ma_open.c
+++ b/storage/maria/ma_open.c
@@ -78,6 +78,7 @@ MARIA_HA *_ma_test_if_reopen(const char *filename)
     mode	Mode of table (O_RDONLY | O_RDWR)
     data_file   Filedescriptor of data file to use < 0 if one should open
 	        open it.
+    internal_table <> 0 if this is an internal temporary table
 
  RETURN
     #   Maria handler
@@ -86,7 +87,8 @@ MARIA_HA *_ma_test_if_reopen(const char *filename)
 
 
 static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, const char *name,
-                                      int mode, File data_file)
+                                      int mode, File data_file,
+                                      uint internal_table)
 {
   int save_errno;
   uint errpos;
@@ -159,7 +161,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, const char *name,
   /* The following should be big enough for all pinning purposes */
   if (my_init_dynamic_array(&info.pinned_pages,
                             sizeof(MARIA_PINNED_PAGE),
-                            max(share->base.blobs*2 + 4,
+                            MY_MAX(share->base.blobs*2 + 4,
                                 MARIA_MAX_TREE_LEVELS*3), 16, MYF(0)))
     goto err;
 
@@ -207,9 +209,17 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, const char *name,
   if (share->options & HA_OPTION_TMP_TABLE)
     m_info->lock.type= TL_WRITE;
 
-  m_info->open_list.data=(void*) m_info;
-  maria_open_list=list_add(maria_open_list,&m_info->open_list);
-
+  if (!internal_table)
+  {
+    m_info->open_list.data=(void*) m_info;
+    maria_open_list=list_add(maria_open_list,&m_info->open_list);
+  }
+  else
+  {
+    /* We don't need to mark internal temporary tables as changed on disk */
+    share->internal_table= 1;
+    share->global_changed= 1;
+  }
   DBUG_RETURN(m_info);
 
 err:
@@ -243,7 +253,7 @@ MARIA_HA *maria_clone(MARIA_SHARE *share, int mode)
   mysql_mutex_lock(&THR_LOCK_maria);
   new_info= maria_clone_internal(share, NullS, mode,
                                  share->data_file_type == BLOCK_RECORD ?
-                                 share->bitmap.file.file : -1);
+                                 share->bitmap.file.file : -1, 0);
   mysql_mutex_unlock(&THR_LOCK_maria);
   return new_info;
 }
@@ -263,6 +273,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
   int kfile,open_mode,save_errno;
   uint i,j,len,errpos,head_length,base_pos,keys, realpath_err,
     key_parts,unique_key_parts,fulltext_keys,uniques;
+  uint internal_table= test(open_flags & HA_OPEN_INTERNAL_TABLE);
   size_t info_length;
   char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
        data_name[FN_REFLEN];
@@ -293,10 +304,11 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
     DBUG_RETURN(0);
   }
 
-  mysql_mutex_lock(&THR_LOCK_maria);
   old_info= 0;
+  if (!internal_table)
+    mysql_mutex_lock(&THR_LOCK_maria);
   if ((open_flags & HA_OPEN_COPY) ||
-      !(old_info=_ma_test_if_reopen(name_buff)))
+      (internal_table || !(old_info=_ma_test_if_reopen(name_buff))))
   {
     share= &share_buff;
     bzero((uchar*) &share_buff,sizeof(share_buff));
@@ -592,7 +604,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
         {
           /* Packed key, ensure we don't get overflow in underflow() */
           keyinfo->underflow_block_length=
-            max((int) (share->max_index_block_size - keyinfo->maxlength * 3),
+            MY_MAX((int) (share->max_index_block_size - keyinfo->maxlength * 3),
                 (int) (share->keypage_header + share->base.key_reflength));
           set_if_smaller(keyinfo->underflow_block_length,
                          keyinfo->block_length/3);
@@ -780,7 +792,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
       /* Need some extra bytes for decode_bytes */
       share->base.extra_rec_buff_size+= 7;
     }
-    share->base.default_rec_buff_size= max(share->base.pack_reclength +
+    share->base.default_rec_buff_size= MY_MAX(share->base.pack_reclength +
                                            share->base.extra_rec_buff_size,
                                            share->base.max_key_length);
 
@@ -981,14 +993,16 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
       data_file= share->bitmap.file.file;       /* Only opened once */
   }
 
-  if (!(m_info= maria_clone_internal(share, name, mode, data_file)))
+  if (!(m_info= maria_clone_internal(share, name, mode, data_file,
+                                     internal_table)))
     goto err;
 
   if (maria_is_crashed(m_info))
     DBUG_PRINT("warning", ("table is crashed: changed: %u",
                            share->state.changed));
 
-  mysql_mutex_unlock(&THR_LOCK_maria);
+  if (!internal_table)
+    mysql_mutex_unlock(&THR_LOCK_maria);
 
   m_info->open_flags= open_flags;
   DBUG_PRINT("exit", ("table: %p  name: %s",m_info, name));
@@ -1027,7 +1041,8 @@ err:
   default:
     break;
   }
-  mysql_mutex_unlock(&THR_LOCK_maria);
+  if (!internal_table)
+    mysql_mutex_unlock(&THR_LOCK_maria);
   my_errno= save_errno;
   DBUG_RETURN (NULL);
 } /* maria_open */
diff --git a/storage/maria/ma_packrec.c b/storage/maria/ma_packrec.c
index c14e69414b5..9b06c0d4f78 100644
--- a/storage/maria/ma_packrec.c
+++ b/storage/maria/ma_packrec.c
@@ -718,7 +718,7 @@ static uint find_longest_bitstream(uint16 *table, uint16 *end)
       return OFFSET_TABLE_SIZE;
     }
     length2= find_longest_bitstream(next, end) + 1;
-    length=max(length,length2);
+    length=MY_MAX(length,length2);
   }
   return length;
 }
@@ -1447,7 +1447,7 @@ uint _ma_pack_get_block_info(MARIA_HA *maria, MARIA_BIT_BUFF *bit_buff,
   info->filepos=filepos+head_length;
   if (file > 0)
   {
-    info->offset=min(info->rec_len, ref_length - head_length);
+    info->offset=MY_MIN(info->rec_len, ref_length - head_length);
     memcpy(*rec_buff_p, header + head_length, info->offset);
   }
   return 0;
diff --git a/storage/maria/ma_recovery.c b/storage/maria/ma_recovery.c
index 9ac42f885b5..c896f730d3f 100644
--- a/storage/maria/ma_recovery.c
+++ b/storage/maria/ma_recovery.c
@@ -3679,7 +3679,7 @@ static void print_redo_phase_progress(TRANSLOG_ADDRESS addr)
   cur_offset= LSN_OFFSET(addr);
   local_remainder= (cur_logno == end_logno) ? (end_offset - cur_offset) :
     (((longlong)log_file_size) - cur_offset +
-     max(end_logno - cur_logno - 1, 0) * ((longlong)log_file_size) +
+     MY_MAX(end_logno - cur_logno - 1, 0) * ((longlong)log_file_size) +
      end_offset);
   if (initial_remainder == (ulonglong)(-1))
     initial_remainder= local_remainder;
diff --git a/storage/maria/ma_rt_mbr.c b/storage/maria/ma_rt_mbr.c
index b3e2b0ceab8..496ace2a84f 100644
--- a/storage/maria/ma_rt_mbr.c
+++ b/storage/maria/ma_rt_mbr.c
@@ -329,8 +329,8 @@ int maria_rtree_d_mbr(const HA_KEYSEG *keyseg, const uchar *a,
   bmin= korr_func(b); \
   amax= korr_func(a+len); \
   bmax= korr_func(b+len); \
-  amin= min(amin, bmin); \
-  amax= max(amax, bmax); \
+  amin= MY_MIN(amin, bmin); \
+  amax= MY_MAX(amax, bmax); \
   store_func(c, amin); \
   store_func(c+len, amax); \
 }
@@ -342,8 +342,8 @@ int maria_rtree_d_mbr(const HA_KEYSEG *keyseg, const uchar *a,
   get_func(bmin, b); \
   get_func(amax, a+len); \
   get_func(bmax, b+len); \
-  amin= min(amin, bmin); \
-  amax= max(amax, bmax); \
+  amin= MY_MIN(amin, bmin); \
+  amax= MY_MAX(amax, bmax); \
   store_func(c, amin); \
   store_func(c+len, amax); \
 }
@@ -422,8 +422,8 @@ int maria_rtree_combine_rect(const HA_KEYSEG *keyseg, const uchar* a,
   bmin= korr_func(b); \
   amax= korr_func(a+len); \
   bmax= korr_func(b+len); \
-  amin= max(amin, bmin); \
-  amax= min(amax, bmax); \
+  amin= MY_MAX(amin, bmin); \
+  amax= MY_MIN(amax, bmax); \
   if (amin >= amax) \
     return 0; \
   res *= amax - amin; \
@@ -436,8 +436,8 @@ int maria_rtree_combine_rect(const HA_KEYSEG *keyseg, const uchar* a,
   get_func(bmin, b); \
   get_func(amax, a+len); \
   get_func(bmax, b+len); \
-  amin= max(amin, bmin); \
-  amax= min(amax, bmax); \
+  amin= MY_MAX(amin, bmin); \
+  amax= MY_MIN(amax, bmax); \
   if (amin >= amax)  \
     return 0; \
   res *= amax - amin; \
@@ -513,7 +513,7 @@ double maria_rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
    amax= korr_func(a+len); \
    bmax= korr_func(b+len); \
    a_area *= (((double)amax) - ((double)amin)); \
-   loc_ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
+   loc_ab_area *= ((double)MY_MAX(amax, bmax) - (double)MY_MIN(amin, bmin)); \
 }
 
 #define RT_AREA_INC_GET(type, get_func, len)\
@@ -524,7 +524,7 @@ double maria_rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
    get_func(amax, a+len); \
    get_func(bmax, b+len); \
    a_area *= (((double)amax) - ((double)amin)); \
-   loc_ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
+   loc_ab_area *= ((double)MY_MAX(amax, bmax) - (double)MY_MIN(amin, bmin)); \
 }
 
 /*
@@ -612,7 +612,7 @@ safe_end:
    amax= korr_func(a+len); \
    bmax= korr_func(b+len); \
    a_perim+= (((double)amax) - ((double)amin)); \
-   *ab_perim+= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
+   *ab_perim+= ((double)MY_MAX(amax, bmax) - (double)MY_MIN(amin, bmin)); \
 }
 
 #define RT_PERIM_INC_GET(type, get_func, len)\
@@ -623,7 +623,7 @@ safe_end:
    get_func(amax, a+len); \
    get_func(bmax, b+len); \
    a_perim+= (((double)amax) - ((double)amin)); \
-   *ab_perim+= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
+   *ab_perim+= ((double)MY_MAX(amax, bmax) - (double)MY_MIN(amin, bmin)); \
 }
 
 /*
diff --git a/storage/maria/ma_sort.c b/storage/maria/ma_sort.c
index 4bc179c3008..72f9c7ceca3 100644
--- a/storage/maria/ma_sort.c
+++ b/storage/maria/ma_sort.c
@@ -133,7 +133,7 @@ int _ma_create_index_by_sort(MARIA_SORT_PARAM *info, my_bool no_messages,
   sort_keys= (uchar **) NULL; error= 1;
   maxbuffer=1;
 
-  memavl=max(sortbuff_size,MIN_SORT_MEMORY);
+  memavl=MY_MAX(sortbuff_size,MIN_SORT_MEMORY);
   records=	info->sort_info->max_records;
   sort_length=	info->key_length;
   LINT_INIT(keys);
@@ -364,7 +364,7 @@ pthread_handler_t _ma_thr_find_all_keys(void *arg)
     bzero((char*) &sort_param->buffpek,sizeof(sort_param->buffpek));
     bzero((char*) &sort_param->unique, sizeof(sort_param->unique));
 
-    memavl=       max(sort_param->sortbuff_size, MIN_SORT_MEMORY);
+    memavl=       MY_MAX(sort_param->sortbuff_size, MIN_SORT_MEMORY);
     idx=          (uint)sort_param->sort_info->max_records;
     sort_length=  sort_param->key_length;
     maxbuffer=    1;
@@ -857,7 +857,7 @@ static uint read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
   register uint count;
   uint length;
 
-  if ((count=(uint) min((ha_rows) buffpek->max_keys,buffpek->count)))
+  if ((count=(uint) MY_MIN((ha_rows) buffpek->max_keys,buffpek->count)))
   {
     if (mysql_file_pread(fromfile->file, buffpek->base,
                  (length= sort_length*count),buffpek->file_pos,MYF_RW))
@@ -877,7 +877,7 @@ static uint read_to_buffer_varlen(IO_CACHE *fromfile, BUFFPEK *buffpek,
   uint idx;
   uchar *buffp;
 
-  if ((count=(uint) min((ha_rows) buffpek->max_keys,buffpek->count)))
+  if ((count=(uint) MY_MIN((ha_rows) buffpek->max_keys,buffpek->count)))
   {
     buffp= buffpek->base;
 
diff --git a/storage/maria/ma_test1.c b/storage/maria/ma_test1.c
index 945654a0bbe..0147d00d6e0 100644
--- a/storage/maria/ma_test1.c
+++ b/storage/maria/ma_test1.c
@@ -631,7 +631,7 @@ static void create_record(uchar *record,uint rownr)
     uint tmp;
     uchar *ptr;;
     sprintf((char*) blob_record,"... row: %d", rownr);
-    strappend((char*) blob_record,max(MAX_REC_LENGTH-rownr,10),' ');
+    strappend((char*) blob_record,MY_MAX(MAX_REC_LENGTH-rownr,10),' ');
     tmp=strlen((char*) blob_record);
     int4store(pos,tmp);
     ptr=blob_record;
diff --git a/storage/maria/ma_test2.c b/storage/maria/ma_test2.c
index ea1978b4ee5..242e5e16333 100644
--- a/storage/maria/ma_test2.c
+++ b/storage/maria/ma_test2.c
@@ -698,7 +698,7 @@ int main(int argc, char *argv[])
     goto err2;
   }
 
-  for (i=min(2,keys) ; i-- > 0 ;)
+  for (i=MY_MIN(2,keys) ; i-- > 0 ;)
   {
     if (maria_rsame(file,read_record2,(int) i)) goto err;
     if (bcmp(read_record,read_record2,reclength) != 0)
diff --git a/storage/maria/ma_write.c b/storage/maria/ma_write.c
index 5d440a40dc0..24a3f96f42e 100644
--- a/storage/maria/ma_write.c
+++ b/storage/maria/ma_write.c
@@ -933,7 +933,7 @@ ChangeSet@1.2562, 2008-04-09 07:41:40+02:00, serg@janus.mylan +9 -0
                                  &s_temp));
   }
   DBUG_RETURN(_ma_split_page(info, key, anc_page,
-                             min(org_anc_length,
+                             MY_MIN(org_anc_length,
                                  info->s->max_index_block_size),
                              key_pos, s_temp.changed_length, t_length,
                              key_buff, insert_last));
@@ -2075,7 +2075,7 @@ static my_bool _ma_log_split(MARIA_PAGE *ma_page,
       Handle case when split happened directly after the newly inserted key.
     */
     max_key_length= new_length - offset;
-    extra_length= min(key_length, max_key_length);
+    extra_length= MY_MIN(key_length, max_key_length);
     if (offset + move_length > new_length)
     {
       /* This is true when move_length includes changes for next packed key */
diff --git a/storage/maria/maria_def.h b/storage/maria/maria_def.h
index e983f561bbb..c1ac49a6b35 100644
--- a/storage/maria/maria_def.h
+++ b/storage/maria/maria_def.h
@@ -465,6 +465,7 @@ typedef struct st_maria_share
   my_bool changed,			/* If changed since lock */
     global_changed,			/* If changed since open */
     not_flushed;
+  my_bool internal_table;               /* Internal tmp table */
   my_bool lock_key_trees;               /* If we have to lock trees on read */
   my_bool non_transactional_concurrent_insert;
   my_bool delay_key_write;
diff --git a/storage/maria/maria_pack.c b/storage/maria/maria_pack.c
index 40686995378..2fe5e818db9 100644
--- a/storage/maria/maria_pack.c
+++ b/storage/maria/maria_pack.c
@@ -1243,7 +1243,7 @@ static void check_counts(HUFF_COUNTS *huff_counts, uint trees,
     {
       if (huff_counts->field_length > 2 &&
 	  huff_counts->empty_fields + (records - huff_counts->empty_fields)*
-	  (1+max_bit(max(huff_counts->max_pre_space,
+	  (1+max_bit(MY_MAX(huff_counts->max_pre_space,
 			 huff_counts->max_end_space))) <
 	  records * max_bit(huff_counts->field_length))
       {
@@ -3021,7 +3021,7 @@ static int save_state_mrg(File file,PACK_MRG_INFO *mrg,my_off_t new_length,
   if (mrg->src_file_has_indexes_disabled)
   {
     isam_file->s->state.state.key_file_length=
-      max(isam_file->s->state.state.key_file_length, new_length);
+      MY_MAX(isam_file->s->state.state.key_file_length, new_length);
   }
   state.dellink= HA_OFFSET_ERROR;
   state.version=(ulong) time((time_t*) 0);
diff --git a/storage/maria/trnman.c b/storage/maria/trnman.c
index f8959c977f8..38fdb358e53 100644
--- a/storage/maria/trnman.c
+++ b/storage/maria/trnman.c
@@ -877,7 +877,7 @@ TrID trnman_get_min_safe_trid()
 {
   TrID trid;
   mysql_mutex_lock(&LOCK_trn_list);
-  trid= min(active_list_min.next->min_read_from,
+  trid= MY_MIN(active_list_min.next->min_read_from,
             global_trid_generator);
   mysql_mutex_unlock(&LOCK_trn_list);
   return trid;
diff --git a/storage/maria/unittest/ma_test_all-t b/storage/maria/unittest/ma_test_all-t
index e66d269ab93..18b26a7bd45 100755
--- a/storage/maria/unittest/ma_test_all-t
+++ b/storage/maria/unittest/ma_test_all-t
@@ -650,6 +650,8 @@ sub ok
   {
     exit 1;
   }
+  # Unlink all files so that we can continue on error
+  unlink_all_possible_tmp_files();
   return 0;
 }
 
@@ -702,7 +704,7 @@ sub unlink_all_possible_tmp_files()
   unlink_log_files();
 
   # Unlink tmp files that may have been created when testing the test programs
-  unlink <$full_tmpdir/*.TMD $full_tmpdir/aria_read_log_test1.txt $full_tmpdir/test1*.MA? $full_tmpdir/ma_test_recovery.output aria_log_control aria_log.00000001 aria_log.00000002 aria_logtest1.MA? test1.MA? test2.MA? test3.MA?>;
+  unlink <$full_tmpdir/*.TMD $full_tmpdir/aria_read_log_test1.txt $full_tmpdir/test1*.MA? $full_tmpdir/ma_test_recovery.output aria_log_control aria_log.00000001 aria_log.00000002 aria_logtest1.MA? test1.MA? test2.MA? test3.MA? *.TMD>;
 }
 
 ####