Added support for 'internal temporary tables' in HEAP tables.

Now we don't take any mutexes when creating or dropping internal HEAP tables during SELECT.
Change buffer sizes to size_t to make keycache 64 bit safe on platforms where sizeof(ulong) != sizeof(size_t)


BitKeeper/etc/ignore:
  added support-files/mysqld_multi.server
include/heap.h:
  Added 'internal_table' to HP_CREATE_INFO
include/keycache.h:
  Change buffer sizes to size_t to make keycache 64 bit safe
include/my_base.h:
  Added HA_OPEN_INTERNAL_TABLE to mark temporary tables that should be deleted on close
mysys/mf_keycache.c:
  Change buffer sizes to size_t to make keycache 64 bit safe
sql/sql_select.cc:
  Added HA_OPEN_INTERNAL_TABLE to mark temporary tables that should be deleted on close
  Removed not anymore needed call to delete_table()
storage/heap/ha_heap.cc:
  Added support for internal temporary tables that should be deleted on close.
  Internal tables now use dedicated open and close calls to avoid taking mutexes.
  If heap_open() failes, now delete the newly created table. (This fixes a possible memory leak)
  Remove never executed info() in create()
storage/heap/ha_heap.h:
  Added slots needed to handle internal temporary tables
storage/heap/heapdef.h:
  Protect against C++ inclusion
storage/heap/hp_close.c:
  Don't call list_delete() for internal temporary tables (They are not in the list)
storage/heap/hp_create.c:
  Added HP_SHARE ** element to heap_create() to store the SHARE of the newly created table.
  For internal temporary tables: Don't take any mutex and don't put them into the open table list.
storage/heap/hp_open.c:
  Split heap_open() into sub functions to be able to create internal temporary tables without putting them in the heap_share_list.
  Add faster open() functions for when we already know the 'share'.
storage/heap/hp_test1.c:
  Update call to heap_create()
  Initialize all keyinfo members.
storage/heap/hp_test2.c:
  Update call to heap_create()

1 files changed, 62 insertions, 19 deletions

diff --git a/storage/heap/hp_open.c b/storage/heap/hp_open.c
index d252704a11b..4d5ec6e27ac 100644
--- a/storage/heap/hp_open.c
+++ b/storage/heap/hp_open.c
@@ -22,43 +22,34 @@
 
 #include "my_sys.h"
 
-HP_INFO *heap_open(const char *name, int mode)
+/*
+  Open heap table based on HP_SHARE structure
+  
+  NOTE
+    This doesn't register the table in the open table list.
+*/
+
+HP_INFO *heap_open_from_share(HP_SHARE *share, int mode)
 {
   HP_INFO *info;
-  HP_SHARE *share;
+  DBUG_ENTER("heap_open_from_share");
 
-  DBUG_ENTER("heap_open");
-  pthread_mutex_lock(&THR_LOCK_heap);
-  if (!(share= hp_find_named_heap(name)))
-  {
-    my_errno= ENOENT;
-    pthread_mutex_unlock(&THR_LOCK_heap);
-    DBUG_RETURN(0);
-  }
   if (!(info= (HP_INFO*) my_malloc((uint) sizeof(HP_INFO) +
 				  2 * share->max_key_length,
 				  MYF(MY_ZEROFILL))))
   {
-    pthread_mutex_unlock(&THR_LOCK_heap);
     DBUG_RETURN(0);
   }
   share->open_count++; 
 #ifdef THREAD
   thr_lock_data_init(&share->lock,&info->lock,NULL);
 #endif
-  info->open_list.data= (void*) info;
-  heap_open_list= list_add(heap_open_list,&info->open_list);
-  pthread_mutex_unlock(&THR_LOCK_heap);
-
   info->s= share;
   info->lastkey= (uchar*) (info + 1);
   info->recbuf= (uchar*) (info->lastkey + share->max_key_length);
   info->mode= mode;
   info->current_record= (ulong) ~0L;		/* No current record */
-  info->current_ptr= 0;
-  info->current_hash_ptr= 0;
   info->lastinx= info->errkey= -1;
-  info->update= 0;
 #ifndef DBUG_OFF
   info->opt_flag= READ_CHECK_USED;		/* Check when changing */
 #endif
@@ -68,7 +59,59 @@ HP_INFO *heap_open(const char *name, int mode)
   DBUG_RETURN(info);
 }
 
-	/* map name to a heap-nr. If name isn't found return 0 */
+
+/*
+  Open heap table based on HP_SHARE structure and register it
+*/
+
+HP_INFO *heap_open_from_share_and_register(HP_SHARE *share, int mode)
+{
+  HP_INFO *info;
+  DBUG_ENTER("heap_open_from_share_and_register");
+
+  pthread_mutex_lock(&THR_LOCK_heap);
+  if ((info= heap_open_from_share(share, mode)))
+  {
+    info->open_list.data= (void*) info;
+    heap_open_list= list_add(heap_open_list,&info->open_list);
+  }
+  pthread_mutex_unlock(&THR_LOCK_heap);
+  DBUG_RETURN(info);
+}
+
+
+/*
+  Open heap table based on name
+
+  NOTE
+    This register the table in the open table list. so that it can be
+    found by future heap_open() calls.
+*/
+
+HP_INFO *heap_open(const char *name, int mode)
+{
+  HP_INFO *info;
+  HP_SHARE *share;
+  DBUG_ENTER("heap_open");
+
+  pthread_mutex_lock(&THR_LOCK_heap);
+  if (!(share= hp_find_named_heap(name)))
+  {
+    my_errno= ENOENT;
+    pthread_mutex_unlock(&THR_LOCK_heap);
+    DBUG_RETURN(0);
+  }
+  if ((info= heap_open_from_share(share, mode)))
+  {
+    info->open_list.data= (void*) info;
+    heap_open_list= list_add(heap_open_list,&info->open_list);
+  }
+  pthread_mutex_unlock(&THR_LOCK_heap);
+  DBUG_RETURN(info);
+}
+
+
+/* map name to a heap-nr. If name isn't found return 0 */
 
 HP_SHARE *hp_find_named_heap(const char *name)
 {