[td-255]

src/client/src/tscUtil.c

@@ -1206,7 +1206,6 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
     createInputDataFilterInfo(px, numOfCol1, &numOfFilterCols, &pFilterInfo);
 
     SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1, pFilterInfo, numOfFilterCols);
-
     pOutput->precision = pSqlObjList[0]->res.precision;
 
     SSchema* schema = NULL;

src/query/inc/qExecutor.h

@@ -333,6 +333,7 @@ enum OPERATOR_TYPE_E {
   OP_StateWindow       = 22,
   OP_AllTimeWindow     = 23,
   OP_AllMultiTableTimeInterval = 24,
+  OP_Order             = 25,
 };
 
 typedef struct SOperatorInfo {
@@ -540,6 +541,13 @@ typedef struct SMultiwayMergeInfo {
   SArray              *udfInfo;
 } SMultiwayMergeInfo;
 
+// todo support the disk-based sort
+typedef struct SOrderOperatorInfo {
+  int32_t      colIndex;
+  int32_t      order;
+  SSDataBlock *pDataBlock;
+} SOrderOperatorInfo;
+
 void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
 
 SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime, int32_t reverseTime);

src/query/inc/qExtbuffer.h

@@ -220,6 +220,8 @@ tOrderDescriptor *tOrderDesCreate(const int32_t *orderColIdx, int32_t numOfOrder
 
 void tOrderDescDestroy(tOrderDescriptor *pDesc);
 
+void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn);
+
 void tColModelAppend(SColumnModel *dstModel, tFilePage *dstPage, void *srcData, int32_t srcStartRows,
                      int32_t numOfRowsToWrite, int32_t srcCapacity);
 

src/query/src/qExtbuffer.c

@@ -1102,3 +1102,57 @@ void tOrderDescDestroy(tOrderDescriptor *pDesc) {
   destroyColumnModel(pDesc->pColumnModel);
   tfree(pDesc);
 }
+
+void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn) {
+  assert(numOfRows > 0 && numOfCols > 0 && index >= 0 && index < numOfCols);
+
+  int32_t bytes = pSchema[index].bytes;
+  int32_t size = bytes + sizeof(int32_t);
+
+  char* buf = calloc(1, size * numOfRows);
+
+  for(int32_t i = 0; i < numOfRows; ++i) {
+    char* dest = buf + size * i;
+    memcpy(dest, pCols[index] + bytes * i, bytes);
+    *(int32_t*)(dest+bytes) = i;
+  }
+
+  qsort(buf, numOfRows, size, compareFn);
+
+  int32_t prevLength = 0;
+  char* p = NULL;
+
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    int32_t bytes1 = pSchema[i].bytes;
+
+    if (i == index) {
+      for(int32_t j = 0; j < numOfRows; ++j){
+        char* src  = buf + (j * size);
+        char* dest = pCols[i] + (j * bytes1);
+        memcpy(dest, src, bytes1);
+      }
+    } else {
+      // make sure memory buffer is enough
+      if (prevLength < bytes1) {
+        char *tmp = realloc(p, bytes1 * numOfRows);
+        assert(tmp);
+
+        p = tmp;
+        prevLength = bytes1;
+      }
+
+      memcpy(p, pCols[i], bytes1 * numOfRows);
+
+      for(int32_t j = 0; j < numOfRows; ++j){
+        char* dest = pCols[i] + bytes1 * j;
+
+        int32_t newPos = *(int32_t*)(buf + (j * size) + bytes);
+        char* src = p + (newPos * bytes1);
+        memcpy(dest, src, bytes1);
+      }
+    }
+  }
+
+  tfree(buf);
+  tfree(p);
+}
\ No newline at end of file

src/query/src/qPercentile.c

@@ -237,7 +237,7 @@ tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval,
   }
 
   pBucket->elemPerPage = (pBucket->bufPageSize - sizeof(tFilePage))/pBucket->bytes;
-  pBucket->comparFn = getKeyComparFunc(pBucket->type);
+  pBucket->comparFn = getKeyComparFunc(pBucket->type, TSDB_ORDER_ASC);
 
   pBucket->hashFunc = getHashFunc(pBucket->type);
   if (pBucket->hashFunc == NULL) {

src/util/inc/tcompare.h

@@ -47,7 +47,7 @@ int WCSPatternMatch(const wchar_t *pattern, const wchar_t *str, size_t size, con
 
 int32_t doCompare(const char* a, const char* b, int32_t type, size_t size);
 
-__compar_fn_t getKeyComparFunc(int32_t keyType);
+__compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order);
 
 __compar_fn_t getComparFunc(int32_t type, int32_t optr);
 

src/util/src/tcompare.c

@@ -16,58 +16,101 @@
 #include "os.h"
 #include "ttype.h"
 #include "tcompare.h"
-#include "tarray.h"
 #include "hash.h"
 
-int32_t compareInt32Val(const void *pLeft, const void *pRight) {
-  int32_t left = GET_INT32_VAL(pLeft), right = GET_INT32_VAL(pRight);
+int32_t setCompareBytes1(const void *pLeft, const void *pRight) {
+  return NULL != taosHashGet((SHashObj *)pRight, pLeft, 1) ? 1 : 0;
+}
+
+int32_t setCompareBytes2(const void *pLeft, const void *pRight) {
+  return NULL != taosHashGet((SHashObj *)pRight, pLeft, 2) ? 1 : 0;
+}
+
+int32_t setCompareBytes4(const void *pLeft, const void *pRight) {
+  return NULL != taosHashGet((SHashObj *)pRight, pLeft, 4) ? 1 : 0;
+}
+
+int32_t setCompareBytes8(const void *pLeft, const void *pRight) {
+  return NULL != taosHashGet((SHashObj *)pRight, pLeft, 8) ? 1 : 0;
+}
+
+int32_t compareInt8Val(const void *pLeft, const void *pRight) {
+  int8_t left = GET_INT8_VAL(pLeft), right = GET_INT8_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
-int32_t compareInt64Val(const void *pLeft, const void *pRight) {
-  int64_t left = GET_INT64_VAL(pLeft), right = GET_INT64_VAL(pRight);
+int32_t compareInt8ValDesc(const void *pLeft, const void *pRight) {
+  return compareInt8Val(pRight, pLeft);
+}
+
+int32_t compareInt16Val(const void *pLeft, const void *pRight) {
+  int16_t left = GET_INT16_VAL(pLeft), right = GET_INT16_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
-int32_t compareInt16Val(const void *pLeft, const void *pRight) {
-  int16_t left = GET_INT16_VAL(pLeft), right = GET_INT16_VAL(pRight);
+int32_t compareInt16ValDesc(const void* pLeft, const void* pRight) {
+  return compareInt16Val(pRight, pLeft);
+}
+
+int32_t compareInt32Val(const void *pLeft, const void *pRight) {
+  int32_t left = GET_INT32_VAL(pLeft), right = GET_INT32_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
-int32_t compareInt8Val(const void *pLeft, const void *pRight) {
-  int8_t left = GET_INT8_VAL(pLeft), right = GET_INT8_VAL(pRight);
+int32_t compareInt32ValDesc(const void* pLeft, const void* pRight) {
+  return compareInt32Val(pRight, pLeft);
+}
+
+int32_t compareInt64Val(const void *pLeft, const void *pRight) {
+  int64_t left = GET_INT64_VAL(pLeft), right = GET_INT64_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
+int32_t compareInt64ValDesc(const void* pLeft, const void* pRight) {
+  return compareInt64Val(pRight, pLeft);
+}
+
 int32_t compareUint32Val(const void *pLeft, const void *pRight) {
-  int32_t left = GET_UINT32_VAL(pLeft), right = GET_UINT32_VAL(pRight);
+  uint32_t left = GET_UINT32_VAL(pLeft), right = GET_UINT32_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
+int32_t compareUint32ValDesc(const void* pLeft, const void* pRight) {
+  return compareUint32Val(pRight, pLeft);
+}
+
 int32_t compareUint64Val(const void *pLeft, const void *pRight) {
-  int64_t left = GET_UINT64_VAL(pLeft), right = GET_UINT64_VAL(pRight);
+  uint64_t left = GET_UINT64_VAL(pLeft), right = GET_UINT64_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
+int32_t compareUint64ValDesc(const void* pLeft, const void* pRight) {
+  return compareUint64Val(pRight, pLeft);
+}
+
 int32_t compareUint16Val(const void *pLeft, const void *pRight) {
-  int16_t left = GET_UINT16_VAL(pLeft), right = GET_UINT16_VAL(pRight);
+  uint16_t left = GET_UINT16_VAL(pLeft), right = GET_UINT16_VAL(pRight);
   if (left > right) return 1;
   if (left < right) return -1;
   return 0;
 }
 
+int32_t compareUint16ValDesc(const void* pLeft, const void* pRight) {
+  return compareUint16Val(pRight, pLeft);
+}
+
 int32_t compareUint8Val(const void* pLeft, const void* pRight) {
   uint8_t left = GET_UINT8_VAL(pLeft), right = GET_UINT8_VAL(pRight);
   if (left > right) return 1;
@@ -75,6 +118,10 @@ int32_t compareUint8Val(const void* pLeft, const void* pRight) {
   return 0;
 }
 
+int32_t compareUint8ValDesc(const void* pLeft, const void* pRight) {
+  return compareUint8Val(pRight, pLeft);
+}
+
 int32_t compareFloatVal(const void *pLeft, const void *pRight) {
   float p1 = GET_FLOAT_VAL(pLeft);
   float p2 = GET_FLOAT_VAL(pRight);
@@ -92,8 +139,12 @@ int32_t compareFloatVal(const void *pLeft, const void *pRight) {
   }
   if (FLT_EQUAL(p1, p2)) {
     return 0;
-  } 
-  return FLT_GREATER(p1, p2) ? 1: -1; 
+  }
+  return FLT_GREATER(p1, p2) ? 1: -1;
+}
+
+int32_t compareFloatValDesc(const void* pLeft, const void* pRight) {
+  return compareFloatVal(pRight, pLeft);
 }
 
 int32_t compareDoubleVal(const void *pLeft, const void *pRight) {
@@ -113,14 +164,18 @@ int32_t compareDoubleVal(const void *pLeft, const void *pRight) {
   }
   if (FLT_EQUAL(p1, p2)) {
     return 0;
-  } 
-  return FLT_GREATER(p1, p2) ? 1: -1; 
+  }
+  return FLT_GREATER(p1, p2) ? 1: -1;
+}
+
+int32_t compareDoubleValDesc(const void* pLeft, const void* pRight) {
+  return compareDoubleVal(pRight, pLeft);
 }
 
 int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight) {
   int32_t len1 = varDataLen(pLeft);
   int32_t len2 = varDataLen(pRight);
-  
+
   if (len1 != len2) {
     return len1 > len2? 1:-1;
   } else {
@@ -133,10 +188,14 @@ int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight) {
   }
 }
 
+int32_t compareLenPrefixedStrDesc(const void* pLeft, const void* pRight) {
+  return compareLenPrefixedStr(pRight, pLeft);
+}
+
 int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight) {
   int32_t len1 = varDataLen(pLeft);
   int32_t len2 = varDataLen(pRight);
-  
+
   if (len1 != len2) {
     return len1 > len2? 1:-1;
   } else {
@@ -149,6 +208,10 @@ int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight) {
   }
 }
 
+int32_t compareLenPrefixedWStrDesc(const void* pLeft, const void* pRight) {
+  return compareLenPrefixedWStr(pRight, pLeft);
+}
+
 /*
  * Compare two strings
  *    TSDB_MATCH:            Match
@@ -161,33 +224,33 @@ int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight) {
  */
 int patternMatch(const char *patterStr, const char *str, size_t size, const SPatternCompareInfo *pInfo) {
   char c, c1;
-  
+
   int32_t i = 0;
   int32_t j = 0;
-  
+
   while ((c = patterStr[i++]) != 0) {
     if (c == pInfo->matchAll) { /* Match "*" */
-      
+
       while ((c = patterStr[i++]) == pInfo->matchAll || c == pInfo->matchOne) {
         if (c == pInfo->matchOne && (j > size || str[j++] == 0)) {
           // empty string, return not match
           return TSDB_PATTERN_NOWILDCARDMATCH;
         }
       }
-      
+
       if (c == 0) {
         return TSDB_PATTERN_MATCH; /* "*" at the end of the pattern matches */
       }
-      
+
       char next[3] = {toupper(c), tolower(c), 0};
       while (1) {
         size_t n = strcspn(str, next);
         str += n;
-        
+
         if (str[0] == 0 || (n >= size)) {
           break;
         }
-        
+
         int32_t ret = patternMatch(&patterStr[i], ++str, size - n - 1, pInfo);
         if (ret != TSDB_PATTERN_NOMATCH) {
           return ret;
@@ -195,18 +258,18 @@ int patternMatch(const char *patterStr, const char *str, size_t size, const SPat
       }
       return TSDB_PATTERN_NOWILDCARDMATCH;
     }
-    
+
     c1 = str[j++];
-    
+
     if (j <= size) {
       if (c == c1 || tolower(c) == tolower(c1) || (c == pInfo->matchOne && c1 != 0)) {
         continue;
       }
     }
-    
+
     return TSDB_PATTERN_NOMATCH;
   }
-  
+
   return (str[j] == 0 || j >= size) ? TSDB_PATTERN_MATCH : TSDB_PATTERN_NOMATCH;
 }
 
@@ -214,13 +277,13 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
   wchar_t c, c1;
   wchar_t matchOne = L'_';  // "_"
   wchar_t matchAll = L'%';  // "%"
-  
+
   int32_t i = 0;
   int32_t j = 0;
-  
+
   while ((c = patterStr[i++]) != 0) {
     if (c == matchAll) { /* Match "%" */
-      
+
       while ((c = patterStr[i++]) == matchAll || c == matchOne) {
         if (c == matchOne && (j > size || str[j++] == 0)) {
           return TSDB_PATTERN_NOWILDCARDMATCH;
@@ -229,40 +292,40 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
       if (c == 0) {
         return TSDB_PATTERN_MATCH;
       }
-      
+
       wchar_t accept[3] = {towupper(c), towlower(c), 0};
       while (1) {
         size_t n = wcscspn(str, accept);
-        
+
         str += n;
         if (str[0] == 0 || (n >= size)) {
           break;
         }
-        
+
         int32_t ret = WCSPatternMatch(&patterStr[i], ++str, size - n - 1, pInfo);
         if (ret != TSDB_PATTERN_NOMATCH) {
           return ret;
         }
       }
-      
+
       return TSDB_PATTERN_NOWILDCARDMATCH;
     }
-    
+
     c1 = str[j++];
-    
+
     if (j <= size) {
       if (c == c1 || towlower(c) == towlower(c1) || (c == matchOne && c1 != 0)) {
         continue;
       }
     }
-    
+
     return TSDB_PATTERN_NOMATCH;
   }
   
   return (str[j] == 0 || j >= size) ? TSDB_PATTERN_MATCH : TSDB_PATTERN_NOMATCH;
 }
 
-static int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
+int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
   SPatternCompareInfo pInfo = {'%', '_'};
   
   char pattern[128] = {0};
@@ -270,8 +333,8 @@ static int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
   assert(varDataLen(pRight) < 128);
 
   size_t sz = varDataLen(pLeft);
-  char *buf = malloc(sz + 1); 
-  memcpy(buf, varDataVal(pLeft), sz); 
+  char *buf = malloc(sz + 1);
+  memcpy(buf, varDataVal(pLeft), sz);
   buf[sz] = 0;
 
   int32_t ret = patternMatch(pattern, buf, sz, &pInfo);
@@ -282,19 +345,15 @@ static int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
 int32_t taosArrayCompareString(const void* a, const void* b) {
   const char* x = *(const char**)a;
   const char* y = *(const char**)b;
-  
+
   return compareLenPrefixedStr(x, y);
 }
 
-//static int32_t compareFindStrInArray(const void* pLeft, const void* pRight) {
-//  const SArray* arr = (const SArray*) pRight;
-//  return taosArraySearchString(arr, pLeft, taosArrayCompareString, TD_EQ) == NULL ? 0 : 1;
-//}
-static int32_t compareFindItemInSet(const void *pLeft, const void* pRight)  {
-  return NULL != taosHashGet((SHashObj *)pRight, varDataVal(pLeft), varDataLen(pLeft)) ? 1 : 0;    
+int32_t compareFindItemInSet(const void *pLeft, const void* pRight)  {
+  return NULL != taosHashGet((SHashObj *)pRight, varDataVal(pLeft), varDataLen(pLeft)) ? 1 : 0;
 }
 
-static int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
+int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
   SPatternCompareInfo pInfo = {'%', '_'};
 
   wchar_t pattern[128] = {0};
@@ -302,14 +361,37 @@ static int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
 
   memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
   assert(varDataLen(pRight) < 128);
-  
+
   int32_t ret = WCSPatternMatch(pattern, varDataVal(pLeft), varDataLen(pLeft)/TSDB_NCHAR_SIZE, &pInfo);
   return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
 }
 
 __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
   __compar_fn_t comparFn = NULL;
-  
+
+  if (optr == TSDB_RELATION_IN && (type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_NCHAR)) {
+    switch (type) {
+      case TSDB_DATA_TYPE_BOOL:
+      case TSDB_DATA_TYPE_TINYINT:
+      case TSDB_DATA_TYPE_UTINYINT:
+        return setCompareBytes1;
+      case TSDB_DATA_TYPE_SMALLINT:
+      case TSDB_DATA_TYPE_USMALLINT:
+        return setCompareBytes2;
+      case TSDB_DATA_TYPE_INT:
+      case TSDB_DATA_TYPE_UINT:
+      case TSDB_DATA_TYPE_FLOAT:
+        return setCompareBytes4;
+      case TSDB_DATA_TYPE_BIGINT:
+      case TSDB_DATA_TYPE_UBIGINT:
+      case TSDB_DATA_TYPE_DOUBLE:
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        return setCompareBytes8;
+      default:
+        assert(0);
+    }
+  }
+
   switch (type) {
     case TSDB_DATA_TYPE_BOOL:
     case TSDB_DATA_TYPE_TINYINT:   comparFn = compareInt8Val;   break;
@@ -327,13 +409,15 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
       } else { /* normal relational comparFn */
         comparFn = compareLenPrefixedStr;
       }
-    
+
       break;
     }
-  
+
     case TSDB_DATA_TYPE_NCHAR: {
       if (optr == TSDB_RELATION_LIKE) {
         comparFn = compareWStrPatternComp;
+      } else if (optr == TSDB_RELATION_IN) {
+        comparFn = compareFindItemInSet;
       } else {
         comparFn = compareLenPrefixedWStr;
       }
@@ -349,57 +433,57 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
       comparFn = compareInt32Val;
       break;
   }
-  
+
   return comparFn;
 }
 
-__compar_fn_t getKeyComparFunc(int32_t keyType) {
+__compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order) {
   __compar_fn_t comparFn = NULL;
-  
+
   switch (keyType) {
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_BOOL:
-      comparFn = compareInt8Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareInt8Val:compareInt8ValDesc;
       break;
     case TSDB_DATA_TYPE_SMALLINT:
-      comparFn = compareInt16Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareInt16Val:compareInt16ValDesc;
       break;
     case TSDB_DATA_TYPE_INT:
-      comparFn = compareInt32Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareInt32Val:compareInt32ValDesc;
       break;
     case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_TIMESTAMP:
-      comparFn = compareInt64Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareInt64Val:compareInt64ValDesc;
       break;
     case TSDB_DATA_TYPE_FLOAT:
-      comparFn = compareFloatVal;
+      comparFn = (order == TSDB_ORDER_ASC)? compareFloatVal:compareFloatValDesc;
       break;
     case TSDB_DATA_TYPE_DOUBLE:
-      comparFn = compareDoubleVal;
+      comparFn = (order == TSDB_ORDER_ASC)? compareDoubleVal:compareDoubleValDesc;
       break;
     case TSDB_DATA_TYPE_UTINYINT:
-      comparFn = compareUint8Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareUint8Val:compareUint8ValDesc;
       break;
     case TSDB_DATA_TYPE_USMALLINT:
-      comparFn = compareUint16Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareUint16Val:compareUint16ValDesc;
       break;
     case TSDB_DATA_TYPE_UINT:
-      comparFn = compareUint32Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareUint32Val:compareUint32ValDesc;
       break;
     case TSDB_DATA_TYPE_UBIGINT:
-      comparFn = compareUint64Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareUint64Val:compareUint64ValDesc;
       break;
     case TSDB_DATA_TYPE_BINARY:
-      comparFn = compareLenPrefixedStr;
+      comparFn = (order == TSDB_ORDER_ASC)? compareLenPrefixedStr:compareLenPrefixedStrDesc;
       break;
     case TSDB_DATA_TYPE_NCHAR:
-      comparFn = compareLenPrefixedWStr;
+      comparFn = (order == TSDB_ORDER_ASC)? compareLenPrefixedWStr:compareLenPrefixedWStrDesc;
       break;
     default:
-      comparFn = compareInt32Val;
+      comparFn = (order == TSDB_ORDER_ASC)? compareInt32Val:compareInt32ValDesc;
       break;
   }
-  
+
   return comparFn;
 }
 
@@ -433,7 +517,7 @@ int32_t doCompare(const char* f1, const char* f2, int32_t type, size_t size) {
     default: {  // todo refactor
       tstr* t1 = (tstr*) f1;
       tstr* t2 = (tstr*) f2;
-      
+
       if (t1->len != t2->len) {
         return t1->len > t2->len? 1:-1;
       } else {

src/util/src/tskiplist.c

@@ -54,7 +54,7 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _
   pSkipList->keyFn = fn;
   pSkipList->seed = rand();
   if (comparFn == NULL) {
-    pSkipList->comparFn = getKeyComparFunc(keyType);
+    pSkipList->comparFn = getKeyComparFunc(keyType, TSDB_ORDER_ASC);
   } else {
     pSkipList->comparFn = comparFn;
   }

src/util/tests/skiplistTest.cpp

@@ -70,7 +70,7 @@ void doubleSkipListTest() {
 }
 
 void randKeyTest() {
-  SSkipList* pSkipList = tSkipListCreate(10, TSDB_DATA_TYPE_INT, sizeof(int32_t), getKeyComparFunc(TSDB_DATA_TYPE_INT),
+  SSkipList* pSkipList = tSkipListCreate(10, TSDB_DATA_TYPE_INT, sizeof(int32_t), getKeyComparFunc(TSDB_DATA_TYPE_INT, TSDB_ORDER_ASC),
       false, getkey);
 
   int32_t size = 200000;