diff --git a/src/util/inc/hash.h b/src/util/inc/hash.h
index 1bbc8dcf5c229112b421de9a4b5ef4f056a39438..0a2cbe8bafaf645c3c680a2c256b27a86f70a98d 100644
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
@@ -94,7 +94,7 @@ size_t taosHashGetSize(const SHashObj *pHashObj);
  * @param size
  * @return
  */
-int32_t taosHashPut(SHashObj *pHashObj, const char *key, size_t keyLen, void *data, size_t size);
+int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *data, size_t size);
 
 /**
  * return the payload data with the specified key
@@ -104,7 +104,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const char *key, size_t keyLen, void *da
  * @param keyLen
  * @return
  */
-void *taosHashGet(SHashObj *pHashObj, const char *key, size_t keyLen);
+void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen);
 
 /**
  * remove item with the specified key
@@ -112,7 +112,7 @@ void *taosHashGet(SHashObj *pHashObj, const char *key, size_t keyLen);
  * @param key
  * @param keyLen
  */
-void taosHashRemove(SHashObj *pHashObj, const char *key, size_t keyLen);
+void taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen);
 
 /**
  * clean up hash table
diff --git a/src/util/src/hash.c b/src/util/src/hash.c
index 37e8123170b4a88f234d2bdc98735b46b2061b1a..12f7b43b7900dab5b6d4e191e91f5db8f1f145cc 100644
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.c
@@ -17,7 +17,6 @@
 
 #include "hash.h"
 #include "tulog.h"
-#include "ttime.h"
 #include "tutil.h"
 
 static FORCE_INLINE void __wr_lock(void *lock) {
@@ -90,154 +89,65 @@ static FORCE_INLINE int32_t taosHashCapacity(int32_t length) {
 
 /**
  * inplace update node in hash table
- * @param pHashObj      hash table object
- * @param pNode     data node
+ * @param pHashObj  hash table object
+ * @param pNode     hash data node
  */
-static void doUpdateHashTable(SHashObj *pHashObj, SHashNode *pNode) {
-  if (pNode->prev1) {
-    pNode->prev1->next = pNode;
-  }
-
-  if (pNode->next) {
-    (pNode->next)->prev = pNode;
-  }
-}
+static void doUpdateHashTable(SHashObj *pHashObj, SHashNode *pNode);
 
 /**
- * get SHashNode from hashlist, nodes from trash are not included.
+ * Get SHashNode from hashlist, nodes from trash are not included.
  * @param pHashObj  Cache objection
  * @param key       key for hash
  * @param keyLen    key length
+ * @param hashVal   hash value by hash function
  * @return
  */
-static SHashNode *doGetNodeFromHashTable(SHashObj *pHashObj, const char *key, uint32_t keyLen, uint32_t *hashVal) {
-  uint32_t hash = (*pHashObj->hashFp)(key, keyLen);
-
-  int32_t     slot = HASH_INDEX(hash, pHashObj->capacity);
-  SHashEntry *pEntry = pHashObj->hashList[slot];
-
-  SHashNode *pNode = pEntry->next;
-  while (pNode) {
-    if ((pNode->keyLen == keyLen) && (memcmp(pNode->key, key, keyLen) == 0)) {
-      break;
-    }
-
-    pNode = pNode->next;
-  }
-
-  if (pNode) {
-    assert(HASH_INDEX(pNode->hashVal, pHashObj->capacity) == slot);
-  }
-
-  // return the calculated hash value, to avoid calculating it again in other functions
-  if (hashVal != NULL) {
-    *hashVal = hash;
-  }
-
-  return pNode;
-}
+static SHashNode *doGetNodeFromHashTable(SHashObj *pHashObj, const void *key, uint32_t keyLen, uint32_t *hashVal);
 
 /**
- * resize the hash list if the threshold is reached
+ * Resize the hash list if the threshold is reached
  *
  * @param pHashObj
  */
-static void taosHashTableResize(SHashObj *pHashObj) {
-  if (pHashObj->size < pHashObj->capacity * HASH_DEFAULT_LOAD_FACTOR) {
-    return;
-  }
-
-  // double the original capacity
-  SHashNode *pNode = NULL;
-  SHashNode *pNext = NULL;
+static void taosHashTableResize(SHashObj *pHashObj);
 
-  int32_t newSize = pHashObj->capacity << 1u;
-  if (newSize > HASH_MAX_CAPACITY) {
-//    uTrace("current capacity:%d, maximum capacity:%d, no resize applied due to limitation is reached",
-//           pHashObj->capacity, HASH_MAX_CAPACITY);
-    return;
-  }
-
-//  int64_t st = taosGetTimestampUs();
-
-  SHashEntry **pNewEntry = realloc(pHashObj->hashList, sizeof(SHashEntry *) * newSize);
-  if (pNewEntry == NULL) {
-//    uTrace("cache resize failed due to out of memory, capacity remain:%d", pHashObj->capacity);
-    return;
-  }
-
-  pHashObj->hashList = pNewEntry;
-  for (int32_t i = pHashObj->capacity; i < newSize; ++i) {
-    pHashObj->hashList[i] = calloc(1, sizeof(SHashEntry));
-  }
-
-  pHashObj->capacity = newSize;
-
-  for (int32_t i = 0; i < pHashObj->capacity; ++i) {
-    SHashEntry *pEntry = pHashObj->hashList[i];
-
-    pNode = pEntry->next;
-    if (pNode != NULL) {
-      assert(pNode->prev1 == pEntry && pEntry->num > 0);
-    }
-
-    while (pNode) {
-      int32_t j = HASH_INDEX(pNode->hashVal, pHashObj->capacity);
-      if (j == i) {  // this key resides in the same slot, no need to relocate it
-        pNode = pNode->next;
-      } else {
-        pNext = pNode->next;
-
-        // remove from current slot
-        assert(pNode->prev1 != NULL);
-
-        if (pNode->prev1 == pEntry) {  // first node of the overflow linked list
-          pEntry->next = pNode->next;
-        } else {
-          pNode->prev->next = pNode->next;
-        }
-
-        pEntry->num--;
-        assert(pEntry->num >= 0);
-
-        if (pNode->next != NULL) {
-          (pNode->next)->prev = pNode->prev;
-        }
-
-        // added into new slot
-        pNode->next = NULL;
-        pNode->prev1 = NULL;
-
-        SHashEntry *pNewIndexEntry = pHashObj->hashList[j];
-
-        if (pNewIndexEntry->next != NULL) {
-          assert(pNewIndexEntry->next->prev1 == pNewIndexEntry);
-
-          pNewIndexEntry->next->prev = pNode;
-        }
-
-        pNode->next = pNewIndexEntry->next;
-        pNode->prev1 = pNewIndexEntry;
-
-        pNewIndexEntry->next = pNode;
-        pNewIndexEntry->num++;
+/**
+ * @param key      key of object for hash, usually a null-terminated string
+ * @param keyLen   length of key
+ * @param pData    actually data. Requires a consecutive memory block, no pointer is allowed in pData.
+ *                 Pointer copy causes memory access error.
+ * @param dsize    size of data
+ * @return         SHashNode
+ */
+static SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal);
 
-        // continue
-        pNode = pNext;
-      }
-    }
-  }
+/**
+ * Update the hash node
+ *
+ * @param pNode   hash node
+ * @param key     key for generate hash value
+ * @param keyLen  key length
+ * @param pData   actual data
+ * @param dsize   size of actual data
+ * @return        hash node
+ */
+static SHashNode *doUpdateHashNode(SHashNode *pNode, const void *key, size_t keyLen, const void *pData, size_t dsize);
 
-//  int64_t et = taosGetTimestampUs();
-//  uTrace("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", pHashObj->capacity,
-//         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
-}
+/**
+ * insert the hash node at the front of the linked list
+ *
+ * @param pHashObj
+ * @param pNode
+ */
+static void doAddToHashTable(SHashObj *pHashObj, SHashNode *pNode);
 
 /**
- * @param capacity maximum slots available for hash elements
- * @param fn       hash function
+ * Get the next element in hash table for iterator
+ * @param pIter
  * @return
  */
+static SHashNode *getNextHashNode(SHashMutableIterator *pIter);
+
 SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool threadsafe) {
   if (capacity == 0 || fn == NULL) {
     return NULL;
@@ -285,79 +195,6 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool threadsafe) {
   return pHashObj;
 }
 
-/**
- * @param key      key of object for hash, usually a null-terminated string
- * @param keyLen   length of key
- * @param pData    actually data. required a consecutive memory block, no pointer is allowed
- *                 in pData. Pointer copy causes memory access error.
- * @param size     size of block
- * @return         SHashNode
- */
-static SHashNode *doCreateHashNode(const char *key, size_t keyLen, const char *pData, size_t dataSize,
-                                   uint32_t hashVal) {
-  size_t totalSize = dataSize + sizeof(SHashNode) + keyLen + 1;  // one extra byte for null
-
-  SHashNode *pNewNode = calloc(1, totalSize);
-  if (pNewNode == NULL) {
-    uError("failed to allocate memory, reason:%s", strerror(errno));
-    return NULL;
-  }
-
-  memcpy(pNewNode->data, pData, dataSize);
-
-  pNewNode->key = pNewNode->data + dataSize;
-  memcpy(pNewNode->key, key, keyLen);
-  pNewNode->keyLen = keyLen;
-
-  pNewNode->hashVal = hashVal;
-
-  return pNewNode;
-}
-
-static SHashNode *doUpdateHashNode(SHashNode *pNode, const char *key, size_t keyLen, const char *pData,
-                                   size_t dataSize) {
-  size_t size = dataSize + sizeof(SHashNode) + keyLen;
-
-  SHashNode *pNewNode = (SHashNode *)realloc(pNode, size);
-  if (pNewNode == NULL) {
-    return NULL;
-  }
-
-  memcpy(pNewNode->data, pData, dataSize);
-
-  pNewNode->key = pNewNode->data + dataSize;
-
-  assert(memcmp(pNewNode->key, key, keyLen) == 0 && keyLen == pNewNode->keyLen);
-
-  memcpy(pNewNode->key, key, keyLen);
-  return pNewNode;
-}
-
-/**
- * insert the hash node at the front of the linked list
- *
- * @param pHashObj
- * @param pNode
- */
-static void doAddToHashTable(SHashObj *pHashObj, SHashNode *pNode) {
-  assert(pNode != NULL);
-
-  int32_t     index = HASH_INDEX(pNode->hashVal, pHashObj->capacity);
-  SHashEntry *pEntry = pHashObj->hashList[index];
-
-  pNode->next = pEntry->next;
-
-  if (pEntry->next) {
-    pEntry->next->prev = pNode;
-  }
-
-  pEntry->next = pNode;
-  pNode->prev1 = pEntry;
-
-  pEntry->num++;
-  pHashObj->size++;
-}
-
 size_t taosHashGetSize(const SHashObj *pHashObj) {
   if (pHashObj == NULL) {
     return 0;
@@ -366,12 +203,7 @@ size_t taosHashGetSize(const SHashObj *pHashObj) {
   return pHashObj->size;
 }
 
-/**
- * add data node into hash table
- * @param pHashObj    hash object
- * @param pNode   hash node
- */
-int32_t taosHashPut(SHashObj *pHashObj, const char *key, size_t keyLen, void *data, size_t size) {
+int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *data, size_t size) {
   __wr_lock(pHashObj->lock);
 
   uint32_t   hashVal = 0;
@@ -402,7 +234,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const char *key, size_t keyLen, void *da
   return 0;
 }
 
-void *taosHashGet(SHashObj *pHashObj, const char *key, size_t keyLen) {
+void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen) {
   __rd_lock(pHashObj->lock);
 
   uint32_t   hashVal = 0;
@@ -419,12 +251,7 @@ void *taosHashGet(SHashObj *pHashObj, const char *key, size_t keyLen) {
   }
 }
 
-/**
- * remove node in hash list
- * @param pHashObj
- * @param pNode
- */
-void taosHashRemove(SHashObj *pHashObj, const char *key, size_t keyLen) {
+void taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) {
   __wr_lock(pHashObj->lock);
 
   uint32_t   val = 0;
@@ -518,23 +345,6 @@ SHashMutableIterator *taosHashCreateIter(SHashObj *pHashObj) {
   return pIter;
 }
 
-static SHashNode *getNextHashNode(SHashMutableIterator *pIter) {
-  assert(pIter != NULL);
-
-  pIter->entryIndex++;
-  while (pIter->entryIndex < pIter->pHashObj->capacity) {
-    SHashEntry *pEntry = pIter->pHashObj->hashList[pIter->entryIndex];
-    if (pEntry->next == NULL) {
-      pIter->entryIndex++;
-      continue;
-    }
-
-    return pEntry->next;
-  }
-
-  return NULL;
-}
-
 bool taosHashIterNext(SHashMutableIterator *pIter) {
   if (pIter == NULL) {
     return false;
@@ -617,3 +427,205 @@ int32_t taosHashGetMaxOverflowLinkLength(const SHashObj *pHashObj) {
 
   return num;
 }
+
+void doUpdateHashTable(SHashObj *pHashObj, SHashNode *pNode) {
+  if (pNode->prev1) {
+    pNode->prev1->next = pNode;
+  }
+  
+  if (pNode->next) {
+    (pNode->next)->prev = pNode;
+  }
+}
+
+SHashNode *doGetNodeFromHashTable(SHashObj *pHashObj, const void *key, uint32_t keyLen, uint32_t *hashVal) {
+  uint32_t hash = (*pHashObj->hashFp)(key, keyLen);
+  
+  int32_t     slot = HASH_INDEX(hash, pHashObj->capacity);
+  SHashEntry *pEntry = pHashObj->hashList[slot];
+  
+  SHashNode *pNode = pEntry->next;
+  while (pNode) {
+    if ((pNode->keyLen == keyLen) && (memcmp(pNode->key, key, keyLen) == 0)) {
+      break;
+    }
+    
+    pNode = pNode->next;
+  }
+  
+  if (pNode) {
+    assert(HASH_INDEX(pNode->hashVal, pHashObj->capacity) == slot);
+  }
+  
+  // return the calculated hash value, to avoid calculating it again in other functions
+  if (hashVal != NULL) {
+    *hashVal = hash;
+  }
+  
+  return pNode;
+}
+
+void taosHashTableResize(SHashObj *pHashObj) {
+  if (pHashObj->size < pHashObj->capacity * HASH_DEFAULT_LOAD_FACTOR) {
+    return;
+  }
+  
+  // double the original capacity
+  SHashNode *pNode = NULL;
+  SHashNode *pNext = NULL;
+  
+  int32_t newSize = pHashObj->capacity << 1u;
+  if (newSize > HASH_MAX_CAPACITY) {
+//    uTrace("current capacity:%d, maximum capacity:%d, no resize applied due to limitation is reached",
+//           pHashObj->capacity, HASH_MAX_CAPACITY);
+    return;
+  }
+
+//  int64_t st = taosGetTimestampUs();
+  
+  SHashEntry **pNewEntry = realloc(pHashObj->hashList, sizeof(SHashEntry *) * newSize);
+  if (pNewEntry == NULL) {
+//    uTrace("cache resize failed due to out of memory, capacity remain:%d", pHashObj->capacity);
+    return;
+  }
+  
+  pHashObj->hashList = pNewEntry;
+  for (int32_t i = pHashObj->capacity; i < newSize; ++i) {
+    pHashObj->hashList[i] = calloc(1, sizeof(SHashEntry));
+  }
+  
+  pHashObj->capacity = newSize;
+  
+  for (int32_t i = 0; i < pHashObj->capacity; ++i) {
+    SHashEntry *pEntry = pHashObj->hashList[i];
+    
+    pNode = pEntry->next;
+    if (pNode != NULL) {
+      assert(pNode->prev1 == pEntry && pEntry->num > 0);
+    }
+    
+    while (pNode) {
+      int32_t j = HASH_INDEX(pNode->hashVal, pHashObj->capacity);
+      if (j == i) {  // this key resides in the same slot, no need to relocate it
+        pNode = pNode->next;
+      } else {
+        pNext = pNode->next;
+        
+        // remove from current slot
+        assert(pNode->prev1 != NULL);
+        
+        if (pNode->prev1 == pEntry) {  // first node of the overflow linked list
+          pEntry->next = pNode->next;
+        } else {
+          pNode->prev->next = pNode->next;
+        }
+        
+        pEntry->num--;
+        assert(pEntry->num >= 0);
+        
+        if (pNode->next != NULL) {
+          (pNode->next)->prev = pNode->prev;
+        }
+        
+        // added into new slot
+        pNode->next = NULL;
+        pNode->prev1 = NULL;
+        
+        SHashEntry *pNewIndexEntry = pHashObj->hashList[j];
+        
+        if (pNewIndexEntry->next != NULL) {
+          assert(pNewIndexEntry->next->prev1 == pNewIndexEntry);
+          
+          pNewIndexEntry->next->prev = pNode;
+        }
+        
+        pNode->next = pNewIndexEntry->next;
+        pNode->prev1 = pNewIndexEntry;
+        
+        pNewIndexEntry->next = pNode;
+        pNewIndexEntry->num++;
+        
+        // continue
+        pNode = pNext;
+      }
+    }
+  }
+
+//  int64_t et = taosGetTimestampUs();
+//  uTrace("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", pHashObj->capacity,
+//         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
+}
+
+SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal) {
+  size_t totalSize = dsize + sizeof(SHashNode) + keyLen + 1;  // one extra byte for null
+  
+  SHashNode *pNewNode = calloc(1, totalSize);
+  if (pNewNode == NULL) {
+    uError("failed to allocate memory, reason:%s", strerror(errno));
+    return NULL;
+  }
+  
+  memcpy(pNewNode->data, pData, dsize);
+  
+  pNewNode->key = pNewNode->data + dsize;
+  memcpy(pNewNode->key, key, keyLen);
+  pNewNode->keyLen = keyLen;
+  
+  pNewNode->hashVal = hashVal;
+  
+  return pNewNode;
+}
+
+SHashNode *doUpdateHashNode(SHashNode *pNode, const void *key, size_t keyLen, const void *pData, size_t dsize) {
+  size_t size = dsize + sizeof(SHashNode) + keyLen;
+  
+  SHashNode *pNewNode = (SHashNode *)realloc(pNode, size);
+  if (pNewNode == NULL) {
+    return NULL;
+  }
+  
+  memcpy(pNewNode->data, pData, dsize);
+  
+  pNewNode->key = pNewNode->data + dsize;
+  
+  assert(memcmp(pNewNode->key, key, keyLen) == 0 && keyLen == pNewNode->keyLen);
+  
+  memcpy(pNewNode->key, key, keyLen);
+  return pNewNode;
+}
+
+void doAddToHashTable(SHashObj *pHashObj, SHashNode *pNode) {
+  assert(pNode != NULL);
+  
+  int32_t     index = HASH_INDEX(pNode->hashVal, pHashObj->capacity);
+  SHashEntry *pEntry = pHashObj->hashList[index];
+  
+  pNode->next = pEntry->next;
+  
+  if (pEntry->next) {
+    pEntry->next->prev = pNode;
+  }
+  
+  pEntry->next = pNode;
+  pNode->prev1 = pEntry;
+  
+  pEntry->num++;
+  pHashObj->size++;
+}
+
+SHashNode *getNextHashNode(SHashMutableIterator *pIter) {
+  assert(pIter != NULL);
+  
+  pIter->entryIndex++;
+  while (pIter->entryIndex < pIter->pHashObj->capacity) {
+    SHashEntry *pEntry = pIter->pHashObj->hashList[pIter->entryIndex];
+    if (pEntry->next == NULL) {
+      pIter->entryIndex++;
+      continue;
+    }
+    
+    return pEntry->next;
+  }
+  
+  return NULL;
+}