Content merge.

sql/ha_innodb.cc:
  Auto merged
sql/ha_innodb.h:
  Auto merged
sql/handler.h:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_yacc.yy:
  Auto merged
innobase/trx/trx0roll.c:
  Auto merged.

17 files changed, 423 insertions, 192 deletions

diff --git a/myisam/ft_static.c b/myisam/ft_static.c
index 3b186f7b179..cdb1580e706 100644
--- a/myisam/ft_static.c
+++ b/myisam/ft_static.c
@@ -25,9 +25,9 @@ char ft_boolean_syntax[]="+ -><()~*:\"\"&|";
 
 const HA_KEYSEG ft_keysegs[FT_SEGS]={
 {
-    HA_KEYTYPE_VARTEXT,               /* type */
+    HA_KEYTYPE_VARTEXT2,              /* type */
     63,                               /* language (will be overwritten) */
-    0, 0, 0,                          /* null_bit, bit_start, bit_end */
+    0, 2, 0,                          /* null_bit, bit_start, bit_end */
     HA_VAR_LENGTH_PART | HA_PACK_KEY,      /* flag */
     HA_FT_MAXBYTELEN,                 /* length */
     HA_FT_WLEN,                       /* start */
diff --git a/myisam/ft_test1.c b/myisam/ft_test1.c
index a92c85924de..14be9aa1e8c 100644
--- a/myisam/ft_test1.c
+++ b/myisam/ft_test1.c
@@ -79,24 +79,24 @@ static int run_test(const char *filename)
   recinfo[0].length= (extra_field == FIELD_BLOB ? 4 + mi_portable_sizeof_char_ptr :
 	      extra_length);
   if (extra_field == FIELD_VARCHAR)
-    recinfo[0].length+=2;
+    recinfo[0].length+= HA_VARCHAR_PACKLENGTH(extra_length);
   recinfo[1].type=key_field;
   recinfo[1].length= (key_field == FIELD_BLOB ? 4+mi_portable_sizeof_char_ptr :
 		      key_length);
   if (key_field == FIELD_VARCHAR)
-    recinfo[1].length+=2;
+    recinfo[1].length+= HA_VARCHAR_PACKLENGTH(key_length);
 
   /* Define a key over the first column */
   keyinfo[0].seg=keyseg;
   keyinfo[0].keysegs=1;
   keyinfo[0].seg[0].type= key_type;
-  keyinfo[0].seg[0].flag= (key_field == FIELD_BLOB)?HA_BLOB_PART:
-			  (key_field == FIELD_VARCHAR)?HA_VAR_LENGTH_PART:0;
+  keyinfo[0].seg[0].flag= (key_field == FIELD_BLOB) ? HA_BLOB_PART:
+			  (key_field == FIELD_VARCHAR) ? HA_VAR_LENGTH_PART:0;
   keyinfo[0].seg[0].start=recinfo[0].length;
   keyinfo[0].seg[0].length=key_length;
   keyinfo[0].seg[0].null_bit= 0;
   keyinfo[0].seg[0].null_pos=0;
-  keyinfo[0].seg[0].language=MY_CHARSET_CURRENT;
+  keyinfo[0].seg[0].language= default_charset_info->number;
   keyinfo[0].flag = (no_fulltext?HA_PACK_KEY:HA_FULLTEXT);
 
   if (!silent)
@@ -155,33 +155,42 @@ static int run_test(const char *filename)
   if (!silent)
     printf("- Reading rows with key\n");
   for (i=0 ; i < NQUERIES ; i++)
-  { FT_DOCLIST *result;
+  {
+    FT_DOCLIST *result;
     result=ft_nlq_init_search(file,0,(char*) query[i],strlen(query[i]),1);
-    if(!result) {
+    if(!result)
+    {
       printf("Query %d: `%s' failed with errno %3d\n",i,query[i],my_errno);
       continue;
     }
     printf("Query %d: `%s'. Found: %d. Top five documents:\n",
-	    i,query[i],result->ndocs);
-    for(j=0;j<5;j++) { double w; int err;
-	err=ft_nlq_read_next(result, read_record);
-	if(err==HA_ERR_END_OF_FILE) {
-	    printf("No more matches!\n");
-	    break;
-	} else if (err) {
-	    printf("ft_read_next %d failed with errno %3d\n",j,my_errno);
-	    break;
-	}
-        w=ft_nlq_get_relevance(result);
-	if(key_field == FIELD_VARCHAR) {
-	    uint l;
-	    char *p;
-	    p=recinfo[0].length+read_record;
-	    l=uint2korr(p);
-	    printf("%10.7f: %.*s\n",w,(int) l,p+2);
-	} else
-	    printf("%10.7f: %.*s\n",w,recinfo[1].length,
-			  recinfo[0].length+read_record);
+           i,query[i],result->ndocs);
+    for (j=0;j<5;j++)
+    {
+      double w; int err;
+      err= ft_nlq_read_next(result, read_record);
+      if (err==HA_ERR_END_OF_FILE)
+      {
+        printf("No more matches!\n");
+        break;
+      }
+      else if (err)
+      {
+        printf("ft_read_next %d failed with errno %3d\n",j,my_errno);
+        break;
+      }
+      w=ft_nlq_get_relevance(result);
+      if (key_field == FIELD_VARCHAR)
+      {
+        uint l;
+        char *p;
+        p=recinfo[0].length+read_record;
+        l=uint2korr(p);
+        printf("%10.7f: %.*s\n",w,(int) l,p+2);
+      }
+      else
+        printf("%10.7f: %.*s\n",w,recinfo[1].length,
+               recinfo[0].length+read_record);
     }
     ft_nlq_close_search(result);
   }
@@ -215,9 +224,14 @@ void create_record(char *pos, int n)
   else if (recinfo[0].type == FIELD_VARCHAR)
   {
     uint tmp;
-    strnmov(pos+2,data[n].f0,keyinfo[0].seg[0].length);
-    tmp=strlen(pos+2);
-    int2store(pos,tmp);
+    /* -1 is here because pack_length is stored in seg->length */
+    uint pack_length= HA_VARCHAR_PACKLENGTH(keyinfo[0].seg[0].length-1);
+    strnmov(pos+pack_length,data[n].f0,keyinfo[0].seg[0].length);
+    tmp=strlen(pos+pack_length);
+    if (pack_length == 1)
+      *pos= (char) tmp;
+    else
+      int2store(pos,tmp);
     pos+=recinfo[0].length;
   }
   else
@@ -239,9 +253,14 @@ void create_record(char *pos, int n)
   else if (recinfo[1].type == FIELD_VARCHAR)
   {
     uint tmp;
-    strnmov(pos+2,data[n].f2,keyinfo[0].seg[0].length);
-    tmp=strlen(pos+2);
-    int2store(pos,tmp);
+    /* -1 is here because pack_length is stored in seg->length */
+    uint pack_length= HA_VARCHAR_PACKLENGTH(keyinfo[0].seg[0].length-1);
+    strnmov(pos+pack_length,data[n].f2,keyinfo[0].seg[0].length);
+    tmp=strlen(pos+1);
+    if (pack_length == 1)
+      *pos= (char) tmp;
+    else
+      int2store(pos,tmp);
     pos+=recinfo[1].length;
   }
   else
diff --git a/myisam/ft_update.c b/myisam/ft_update.c
index 8dafefe77a8..b8cd925bf4f 100644
--- a/myisam/ft_update.c
+++ b/myisam/ft_update.c
@@ -58,29 +58,27 @@ uint _mi_ft_segiterator(register FT_SEG_ITERATOR *ftsi)
   DBUG_ENTER("_mi_ft_segiterator");
 
   if (!ftsi->num)
-  {
     DBUG_RETURN(0);
-  }
-  else
-    ftsi->num--;
+
+  ftsi->num--;
   if (!ftsi->seg)
-  {
     DBUG_RETURN(1);
-  }
-  else
-    ftsi->seg--;
+
+  ftsi->seg--;
 
   if (ftsi->seg->null_bit &&
       (ftsi->rec[ftsi->seg->null_pos] & ftsi->seg->null_bit))
   {
-      ftsi->pos=0;
-      DBUG_RETURN(1);
+    ftsi->pos=0;
+    DBUG_RETURN(1);
   }
   ftsi->pos= ftsi->rec+ftsi->seg->start;
   if (ftsi->seg->flag & HA_VAR_LENGTH_PART)
   {
-    ftsi->len=uint2korr(ftsi->pos);
-    ftsi->pos+=2;				 /* Skip VARCHAR length */
+    uint pack_length= (ftsi->seg->bit_start);
+    ftsi->len= (pack_length == 1 ? (uint) *(uchar*) ftsi->pos :
+                uint2korr(ftsi->pos)); 
+    ftsi->pos+= pack_length;			 /* Skip VARCHAR length */
     DBUG_RETURN(1);
   }
   if (ftsi->seg->flag & HA_BLOB_PART)
@@ -296,9 +294,11 @@ uint _ft_make_key(MI_INFO *info, uint keynr, byte *keybuf, FT_WORD *wptr,
   DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
 }
 
+
 /*
   convert key value to ft2
 */
+
 uint _mi_ft_convert_to_ft2(MI_INFO *info, uint keynr, uchar *key)
 {
   my_off_t root;
@@ -316,9 +316,12 @@ uint _mi_ft_convert_to_ft2(MI_INFO *info, uint keynr, uchar *key)
 
   get_key_full_length_rdonly(key_length, key);
   while (_mi_ck_delete(info, keynr, key, key_length) == 0)
-    /* nothing to do here.
-       _mi_ck_delete() will populate info->ft1_to_ft2 with deleted keys
-     */;
+  {
+    /*
+      nothing to do here.
+      _mi_ck_delete() will populate info->ft1_to_ft2 with deleted keys
+     */
+  }
 
   /* creating pageful of keys */
   mi_putint(info->buff,length+2,0);
diff --git a/myisam/mi_check.c b/myisam/mi_check.c
index 112a371c9fe..b8f992dc21a 100644
--- a/myisam/mi_check.c
+++ b/myisam/mi_check.c
@@ -280,7 +280,8 @@ int chk_size(MI_CHECK *param, register MI_INFO *info)
   size=my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0));
   if ((skr=(my_off_t) info->state->key_file_length) != size)
   {
-    if (skr > size)
+    /* Don't give error if file generated by myisampack */
+    if (skr > size && info->s->state.key_map)
     {
       error=1;
       mi_check_print_error(param,
diff --git a/myisam/mi_checksum.c b/myisam/mi_checksum.c
index 95338434211..33a51068fb0 100644
--- a/myisam/mi_checksum.c
+++ b/myisam/mi_checksum.c
@@ -40,8 +40,12 @@ ha_checksum mi_checksum(MI_INFO *info, const byte *buf)
     }
     case FIELD_VARCHAR:
     {
-      length=uint2korr(buf);
-      pos=buf+2;
+      uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length-1);
+      if (pack_length == 1)
+        length= (ulong) *(uchar*) buf;
+      else
+        length= uint2korr(buf);
+      pos= buf+pack_length;
       break;
     }
     default:
diff --git a/myisam/mi_create.c b/myisam/mi_create.c
index e139997e0c7..0164555272d 100644
--- a/myisam/mi_create.c
+++ b/myisam/mi_create.c
@@ -43,7 +43,7 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
   myf create_flag;
   uint fields,length,max_key_length,packed,pointer,real_length_diff,
        key_length,info_length,key_segs,options,min_key_length_skip,
-       base_pos,varchar_count,long_varchar_count,varchar_length,
+       base_pos,long_varchar_count,varchar_length,
        max_key_block_length,unique_key_parts,fulltext_keys,offset;
   ulong reclength, real_reclength,min_pack_length;
   char filename[FN_REFLEN],linkname[FN_REFLEN], *linkname_ptr;
@@ -99,7 +99,7 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
 
 	/* Start by checking fields and field-types used */
 
-  reclength=varchar_count=varchar_length=long_varchar_count=packed=
+  reclength=varchar_length=long_varchar_count=packed=
     min_pack_length=pack_reclength=0;
   for (rec=recinfo, fields=0 ;
        fields != columns ;
@@ -130,14 +130,15 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
       }
       else if (type == FIELD_VARCHAR)
       {
-	varchar_count++;
-	varchar_length+=rec->length-2;
+	varchar_length+= rec->length-1;          /* Used for min_pack_length */
 	packed--;
-	pack_reclength+=1;
-	if (test(rec->length > 257))
-	{					/* May be packed on 3 bytes */
+	pack_reclength++;
+        min_pack_length++;
+        /* We must test for 257 as length includes pack-length */
+ 	if (test(rec->length >= 257))
+	{
 	  long_varchar_count++;
-	  pack_reclength+=2;
+	  pack_reclength+= 2;			/* May be packed on 3 bytes */
 	}
       }
       else if (type != FIELD_SKIP_ZERO)
@@ -169,12 +170,8 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
   /* We can't use checksum with static length rows */
   if (!(options & HA_OPTION_PACK_RECORD))
     options&= ~HA_OPTION_CHECKSUM;
-  if (options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
-    min_pack_length+=varchar_count;		/* Min length to pack */
-  else
-  {
-    min_pack_length+=varchar_length+2*varchar_count;
-  }
+  if (!(options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)))
+    min_pack_length+= varchar_length;
   if (flags & HA_CREATE_TMP_TABLE)
     options|= HA_OPTION_TMP_TABLE;
   if (flags & HA_CREATE_CHECKSUM || (options & HA_OPTION_CHECKSUM))
@@ -220,7 +217,7 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
       reclength=pointer+1;		/* reserve place for delete link */
   }
   else
-    reclength+=long_varchar_count;	/* We need space for this! */
+    reclength+= long_varchar_count;	/* We need space for varchar! */
 
   max_key_length=0; tot_length=0 ; key_segs=0;
   fulltext_keys=0;
@@ -261,7 +258,8 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
 	   j++, keyseg++)
       {
         if (keyseg->type != HA_KEYTYPE_BINARY &&
-	    keyseg->type != HA_KEYTYPE_VARBINARY)
+	    keyseg->type != HA_KEYTYPE_VARBINARY1 &&
+            keyseg->type != HA_KEYTYPE_VARBINARY2)
         {
           my_errno=HA_WRONG_CREATE_OPTION;
           goto err;
@@ -285,11 +283,22 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
 	   j++, keyseg++)
       {
         if (keyseg->type != HA_KEYTYPE_TEXT &&
-	    keyseg->type != HA_KEYTYPE_VARTEXT)
+	    keyseg->type != HA_KEYTYPE_VARTEXT1 &&
+            keyseg->type != HA_KEYTYPE_VARTEXT2)
         {
           my_errno=HA_WRONG_CREATE_OPTION;
           goto err;
         }
+        if (!(keyseg->flag & HA_BLOB_PART) &&
+	    (keyseg->type == HA_KEYTYPE_VARTEXT1 ||
+             keyseg->type == HA_KEYTYPE_VARTEXT2))
+        {
+          /* Make a flag that this is a VARCHAR */
+          keyseg->flag|= HA_VAR_LENGTH_PART;
+          /* Store in bit_start number of bytes used to pack the length */
+          keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1)?
+                              1 : 2);
+        }
       }
 
       fulltext_keys++;
@@ -345,10 +354,19 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
 	case HA_KEYTYPE_INT8:
 	  keyseg->flag|= HA_SWAP_KEY;
           break;
-        case HA_KEYTYPE_VARTEXT:
-        case HA_KEYTYPE_VARBINARY:
+        case HA_KEYTYPE_VARTEXT1:
+        case HA_KEYTYPE_VARTEXT2:
+        case HA_KEYTYPE_VARBINARY1:
+        case HA_KEYTYPE_VARBINARY2:
           if (!(keyseg->flag & HA_BLOB_PART))
+          {
+            /* Make a flag that this is a VARCHAR */
             keyseg->flag|= HA_VAR_LENGTH_PART;
+            /* Store in bit_start number of bytes used to pack the length */
+            keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1 ||
+                                 keyseg->type == HA_KEYTYPE_VARBINARY1) ?
+                                1 : 2);
+          }
           break;
 	default:
 	  break;
@@ -368,6 +386,8 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
 	}
 	if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
 	{
+          DBUG_ASSERT(!test_all_bits(keyseg->flag,
+                                    (HA_VAR_LENGTH_PART | HA_BLOB_PART)));
 	  keydef->flag|=HA_VAR_LENGTH_KEY;
 	  length++;				/* At least one length byte */
 	  options|=HA_OPTION_PACK_KEYS;		/* Using packed keys */
@@ -646,11 +666,31 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
   /* Save unique definition */
   for (i=0 ; i < share.state.header.uniques ; i++)
   {
+    HA_KEYSEG *keyseg_end;
+    keyseg= uniquedefs[i].seg;
     if (mi_uniquedef_write(file, &uniquedefs[i]))
       goto err;
-    for (j=0 ; j < uniquedefs[i].keysegs ; j++)
+    for (keyseg= uniquedefs[i].seg, keyseg_end= keyseg+ uniquedefs[i].keysegs;
+         keyseg < keyseg_end;
+         keyseg++)
     {
-      if (mi_keyseg_write(file, &uniquedefs[i].seg[j]))
+      switch (keyseg->type) {
+      case HA_KEYTYPE_VARTEXT1:
+      case HA_KEYTYPE_VARTEXT2:
+      case HA_KEYTYPE_VARBINARY1:
+      case HA_KEYTYPE_VARBINARY2:
+        if (!(keyseg->flag & HA_BLOB_PART))
+        {
+          keyseg->flag|= HA_VAR_LENGTH_PART;
+          keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1 ||
+                               keyseg->type == HA_KEYTYPE_VARBINARY1) ?
+                              1 : 2);
+        }
+        break;
+      default:
+        break;
+      }
+      if (mi_keyseg_write(file, keyseg))
 	goto err;
     }
   }
diff --git a/myisam/mi_dbug.c b/myisam/mi_dbug.c
index 02d1c7d05d6..e782d21afe7 100644
--- a/myisam/mi_dbug.c
+++ b/myisam/mi_dbug.c
@@ -131,9 +131,21 @@ void _mi_print_key(FILE *stream, register HA_KEYSEG *keyseg,
       key=end;
       break;
     }
+    case HA_KEYTYPE_BIT:
+    {
+      uint i;
+      fputs("0x",stream);
+      for (i=0 ; i < keyseg->length ; i++)
+        fprintf(stream, "%02x", (uint) *key++);
+      key= end;
+      break;
+    }
+
 #endif
-    case HA_KEYTYPE_VARTEXT:			/* VARCHAR and TEXT */
-    case HA_KEYTYPE_VARBINARY:			/* VARBINARY and BLOB */
+    case HA_KEYTYPE_VARTEXT1:                   /* VARCHAR and TEXT */
+    case HA_KEYTYPE_VARTEXT2:                   /* VARCHAR and TEXT */
+    case HA_KEYTYPE_VARBINARY1:                 /* VARBINARY and BLOB */
+    case HA_KEYTYPE_VARBINARY2:                 /* VARBINARY and BLOB */
     {
       uint tmp_length;
       get_key_length(tmp_length,key);
diff --git a/myisam/mi_dynrec.c b/myisam/mi_dynrec.c
index 0b8d3c97872..9d8e161b8fe 100644
--- a/myisam/mi_dynrec.c
+++ b/myisam/mi_dynrec.c
@@ -768,11 +768,21 @@ uint _mi_rec_pack(MI_INFO *info, register byte *to, register const byte *from)
       }
       else if (type == FIELD_VARCHAR)
       {
-	uint tmp_length=uint2korr(from);
-	store_key_length_inc(to,tmp_length);
-	memcpy(to,from+2,tmp_length);
-	to+=tmp_length;
-	continue;
+        uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
+	uint tmp_length;
+        if (pack_length == 1)
+        {
+          tmp_length= (uint) *(uchar*) from;
+          *to++= *from;
+        }
+        else
+        {
+          tmp_length= uint2korr(from);
+          store_key_length_inc(to,tmp_length);
+        }
+        memcpy(to, from+pack_length,tmp_length);
+        to+= tmp_length;
+        continue;
       }
       else
       {
@@ -878,9 +888,20 @@ my_bool _mi_rec_check(MI_INFO *info,const char *record, byte *rec_buff,
       }
       else if (type == FIELD_VARCHAR)
       {
-	uint tmp_length=uint2korr(record);
-	to+=get_pack_length(tmp_length)+tmp_length;
-	continue;
+        uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
+	uint tmp_length;
+        if (pack_length == 1)
+        {
+          tmp_length= (uint) *(uchar*) record;
+          to+= 1+ tmp_length;
+          continue;
+        }
+        else
+        {
+          tmp_length= uint2korr(record);
+          to+= get_pack_length(tmp_length)+tmp_length;
+        }
+        continue;
       }
       else
       {
@@ -894,9 +915,7 @@ my_bool _mi_rec_check(MI_INFO *info,const char *record, byte *rec_buff,
       }
     }
     else
-    {
-      to+=length;
-    }
+      to+= length;
   }
   if (packed_length != (uint) (to - rec_buff) + test(info->s->calc_checksum) ||
       (bit != 1 && (flag & ~(bit - 1))))
@@ -947,13 +966,27 @@ ulong _mi_rec_unpack(register MI_INFO *info, register byte *to, byte *from,
     {
       if (type == FIELD_VARCHAR)
       {
-	get_key_length(length,from);
-	if (length > rec_length-2)
-	  goto err;
-	int2store(to,length);
-	memcpy(to+2,from,length);
-	from+=length;
-	continue;
+        uint pack_length= HA_VARCHAR_PACKLENGTH(rec_length-1);
+        if (pack_length == 1)
+        {
+          length= (uint) *(uchar*) from;
+          if (length > rec_length-1)
+            goto err;
+          *to= *from++;
+        }
+        else
+        {
+          get_key_length(length, from);
+          if (length > rec_length-2)
+            goto err;
+          int2store(to,length);
+        }
+        if (from+length > from_end)
+          goto err;
+        memcpy(to+pack_length, from, length);
+        from+= length;
+        min_pack_length--;
+        continue;
       }
       if (flag & bit)
       {
@@ -1021,15 +1054,17 @@ ulong _mi_rec_unpack(register MI_INFO *info, register byte *to, byte *from,
       if (min_pack_length > (uint) (from_end - from))
 	goto err;
       min_pack_length-=rec_length;
-      memcpy(to,(byte*) from,(size_t) rec_length); from+=rec_length;
+      memcpy(to, (byte*) from, (size_t) rec_length);
+      from+=rec_length;
     }
   }
   if (info->s->calc_checksum)
     from++;
   if (to == to_end && from == from_end && (bit == 1 || !(flag & ~(bit-1))))
     DBUG_RETURN(found_length);
+
 err:
-  my_errno=HA_ERR_RECORD_DELETED;
+  my_errno= HA_ERR_WRONG_IN_RECORD;
   DBUG_PRINT("error",("to_end: %lx -> %lx  from_end: %lx -> %lx",
 		      to,to_end,from,from_end));
   DBUG_DUMP("from",(byte*) info->rec_buff,info->s->base.min_pack_length);
diff --git a/myisam/mi_key.c b/myisam/mi_key.c
index a775e0ba2d0..caca63452b0 100644
--- a/myisam/mi_key.c
+++ b/myisam/mi_key.c
@@ -34,10 +34,20 @@
 
 static int _mi_put_key_in_record(MI_INFO *info,uint keynr,byte *record);
 
-	/*
-	** Make a intern key from a record
-	** Ret: Length of key
-	*/
+/*
+  Make a intern key from a record
+
+  SYNOPSIS
+    _mi_make_key()
+    info		MyiSAM handler
+    keynr		key number
+    key			Store created key here
+    record		Record
+    filepos		Position to record in the data file
+
+  RETURN
+    Length of key
+*/
 
 uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
 		  const byte *record, my_off_t filepos)
@@ -82,6 +92,19 @@ uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
                   length);
 
     pos= (byte*) record+keyseg->start;
+    if (type == HA_KEYTYPE_BIT)
+    {
+      if (keyseg->bit_length)
+      {
+        uchar bits= get_rec_bits((uchar*) record + keyseg->bit_pos,
+                                 keyseg->bit_start, keyseg->bit_length);
+        *key++= bits;
+        length--;
+      }
+      memcpy((byte*) key, pos, length);
+      key+= length;
+      continue;
+    }
     if (keyseg->flag & HA_SPACE_PACK)
     {
       end=pos+length;
@@ -104,8 +127,10 @@ uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
     }
     if (keyseg->flag & HA_VAR_LENGTH_PART)
     {
-      uint tmp_length=uint2korr(pos);
-      pos+=2;					/* Skip VARCHAR length */
+      uint pack_length= keyseg->bit_start;
+      uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
+                        uint2korr(pos));
+      pos+= pack_length;			/* Skip VARCHAR length */
       set_if_smaller(length,tmp_length);
       FIX_LENGTH(cs, pos, length, char_length);
       store_key_length_inc(key,char_length);
@@ -333,6 +358,26 @@ static int _mi_put_key_in_record(register MI_INFO *info, uint keynr,
       }
       record[keyseg->null_pos]&= ~keyseg->null_bit;
     }
+    if (keyseg->type == HA_KEYTYPE_BIT)
+    {
+      uint length= keyseg->length;
+
+      if (keyseg->bit_length)
+      {
+        uchar bits= *key++;
+        set_rec_bits(bits, record + keyseg->bit_pos, keyseg->bit_start,
+                     keyseg->bit_length);
+        length--;
+      }
+      else
+      {
+        clr_rec_bits(record + keyseg->bit_pos, keyseg->bit_start,
+                     keyseg->bit_length);
+      }
+      memcpy(record + keyseg->start, (byte*) key, length);
+      key+= length;
+      continue;
+    }
     if (keyseg->flag & HA_SPACE_PACK)
     {
       uint length;
@@ -365,9 +410,12 @@ static int _mi_put_key_in_record(register MI_INFO *info, uint keynr,
 	goto err;
 #endif
       /* Store key length */
-      int2store(record+keyseg->start, length);
+      if (keyseg->bit_start == 1)
+        *(uchar*) (record+keyseg->start)= (uchar) length;
+      else
+        int2store(record+keyseg->start, length);
       /* And key data */
-      memcpy(record+keyseg->start+2,(byte*) key, length);
+      memcpy(record+keyseg->start + keyseg->bit_start, (byte*) key, length);
       key+= length;
     }
     else if (keyseg->flag & HA_BLOB_PART)
diff --git a/myisam/mi_open.c b/myisam/mi_open.c
index 562227d2f03..58db2e47c1f 100644
--- a/myisam/mi_open.c
+++ b/myisam/mi_open.c
@@ -314,7 +314,9 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
 	{
 	  disk_pos=mi_keyseg_read(disk_pos, pos);
 
-	  if (pos->type == HA_KEYTYPE_TEXT || pos->type == HA_KEYTYPE_VARTEXT)
+	  if (pos->type == HA_KEYTYPE_TEXT ||
+              pos->type == HA_KEYTYPE_VARTEXT1 ||
+              pos->type == HA_KEYTYPE_VARTEXT2)
 	  {
 	    if (!pos->language)
 	      pos->charset=default_charset_info;
@@ -389,7 +391,9 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
 	for (j=0 ; j < share->uniqueinfo[i].keysegs; j++,pos++)
 	{
 	  disk_pos=mi_keyseg_read(disk_pos, pos);
-	  if (pos->type == HA_KEYTYPE_TEXT || pos->type == HA_KEYTYPE_VARTEXT)
+	  if (pos->type == HA_KEYTYPE_TEXT ||
+              pos->type == HA_KEYTYPE_VARTEXT1 ||
+              pos->type == HA_KEYTYPE_VARTEXT2)
 	  {
 	    if (!pos->language)
 	      pos->charset=default_charset_info;
@@ -1049,12 +1053,13 @@ int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
   *ptr++ =keyseg->null_bit;
   *ptr++ =keyseg->bit_start;
   *ptr++ =keyseg->bit_end;
-  *ptr++ =0;					/* Not used */
+  *ptr++= keyseg->bit_length;
   mi_int2store(ptr,keyseg->flag);	ptr+=2;
   mi_int2store(ptr,keyseg->length);	ptr+=2;
   mi_int4store(ptr,keyseg->start);	ptr+=4;
-  mi_int4store(ptr,keyseg->null_pos);	ptr+=4;
-
+  mi_int4store(ptr, keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos);
+  ptr+=4;
+  
   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
 }
 
@@ -1066,12 +1071,19 @@ char *mi_keyseg_read(char *ptr, HA_KEYSEG *keyseg)
    keyseg->null_bit	= *ptr++;
    keyseg->bit_start	= *ptr++;
    keyseg->bit_end	= *ptr++;
-   ptr++;
+   keyseg->bit_length   = *ptr++;
    keyseg->flag		= mi_uint2korr(ptr);  ptr +=2;
    keyseg->length	= mi_uint2korr(ptr);  ptr +=2;
    keyseg->start	= mi_uint4korr(ptr);  ptr +=4;
    keyseg->null_pos	= mi_uint4korr(ptr);  ptr +=4;
    keyseg->charset=0;				/* Will be filled in later */
+   if (keyseg->null_bit)
+     keyseg->bit_pos= keyseg->null_pos + (keyseg->null_bit == 7);
+   else
+   {
+     keyseg->bit_pos= keyseg->null_pos;
+     keyseg->null_pos= 0;
+   }
    return ptr;
 }
 
diff --git a/myisam/mi_packrec.c b/myisam/mi_packrec.c
index a277c2ca9d1..62d15c03266 100644
--- a/myisam/mi_packrec.c
+++ b/myisam/mi_packrec.c
@@ -91,8 +91,10 @@ static void uf_zero(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
 		    uchar *to,uchar *end);
 static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
 		    uchar *to, uchar *end);
-static void uf_varchar(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
-		       uchar *to, uchar *end);
+static void uf_varchar1(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
+                        uchar *to, uchar *end);
+static void uf_varchar2(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
+                        uchar *to, uchar *end);
 static void decode_bytes(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
 			 uchar *to,uchar *end);
 static uint decode_pos(MI_BIT_BUFF *bit_buff,MI_DECODE_TREE *decode_tree);
@@ -522,14 +524,16 @@ static void (*get_unpack_function(MI_COLUMNDEF *rec))
   case FIELD_BLOB:
     return &uf_blob;
   case FIELD_VARCHAR:
-    return &uf_varchar;
+    if (rec->length <= 256)                      /* 255 + 1 byte length */
+      return &uf_varchar1;
+    return &uf_varchar2;
   case FIELD_LAST:
   default:
     return 0;			/* This should never happend */
   }
 }
 
-	/* De different functions to unpack a field */
+	/* The different functions to unpack a field */
 
 static void uf_zerofill_skip_zero(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
 				   uchar *to, uchar *end)
@@ -773,7 +777,22 @@ static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
   }
 }
 
-static void uf_varchar(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
+
+static void uf_varchar1(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
+		       uchar *to, uchar *end __attribute__((unused)))
+{
+  if (get_bit(bit_buff))
+    to[0]= 0;				/* Zero lengths */
+  else
+  {
+    ulong length=get_bits(bit_buff,rec->space_length_bits);
+    *to= (uchar) length;
+    decode_bytes(rec,bit_buff,to+1,to+1+length);
+  }
+}
+
+
+static void uf_varchar2(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
 		       uchar *to, uchar *end __attribute__((unused)))
 {
   if (get_bit(bit_buff))
diff --git a/myisam/mi_search.c b/myisam/mi_search.c
index 2fef70db9f0..2259dd17fcd 100644
--- a/myisam/mi_search.c
+++ b/myisam/mi_search.c
@@ -425,7 +425,8 @@ int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
         if (len < cmplen)
         {
 	  if ((keyinfo->seg->type != HA_KEYTYPE_TEXT &&
-	       keyinfo->seg->type != HA_KEYTYPE_VARTEXT))
+	       keyinfo->seg->type != HA_KEYTYPE_VARTEXT1 &&
+               keyinfo->seg->type != HA_KEYTYPE_VARTEXT2))
 	    my_flag= -1;
 	  else
 	  {
@@ -1371,7 +1372,8 @@ _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
   sort_order=0;
   if ((keyinfo->flag & HA_FULLTEXT) &&
       ((keyseg->type == HA_KEYTYPE_TEXT) ||
-       (keyseg->type == HA_KEYTYPE_VARTEXT)) &&
+       (keyseg->type == HA_KEYTYPE_VARTEXT1) ||
+       (keyseg->type == HA_KEYTYPE_VARTEXT2)) &&
       !use_strnxfrm(keyseg->charset))
     sort_order=keyseg->charset->sort_order;
 
diff --git a/myisam/mi_test1.c b/myisam/mi_test1.c
index 15ce7515ac2..aa6cd98ac8e 100644
--- a/myisam/mi_test1.c
+++ b/myisam/mi_test1.c
@@ -75,11 +75,11 @@ static int run_test(const char *filename)
   recinfo[1].length= (key_field == FIELD_BLOB ? 4+mi_portable_sizeof_char_ptr :
 		      key_length);
   if (key_field == FIELD_VARCHAR)
-    recinfo[1].length+=2;
+    recinfo[1].length+= HA_VARCHAR_PACKLENGTH(key_length);;
   recinfo[2].type=extra_field;
   recinfo[2].length= (extra_field == FIELD_BLOB ? 4 + mi_portable_sizeof_char_ptr : 24);
   if (extra_field == FIELD_VARCHAR)
-    recinfo[2].length+=2;
+    recinfo[2].length+= HA_VARCHAR_PACKLENGTH(recinfo[2].length);
   if (opt_unique)
   {
     recinfo[3].type=FIELD_CHECK;
@@ -88,6 +88,9 @@ static int run_test(const char *filename)
   rec_length=recinfo[0].length+recinfo[1].length+recinfo[2].length+
     recinfo[3].length;
 
+  if (key_type == HA_KEYTYPE_VARTEXT1 &&
+      key_length > 255)
+    key_type= HA_KEYTYPE_VARTEXT2;
 
   /* Define a key over the first column */
   keyinfo[0].seg=keyseg;
@@ -330,7 +333,8 @@ static void create_key_part(char *key,uint rownr)
   {
     sprintf(key,"%*d",keyinfo[0].seg[0].length,rownr);
   }
-  else if (keyinfo[0].seg[0].type == HA_KEYTYPE_VARTEXT)
+  else if (keyinfo[0].seg[0].type == HA_KEYTYPE_VARTEXT1 ||
+           keyinfo[0].seg[0].type == HA_KEYTYPE_VARTEXT2)
   {						/* Alpha record */
     /* Create a key that may be easily packed */
     bfill(key,keyinfo[0].seg[0].length,rownr < 10 ? 'A' : 'B');
@@ -410,11 +414,14 @@ static void create_record(char *record,uint rownr)
   }
   else if (recinfo[1].type == FIELD_VARCHAR)
   {
-    uint tmp;
-    create_key_part(pos+2,rownr);
-    tmp=strlen(pos+2);
-    int2store(pos,tmp);
-    pos+=recinfo[1].length;
+    uint tmp, pack_length= HA_VARCHAR_PACKLENGTH(recinfo[1].length-1);
+    create_key_part(pos+pack_length,rownr);
+    tmp= strlen(pos+pack_length);
+    if (pack_length == 1)
+      *(uchar*) pos= (uchar) tmp;
+    else
+      int2store(pos,tmp);
+    pos+= recinfo[1].length;
   }
   else
   {
@@ -434,10 +441,13 @@ static void create_record(char *record,uint rownr)
   }
   else if (recinfo[2].type == FIELD_VARCHAR)
   {
-    uint tmp;
-    sprintf(pos+2,"... row: %d", rownr);
-    tmp=strlen(pos+2);
-    int2store(pos,tmp);
+    uint tmp, pack_length= HA_VARCHAR_PACKLENGTH(recinfo[1].length-1);
+    sprintf(pos+pack_length, "... row: %d", rownr);
+    tmp= strlen(pos+pack_length);
+    if (pack_length == 1)
+      *(uchar*) pos= (uchar) tmp;
+    else
+      int2store(pos,tmp);
   }
   else
   {
@@ -466,8 +476,9 @@ static void update_record(char *record)
   }
   else if (recinfo[1].type == FIELD_VARCHAR)
   {
-    uint length=uint2korr(pos);
-    my_casedn(default_charset_info,pos+2,length);
+    uint pack_length= HA_VARCHAR_PACKLENGTH(recinfo[1].length-1);
+    uint length= pack_length == 1 ? (uint) *(uchar*) pos : uint2korr(pos);
+    my_casedn(default_charset_info,pos+pack_length,length);
     pos+=recinfo[1].length;
   }
   else
@@ -493,10 +504,14 @@ static void update_record(char *record)
   else if (recinfo[2].type == FIELD_VARCHAR)
   {
     /* Second field is longer than 10 characters */
-    uint length=uint2korr(pos);
-    bfill(pos+2+length,recinfo[2].length-length-2,'.');
-    length=recinfo[2].length-2;
-    int2store(pos,length);
+    uint pack_length= HA_VARCHAR_PACKLENGTH(recinfo[1].length-1);
+    uint length= pack_length == 1 ? (uint) *(uchar*) pos : uint2korr(pos);
+    bfill(pos+pack_length+length,recinfo[2].length-length-pack_length,'.');
+    length=recinfo[2].length-pack_length;
+    if (pack_length == 1)
+      *(uchar*) pos= (uchar) length;
+    else
+      int2store(pos,length);
   }
   else
   {
@@ -519,7 +534,7 @@ static struct my_option my_long_options[] =
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"insert_rows", 'i', "Undocumented", (gptr*) &insert_count,
    (gptr*) &insert_count, 0, GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0},
-  {"key_alpha", 'a', "Undocumented",
+  {"key_alpha", 'a', "Use a key of type HA_KEYTYPE_TEXT",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"key_binary_pack", 'B', "Undocumented",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
@@ -535,9 +550,9 @@ static struct my_option my_long_options[] =
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"key_space_pack", 'p', "Undocumented",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"key_varchar", 'w', "Undocumented",
+  {"key_varchar", 'w', "Test VARCHAR keys",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"null_fields", 'N', "Undocumented",
+  {"null_fields", 'N', "Define fields with NULL",
    (gptr*) &null_fields, (gptr*) &null_fields, 0, GET_BOOL, NO_ARG,
    0, 0, 0, 0, 0, 0},
   {"row_fixed_size", 'S', "Undocumented",
@@ -604,7 +619,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
     key_field=FIELD_BLOB;			/* blob key */
     extra_field= FIELD_BLOB;
     pack_seg|= HA_BLOB_PART;
-    key_type= HA_KEYTYPE_VARTEXT;
+    key_type= HA_KEYTYPE_VARTEXT1;
     break;
   case 'k':
     if (key_length < 4 || key_length > MI_MAX_KEY_LENGTH)
@@ -616,11 +631,11 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
   case 'w':
     key_field=FIELD_VARCHAR;			/* varchar keys */
     extra_field= FIELD_VARCHAR;
-    key_type= HA_KEYTYPE_VARTEXT;
+    key_type= HA_KEYTYPE_VARTEXT1;
     pack_seg|= HA_VAR_LENGTH_PART;
     create_flag|= HA_PACK_RECORD;
     break;
-  case 'K':				/* Use key cacheing */
+  case 'K':                                     /* Use key cacheing */
     key_cacheing=1;
     break;
   case 'V':
diff --git a/myisam/mi_test3.c b/myisam/mi_test3.c
index 27d23317b5c..be4277cc65c 100644
--- a/myisam/mi_test3.c
+++ b/myisam/mi_test3.c
@@ -67,6 +67,7 @@ int main(int argc,char **argv)
 
   bzero((char*) keyinfo,sizeof(keyinfo));
   bzero((char*) recinfo,sizeof(recinfo));
+  bzero((char*) keyseg,sizeof(keyseg));
   keyinfo[0].seg= &keyseg[0][0];
   keyinfo[0].seg[0].start=0;
   keyinfo[0].seg[0].length=8;
diff --git a/myisam/mi_test_all.res b/myisam/mi_test_all.res
index 94355bf1aa2..16b517d3f76 100644
--- a/myisam/mi_test_all.res
+++ b/myisam/mi_test_all.res
@@ -1,3 +1,6 @@
+myisamchk: MyISAM file test1
+myisamchk: warning: Size of indexfile is: 1024          Should be: 2048
+MyISAM-table 'test1' is usable but should be fixed
 mi_test2 -s -L -K -R1 -m2000 ;  Should give error 135
 Error: 135 in write at record: 1105
 got error: 135 when using MyISAM-database
@@ -5,46 +8,46 @@ myisamchk: MyISAM file test2
 myisamchk: warning: Datafile is almost full,      65532 of      65534 used
 MyISAM-table 'test2' is usable but should be fixed
 Commands   Used count    Errors   Recover errors
-open               17         0                0
-write             850         0                0
-update             85         0                0
-delete            850         0                0
-close              17         0                0
-extra             102         0                0
-Total            1921         0                0
+open                1         0                0
+write              50         0                0
+update              5         0                0
+delete             50         0                0
+close               1         0                0
+extra               6         0                0
+Total             113         0                0
 Commands   Used count    Errors   Recover errors
-open               18         0                0
-write             900         0                0
-update             90         0                0
-delete            900         0                0
-close              18         0                0
-extra             108         0                0
-Total            2034         0                0
+open                2         0                0
+write             100         0                0
+update             10         0                0
+delete            100         0                0
+close               2         0                0
+extra              12         0                0
+Total             226         0                0
 
-real	0m1.054s
-user	0m0.410s
-sys	0m0.640s
+real	0m0.791s
+user	0m0.137s
+sys	0m0.117s
 
-real	0m1.077s
-user	0m0.550s
-sys	0m0.530s
+real	0m0.659s
+user	0m0.252s
+sys	0m0.102s
 
-real	0m1.100s
-user	0m0.420s
-sys	0m0.680s
+real	0m0.571s
+user	0m0.188s
+sys	0m0.098s
 
-real	0m0.783s
-user	0m0.590s
-sys	0m0.200s
+real	0m1.111s
+user	0m0.236s
+sys	0m0.037s
 
-real	0m0.764s
-user	0m0.560s
-sys	0m0.210s
+real	0m0.621s
+user	0m0.242s
+sys	0m0.022s
 
-real	0m0.699s
-user	0m0.570s
-sys	0m0.130s
+real	0m0.698s
+user	0m0.248s
+sys	0m0.021s
 
-real	0m0.991s
-user	0m0.630s
-sys	0m0.350s
+real	0m0.683s
+user	0m0.265s
+sys	0m0.079s
diff --git a/myisam/mi_unique.c b/myisam/mi_unique.c
index c03182456df..f2d5f01be25 100644
--- a/myisam/mi_unique.c
+++ b/myisam/mi_unique.c
@@ -95,8 +95,10 @@ ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const byte *record)
     pos= record+keyseg->start;
     if (keyseg->flag & HA_VAR_LENGTH_PART)
     {
-      uint tmp_length=uint2korr(pos);
-      pos+=2;					/* Skip VARCHAR length */
+      uint pack_length=  keyseg->bit_start;
+      uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
+                        uint2korr(pos));
+      pos+= pack_length;			/* Skip VARCHAR length */
       set_if_smaller(length,tmp_length);
     }
     else if (keyseg->flag & HA_BLOB_PART)
@@ -107,7 +109,8 @@ ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const byte *record)
 	length=tmp_length;			/* The whole blob */
     }
     end= pos+length;
-    if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT)
+    if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
+        type == HA_KEYTYPE_VARTEXT2)
     {
       keyseg->charset->coll->hash_sort(keyseg->charset,
                                        (const uchar*) pos, length, &seed1,
@@ -157,12 +160,21 @@ int mi_unique_comp(MI_UNIQUEDEF *def, const byte *a, const byte *b,
     pos_b= b+keyseg->start;
     if (keyseg->flag & HA_VAR_LENGTH_PART)
     {
-      a_length= uint2korr(pos_a);
-      b_length= uint2korr(pos_b);
-      pos_a+= 2;				/* Skip VARCHAR length */
-      pos_b+= 2;
-      set_if_smaller(a_length, keyseg->length);
-      set_if_smaller(b_length, keyseg->length);
+      uint pack_length= keyseg->bit_start;
+      if (pack_length == 1)
+      {
+        a_length= (uint) *(uchar*) pos_a++;
+        b_length= (uint) *(uchar*) pos_b++;
+      }
+      else
+      {
+        a_length= uint2korr(pos_a);
+        b_length= uint2korr(pos_b);
+        pos_a+= 2;				/* Skip VARCHAR length */
+        pos_b+= 2;
+      }
+      set_if_smaller(a_length, keyseg->length); /* Safety */
+      set_if_smaller(b_length, keyseg->length); /* safety */
     }
     else if (keyseg->flag & HA_BLOB_PART)
     {
@@ -182,7 +194,8 @@ int mi_unique_comp(MI_UNIQUEDEF *def, const byte *a, const byte *b,
       memcpy_fixed((byte*) &pos_a,pos_a+keyseg->bit_start,sizeof(char*));
       memcpy_fixed((byte*) &pos_b,pos_b+keyseg->bit_start,sizeof(char*));
     }
-    if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT)
+    if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
+        type == HA_KEYTYPE_VARTEXT2)
     {
       if (mi_compare_text(keyseg->charset, (uchar *) pos_a, a_length,
                                            (uchar *) pos_b, b_length, 0, 1))
diff --git a/myisam/myisampack.c b/myisam/myisampack.c
index cc520847f70..bda620a594a 100644
--- a/myisam/myisampack.c
+++ b/myisam/myisampack.c
@@ -849,9 +849,11 @@ static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts)
 	}
 	else if (count->field_type == FIELD_VARCHAR)
 	{
-	  length=uint2korr(start_pos);
-	  pos=start_pos+2;
-	  end_pos=start_pos+length;
+          uint pack_length= HA_VARCHAR_PACKLENGTH(count->field_length-1);
+	  length= (pack_length == 1 ? (uint) *(uchar*) start_pos :
+                   uint2korr(start_pos));
+	  pos= start_pos+pack_length;
+	  end_pos= pos+length;
 	  set_if_bigger(count->max_length,length);
 	}
 	if (count->field_length <= 8 &&
@@ -1833,17 +1835,19 @@ static int compress_isam_file(PACK_MRG_INFO *mrg, HUFF_COUNTS *huff_counts)
 	}
 	case FIELD_VARCHAR:
 	{
-	  ulong col_length= uint2korr(start_pos);
+          uint pack_length= HA_VARCHAR_PACKLENGTH(count->field_length-1);
+	  ulong col_length= (pack_length == 1 ? (uint) *(uchar*) start_pos :
+                             uint2korr(start_pos));
 	  if (!col_length)
 	  {
 	    write_bits(1,1);			/* Empty varchar */
 	  }
 	  else
 	  {
-	    byte *end=start_pos+2+col_length;
+	    byte *end=start_pos+pack_length+col_length;
 	    write_bits(0,1);
 	    write_bits(col_length,count->length_bits);
-	    for (start_pos+=2 ; start_pos < end ; start_pos++)
+	    for (start_pos+=pack_length ; start_pos < end ; start_pos++)
 	      write_bits(tree->code[(uchar) *start_pos],
 			 (uint) tree->code_len[(uchar) *start_pos]);
 	  }