Auto-merge from mysql-next-mr-summit0.3.

2 files changed, 64 insertions, 9 deletions

diff --git a/mysys/hash.c b/mysys/hash.c
index 6996b045d1c..5fa804ce7ce 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -33,16 +33,18 @@ typedef struct st_hash_info {
   uchar *data;					/* data for current entry */
 } HASH_LINK;
 
-static uint my_hash_mask(size_t hashnr, size_t buffmax, size_t maxlength);
+static uint my_hash_mask(my_hash_value_type hashnr,
+                         size_t buffmax, size_t maxlength);
 static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
 static int hashcmp(const HASH *hash, HASH_LINK *pos, const uchar *key,
                    size_t length);
 
-static uint calc_hash(const HASH *hash, const uchar *key, size_t length)
+static my_hash_value_type calc_hash(const HASH *hash,
+                                    const uchar *key, size_t length)
 {
   ulong nr1=1, nr2=4;
   hash->charset->coll->hash_sort(hash->charset,(uchar*) key,length,&nr1,&nr2);
-  return nr1;
+  return (my_hash_value_type)nr1;
 }
 
 /**
@@ -179,7 +181,8 @@ my_hash_key(const HASH *hash, const uchar *record, size_t *length,
 
 	/* Calculate pos according to keys */
 
-static uint my_hash_mask(size_t hashnr, size_t buffmax, size_t maxlength)
+static uint my_hash_mask(my_hash_value_type hashnr, size_t buffmax,
+                         size_t maxlength)
 {
   if ((hashnr & (buffmax-1)) < maxlength) return (hashnr & (buffmax-1));
   return (hashnr & ((buffmax >> 1) -1));
@@ -200,7 +203,7 @@ static
 #if !defined(__USLC__) && !defined(__sgi)
 inline
 #endif
-unsigned int rec_hashnr(HASH *hash,const uchar *record)
+my_hash_value_type rec_hashnr(HASH *hash,const uchar *record)
 {
   size_t length;
   uchar *key= (uchar*) my_hash_key(hash, record, &length, 0);
@@ -214,6 +217,21 @@ uchar* my_hash_search(const HASH *hash, const uchar *key, size_t length)
   return my_hash_first(hash, key, length, &state);
 }
 
+uchar* my_hash_search_using_hash_value(const HASH *hash, 
+                                       my_hash_value_type hash_value,
+                                       const uchar *key,
+                                       size_t length)
+{
+  HASH_SEARCH_STATE state;
+  return my_hash_first_from_hash_value(hash, hash_value,
+                                       key, length, &state);
+}
+
+my_hash_value_type my_calc_hash(const HASH *hash,
+                                const uchar *key, size_t length)
+{
+  return calc_hash(hash, key, length ? length : hash->key_length);
+}
 /*
   Search after a record based on a key
 
@@ -224,14 +242,25 @@ uchar* my_hash_search(const HASH *hash, const uchar *key, size_t length)
 uchar* my_hash_first(const HASH *hash, const uchar *key, size_t length,
                      HASH_SEARCH_STATE *current_record)
 {
+  return my_hash_first_from_hash_value(hash,
+                 calc_hash(hash, key, length ? length : hash->key_length),
+                 key, length, current_record);
+}
+                    
+uchar* my_hash_first_from_hash_value(const HASH *hash,
+                                     my_hash_value_type hash_value,
+                                     const uchar *key,
+                                     size_t length,
+                                     HASH_SEARCH_STATE *current_record)
+{
   HASH_LINK *pos;
   uint flag,idx;
-  DBUG_ENTER("my_hash_first");
+  DBUG_ENTER("my_hash_first_from_hash_value");
 
   flag=1;
   if (hash->records)
   {
-    idx= my_hash_mask(calc_hash(hash, key, length ? length : hash->key_length),
+    idx= my_hash_mask(hash_value,
                       hash->blength, hash->records);
     do
     {
@@ -331,7 +360,8 @@ static int hashcmp(const HASH *hash, HASH_LINK *pos, const uchar *key,
 my_bool my_hash_insert(HASH *info, const uchar *record)
 {
   int flag;
-  size_t idx,halfbuff,hash_nr,first_index;
+  size_t idx,halfbuff,first_index;
+  my_hash_value_type hash_nr;
   uchar *UNINIT_VAR(ptr_to_rec),*UNINIT_VAR(ptr_to_rec2);
   HASH_LINK *data,*empty,*UNINIT_VAR(gpos),*UNINIT_VAR(gpos2),*pos;
 
@@ -467,7 +497,8 @@ my_bool my_hash_insert(HASH *info, const uchar *record)
 
 my_bool my_hash_delete(HASH *hash, uchar *record)
 {
-  uint blength,pos2,pos_hashnr,lastpos_hashnr,idx,empty_index;
+  uint blength,pos2,idx,empty_index;
+  my_hash_value_type pos_hashnr, lastpos_hashnr;
   HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
   DBUG_ENTER("my_hash_delete");
   if (!hash->records)
diff --git a/mysys/ptr_cmp.c b/mysys/ptr_cmp.c
index 24ab6a1ea9c..2005e3eb2b7 100644
--- a/mysys/ptr_cmp.c
+++ b/mysys/ptr_cmp.c
@@ -22,16 +22,39 @@
 #include "mysys_priv.h"
 #include <myisampack.h>
 
+#ifdef TARGET_OS_SOLARIS
+/*
+ * On Solaris, memcmp() is normally faster than the unrolled ptr_compare_N
+ * functions, as memcmp() is usually a platform-specific implementation
+ * written in assembler, provided in /usr/lib/libc/libc_hwcap*.so.1.
+ * This implementation is also usually faster than the built-in memcmp
+ * supplied by GCC, so it is recommended to build with "-fno-builtin-memcmp"
+ * in CFLAGS if building with GCC on Solaris.
+ */
+
+#include <string.h>
+
+static int native_compare(size_t *length, unsigned char **a, unsigned char **b)
+{
+  return memcmp(*a, *b, *length);
+}
+
+#else	/* TARGET_OS_SOLARIS */
+
 static int ptr_compare(size_t *compare_length, uchar **a, uchar **b);
 static int ptr_compare_0(size_t *compare_length, uchar **a, uchar **b);
 static int ptr_compare_1(size_t *compare_length, uchar **a, uchar **b);
 static int ptr_compare_2(size_t *compare_length, uchar **a, uchar **b);
 static int ptr_compare_3(size_t *compare_length, uchar **a, uchar **b);
+#endif	/* TARGET_OS_SOLARIS */
 
 	/* Get a pointer to a optimal byte-compare function for a given size */
 
 qsort2_cmp get_ptr_compare (size_t size)
 {
+#ifdef TARGET_OS_SOLARIS
+  return (qsort2_cmp) native_compare;
+#else
   if (size < 4)
     return (qsort2_cmp) ptr_compare;
   switch (size & 3) {
@@ -41,6 +64,7 @@ qsort2_cmp get_ptr_compare (size_t size)
     case 3: return (qsort2_cmp) ptr_compare_3;
     }
   return 0;					/* Impossible */
+#endif /* TARGET_OS_SOLARIS */
 }