find() method for Hash_set<>.

Move key function from template parameter to the constructor

sql/sql_base.cc

@@ -4542,10 +4542,9 @@ end:
   DBUG_RETURN(error);
 }
 
-extern "C" uchar *schema_set_get_key(const uchar *record, size_t *length,
+extern "C" uchar *schema_set_get_key(const TABLE_LIST *table, size_t *length,
                                      my_bool not_used __attribute__((unused)))
 {
-  TABLE_LIST *table=(TABLE_LIST*) record;
   *length= table->db_length;
   return (uchar*) table->db;
 }
@@ -4586,7 +4585,7 @@ lock_table_names(THD *thd,
   MDL_request_list mdl_requests;
   TABLE_LIST *table;
   MDL_request global_request;
-  Hash_set<TABLE_LIST, schema_set_get_key> schema_set;
+  Hash_set<TABLE_LIST> schema_set(schema_set_get_key);
   ulong org_lock_wait_timeout= lock_wait_timeout;
   /* Check if we are using CREATE TABLE ... IF NOT EXISTS */
   bool create_table;
@@ -4625,7 +4624,7 @@ lock_table_names(THD *thd,
       Scoped locks: Take intention exclusive locks on all involved
       schemas.
     */
-    Hash_set<TABLE_LIST, schema_set_get_key>::Iterator it(schema_set);
+    Hash_set<TABLE_LIST>::Iterator it(schema_set);
     while ((table= it++))
     {
       MDL_request *schema_request= new (thd->mem_root) MDL_request;

sql/sql_hset.h

@@ -23,19 +23,19 @@
   A type-safe wrapper around mysys HASH.
 */
 
-template <typename T, my_hash_get_key K>
+template <typename T>
 class Hash_set
 {
 public:
-  typedef T Value_type;
   enum { START_SIZE= 8 };
   /**
     Constructs an empty hash. Does not allocate memory, it is done upon
     the first insert. Thus does not cause or return errors.
   */
-  Hash_set()
+  Hash_set(uchar *(*K)(const T *, size_t *, my_bool))
   {
     my_hash_clear(&m_hash);
+    m_hash.get_key= (my_hash_get_key)K;
   }
   /**
     Destroy the hash by freeing the buckets table. Does
@@ -56,13 +56,19 @@ public:
   */
   bool insert(T *value)
   {
-    my_hash_init_opt(&m_hash, &my_charset_bin, START_SIZE, 0, 0, K, 0, MYF(0));
+    my_hash_init_opt(&m_hash, &my_charset_bin, START_SIZE, 0, 0,
+                     m_hash.get_key, 0, MYF(0));
     size_t key_len;
-    const uchar *key= K(reinterpret_cast<uchar*>(value), &key_len, FALSE);
-    if (my_hash_search(&m_hash, key, key_len) == NULL)
-      return my_hash_insert(&m_hash, reinterpret_cast<uchar *>(value));
+    uchar *v= reinterpret_cast<uchar *>(value);
+    const uchar *key= m_hash.get_key(v, &key_len, FALSE);
+    if (find(key, key_len) == NULL)
+      return my_hash_insert(&m_hash, v);
     return FALSE;
   }
+  T *find(const void *key, size_t klen) const
+  {
+    return (T*)my_hash_search(&m_hash, reinterpret_cast<const uchar *>(key), klen);
+  }
   /** Is this hash set empty? */
   bool is_empty() const { return m_hash.records == 0; }
   /** Returns the number of unique elements. */