merge

sql/item.cc:
  Auto merged
sql/item.h:
  Auto merged
sql/item_sum.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_lex.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_select.h:
  Auto merged
sql/sql_yacc.yy:
  Auto merged
sql/table.h:
  Auto merged
sql/item_strfunc.h:
  merge layout fixing
sql/sql_update.cc:
  merge layout fixing

heap/heapdef.h

@@ -79,13 +79,14 @@ extern int hp_rec_key_cmp(HP_KEYDEF *keydef,const byte *rec1,
 extern int hp_key_cmp(HP_KEYDEF *keydef,const byte *rec,
 		      const byte *key);
 extern void hp_make_key(HP_KEYDEF *keydef,byte *key,const byte *rec);
-extern void hp_rb_make_key(HP_KEYDEF *keydef, byte *key, 
+extern uint hp_rb_make_key(HP_KEYDEF *keydef, byte *key, 
 			   const byte *rec, byte *recpos);
+extern uint hp_rb_key_length(HP_KEYDEF *keydef, const byte *key);
+extern uint hp_rb_null_key_length(HP_KEYDEF *keydef, const byte *key);
 extern my_bool hp_if_null_in_key(HP_KEYDEF *keyinfo, const byte *record);
 extern int hp_close(register HP_INFO *info);
 extern void hp_clear(HP_SHARE *info);
-extern uint hp_rb_pack_key(HP_INFO *info, uint inx, uchar *key, 
-			   const uchar *old, uint k_length);
+extern uint hp_rb_pack_key(HP_KEYDEF *keydef, uchar *key, const uchar *old);
 #ifdef THREAD
 extern pthread_mutex_t THR_LOCK_heap;
 #else

heap/hp_delete.c

@@ -65,12 +65,11 @@ int hp_rb_delete_key(HP_INFO *info, register HP_KEYDEF *keyinfo,
   heap_rb_param custom_arg;
 
   if (flag) 
-    info->last_pos = NULL; /* For heap_rnext/heap_rprev */
+    info->last_pos= NULL; /* For heap_rnext/heap_rprev */
 
-  hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
-  custom_arg.keyseg = keyinfo->seg;
-  custom_arg.key_length = keyinfo->length;
-  custom_arg.search_flag = SEARCH_SAME;
+  custom_arg.keyseg= keyinfo->seg;
+  custom_arg.key_length= hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
+  custom_arg.search_flag= SEARCH_SAME;
   return tree_delete(&keyinfo->rb_tree, info->recbuf, &custom_arg);
 }
 

heap/hp_hash.c

@@ -26,16 +26,17 @@ ha_rows hp_rb_records_in_range(HP_INFO *info, int inx, const byte *start_key,
 			       enum ha_rkey_function end_search_flag)
 {
   ha_rows start_pos, end_pos;
-  TREE *rb_tree = &info->s->keydef[inx].rb_tree;
+  HP_KEYDEF *keyinfo= info->s->keydef + inx;
+  TREE *rb_tree = &keyinfo->rb_tree;
   heap_rb_param custom_arg;
 
   info->lastinx = inx;
-  custom_arg.keyseg = info->s->keydef[inx].seg;
+  custom_arg.keyseg = keyinfo->seg;
   custom_arg.search_flag = SEARCH_FIND | SEARCH_SAME;
   custom_arg.key_length = start_key_len;
   if (start_key)
   {
-    hp_rb_pack_key(info, inx, info->recbuf, start_key, start_key_len);
+    hp_rb_pack_key(keyinfo, info->recbuf, start_key);
     start_pos= tree_record_pos(rb_tree, info->recbuf, start_search_flag, 
 				&custom_arg);
   }
@@ -47,7 +48,7 @@ ha_rows hp_rb_records_in_range(HP_INFO *info, int inx, const byte *start_key,
   custom_arg.key_length = end_key_len;
   if (end_key)
   {
-    hp_rb_pack_key(info, inx, info->recbuf, end_key, end_key_len);
+    hp_rb_pack_key(keyinfo, info->recbuf, end_key);
     end_pos= tree_record_pos(rb_tree, info->recbuf, end_search_flag, 
 				&custom_arg);
   }
@@ -391,14 +392,13 @@ int hp_rec_key_cmp(HP_KEYDEF *keydef, const byte *rec1, const byte *rec2)
       if (rec1[seg->null_pos] & seg->null_bit)
 	continue;
     }
-    switch (seg->type) {
-    case HA_KEYTYPE_END:
-      return 0;
-    case HA_KEYTYPE_TEXT:
+    if (seg->type == HA_KEYTYPE_TEXT)
+    {
       if (my_sortcmp(seg->charset,rec1+seg->start,rec2+seg->start,seg->length))
 	return 1;
-      break;
-    default:
+    }
+    else
+    {
       if (bcmp(rec1+seg->start,rec2+seg->start,seg->length))
 	return 1;
     }
@@ -454,29 +454,30 @@ void hp_make_key(HP_KEYDEF *keydef, byte *key, const byte *rec)
   }
 }
 
-void hp_rb_make_key(HP_KEYDEF *keydef, byte *key, 
+uint hp_rb_make_key(HP_KEYDEF *keydef, byte *key, 
 		    const byte *rec, byte *recpos)
 {
+  byte *start_key= key;
   HA_KEYSEG *seg, *endseg;
 
-  /* -1 means that HA_KEYTYPE_END segment will not copy */
-  for (seg= keydef->seg, endseg= seg + keydef->keysegs - 1; seg < endseg; 
-       seg++)
+  for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
   {
     if (seg->null_bit)
-      *key++= 1 - test(rec[seg->null_pos] & seg->null_bit);
+    {
+      if (!(*key++= 1 - test(rec[seg->null_pos] & seg->null_bit)))
+        continue;
+    }
     memcpy(key, rec + seg->start, (size_t) seg->length);
     key+= seg->length;
   }
   memcpy(key, &recpos, sizeof(byte*));
+  return key - start_key;
 }
 
-uint hp_rb_pack_key(HP_INFO *info, uint inx, uchar *key, const uchar *old,
-                  uint k_length)
+uint hp_rb_pack_key(HP_KEYDEF *keydef, uchar *key, const uchar *old)
 {
   HA_KEYSEG *seg, *endseg;
   uchar *start_key= key;
-  HP_KEYDEF *keydef= info->s->keydef + inx;
   
   for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; 
        old+= seg->length, seg++)
@@ -491,6 +492,26 @@ uint hp_rb_pack_key(HP_INFO *info, uint inx, uchar *key, const uchar *old,
   }
   return key - start_key;
 }
+
+uint hp_rb_key_length(HP_KEYDEF *keydef, 
+		      const byte *key __attribute__((unused)))
+{
+  return keydef->length;
+}
+
+uint hp_rb_null_key_length(HP_KEYDEF *keydef, const byte *key)
+{
+  const byte *start_key= key;
+  HA_KEYSEG *seg, *endseg;
+  
+  for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
+  {
+    if (seg->null_bit && !*key++)
+      continue;
+    key+= seg->length;
+  }
+  return key - start_key;
+}
                   
 /*
   Test if any of the key parts are NULL.

heap/hp_open.c

@@ -26,8 +26,8 @@
 static int keys_compare(heap_rb_param *param, uchar *key1, uchar *key2)
 {
   uint not_used;
-  return hp_rb_key_cmp(param->keyseg, key1, key2, param->key_length, 
-		       param->search_flag, &not_used);
+  return ha_key_cmp(param->keyseg, key1, key2, param->key_length, 
+		    param->search_flag, &not_used);
 }
 
 static void init_block(HP_BLOCK *block,uint reclength,ulong min_records,
@@ -48,29 +48,39 @@ HP_INFO *heap_open(const char *name, int mode, uint keys, HP_KEYDEF *keydef,
   pthread_mutex_lock(&THR_LOCK_heap);
   if (!(share = hp_find_named_heap(name)))
   {
+    HP_KEYDEF *keyinfo;
     DBUG_PRINT("info",("Initializing new table"));
-    for (i=key_segs=max_length=0 ; i < keys ; i++)
+    for (i=key_segs=max_length=0, keyinfo= keydef; i < keys; i++, keyinfo++)
     {
-      key_segs+= keydef[i].keysegs;
-      bzero((char*) &keydef[i].block,sizeof(keydef[i].block));
-      bzero((char*) &keydef[i].rb_tree ,sizeof(keydef[i].rb_tree));
-      for (j=length=0 ; j < keydef[i].keysegs; j++)
+      bzero((char*) &keyinfo->block,sizeof(keyinfo->block));
+      bzero((char*) &keyinfo->rb_tree ,sizeof(keyinfo->rb_tree));
+      for (j=length=0 ; j < keyinfo->keysegs; j++)
       {
-	length+=keydef[i].seg[j].length;
-	if (keydef[i].seg[j].null_bit &&
-	    !(keydef[i].flag & HA_NULL_ARE_EQUAL))
-	  keydef[i].flag |= HA_NULL_PART_KEY;
-	if (keydef[i].algorithm == HA_KEY_ALG_BTREE &&
-	    keydef[i].seg[j].null_bit)
-	  keydef[i].rb_tree.size_of_element++;
+	length+=keyinfo->seg[j].length;
+	if (keyinfo->seg[j].null_bit)
+	{
+	  if (!(keyinfo->flag & HA_NULL_ARE_EQUAL))
+	    keyinfo->flag |= HA_NULL_PART_KEY;
+	  if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
+	    keyinfo->rb_tree.size_of_element++;
+	}
+      }
+      keyinfo->length= length;
+      length+= keyinfo->rb_tree.size_of_element + 
+	       ((keyinfo->algorithm == HA_KEY_ALG_BTREE) ? sizeof(byte*) : 0);
+      if (length > max_length)
+	max_length= length;
+      key_segs+= keyinfo->keysegs;
+      if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
+      {
+        key_segs++; /* additional HA_KEYTYPE_END segment */
+        if (keyinfo->flag & HA_NULL_PART_KEY)
+          keyinfo->get_key_length = hp_rb_null_key_length;
+        else
+          keyinfo->get_key_length = hp_rb_key_length;
       }
-      keydef[i].length=   length;
-      keydef[i].ref_offs= length + keydef[i].rb_tree.size_of_element - 
-			  sizeof(byte*);
-      if (length + keydef[i].rb_tree.size_of_element > max_length)
-	max_length= length + keydef[i].rb_tree.size_of_element;
     }
-    if (!(share = (HP_SHARE*) my_malloc((uint) sizeof(HP_SHARE)+
+    if (!(share= (HP_SHARE*) my_malloc((uint) sizeof(HP_SHARE)+
 				       keys*sizeof(HP_KEYDEF)+
 				       key_segs*sizeof(HA_KEYSEG),
 				       MYF(MY_ZEROFILL))))
@@ -78,44 +88,45 @@ HP_INFO *heap_open(const char *name, int mode, uint keys, HP_KEYDEF *keydef,
       pthread_mutex_unlock(&THR_LOCK_heap);
       DBUG_RETURN(0);
     }
-    share->keydef=(HP_KEYDEF*) (share+1);
-    keyseg=(HA_KEYSEG*) (share->keydef+keys);
-    init_block(&share->block,reclength+1,min_records,max_records);
+    share->keydef= (HP_KEYDEF*) (share + 1);
+    keyseg= (HA_KEYSEG*) (share->keydef + keys);
+    init_block(&share->block, reclength + 1, min_records, max_records);
 	/* Fix keys */
-    memcpy(share->keydef,keydef,(size_t) (sizeof(keydef[0])*keys));
-    for (i=0 ; i < keys ; i++)
+    memcpy(share->keydef, keydef, (size_t) (sizeof(keydef[0]) * keys));
+    for (i= 0, keyinfo= share->keydef; i < keys; i++, keyinfo++)
     {
-      HP_KEYDEF *keyinfo = share->keydef + i;
-      keyinfo->seg = keyseg;
-      memcpy(keyseg, keydef[i].seg,
-	     (size_t) (sizeof(keyseg[0]) * keydef[i].keysegs));
-      keyseg += keydef[i].keysegs;
+      uint nsegs= keydef[i].keysegs;
+
       if (keydef[i].algorithm == HA_KEY_ALG_BTREE)
       {
-	init_tree(&keyinfo->rb_tree, 0, 0, keydef[i].length + 
-		keydef[i].rb_tree.size_of_element, 
-          (qsort_cmp2)keys_compare, 1, NULL, NULL);
-	keyinfo->delete_key = hp_rb_delete_key;
-	keyinfo->write_key = hp_rb_write_key;
+	init_tree(&keyinfo->rb_tree, 0, 0, 0, (qsort_cmp2)keys_compare, 1, 
+		  NULL, NULL);
+	keyinfo->delete_key= hp_rb_delete_key;
+	keyinfo->write_key= hp_rb_write_key;
+	nsegs++;
       }
       else
       {
 	init_block(&keyinfo->block, sizeof(HASH_INFO), min_records, 
 		   max_records);
-	keyinfo->delete_key = hp_delete_key;
-	keyinfo->write_key = hp_write_key;
+	keyinfo->delete_key= hp_delete_key;
+	keyinfo->write_key= hp_write_key;
       }
+      keyinfo->seg= keyseg;
+      memcpy(keyseg, keydef[i].seg,
+	     (size_t) (sizeof(keyseg[0]) * nsegs));
+      keyseg+= nsegs;
     }
 
-    share->min_records=min_records;
-    share->max_records=max_records;
-    share->data_length=share->index_length=0;
-    share->reclength=reclength;
-    share->blength=1;
-    share->keys=keys;
-    share->max_key_length=max_length;
-    share->changed=0;
-    if (!(share->name=my_strdup(name,MYF(0))))
+    share->min_records= min_records;
+    share->max_records= max_records;
+    share->data_length= share->index_length= 0;
+    share->reclength= reclength;
+    share->blength= 1;
+    share->keys= keys;
+    share->max_key_length= max_length;
+    share->changed= 0;
+    if (!(share->name= my_strdup(name,MYF(0))))
     {
       my_free((gptr) share,MYF(0));
       pthread_mutex_unlock(&THR_LOCK_heap);
@@ -125,8 +136,8 @@ HP_INFO *heap_open(const char *name, int mode, uint keys, HP_KEYDEF *keydef,
     thr_lock_init(&share->lock);
     VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
 #endif
-    share->open_list.data=(void*) share;
-    heap_share_list=list_add(heap_share_list,&share->open_list);
+    share->open_list.data= (void*) share;
+    heap_share_list= list_add(heap_share_list,&share->open_list);
   }
   if (!(info= (HP_INFO*) my_malloc((uint) sizeof(HP_INFO)+
 				  2 * share->max_key_length,
@@ -139,21 +150,21 @@ HP_INFO *heap_open(const char *name, int mode, uint keys, HP_KEYDEF *keydef,
 #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);
+  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=(byte*) (info+1);
-  info->recbuf = (byte*) (info->lastkey + share->max_key_length);
-  info->mode=mode;
+  info->s= share;
+  info->lastkey= (byte*) (info + 1);
+  info->recbuf= (byte*) (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;
+  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 */
+  info->opt_flag= READ_CHECK_USED;		/* Check when changing */
 #endif
   DBUG_PRINT("exit",("heap: %lx  reclength: %d  records_in_block: %d",
 		     info,share->reclength,share->block.records_in_block));

heap/hp_rfirst.c

@@ -31,7 +31,8 @@ int heap_rfirst(HP_INFO *info, byte *record, int inx)
     if ((pos = tree_search_edge(&keyinfo->rb_tree, info->parents,
                                 &info->last_pos, offsetof(TREE_ELEMENT, left))))
     {
-      memcpy(&pos, pos + keyinfo->ref_offs, sizeof(byte*));
+      memcpy(&pos, pos + (*keyinfo->get_key_length)(keyinfo, pos), 
+	     sizeof(byte*));
       info->current_ptr = pos;
       memcpy(record, pos, (size_t)share->reclength);
       info->update = HA_STATE_AKTIV;

heap/hp_rkey.c

@@ -20,56 +20,56 @@ int heap_rkey(HP_INFO *info, byte *record, int inx, const byte *key,
               uint key_len, enum ha_rkey_function find_flag)
 {
   byte *pos;
-  HP_SHARE *share=info->s;
-  HP_KEYDEF *keyinfo = share->keydef+inx;
+  HP_SHARE *share= info->s;
+  HP_KEYDEF *keyinfo= share->keydef + inx;
   DBUG_ENTER("heap_rkey");
   DBUG_PRINT("enter",("base: %lx  inx: %d",info,inx));
 
   if ((uint) inx >= share->keys)
   {
-    DBUG_RETURN(my_errno=HA_ERR_WRONG_INDEX);
+    DBUG_RETURN(my_errno= HA_ERR_WRONG_INDEX);
   }
-  info->lastinx=inx;
-  info->current_record = (ulong) ~0L;		/* For heap_rrnd() */
+  info->lastinx= inx;
+  info->current_record= (ulong) ~0L;		/* For heap_rrnd() */
 
   if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
   {
     heap_rb_param custom_arg;
 
-    hp_rb_pack_key(info, inx, info->recbuf, key, key_len);
+    hp_rb_pack_key(keyinfo, info->recbuf, key);
 
-    custom_arg.keyseg = info->s->keydef[inx].seg;
-    custom_arg.key_length = key_len;
-    custom_arg.search_flag = SEARCH_FIND | SEARCH_SAME;
+    custom_arg.keyseg= info->s->keydef[inx].seg;
+    custom_arg.key_length= key_len;
+    custom_arg.search_flag= SEARCH_FIND | SEARCH_SAME;
     /* for next rkey() after deletion */
     if (find_flag == HA_READ_AFTER_KEY)
-      info->last_find_flag = HA_READ_KEY_OR_NEXT;
+      info->last_find_flag= HA_READ_KEY_OR_NEXT;
     else if (find_flag == HA_READ_BEFORE_KEY)
-      info->last_find_flag = HA_READ_KEY_OR_PREV;
+      info->last_find_flag= HA_READ_KEY_OR_PREV;
     else
-      info->last_find_flag = find_flag;
-    info->lastkey_len = key_len;
-    if (!(pos = tree_search_key(&keyinfo->rb_tree, info->recbuf, info->parents,
-                                &info->last_pos, find_flag, &custom_arg)))
+      info->last_find_flag= find_flag;
+    info->lastkey_len= key_len;
+    if (!(pos= tree_search_key(&keyinfo->rb_tree, info->recbuf, info->parents,
+			       &info->last_pos, find_flag, &custom_arg)))
     {
-      info->update = 0;
-      DBUG_RETURN(my_errno = HA_ERR_KEY_NOT_FOUND);
+      info->update= 0;
+      DBUG_RETURN(my_errno= HA_ERR_KEY_NOT_FOUND);
     }
-    memcpy(&pos, pos + keyinfo->ref_offs, sizeof(byte*));
-    info->current_ptr = pos;
+    memcpy(&pos, pos + (*keyinfo->get_key_length)(keyinfo, pos), sizeof(byte*));
+    info->current_ptr= pos;
   }
   else
   {
-    if (!(pos=hp_search(info,share->keydef+inx,key,0)))
+    if (!(pos= hp_search(info, share->keydef + inx, key, 0)))
     {
-      info->update=0;
+      info->update= 0;
       DBUG_RETURN(my_errno);
     }
     if (!(keyinfo->flag & HA_NOSAME))
-      memcpy(info->lastkey,key,(size_t) keyinfo->length);
+      memcpy(info->lastkey, key, (size_t) keyinfo->length);
   }
-  memcpy(record,pos,(size_t) share->reclength);
-  info->update=HA_STATE_AKTIV;
+  memcpy(record, pos, (size_t) share->reclength);
+  info->update= HA_STATE_AKTIV;
   DBUG_RETURN(0);
 }
 

heap/hp_rlast.c

@@ -32,7 +32,8 @@ int heap_rlast(HP_INFO *info, byte *record, int inx)
     if ((pos = tree_search_edge(&keyinfo->rb_tree, info->parents,
                                 &info->last_pos, offsetof(TREE_ELEMENT, right))))
     {
-      memcpy(&pos, pos + keyinfo->ref_offs, sizeof(byte*));
+      memcpy(&pos, pos + (*keyinfo->get_key_length)(keyinfo, pos), 
+	     sizeof(byte*));
       info->current_ptr = pos;
       memcpy(record, pos, (size_t)share->reclength);
       info->update = HA_STATE_AKTIV;

heap/hp_rnext.c

@@ -47,7 +47,8 @@ int heap_rnext(HP_INFO *info, byte *record)
     }
     if (pos)
     {
-      memcpy(&pos, pos + keyinfo->ref_offs, sizeof(byte*));
+      memcpy(&pos, pos + (*keyinfo->get_key_length)(keyinfo, pos), 
+	     sizeof(byte*));
       info->current_ptr = pos;
     }
     else

heap/hp_rprev.c

@@ -47,7 +47,8 @@ int heap_rprev(HP_INFO *info, byte *record)
     }
     if (pos)
     {
-      memcpy(&pos, pos + keyinfo->ref_offs, sizeof(byte*));
+      memcpy(&pos, pos + (*keyinfo->get_key_length)(keyinfo, pos),
+	     sizeof(byte*));
       info->current_ptr = pos;
     }
     else

heap/hp_write.c

@@ -93,25 +93,25 @@ int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const byte *record,
 {
   heap_rb_param custom_arg;
 
-  info->last_pos = NULL; /* For heap_rnext/heap_rprev */
-  hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
-  custom_arg.keyseg = keyinfo->seg;
-  custom_arg.key_length = keyinfo->length;
+  info->last_pos= NULL; /* For heap_rnext/heap_rprev */
+  custom_arg.keyseg= keyinfo->seg;
+  custom_arg.key_length= hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
   if ((keyinfo->flag & HA_NOSAME) &&
       (!(keyinfo->flag & HA_NULL_PART_KEY) ||
        !hp_if_null_in_key(keyinfo, record)))
   {
-    custom_arg.search_flag = SEARCH_FIND | SEARCH_SAME;
+    custom_arg.search_flag= SEARCH_FIND | SEARCH_SAME;
     if (tree_search_key(&keyinfo->rb_tree, info->recbuf, info->parents, 
 	&info->last_pos, 0, &custom_arg))
     {
-      my_errno = HA_ERR_FOUND_DUPP_KEY;
+      my_errno= HA_ERR_FOUND_DUPP_KEY;
       return 1;
     }
   }
-  custom_arg.search_flag = SEARCH_SAME;
-  return tree_insert(&keyinfo->rb_tree, (void*)info->recbuf, keyinfo->length + 
-                     sizeof(byte*), &custom_arg) ? 0 : 1;
+  custom_arg.search_flag= SEARCH_SAME;
+  return tree_insert(&keyinfo->rb_tree, (void*)info->recbuf,
+		     custom_arg.key_length + sizeof(byte*),
+		     &custom_arg) ? 0 : 1;
 }
 
 	/* Find where to place new record */

include/heap.h

@@ -84,7 +84,6 @@ typedef struct st_hp_keydef		/* Key definition with open */
   uint keysegs;				/* Number of key-segment */
   uint length;				/* Length of key (automatic) */
   uint8 algorithm;			/* HASH / BTREE */
-  uint ref_offs;			/* Data reference offset */
   HA_KEYSEG *seg;
   HP_BLOCK block;			/* Where keys are saved */
   TREE rb_tree;
@@ -92,6 +91,7 @@ typedef struct st_hp_keydef		/* Key definition with open */
 		   const byte *record, byte *recpos);
   int (*delete_key)(struct st_heap_info *info, struct st_hp_keydef *keyinfo, 
   		   const byte *record, byte *recpos, int flag);
+  uint (*get_key_length)(struct st_hp_keydef *keydef, const byte *key);
 } HP_KEYDEF;
 
 typedef struct st_heap_share
@@ -131,7 +131,7 @@ typedef struct st_heap_info
   byte *lastkey;			/* Last used key with rkey */
   byte *recbuf;                         /* Record buffer for rb-tree keys */
   enum ha_rkey_function last_find_flag;
-  TREE_ELEMENT *parents[MAX_TREE_HIGHT+1];
+  TREE_ELEMENT *parents[MAX_TREE_HEIGHT+1];
   TREE_ELEMENT **last_pos;
   uint lastkey_len;
 #ifdef THREAD

include/my_base.h

@@ -147,11 +147,11 @@ enum ha_base_keytype {
 
 #define HA_NOSAME		 1	/* Set if not dupplicated records */
 #define HA_PACK_KEY		 2	/* Pack string key to previous key */
-#define HA_AUTO_KEY		1024
+#define HA_AUTO_KEY		 16
 #define HA_BINARY_PACK_KEY	 32	/* Packing of all keys to prev key */
-#define HA_FULLTEXT		128     /* SerG: for full-text search */
+#define HA_FULLTEXT		128     /* For full-text search */
 #define HA_UNIQUE_CHECK		256	/* Check the key for uniqueness */
-#define HA_SPATIAL		 16     /* Alex Barkov: for spatial search */
+#define HA_SPATIAL		1024    /* For spatial search */
 #define HA_NULL_ARE_EQUAL	2048	/* NULL in key are cmp as equal */
 
 

include/my_handler.h

@@ -50,14 +50,10 @@ typedef struct st_HA_KEYSEG		/* Key-portion */
   { length=mi_uint2korr((key)+1); (key)+=3; length_pack=3; } \
 }
 
-extern int _mi_compare_text(CHARSET_INFO *, uchar *, uint, uchar *, uint ,
-			    my_bool);
+extern int mi_compare_text(CHARSET_INFO *, uchar *, uint, uchar *, uint ,
+			   my_bool);
 extern int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
-		       register uchar *b, uint key_length, uint nextflag,
-		       uint *diff_pos);
-
-extern int hp_rb_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
-			 register uchar *b, uint key_length, uint nextflag,
-			 uint *diff_pos);
+		      register uchar *b, uint key_length, uint nextflag,
+		      uint *diff_pos);
 
 #endif /* _my_handler_h */

include/my_tree.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#define MAX_TREE_HIGHT	40	/* = max 1048576 leafs in tree */
+#define MAX_TREE_HEIGHT	40	/* = max 1048576 leafs in tree */
 #define ELEMENT_KEY(tree,element)\
 (tree->offset_to_key ? (void*)((byte*) element+tree->offset_to_key) :\
 			*((void**) (element+1)))
@@ -52,7 +52,7 @@ typedef struct st_tree_element {
 
 typedef struct st_tree {
   TREE_ELEMENT *root,null_element;
-  TREE_ELEMENT **parents[MAX_TREE_HIGHT];
+  TREE_ELEMENT **parents[MAX_TREE_HEIGHT];
   uint offset_to_key,elements_in_tree,size_of_element,memory_limit,allocated;
   qsort_cmp2 compare;
   void* custom_arg;

myisam/ft_boolean_search.c

@@ -104,7 +104,7 @@ int FTB_WORD_cmp(void *v __attribute__((unused)), FTB_WORD *a, FTB_WORD *b)
 int FTB_WORD_cmp_list(void *v __attribute__((unused)), FTB_WORD **a, FTB_WORD **b)
 {
   /* ORDER BY word DESC, ndepth DESC */
-  int i=_mi_compare_text(default_charset_info, (*b)->word+1,(*b)->len-1,
+  int i= mi_compare_text(default_charset_info, (*b)->word+1,(*b)->len-1,
                                                (*a)->word+1,(*a)->len-1,0);
   if (!i)
     i=CMP_NUM((*b)->ndepth,(*a)->ndepth);
@@ -203,7 +203,7 @@ void  _ftb_init_index_search(FT_INFO *ftb)
                               SEARCH_FIND | SEARCH_BIGGER, keyroot);
     if (!r)
     {
-      r=_mi_compare_text(default_charset_info,
+      r= mi_compare_text(default_charset_info,
                          info->lastkey + (ftbw->flags&FTB_FLAG_TRUNC),
                          ftbw->len     - (ftbw->flags&FTB_FLAG_TRUNC),
                          ftbw->word    + (ftbw->flags&FTB_FLAG_TRUNC),
@@ -359,7 +359,7 @@ int ft_boolean_read_next(FT_INFO *ftb, char *record)
                    SEARCH_BIGGER , keyroot);
       if (!r)
       {
-        r=_mi_compare_text(default_charset_info,
+        r= mi_compare_text(default_charset_info,
                            info->lastkey + (ftbw->flags&FTB_FLAG_TRUNC),
                            ftbw->len     - (ftbw->flags&FTB_FLAG_TRUNC),
                            ftbw->word    + (ftbw->flags&FTB_FLAG_TRUNC),
@@ -443,7 +443,7 @@ float ft_boolean_find_relevance(FT_INFO *ftb, byte *record, uint length)
       for (a=0, b=ftb->queue.elements, c=(a+b)/2; b-a>1; c=(a+b)/2)
       {
         ftbw=(FTB_WORD *)(ftb->list[c]);
-        if (_mi_compare_text(default_charset_info, word.pos,word.len,
+        if (mi_compare_text(default_charset_info, word.pos,word.len,
                          (uchar*) ftbw->word+1,ftbw->len-1,
                          (ftbw->flags&FTB_FLAG_TRUNC) ) >0)
           b=c;
@@ -453,7 +453,7 @@ float ft_boolean_find_relevance(FT_INFO *ftb, byte *record, uint length)
       for (; c>=0; c--)
       {
         ftbw=(FTB_WORD *)(ftb->list[c]);
-        if (_mi_compare_text(default_charset_info, word.pos,word.len,
+        if (mi_compare_text(default_charset_info, word.pos,word.len,
                          (uchar*) ftbw->word+1,ftbw->len-1,
                          (ftbw->flags&FTB_FLAG_TRUNC) ))
           break;

myisam/ft_nlq_search.c

@@ -93,9 +93,9 @@ static int walk_and_match(FT_WORD *word, uint32 count, ALL_IN_ONE *aio)
 
   while(!r)
   {
-    if (_mi_compare_text(default_charset_info,
-			 aio->info->lastkey,keylen,
-			 aio->keybuff,keylen,0)) break;
+    if (mi_compare_text(default_charset_info,
+			aio->info->lastkey,keylen,
+			aio->keybuff,keylen,0)) break;
 
 #if HA_FT_WTYPE == HA_KEYTYPE_FLOAT
 #ifdef EVAL_RUN

myisam/ft_parser.c

@@ -37,10 +37,10 @@ typedef struct st_ft_docstat {
 
 static int FT_WORD_cmp(void* cmp_arg, FT_WORD *w1, FT_WORD *w2)
 {
-  return _mi_compare_text(default_charset_info,
-			  (uchar*) w1->pos, w1->len,
-			  (uchar*) w2->pos, w2->len,
-			  (my_bool) (cmp_arg != 0));
+  return mi_compare_text(default_charset_info,
+			 (uchar*) w1->pos, w1->len,
+			 (uchar*) w2->pos, w2->len,
+			 (my_bool) (cmp_arg != 0));
 }
 
 static int walk_and_copy(FT_WORD *word,uint32 count,FT_DOCSTAT *docstat)

myisam/ft_stopwords.c

@@ -28,9 +28,9 @@ static TREE *stopwords3=NULL;
 static int FT_STOPWORD_cmp(void* cmp_arg __attribute__((unused)),
 			   FT_STOPWORD *w1, FT_STOPWORD *w2)
 {
-  return _mi_compare_text(default_charset_info,
-			  (uchar *)w1->pos,w1->len,
-			  (uchar *)w2->pos,w2->len,0);
+  return mi_compare_text(default_charset_info,
+			 (uchar *)w1->pos,w1->len,
+			 (uchar *)w2->pos,w2->len,0);
 }
 
 int ft_init_stopwords(const char **sws)

myisam/ft_update.c

@@ -160,7 +160,7 @@ int _mi_ft_cmp(MI_INFO *info, uint keynr, const byte *rec1, const byte *rec2)
   {
     if ((ftsi1.pos != ftsi2.pos) &&
         (!ftsi1.pos || !ftsi2.pos ||
-          _mi_compare_text(default_charset_info,
+         mi_compare_text(default_charset_info,
 	                 (uchar*) ftsi1.pos,ftsi1.len,
 			 (uchar*) ftsi2.pos,ftsi2.len,0)))
       return THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT;
@@ -185,7 +185,7 @@ int _mi_ft_update(MI_INFO *info, uint keynr, byte *keybuf,
   error=0;
   while(old_word->pos && new_word->pos)
   {
-    cmp=_mi_compare_text(default_charset_info,
+    cmp= mi_compare_text(default_charset_info,
 	                 (uchar*) old_word->pos,old_word->len,
 			 (uchar*) new_word->pos,new_word->len,0);
     cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);

myisam/mi_open.c

@@ -920,7 +920,7 @@ uint mi_keydef_write(File file, MI_KEYDEF *keydef)
   uchar *ptr=buff;
 
   *ptr++ = (uchar) keydef->keysegs;
-  *ptr++ = keydef->key_alg;			/* +BAR Rtree or Btree */
+  *ptr++ = keydef->key_alg;			/* Rtree or Btree */
   mi_int2store(ptr,keydef->flag);		ptr +=2;
   mi_int2store(ptr,keydef->block_length);	ptr +=2;
   mi_int2store(ptr,keydef->keylength);		ptr +=2;
@@ -932,7 +932,7 @@ uint mi_keydef_write(File file, MI_KEYDEF *keydef)
 char *mi_keydef_read(char *ptr, MI_KEYDEF *keydef)
 {
    keydef->keysegs	= (uint) *ptr++;
-   keydef->key_alg	= *ptr++; /* +BAR Rtree or Btree */
+   keydef->key_alg	= *ptr++;		/* Rtree or Btree */
 
    keydef->flag		= mi_uint2korr(ptr);	ptr +=2;
    keydef->block_length = mi_uint2korr(ptr);	ptr +=2;