Some optimization in CHARSET_INFO:

We don't need separate hash_sort() and hash_caseup()
  We don't need tosort(). strnxfrm will do the same.

include/hash.h

@@ -25,9 +25,6 @@ extern "C" {
 typedef byte *(*hash_get_key)(const byte *,uint*,my_bool);
 typedef void (*hash_free_key)(void *);
 
-  /* flags for hash_init */
-#define HASH_CASE_INSENSITIVE	1
-
 typedef struct st_hash_info {
   uint next;					/* index to next key */
   byte *data;					/* data for current entry */
@@ -40,7 +37,6 @@ typedef struct st_hash {
   DYNAMIC_ARRAY array;				/* Place for hash_keys */
   hash_get_key get_key;
   void (*free)(void *);
-  uint (*calc_hashnr)(CHARSET_INFO *cs, const byte *key,uint length);
   CHARSET_INFO *charset;
 } HASH;
 

include/m_ctype.h

@@ -147,7 +147,6 @@ typedef struct charset_info_st
   void    (*casedn_str)(struct charset_info_st *, char *);
   void    (*caseup)(struct charset_info_st *, char *, uint);
   void    (*casedn)(struct charset_info_st *, char *, uint);
-  void    (*tosort)(struct charset_info_st *, char *, uint);
   
   /* Functions for case comparison */
   int  (*strcasecmp)(struct charset_info_st *, const char *, const char *);
@@ -155,7 +154,6 @@ typedef struct charset_info_st
 		      uint);
   
   /* Hash calculation */
-  uint (*hash_caseup)(struct charset_info_st *cs, const byte *key, uint len);
   void (*hash_sort)(struct charset_info_st *cs, const uchar *key, uint len,
 		    ulong *nr1, ulong *nr2); 
   
@@ -218,9 +216,6 @@ extern int  my_strnncoll_simple(CHARSET_INFO *, const uchar *, uint,
 extern int  my_strnncollsp_simple(CHARSET_INFO *, const uchar *, uint,
 				const uchar *, uint);
 
-extern uint my_hash_caseup_simple(CHARSET_INFO *cs,
-				  const byte *key, uint len);
-				  
 extern void my_hash_sort_simple(CHARSET_INFO *cs,
 				const uchar *key, uint len,
 				ulong *nr1, ulong *nr2); 
@@ -231,7 +226,6 @@ extern void my_caseup_str_8bit(CHARSET_INFO *, char *);
 extern void my_casedn_str_8bit(CHARSET_INFO *, char *);
 extern void my_caseup_8bit(CHARSET_INFO *, char *, uint);
 extern void my_casedn_8bit(CHARSET_INFO *, char *, uint);
-extern void my_tosort_8bit(CHARSET_INFO *, char *, uint);
 
 extern int my_strcasecmp_8bit(CHARSET_INFO * cs, const char *, const char *);
 extern int my_strncasecmp_8bit(CHARSET_INFO * cs, const char *, const char *,
@@ -344,7 +338,6 @@ uint my_charpos_mb(CHARSET_INFO *, const char *b, const char *e, uint pos);
 
 #define my_caseup(s, a, l)            ((s)->caseup((s), (a), (l)))
 #define my_casedn(s, a, l)            ((s)->casedn((s), (a), (l)))
-#define my_tosort(s, a, l)            ((s)->tosort((s), (a), (l)))
 #define my_caseup_str(s, a)           ((s)->caseup_str((s), (a)))
 #define my_casedn_str(s, a)           ((s)->casedn_str((s), (a)))
 #define my_strcasecmp(s, a, b)        ((s)->strcasecmp((s), (a), (b)))

isam/_key.c

@@ -56,7 +56,8 @@ uint _nisam_make_key(register N_INFO *info, uint keynr, uchar *key, const char *
       if (!use_strnxfrm(default_charset_info))
       {
 	if (type == HA_KEYTYPE_TEXT)
-	  my_tosort(default_charset_info,(byte*) key,length);
+	  my_strnxfrm(default_charset_info,(uchar*) key, length,
+	  				   (uchar*) key, length);
       }
       key+=length;
     }
@@ -67,7 +68,10 @@ uint _nisam_make_key(register N_INFO *info, uint keynr, uchar *key, const char *
       if (!use_strnxfrm(default_charset_info))
       {
 	if (type == HA_KEYTYPE_TEXT)
-	  my_tosort(default_charset_info,(byte*) key,(uint) keyseg->base.length);
+	  my_strnxfrm(default_charset_info,(uchar*) key,
+	  				 (uint) keyseg->base.length,
+	  				 (uchar*) key,
+	  				 (uint) keyseg->base.length);
       }
 #ifdef NAN_TEST
       else if (type == HA_KEYTYPE_FLOAT)
@@ -148,7 +152,8 @@ uint _nisam_pack_key(register N_INFO *info, uint keynr, uchar *key, uchar *old,
       if (!use_strnxfrm(default_charset_info))
       {
 	if (type == HA_KEYTYPE_TEXT)
-	  my_tosort(default_charset_info,(byte*) key,length);
+	  my_strnxfrm(default_charset_info,(uchar*) key,length,
+	  				 (uchar*) key,length);
       }
       key+= length;
   }

mysys/charset.c

@@ -126,10 +126,8 @@ static void simple_cs_init_functions(CHARSET_INFO *cs)
     cs->wildcmp     = b->wildcmp;
     cs->strnncoll   = b->strnncoll;
     cs->strnncollsp = b->strnncollsp;
-    cs->tosort      = b->tosort;
     cs->strcasecmp  = b->strcasecmp;
     cs->strncasecmp = b->strncasecmp;
-    cs->hash_caseup = b->hash_caseup;
     cs->hash_sort   = b->hash_sort;
   }
   else
@@ -139,10 +137,8 @@ static void simple_cs_init_functions(CHARSET_INFO *cs)
     cs->wildcmp     = my_wildcmp_8bit;
     cs->strnncoll   = my_strnncoll_simple;
     cs->strnncollsp = my_strnncollsp_simple;
-    cs->tosort      = my_tosort_8bit;
     cs->strcasecmp  = my_strcasecmp_8bit;
     cs->strncasecmp = my_strncasecmp_8bit;
-    cs->hash_caseup = my_hash_caseup_simple;
     cs->hash_sort   = my_hash_sort_simple;
   }
   

mysys/hash.c

@@ -31,9 +31,14 @@
 
 static uint hash_mask(uint hashnr,uint buffmax,uint maxlength);
 static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
-static uint calc_hashnr(CHARSET_INFO *cs,const byte *key,uint length);
 static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
 
+static uint calc_hash(HASH *hash,const byte *key,uint length)
+{
+  ulong nr1=1, nr2=4;
+  hash->charset->hash_sort(hash->charset,key,length,&nr1,&nr2);
+  return nr1;
+}
 
 my_bool
 _hash_init(HASH *hash,CHARSET_INFO *charset,
@@ -58,10 +63,6 @@ _hash_init(HASH *hash,CHARSET_INFO *charset,
   hash->free=free_element;
   hash->flags=flags;
   hash->charset=charset;
-  if (flags & HASH_CASE_INSENSITIVE)
-    hash->calc_hashnr=charset->hash_caseup;
-  else
-    hash->calc_hashnr=calc_hashnr;
   DBUG_RETURN(0);
 }
 
@@ -111,54 +112,9 @@ static uint hash_rec_mask(HASH *hash,HASH_LINK *pos,uint buffmax,
 {
   uint length;
   byte *key= (byte*) hash_key(hash,pos->data,&length,0);
-  return hash_mask((*hash->calc_hashnr)(hash->charset,key,length),
+  return hash_mask(calc_hash(hash,key,length),buffmax,maxlength);
-  		   buffmax,maxlength);
 }
 
-#ifndef NEW_HASH_FUNCTION
-
-	/* Calc hashvalue for a key */
-
-static uint calc_hashnr(CHARSET_INFO *cs __attribute__((unused)), 
-			const byte *key,uint length)
-{
-  register uint nr=1, nr2=4;
-  while (length--)
-  {
-    nr^= (((nr & 63)+nr2)*((uint) (uchar) *key++))+ (nr << 8);
-    nr2+=3;
-  }
-  return((uint) nr);
-}
-
-#else
-
-/*
- * Fowler/Noll/Vo hash
- *
- * The basis of the hash algorithm was taken from an idea sent by email to the
- * IEEE Posix P1003.2 mailing list from Phong Vo (kpv@research.att.com) and
- * Glenn Fowler (gsf@research.att.com).  Landon Curt Noll (chongo@toad.com)
- * later improved on their algorithm.
- *
- * The magic is in the interesting relationship between the special prime
- * 16777619 (2^24 + 403) and 2^32 and 2^8.
- * This works well on both numbers and strings.
- */
-
-uint calc_hashnr(CHARSET_INFO *cs, const byte *key, uint len)
-{
-  const byte *end=key+len;
-  uint hash;
-  for (hash = 0; key < end; key++)
-  {
-    hash *= 16777619;
-    hash ^= (uint) *(uchar*) key;
-  }
-  return (hash);
-}
-
-#endif
 
 
 #ifndef __SUNPRO_C				/* SUNPRO can't handle this */
@@ -168,7 +124,7 @@ unsigned int rec_hashnr(HASH *hash,const byte *record)
 {
   uint length;
   byte *key= (byte*) hash_key(hash,record,&length,0);
-  return (*hash->calc_hashnr)(hash->charset,key,length);
+  return calc_hash(hash,key,length);
 }
 
 
@@ -184,8 +140,7 @@ gptr hash_search(HASH *hash,const byte *key,uint length)
   flag=1;
   if (hash->records)
   {
-    idx=hash_mask((*hash->calc_hashnr)(hash->charset,key,length ? length :
+    idx=hash_mask(calc_hash(hash,key,length ? length : hash->key_length),
-					 hash->key_length),
 		    hash->blength,hash->records);
     do
     {
@@ -256,9 +211,7 @@ static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
   uint rec_keylength;
   byte *rec_key= (byte*) hash_key(hash,pos->data,&rec_keylength,1);
   return (length && length != rec_keylength) ||
-    (hash->flags & HASH_CASE_INSENSITIVE ?
+     my_strncasecmp(hash->charset, rec_key,key,rec_keylength);
-     my_strncasecmp(hash->charset, rec_key,key,rec_keylength) :
-     memcmp(rec_key,key,rec_keylength));
 }
 
 
@@ -497,7 +450,7 @@ my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
 
   /* Search after record with key */
 
-  idx=hash_mask((*hash->calc_hashnr)(hash->charset, old_key,(old_key_length ?
+  idx=hash_mask(calc_hash(hash, old_key,(old_key_length ?
 					      old_key_length :
 					      hash->key_length)),
 		  blength,records);

sql/filesort.cc

@@ -505,10 +505,8 @@ static void make_sortkey(register SORTPARAM *param,
           }
           else
           {
-            if (res->ptr() != (char*) to)
+	    my_strnxfrm(cs,(uchar*)to,length,(const uchar*)res->ptr(),length);
-              memcpy(to,res->ptr(),length);
 	    bzero((char *)to+length,diff);
-            my_tosort(cs, (char*) to,length);
           }
 	  break;
 	}

sql/set_var.cc

@@ -1465,7 +1465,7 @@ void set_var_init()
 
   hash_init(&system_variable_hash, system_charset_info,
 	    array_elements(sys_variables),0,0,
-	    (hash_get_key) get_sys_var_length,0, HASH_CASE_INSENSITIVE);
+	    (hash_get_key) get_sys_var_length,0,0);
   sys_var **var, **end;
   for (var= sys_variables, end= sys_variables+array_elements(sys_variables) ;
        var < end;

sql/sql_acl.cc

@@ -983,7 +983,7 @@ static void init_check_host(void)
   VOID(my_init_dynamic_array(&acl_wild_hosts,sizeof(struct acl_host_and_ip),
 			  acl_users.elements,1));
   VOID(hash_init(&acl_check_hosts,&my_charset_latin1,acl_users.elements,0,0,
-		 (hash_get_key) check_get_key,0,HASH_CASE_INSENSITIVE));
+		 (hash_get_key) check_get_key,0,0));
   if (!allow_all_hosts)
   {
     for (uint i=0 ; i < acl_users.elements ; i++)
@@ -1639,8 +1639,7 @@ public:
     hash_key = (char*) alloc_root(&memex,key_length);
     strmov(strmov(strmov(hash_key,user)+1,db)+1,tname);
     (void) hash_init(&hash_columns,&my_charset_latin1,
-		     0,0,0, (hash_get_key) get_key_column,0,
+		     0,0,0, (hash_get_key) get_key_column,0,0);
-		     HASH_CASE_INSENSITIVE);
   }
 
   GRANT_TABLE (TABLE *form, TABLE *col_privs)
@@ -1674,8 +1673,7 @@ public:
     cols =  fix_rights_for_column(cols);
 
     (void) hash_init(&hash_columns,&my_charset_latin1,
-		     0,0,0, (hash_get_key) get_key_column,0,
+		     0,0,0, (hash_get_key) get_key_column,0,0);
-		     HASH_CASE_INSENSITIVE);
     if (cols)
     {
       int key_len;

sql/sql_class.cc

@@ -142,7 +142,7 @@ THD::THD():user_time(0), is_fatal_error(0),
   bzero((char*) &warn_root,sizeof(warn_root));
   init_alloc_root(&warn_root, 1024, 0);
   user_connect=(USER_CONN *)0;
-  hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
+  hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
 	    (hash_get_key) get_var_key,
 	    (hash_free_key) free_user_var,0);
 
@@ -246,7 +246,7 @@ void THD::change_user(void)
   cleanup();
   cleanup_done= 0;
   init();
-  hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
+  hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
 	    (hash_get_key) get_var_key,
 	    (hash_free_key) free_user_var, 0);
 }

sql/sql_udf.cc

@@ -128,8 +128,7 @@ void udf_init()
   init_sql_alloc(&mem, 1024,0);
   THD *new_thd = new THD;
   if (!new_thd ||
-      hash_init(&udf_hash,system_charset_info,
+      hash_init(&udf_hash,system_charset_info,32,0,0,get_hash_key, NULL, 0))
-		32,0,0,get_hash_key, NULL, HASH_CASE_INSENSITIVE))
   {
     sql_print_error("Can't allocate memory for udf structures");
     hash_free(&udf_hash);

sql/table.cc

@@ -363,8 +363,7 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
     use_hash= !hash_init(&outparam->name_hash,
 			 system_charset_info,
 			 outparam->fields,0,0,
-			 (hash_get_key) get_field_name,0,
+			 (hash_get_key) get_field_name,0,0);
-			 HASH_CASE_INSENSITIVE);
 
   for (i=0 ; i < outparam->fields; i++, strpos+=field_pack_length, field_ptr++)
   {

strings/ctype-big5.c

@@ -6263,10 +6263,8 @@ CHARSET_INFO my_charset_big5 =
     my_casedn_str_mb,
     my_caseup_mb,
     my_casedn_mb,
-    NULL,		/* tosort      */
     my_strcasecmp_mb,
     my_strncasecmp_mb,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-bin.c

@@ -112,12 +112,6 @@ static void my_casedn_bin(CHARSET_INFO * cs __attribute__((unused)),
 {
 }
 
-static void my_tosort_bin(CHARSET_INFO * cs __attribute__((unused)),
-		   char *str __attribute__((unused)),
-		   uint length  __attribute__((unused)))
-{
-}
-
 static int my_strcasecmp_bin(CHARSET_INFO * cs __attribute__((unused)),
 		      const char *s, const char *t)
 {
@@ -159,41 +153,6 @@ static int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
 }
 
 
-#ifndef NEW_HASH_FUNCTION
-
-	/* Calc hashvalue for a key, case indepenently */
-
-static uint my_hash_caseup_bin(CHARSET_INFO *cs __attribute__((unused)),
-				const byte *key, uint length)
-{
-  register uint nr=1, nr2=4;
-  
-  while (length--)
-  {
-    nr^= (((nr & 63)+nr2)*
-         ((uint) (uchar) *key++)) + (nr << 8);
-    nr2+=3;
-  }
-  return((uint) nr);
-}
-
-#else
-
-static uint my_hash_caseup_bin(CHARSET_INFO *cs __attribute__((unused)),
-			       const byte *key, uint len)
-{
-  const byte *end=key+len;
-  uint hash;
-  for (hash = 0; key < end; key++)
-  {
-    hash *= 16777619;
-    hash ^= (uint) (uchar) *key;
-  }
-  return (hash);
-}
-
-#endif
-				  
 void my_hash_sort_bin(CHARSET_INFO *cs __attribute__((unused)),
 		      const uchar *key, uint len,ulong *nr1, ulong *nr2)
 {
@@ -304,6 +263,7 @@ static int my_strnxfrm_bin(CHARSET_INFO *cs __attribute__((unused)),
 			    const uchar *src, 
 			    uint srclen __attribute__((unused)))
 {
+  if (dest != src)
     memcpy(dest,src,len= min(len,srclen));
   return len;
 }
@@ -340,10 +300,8 @@ CHARSET_INFO my_charset_bin =
     my_casedn_str_bin,		/* casedn_str    */
     my_caseup_bin,		/* caseup        */
     my_casedn_bin,		/* casedn        */
-    my_tosort_bin,		/* tosort        */
     my_strcasecmp_bin,		/* strcasecmp    */
     my_strncasecmp_bin,		/* strncasecmp   */
-    my_hash_caseup_bin,		/* hash_caseup   */
     my_hash_sort_bin,		/* hash_sort     */
     (char) 255,			/* max_sort_char */
     my_snprintf_8bit,		/* snprintf      */

strings/ctype-czech.c

@@ -637,10 +637,8 @@ CHARSET_INFO my_charset_czech =
     my_casedn_str_8bit,
     my_caseup_8bit,
     my_casedn_8bit,
-    NULL,		/* tosort      */
     my_strcasecmp_8bit,
     my_strncasecmp_8bit,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-euc_kr.c

@@ -8671,10 +8671,8 @@ CHARSET_INFO my_charset_euc_kr =
     my_casedn_str_mb,
     my_caseup_mb,
     my_casedn_mb,
-    my_tosort_8bit,
     my_strcasecmp_mb,
     my_strncasecmp_mb,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-extra.c

@@ -52,8 +52,6 @@ CHARSET_INFO compiled_charsets[] = {
     NULL,
     NULL,
     NULL,
-    NULL,
-    NULL,		/* hash_caseup */
     NULL,		/* hash_sort   */
     0,
     NULL,

strings/ctype-gb2312.c

@@ -5721,10 +5721,8 @@ CHARSET_INFO my_charset_gb2312 =
     my_casedn_str_mb,
     my_caseup_mb,
     my_casedn_mb,
-    my_tosort_8bit,
     my_strcasecmp_mb,
     my_strncasecmp_mb,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-gbk.c

@@ -9918,10 +9918,8 @@ CHARSET_INFO my_charset_gbk =
     my_casedn_str_mb,
     my_caseup_mb,
     my_casedn_mb,
-    NULL,		/* tosort      */
     my_strcasecmp_mb,
     my_strncasecmp_mb,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-latin1.c

@@ -207,10 +207,8 @@ CHARSET_INFO my_charset_latin1 =
     my_casedn_str_8bit,
     my_caseup_8bit,
     my_casedn_8bit,
-    my_tosort_8bit,	/* tosort    */
     my_strcasecmp_8bit,
     my_strncasecmp_8bit,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,
@@ -464,10 +462,8 @@ CHARSET_INFO my_charset_latin1_de =
     my_casedn_str_8bit,
     my_caseup_8bit,
     my_casedn_8bit,
-    NULL,				/* tosort    */
     my_strcasecmp_8bit,
     my_strncasecmp_8bit,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-simple.c

@@ -28,14 +28,23 @@ int my_strnxfrm_simple(CHARSET_INFO * cs,
                        const uchar *src, uint srclen)
 {
   uchar *map= cs->sort_order;
-  const uchar *end;
   DBUG_ASSERT(len >= srclen);
-  
   len= min(len,srclen);
+  if (dest != src)
+  {
+    const uchar *end;
     for ( end=src+len; src < end ;  )
       *dest++= map[*src++];
     return len;
   }
+  else
+  {
+    const uchar *end;
+    for ( end=dest+len; dest < end ; dest++)
+      *dest= (char) map[(uchar) *dest];
+    return len;
+  }
+}
 
 int my_strnncoll_simple(CHARSET_INFO * cs, const uchar *s, uint slen, 
 			const uchar *t, uint tlen)
@@ -98,13 +107,6 @@ void my_casedn_8bit(CHARSET_INFO * cs, char *str, uint length)
     *str= (char) map[(uchar) *str];
 }
 
-void my_tosort_8bit(CHARSET_INFO *cs, char *str, uint length)
-{
-  register uchar *map=cs->sort_order;
-  for ( ; length>0 ; length--, str++)
-    *str= (char) map[(uchar) *str];
-}
-
 int my_strcasecmp_8bit(CHARSET_INFO * cs,const char *s, const char *t)
 {
   register uchar *map=cs->to_upper;
@@ -174,41 +176,6 @@ int my_snprintf_8bit(CHARSET_INFO *cs  __attribute__((unused)),
 }
 
 
-
-#ifndef NEW_HASH_FUNCTION
-
-	/* Calc hashvalue for a key, case indepenently */
-
-uint my_hash_caseup_simple(CHARSET_INFO *cs, const byte *key, uint length)
-{
-  register uint nr=1, nr2=4;
-  register uchar *map=cs->to_upper;
-  
-  while (length--)
-  {
-    nr^= (((nr & 63)+nr2)*
-         ((uint) (uchar) map[(uchar)*key++])) + (nr << 8);
-    nr2+=3;
-  }
-  return((uint) nr);
-}
-
-#else
-
-uint my_hash_caseup_simple(CHARSET_INFO *cs, const byte *key, uint len)
-{
-  const byte *end=key+len;
-  uint hash;
-  for (hash = 0; key < end; key++)
-  {
-    hash *= 16777619;
-    hash ^= (uint) (uchar) my_toupper(cs,*key);
-  }
-  return (hash);
-}
-
-#endif
-				  
 void my_hash_sort_simple(CHARSET_INFO *cs,
 				const uchar *key, uint len,
 				ulong *nr1, ulong *nr2)

strings/ctype-sjis.c

@@ -4505,10 +4505,8 @@ CHARSET_INFO my_charset_sjis =
     my_casedn_str_8bit,
     my_caseup_8bit,
     my_casedn_8bit,
-    NULL,		/* tosort      */
     my_strcasecmp_8bit,
     my_strncasecmp_8bit,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-tis620.c

@@ -728,10 +728,8 @@ CHARSET_INFO my_charset_tis620 =
     my_casedn_str_8bit,
     my_caseup_8bit,
     my_casedn_8bit,
-    NULL,		/* tosort    */
     my_strcasecmp_8bit,
     my_strncasecmp_8bit,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-ujis.c

@@ -8462,10 +8462,8 @@ CHARSET_INFO my_charset_ujis =
     my_casedn_str_mb,
     my_caseup_mb,
     my_casedn_mb,
-    my_tosort_8bit,
     my_strcasecmp_mb,
     my_strncasecmp_mb,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,

strings/ctype-utf8.c

@@ -1751,29 +1751,6 @@ static void my_caseup_utf8(CHARSET_INFO *cs, char *s, uint slen)
   }
 }
 
-static uint my_hash_caseup_utf8(CHARSET_INFO *cs, const byte *s, uint slen)
-{
-  my_wc_t wc;
-  register uint nr=1, nr2=4;
-  int res;
-  const char *e=s+slen;
-
-  while ((s < e) && (res=my_utf8_uni(cs,&wc, (uchar *)s, (uchar*)e))>0 )
-  {
-    int plane = (wc>>8) & 0xFF;
-    wc = uni_plane[plane] ? uni_plane[plane][wc & 0xFF].toupper : wc;
-    nr^= (((nr & 63)+nr2)*(wc & 0xFF))+ (nr << 8);
-    nr2+=3;
-    nr^= (((nr & 63)+nr2)*(wc >> 8))+ (nr << 8);
-    nr2+=3;
-    
-    s+=res;
-  }
-
-  return nr;
-}
-
-
 static void my_hash_sort_utf8(CHARSET_INFO *cs, const uchar *s, uint slen, ulong *n1, ulong *n2)
 {
   my_wc_t wc;
@@ -2010,10 +1987,8 @@ CHARSET_INFO my_charset_utf8 =
     my_casedn_str_utf8,
     my_caseup_utf8,
     my_casedn_utf8,
-    NULL,		/* tosort       */
     my_strcasecmp_utf8,
     my_strncasecmp_utf8,
-    my_hash_caseup_utf8,/* hash_caseup  */
     my_hash_sort_utf8,	/* hash_sort    */
     0,
     my_snprintf_8bit,
@@ -2184,29 +2159,6 @@ static void my_caseup_ucs2(CHARSET_INFO *cs, char *s, uint slen)
   }
 }
 
-static uint my_hash_caseup_ucs2(CHARSET_INFO *cs, const byte *s, uint slen)
-{
-  my_wc_t wc;
-  register uint nr=1, nr2=4;
-  int res;
-  const char *e=s+slen;
-
-  while ((s < e) && (res=my_ucs2_uni(cs,&wc, (uchar *)s, (uchar*)e))>0 )
-  {
-    int plane = (wc>>8) & 0xFF;
-    wc = uni_plane[plane] ? uni_plane[plane][wc & 0xFF].toupper : wc;
-    nr^= (((nr & 63)+nr2)*(wc & 0xFF))+ (nr << 8);
-    nr2+=3;
-    nr^= (((nr & 63)+nr2)*(wc >> 8))+ (nr << 8);
-    nr2+=3;
-    
-    s+=res;
-  }
-
-  return nr;
-}
-
-
 static void my_hash_sort_ucs2(CHARSET_INFO *cs, const uchar *s, uint slen, ulong *n1, ulong *n2)
 {
   my_wc_t wc;
@@ -3118,10 +3070,8 @@ CHARSET_INFO my_charset_ucs2 =
     my_casedn_str_ucs2,
     my_caseup_ucs2,
     my_casedn_ucs2,
-    NULL,		/* tosort       */
     my_strcasecmp_ucs2,
     my_strncasecmp_ucs2,
-    my_hash_caseup_ucs2,/* hash_caseup  */
     my_hash_sort_ucs2,	/* hash_sort    */
     0,
     my_snprintf_ucs2,

strings/ctype-win1250ch.c

@@ -672,10 +672,8 @@ CHARSET_INFO my_charset_win1250ch =
     my_casedn_str_8bit,
     my_caseup_8bit,
     my_casedn_8bit,
-    NULL,			/* tosort     */
     my_strcasecmp_8bit,
     my_strncasecmp_8bit,
-    my_hash_caseup_simple,
     my_hash_sort_simple,
     0,
     my_snprintf_8bit,