Merge pull request #27396 from taosdata/fix/TD-TD-31538-4

enh: clear useless asserts

include/util/texception.h

@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_UTIL_EXCEPTION_H_
-#define _TD_UTIL_EXCEPTION_H_
-
-#include "os.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * cleanup actions
- */
-typedef struct SCleanupAction {
-  bool     failOnly;
-  uint8_t  wrapper;
-  uint16_t reserved;
-  void*    func;
-  union {
-    void*    Ptr;
-    bool     Bool;
-    char     Char;
-    int8_t   Int8;
-    uint8_t  Uint8;
-    int16_t  Int16;
-    uint16_t Uint16;
-    int32_t  Int;
-    uint32_t Uint;
-    int32_t  Int32;
-    uint32_t Uint32;
-    int64_t  Int64;
-    uint64_t Uint64;
-    float    Float;
-    double   Double;
-  } arg1, arg2;
-} SCleanupAction;
-
-/*
- * exception hander registration
- */
-typedef struct SExceptionNode {
-  struct SExceptionNode* prev;
-  jmp_buf                jb;
-  int32_t                code;
-  int32_t                maxCleanupAction;
-  int32_t                numCleanupAction;
-  SCleanupAction*        cleanupActions;
-} SExceptionNode;
-
-// functions & macros for auto-cleanup
-
-void cleanupPush_void_ptr_ptr(bool failOnly, void* func, void* arg1, void* arg2);
-void cleanupPush_void_ptr_bool(bool failOnly, void* func, void* arg1, bool arg2);
-void cleanupPush_void_ptr(bool failOnly, void* func, void* arg);
-void cleanupPush_int_int(bool failOnly, void* func, int32_t arg);
-void cleanupPush_void(bool failOnly, void* func);
-void cleanupPush_int_ptr(bool failOnly, void* func, void* arg);
-
-int32_t cleanupGetActionCount();
-void    cleanupExecuteTo(int32_t anchor, bool failed);
-void    cleanupExecute(SExceptionNode* node, bool failed);
-bool    cleanupExceedLimit();
-
-#define CLEANUP_PUSH_VOID_PTR_PTR(failOnly, func, arg1, arg2) \
-  cleanupPush_void_ptr_ptr((failOnly), (void*)(func), (void*)(arg1), (void*)(arg2))
-#define CLEANUP_PUSH_VOID_PTR_BOOL(failOnly, func, arg1, arg2) \
-  cleanupPush_void_ptr_bool((failOnly), (void*)(func), (void*)(arg1), (bool)(arg2))
-#define CLEANUP_PUSH_VOID_PTR(failOnly, func, arg) cleanupPush_void_ptr((failOnly), (void*)(func), (void*)(arg))
-#define CLEANUP_PUSH_INT_INT(failOnly, func, arg)  cleanupPush_void_ptr((failOnly), (void*)(func), (int32_t)(arg))
-#define CLEANUP_PUSH_VOID(failOnly, func)          cleanupPush_void((failOnly), (void*)(func))
-#define CLEANUP_PUSH_INT_PTR(failOnly, func, arg)  cleanupPush_int_ptr((failOnly), (void*)(func), (void*)(arg))
-#define CLEANUP_PUSH_FREE(failOnly, arg)           cleanupPush_void_ptr((failOnly), free, (void*)(arg))
-#define CLEANUP_PUSH_CLOSE(failOnly, arg)          cleanupPush_int_int((failOnly), close, (int32_t)(arg))
-#define CLEANUP_PUSH_FCLOSE(failOnly, arg)         cleanupPush_int_ptr((failOnly), fclose, (void*)(arg))
-
-#define CLEANUP_GET_ANCHOR()               cleanupGetActionCount()
-#define CLEANUP_EXECUTE_TO(anchor, failed) cleanupExecuteTo((anchor), (failed))
-#define CLEANUP_EXCEED_LIMIT()             cleanupExceedLimit()
-
-// functions & macros for exception handling
-
-void    exceptionPushNode(SExceptionNode* node);
-int32_t exceptionPopNode();
-void    exceptionThrow(int32_t code);
-
-#define TRY(maxCleanupActions)                                                          \
-  do {                                                                                  \
-    SExceptionNode exceptionNode = {0};                                                 \
-    SCleanupAction cleanupActions[(maxCleanupActions) > 0 ? (maxCleanupActions) : 1];   \
-    exceptionNode.maxCleanupAction = (maxCleanupActions) > 0 ? (maxCleanupActions) : 1; \
-    exceptionNode.cleanupActions = cleanupActions;                                      \
-    exceptionPushNode(&exceptionNode);                                                  \
-    int32_t caughtException = setjmp(exceptionNode.jb);                                 \
-    if (caughtException == 0)
-
-#define CATCH(code)                  \
-  int32_t code = exceptionPopNode(); \
-  if (caughtException == 1)
-
-#define FINALLY(code) int32_t code = exceptionPopNode();
-
-#define END_TRY \
-  }             \
-  while (0)     \
-    ;
-
-#define THROW(x)           exceptionThrow((x))
-#define CAUGHT_EXCEPTION() ((bool)(caughtException == 1))
-#define CLEANUP_EXECUTE()  cleanupExecute(&exceptionNode, CAUGHT_EXCEPTION())
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_EXCEPTION_H_*/

source/dnode/vnode/src/meta/metaCache.c

@@ -512,7 +512,6 @@ static void initCacheKey(uint64_t* buf, const SHashObj* pHashMap, uint64_t suid,
   buf[0] = (uint64_t)pHashMap;
   buf[1] = suid;
   setMD5DigestInKey(buf, key, keyLen);
-  ASSERT(keyLen == sizeof(uint64_t) * 2);
 }
 
 int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray* pList1,

source/dnode/vnode/src/meta/metaQuery.c

@@ -673,7 +673,7 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv
     }
   }
 
-  if (ASSERTS(sver > 0, "failed to get table schema version: %d", sver)) {
+  if (!(sver > 0)) {
     code = TSDB_CODE_NOT_FOUND;
     goto _exit;
   }
@@ -1608,8 +1608,6 @@ int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables, int32_t
     metaULock(pVnodeObj->pMeta);
     if (numOfTables) *numOfTables = state.ctbNum;
     if (numOfCols) *numOfCols = state.colNum;
-    ASSERTS(state.colNum > 0, "vgId:%d, suid:%" PRIi64 " nCols:%d <= 0 in metaCache", TD_VID(pVnodeObj), uid,
-            state.colNum);
     goto _exit;
   }
 

source/util/src/tarray.c

@@ -266,9 +266,10 @@ void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
 }
 
 void taosArraySet(SArray* pArray, size_t index, void* pData) {
-  ASSERT(index < pArray->size);
+  if (index < pArray->size) {
     memcpy(TARRAY_GET_ELEM(pArray, index), pData, pArray->elemSize);
   }
+}
 
 void taosArrayPopFrontBatch(SArray* pArray, size_t cnt) {
   if (cnt > pArray->size) {
@@ -291,7 +292,9 @@ void taosArrayPopTailBatch(SArray* pArray, size_t cnt) {
 }
 
 void taosArrayRemove(SArray* pArray, size_t index) {
-  ASSERT(index < pArray->size);
+  if (!(index < pArray->size)) {
+    return;
+  }
 
   if (index == pArray->size - 1) {
     (void)taosArrayPop(pArray);
@@ -305,8 +308,7 @@ void taosArrayRemove(SArray* pArray, size_t index) {
 }
 
 void taosArrayRemoveBatch(SArray* pArray, size_t index, size_t num, FDelete fp) {
-  ASSERT(index + num <= pArray->size);
+  if (index + num <= pArray->size) {
-
     if (fp) {
       for (int32_t i = 0; i < num; i++) {
         fp(taosArrayGet(pArray, index + i));
@@ -317,6 +319,7 @@ void taosArrayRemoveBatch(SArray* pArray, size_t index, size_t num, FDelete fp)
             (pArray->size - index - num) * pArray->elemSize);
     pArray->size -= num;
   }
+}
 
 SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
   if (elemSize <= 0) {
@@ -349,8 +352,6 @@ SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
     if (fn == NULL) {
       memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
     } else {
-      ASSERT(pSrc->elemSize == sizeof(void*));
-
       for (int32_t i = 0; i < pSrc->size; ++i) {
         void* p = fn(taosArrayGetP(pSrc, i));
         memcpy(((char*)dst->pData) + i * dst->elemSize, &p, dst->elemSize);

source/util/src/tbloomfilter.c

@@ -78,7 +78,9 @@ _error:
 }
 
 int32_t tBloomFilterPutHash(SBloomFilter* pBF, uint64_t hash1, uint64_t hash2) {
-  ASSERT(!tBloomFilterIsFull(pBF));
+  if (tBloomFilterIsFull(pBF)) {
+    return TSDB_CODE_FAILED;
+  }
   bool                    hasChange = false;
   const register uint64_t size = pBF->numBits;
   uint64_t                cbHash = hash1;

source/util/src/tconfig.c

@@ -121,7 +121,9 @@ int32_t cfgGetSize(SConfig *pCfg) { return taosArrayGetSize(pCfg->array); }
 
 static int32_t cfgCheckAndSetConf(SConfigItem *pItem, const char *conf) {
   cfgItemFreeVal(pItem);
-  ASSERT(pItem->str == NULL);
+  if (!(pItem->str == NULL)) {
+    return TSDB_CODE_INVALID_PARA;
+  }
 
   pItem->str = taosStrdup(conf);
   if (pItem->str == NULL) {

source/util/src/tdigest.c

@@ -143,24 +143,20 @@ int32_t tdigestCompress(TDigest *t) {
 
     if (a->mean <= b->mean) {
       mergeCentroid(&args, a);
-      ASSERTS(args.idx < t->size, "idx over size");
       i++;
     } else {
       mergeCentroid(&args, b);
-      ASSERTS(args.idx < t->size, "idx over size");
       j++;
     }
   }
 
   while (i < num_unmerged) {
     mergeCentroid(&args, &unmerged_centroids[i++]);
-    ASSERTS(args.idx < t->size, "idx over size");
   }
   taosMemoryFree((void *)unmerged_centroids);
 
   while (j < t->num_centroids) {
     mergeCentroid(&args, &t->centroids[j++]);
-    ASSERTS(args.idx < t->size, "idx over size");
   }
 
   if (t->total_weight > 0) {

source/util/src/tencode.c

@@ -104,7 +104,6 @@ void tEndEncode(SEncoder* pCoder) {
 
   if (pCoder->data) {
     pNode = pCoder->eStack;
-    ASSERT(pNode);
     pCoder->eStack = pNode->pNext;
 
     len = pCoder->pos;
@@ -148,7 +147,6 @@ void tEndDecode(SDecoder* pCoder) {
   SDecoderNode* pNode;
 
   pNode = pCoder->dStack;
-  ASSERT(pNode);
   pCoder->dStack = pNode->pNext;
 
   pCoder->data = pNode->data;

source/util/src/texception.c

@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "texception.h"
-#include "tlog.h"
-
-static threadlocal SExceptionNode* expList;
-
-void exceptionPushNode(SExceptionNode* node) {
-  node->prev = expList;
-  expList = node;
-}
-
-int32_t exceptionPopNode() {
-  SExceptionNode* node = expList;
-  expList = node->prev;
-  return node->code;
-}
-
-void exceptionThrow(int32_t code) {
-  expList->code = code;
-  longjmp(expList->jb, 1);
-}
-
-static void cleanupWrapper_void_ptr_ptr(SCleanupAction* ca) {
-  void (*func)(void*, void*) = ca->func;
-  func(ca->arg1.Ptr, ca->arg2.Ptr);
-}
-
-static void cleanupWrapper_void_ptr_bool(SCleanupAction* ca) {
-  void (*func)(void*, bool) = ca->func;
-  func(ca->arg1.Ptr, ca->arg2.Bool);
-}
-
-static void cleanupWrapper_void_ptr(SCleanupAction* ca) {
-  void (*func)(void*) = ca->func;
-  func(ca->arg1.Ptr);
-}
-
-static void cleanupWrapper_int_int(SCleanupAction* ca) {
-  int32_t (*func)(int32_t) = ca->func;
-  (void)func(ca->arg1.Int);
-}
-
-static void cleanupWrapper_void(SCleanupAction* ca) {
-  void (*func)() = ca->func;
-  func();
-}
-
-static void cleanupWrapper_int_ptr(SCleanupAction* ca) {
-  int32_t (*func)(void*) = ca->func;
-  (void)func(ca->arg1.Ptr);
-}
-
-typedef void (*wrapper)(SCleanupAction*);
-static wrapper wrappers[] = {
-    cleanupWrapper_void_ptr_ptr, cleanupWrapper_void_ptr_bool, cleanupWrapper_void_ptr,
-    cleanupWrapper_int_int,      cleanupWrapper_void,          cleanupWrapper_int_ptr,
-};
-
-void cleanupPush_void_ptr_ptr(bool failOnly, void* func, void* arg1, void* arg2) {
-  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
-
-  SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
-  ca->wrapper = 0;
-  ca->failOnly = failOnly;
-  ca->func = func;
-  ca->arg1.Ptr = arg1;
-  ca->arg2.Ptr = arg2;
-}
-
-void cleanupPush_void_ptr_bool(bool failOnly, void* func, void* arg1, bool arg2) {
-  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
-
-  SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
-  ca->wrapper = 1;
-  ca->failOnly = failOnly;
-  ca->func = func;
-  ca->arg1.Ptr = arg1;
-  ca->arg2.Bool = arg2;
-}
-
-void cleanupPush_void_ptr(bool failOnly, void* func, void* arg) {
-  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
-
-  SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
-  ca->wrapper = 2;
-  ca->failOnly = failOnly;
-  ca->func = func;
-  ca->arg1.Ptr = arg;
-}
-
-void cleanupPush_int_int(bool failOnly, void* func, int32_t arg) {
-  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
-
-  SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
-  ca->wrapper = 3;
-  ca->failOnly = failOnly;
-  ca->func = func;
-  ca->arg1.Int = arg;
-}
-
-void cleanupPush_void(bool failOnly, void* func) {
-  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
-
-  SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
-  ca->wrapper = 4;
-  ca->failOnly = failOnly;
-  ca->func = func;
-}
-
-void cleanupPush_int_ptr(bool failOnly, void* func, void* arg) {
-  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
-
-  SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
-  ca->wrapper = 5;
-  ca->failOnly = failOnly;
-  ca->func = func;
-  ca->arg1.Ptr = arg;
-}
-
-int32_t cleanupGetActionCount() { return expList->numCleanupAction; }
-
-static void doExecuteCleanup(SExceptionNode* node, int32_t anchor, bool failed) {
-  while (node->numCleanupAction > anchor) {
-    --node->numCleanupAction;
-    SCleanupAction* ca = node->cleanupActions + node->numCleanupAction;
-    if (failed || !(ca->failOnly)) {
-      wrappers[ca->wrapper](ca);
-    }
-  }
-}
-
-void cleanupExecuteTo(int32_t anchor, bool failed) { doExecuteCleanup(expList, anchor, failed); }
-
-void cleanupExecute(SExceptionNode* node, bool failed) { doExecuteCleanup(node, 0, failed); }
-bool cleanupExceedLimit() { return expList->numCleanupAction >= expList->maxCleanupAction; }

source/util/src/thash.c

@@ -191,14 +191,12 @@ static FORCE_INLINE void doUpdateHashNode(SHashObj *pHashObj, SHashEntry *pe, SH
   (void)atomic_sub_fetch_16(&pNode->refCount, 1);
   if (prev != NULL) {
     prev->next = pNewNode;
-    ASSERT(prev->next != prev);
   } else {
     pe->next = pNewNode;
   }
 
   if (pNode->refCount <= 0) {
     pNewNode->next = pNode->next;
-    ASSERT(pNewNode->next != pNewNode);
 
     FREE_HASH_NODE(pHashObj->freeFp, pNode);
   } else {
@@ -508,7 +506,6 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) {
           pe->next = pNode->next;
         } else {
           prevNode->next = pNode->next;
-          ASSERT(prevNode->next != prevNode);
         }
 
         pe->num--;
@@ -759,12 +756,10 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) {
     if (pOld->refCount <= 0) {
       if (prevNode) {
         prevNode->next = pOld->next;
-        ASSERT(prevNode->next != prevNode);
       } else {
         pe->next = pOld->next;
         SHashNode *x = pe->next;
         if (x != NULL) {
-          ASSERT(x->next != x);
         }
       }
 

source/util/src/tpagedbuf.c

@@ -2,8 +2,8 @@
 #include "tpagedbuf.h"
 #include "taoserror.h"
 #include "tcompression.h"
-#include "tsimplehash.h"
 #include "tlog.h"
+#include "tsimplehash.h"
 
 #define GET_PAYLOAD_DATA(_p)           ((char*)(_p)->pData + POINTER_BYTES)
 #define BUF_PAGE_IN_MEM(_p)            ((_p)->pData != NULL)
@@ -95,7 +95,8 @@ static int32_t doDecompressData(void* data, int32_t srcSize, int32_t* dst, SDisk
   } else if (*dst < 0) {
     return terrno;
   }
-  return code;;
+  return code;
+  ;
 }
 
 static uint64_t allocateNewPositionInFile(SDiskbasedBuf* pBuf, size_t size) {
@@ -300,7 +301,6 @@ static SListNode* getEldestUnrefedPage(SDiskbasedBuf* pBuf) {
     SPageInfo* pageInfo = *(SPageInfo**)pn->data;
 
     SPageInfo* p = *(SPageInfo**)(pageInfo->pData);
-    ASSERT(pageInfo->pageId >= 0 && pageInfo->pn == pn && p == pageInfo);
 
     if (!pageInfo->used) {
       break;
@@ -538,8 +538,6 @@ void* getBufPage(SDiskbasedBuf* pBuf, int32_t id) {
 #endif
     return (void*)(GET_PAYLOAD_DATA(*pi));
   } else {  // not in memory
-    ASSERT((!BUF_PAGE_IN_MEM(*pi)) && (*pi)->pn == NULL &&
-           (((*pi)->length >= 0 && (*pi)->offset >= 0) || ((*pi)->length == -1 && (*pi)->offset == -1)));
 
     bool newPage = false;
     (*pi)->pData = doExtractPage(pBuf, &newPage);

source/util/src/trbtree.c

@@ -263,7 +263,6 @@ static void rbtree_delete_fixup(rbtree_t *rbtree, rbnode_t *child, rbnode_t *chi
     child_parent->color = BLACK;
     return;
   }
-  ASSERTS(sibling != RBTREE_NULL, "sibling is NULL");
 
   /* get a new sibling, by rotating at sibling. See which child
      of sibling is red */
@@ -293,11 +292,9 @@ static void rbtree_delete_fixup(rbtree_t *rbtree, rbnode_t *child, rbnode_t *chi
   sibling->color = child_parent->color;
   child_parent->color = BLACK;
   if (child_parent->right == child) {
-    ASSERTS(sibling->left->color == RED, "slibing->left->color=%d not equal RED", sibling->left->color);
     sibling->left->color = BLACK;
     rbtree_rotate_right(rbtree, child_parent);
   } else {
-    ASSERTS(sibling->right->color == RED, "slibing->right->color=%d not equal RED", sibling->right->color);
     sibling->right->color = BLACK;
     rbtree_rotate_left(rbtree, child_parent);
   }
@@ -320,18 +317,15 @@ static void swap_np(rbnode_t **x, rbnode_t **y) {
 /** Update parent pointers of child trees of 'parent' */
 static void change_parent_ptr(rbtree_t *rbtree, rbnode_t *parent, rbnode_t *old, rbnode_t *new) {
   if (parent == RBTREE_NULL) {
-    ASSERTS(rbtree->root == old, "root not equal old");
     if (rbtree->root == old) rbtree->root = new;
     return;
   }
-  ASSERT(parent->left == old || parent->right == old || parent->left == new || parent->right == new);
   if (parent->left == old) parent->left = new;
   if (parent->right == old) parent->right = new;
 }
 /** Update parent pointer of a node 'child' */
 static void change_child_ptr(rbtree_t *rbtree, rbnode_t *child, rbnode_t *old, rbnode_t *new) {
   if (child == RBTREE_NULL) return;
-  ASSERT(child->parent == old || child->parent == new);
   if (child->parent == old) child->parent = new;
 }
 
@@ -376,7 +370,6 @@ rbnode_t *rbtree_delete(rbtree_t *rbtree, void *key) {
 
     /* now delete to_delete (which is at the location where the smright previously was) */
   }
-  ASSERT(to_delete->left == RBTREE_NULL || to_delete->right == RBTREE_NULL);
 
   if (to_delete->left != RBTREE_NULL)
     child = to_delete->left;

source/util/src/tsimplehash.c

@@ -262,7 +262,6 @@ static FORCE_INLINE SHNode *doSearchInEntryList(SSHashObj *pHashObj, const void
   SHNode *pNode = pHashObj->hashList[index];
   while (pNode) {
     const char *p = GET_SHASH_NODE_KEY(pNode, pNode->dataLen);
-    ASSERT(keyLen > 0);
 
     if (pNode->keyLen == keyLen && ((*(pHashObj->equalFp))(p, key, keyLen) == 0)) {
       break;

source/util/src/tskiplist.c

@@ -366,51 +366,6 @@ void *tSkipListDestroyIter(SSkipListIterator *iter) {
   return NULL;
 }
 
-#ifdef BUILD_NO_CALL
-void tSkipListPrint(SSkipList *pSkipList, int16_t nlevel) {
-  if (pSkipList == NULL || pSkipList->level < nlevel || nlevel <= 0) {
-    return;
-  }
-
-  SSkipListNode *p = SL_NODE_GET_FORWARD_POINTER(pSkipList->pHead, nlevel - 1);
-
-  int32_t id = 1;
-  char   *prev = NULL;
-
-  while (p != pSkipList->pTail) {
-    char *key = SL_GET_NODE_KEY(pSkipList, p);
-    if (prev != NULL) {
-      ASSERT(pSkipList->comparFn(prev, key) < 0);
-    }
-
-    switch (pSkipList->type) {
-      case TSDB_DATA_TYPE_INT:
-        fprintf(stdout, "%d: %d\n", id++, *(int32_t *)key);
-        break;
-      case TSDB_DATA_TYPE_SMALLINT:
-      case TSDB_DATA_TYPE_TINYINT:
-      case TSDB_DATA_TYPE_BIGINT:
-        fprintf(stdout, "%d: %" PRId64 " \n", id++, *(int64_t *)key);
-        break;
-      case TSDB_DATA_TYPE_BINARY:
-      case TSDB_DATA_TYPE_VARBINARY:
-      case TSDB_DATA_TYPE_GEOMETRY:
-        fprintf(stdout, "%d: %s \n", id++, key);
-        break;
-      case TSDB_DATA_TYPE_DOUBLE:
-        fprintf(stdout, "%d: %lf \n", id++, *(double *)key);
-        break;
-      default:
-        fprintf(stdout, "\n");
-    }
-
-    prev = SL_GET_NODE_KEY(pSkipList, p);
-
-    p = SL_NODE_GET_FORWARD_POINTER(p, nlevel - 1);
-  }
-}
-#endif
-
 static void tSkipListDoInsert(SSkipList *pSkipList, SSkipListNode **direction, SSkipListNode *pNode, bool isForward) {
   for (int32_t i = 0; i < pNode->level; ++i) {
     SSkipListNode *x = direction[i];
@@ -538,33 +493,6 @@ static bool tSkipListGetPosToPut(SSkipList *pSkipList, SSkipListNode **backward,
   return hasDupKey;
 }
 
-#ifdef BUILD_NO_CALL
-static void tSkipListRemoveNodeImpl(SSkipList *pSkipList, SSkipListNode *pNode) {
-  int32_t level = pNode->level;
-  uint8_t dupMode = SL_DUP_MODE(pSkipList);
-  ASSERT(dupMode != SL_DISCARD_DUP_KEY && dupMode != SL_UPDATE_DUP_KEY);
-
-  for (int32_t j = level - 1; j >= 0; --j) {
-    SSkipListNode *prev = SL_NODE_GET_BACKWARD_POINTER(pNode, j);
-    SSkipListNode *next = SL_NODE_GET_FORWARD_POINTER(pNode, j);
-
-    SL_NODE_GET_FORWARD_POINTER(prev, j) = next;
-    SL_NODE_GET_BACKWARD_POINTER(next, j) = prev;
-  }
-
-  tSkipListFreeNode(pNode);
-  pSkipList->size--;
-}
-
-// Function must be called after calling tSkipListRemoveNodeImpl() function
-static void tSkipListCorrectLevel(SSkipList *pSkipList) {
-  while (pSkipList->level > 0 &&
-         SL_NODE_GET_FORWARD_POINTER(pSkipList->pHead, pSkipList->level - 1) == pSkipList->pTail) {
-    pSkipList->level -= 1;
-  }
-}
-#endif
-
 UNUSED_FUNC static FORCE_INLINE void recordNodeEachLevel(SSkipList *pSkipList,
                                                          int32_t    level) {  // record link count in each level
 #if SKIP_LIST_RECORD_PERFORMANCE

source/util/src/tutil.c

@@ -124,7 +124,6 @@ char **strsplit(char *z, const char *delim, int32_t *num) {
       if (split == NULL) {
         return NULL;
       }
-      ASSERTS(NULL != split, "realloc memory failed. size=%d", (int32_t)POINTER_BYTES * size);
     }
   }