support ts range

src/client/src/tscSQLParser.c

@@ -4123,6 +4123,19 @@ static int32_t validateLikeExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t handleNeOptr(tSqlExpr** rexpr, tSqlExpr* expr) {
+  tSqlExpr* left = tSqlExprClone(expr);
+  tSqlExpr* right = expr;
+
+  left->tokenId = TK_LT;
+  right->tokenId = TK_GT;
+
+  *rexpr = tSqlExprCreate(left, right, TK_OR);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SCondExpr* pCondExpr,
                                      int32_t* type, int32_t* tbIdx, int32_t parentOptr, tSqlExpr** columnExpr, tSqlExpr** tsExpr) {
   const char* msg1 = "table query cannot use tags filter";
@@ -4221,7 +4234,14 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
         *type |= TSQL_EXPR_JOIN;
       }
     } else {
-      ret = setNormalExprToCond(tsExpr, *pExpr, parentOptr);
+      tSqlExpr *rexpr = NULL;
+      if ((*pExpr)->tokenId == TK_NE) {
+        handleNeOptr(&rexpr, *pExpr);
+      } else {
+        rexpr = *pExpr;
+      }
+      
+      ret = setNormalExprToCond(tsExpr, rexpr, parentOptr);
       if (type) {
         *type |= TSQL_EXPR_TS;
       }
@@ -4272,6 +4292,12 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
         // do nothing
         //                ret = setExprToCond(pCmd, &pCondExpr->pTagCond,
         //                *pExpr, NULL, parentOptr);
+        tSqlExpr *rexpr = NULL;
+        if ((*pExpr)->tokenId == TK_NE && (pSchema->type != TSDB_DATA_TYPE_BINARY && pSchema->type != TSDB_DATA_TYPE_NCHAR && pSchema->type != TSDB_DATA_TYPE_BOOL)) {
+          handleNeOptr(&rexpr, *pExpr);
+          *pExpr = rexpr;
+        }
+        
         if (type) {
           *type |= TSQL_EXPR_TAG;
         }
@@ -4286,7 +4312,14 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     }
 
-    ret = setNormalExprToCond(columnExpr, *pExpr, parentOptr);
+    tSqlExpr *rexpr = NULL;
+    if ((*pExpr)->tokenId == TK_NE && (pSchema->type != TSDB_DATA_TYPE_BINARY && pSchema->type != TSDB_DATA_TYPE_NCHAR && pSchema->type != TSDB_DATA_TYPE_BOOL)) {
+      handleNeOptr(&rexpr, *pExpr);
+    } else {
+      rexpr = *pExpr;
+    }
+
+    ret = setNormalExprToCond(columnExpr, rexpr, parentOptr);
     *pExpr = NULL;  // remove it from expr tree
   }
 
@@ -4575,37 +4608,40 @@ int32_t mergeTimeRange(SSqlCmd* pCmd, STimeWindow* res, STimeWindow* win, int32_
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t createTimeRangeExpr(tSqlExpr** pExpr, STimeWindow* win, uint32_t tokenId) {
+  *pExpr = calloc(1, sizeof(tSqlExpr));
+  
+  (*pExpr)->type = SQL_NODE_VALUE;
+  (*pExpr)->tokenId = tokenId;
+  (*pExpr)->value.nType = TSDB_DATA_TYPE_VALUE_ARRAY;
+  (*pExpr)->value.nLen = 2;
+  (*pExpr)->value.arr = taosArrayInit(2, sizeof(int64_t));
+
+  taosArrayPush((*pExpr)->value.arr, &win->skey);
+  taosArrayPush((*pExpr)->value.arr, &win->ekey);
 
-static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, STimeWindow* win) {
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t convertTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr) {
   const char* msg0 = "invalid timestamp or operator for timestamp";
   int32_t code = 0;
-  STimeWindow win2 = {.skey = INT64_MIN, .ekey = INT64_MAX};
+  STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX};
 
   if (pExpr == NULL) {
     return TSDB_CODE_SUCCESS;
   }
 
   if (!tSqlExprIsParentOfLeaf(pExpr)) {
-    if (pExpr->tokenId == TK_OR) {
-      code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft, win);
+      code = convertTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft);
       if (code) {
         return code;
       }
 
-      code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pRight, &win2);
+      code = convertTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pRight);
       if (code) {
         return code;
       }
-
-      return mergeTimeRange(pCmd, win, &win2, TSDB_RELATION_OR);
-    }
-
-    code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft, win);
-    if (code) {
-      return code;
-    }
-
-    return getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pRight, win);
   } else {
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
@@ -4617,11 +4653,13 @@ static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlE
     
     tSqlExpr* pRight = pExpr->pRight;
 
-    if (getTimeRange(&win2, pRight, pExpr->tokenId, tinfo.precision) != TSDB_CODE_SUCCESS) {
+    if (getTimeRange(&win, pRight, pExpr->tokenId, tinfo.precision) != TSDB_CODE_SUCCESS) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
     }
 
-    return mergeTimeRange(pCmd, win, &win2, TSDB_RELATION_AND);
+    createTimeRangeExpr(&pExpr->pRight, &win, pRight->tokenId);
+
+    tSqlExprDestroy(pRight);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -4950,6 +4988,42 @@ int32_t mergeJoinNodes(SQueryInfo* pQueryInfo, SSqlObj* pSql) {
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t getQueryTimeRange(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr) {
+  int32_t ret = TSDB_CODE_SUCCESS;
+
+  if (*pExpr == NULL) {
+    return ret;
+  }
+  
+  //multiple tables's query time range mixed together
+  
+  tExprNode* p = NULL;
+  SFilterInfo *filter = NULL;
+
+  SArray* colList = taosArrayInit(10, sizeof(SColIndex));
+  ret = exprTreeFromSqlExpr(pCmd, &p, *pExpr, pQueryInfo, colList, NULL);
+  if (ret != TSDB_CODE_SUCCESS) {
+    goto _ret;
+  }
+
+  ret = filterInitFromTree(p, &filter);
+  if (ret != TSDB_CODE_SUCCESS) {
+    goto _ret;
+  }
+
+  ret = filterGetTimeRange(filter, &pQueryInfo->window);
+
+_ret:
+  tExprTreeDestroy(p, NULL);
+
+  if (ret) {
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), tstrerror(ret));
+  }
+
+  return ret;
+}
+
+
 
 int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql) {
   if (pExpr == NULL) {
@@ -5000,12 +5074,11 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
   }
 
   // 2. get the query time range
-  STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX};  
-  if ((ret = getTimeRangeFromExpr(&pSql->cmd, pQueryInfo, condExpr.pTimewindow, &win)) != TSDB_CODE_SUCCESS) {
+  if ((ret = convertTimeRangeFromExpr(&pSql->cmd, pQueryInfo, condExpr.pTimewindow)) != TSDB_CODE_SUCCESS) {
     return ret;
   }
 
-  if ((ret = mergeTimeRange(&pSql->cmd, &pQueryInfo->window,&win, TSDB_RELATION_AND)) != TSDB_CODE_SUCCESS) {
+  if ((ret = getQueryTimeRange(&pSql->cmd, pQueryInfo, &condExpr.pTimewindow)) != TSDB_CODE_SUCCESS) {
     return ret;
   }
 
@@ -5024,14 +5097,6 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
     goto PARSE_WHERE_EXIT;
   }
 
-/*  
-  if (taosArrayGetSize(pQueryInfo->pUpstream) > 0 ) {
-    if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pTimewindow, TK_AND)) != TSDB_CODE_SUCCESS) {
-      goto PARSE_WHERE_EXIT;
-    }
-  }
-*/
-
   if ((ret = getColQueryCondExpr(&pSql->cmd, pQueryInfo, &condExpr.pColumnCond)) != TSDB_CODE_SUCCESS) {
     goto PARSE_WHERE_EXIT;
   }

src/common/src/texpr.c

@@ -118,7 +118,7 @@ void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *)) {
   } else if (pNode->nodeType == TSQL_NODE_VALUE) {
     tVariantDestroy(pNode->pVal);
   } else if (pNode->nodeType == TSQL_NODE_COL) {
-    free(pNode->pSchema);
+    tfree(pNode->pSchema);
   }
 
   free(pNode);
@@ -435,7 +435,7 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
     expr->_node.optr = TSDB_RELATION_IN;
     tVariant* pVal = exception_calloc(1, sizeof(tVariant));
     right->pVal = pVal;
-    pVal->nType = TSDB_DATA_TYPE_ARRAY;
+    pVal->nType = TSDB_DATA_TYPE_POINTER_ARRAY;
     pVal->arr = taosArrayInit(2, POINTER_BYTES);
 
     const char* cond = tbnameCond + QUERY_COND_REL_PREFIX_IN_LEN;

src/common/src/ttypes.c

@@ -368,21 +368,21 @@ static void getStatics_nchr(const void *pData, int32_t numOfRow, int64_t *min, i
 }
 
 tDataTypeDescriptor tDataTypes[15] = {
-  {TSDB_DATA_TYPE_NULL,      6,1,        "NOTYPE",   NULL,     NULL,      NULL},
-  {TSDB_DATA_TYPE_BOOL,      4,  CHAR_BYTES,   "BOOL",               tsCompressBool,      tsDecompressBool,      getStatics_bool},
-  {TSDB_DATA_TYPE_TINYINT,   7,  CHAR_BYTES,   "TINYINT",            tsCompressTinyint,   tsDecompressTinyint,   getStatics_i8},
-  {TSDB_DATA_TYPE_SMALLINT,  8,  SHORT_BYTES,  "SMALLINT",           tsCompressSmallint,  tsDecompressSmallint,  getStatics_i16},
-  {TSDB_DATA_TYPE_INT,       3,  INT_BYTES,    "INT",                tsCompressInt,       tsDecompressInt,       getStatics_i32},
-  {TSDB_DATA_TYPE_BIGINT,    6,  LONG_BYTES,   "BIGINT",             tsCompressBigint,    tsDecompressBigint,    getStatics_i64},
-  {TSDB_DATA_TYPE_FLOAT,     5,  FLOAT_BYTES,  "FLOAT",              tsCompressFloat,     tsDecompressFloat,     getStatics_f},
-  {TSDB_DATA_TYPE_DOUBLE,    6,  DOUBLE_BYTES, "DOUBLE",             tsCompressDouble,    tsDecompressDouble,    getStatics_d},
-  {TSDB_DATA_TYPE_BINARY,    6,  0,      "BINARY",             tsCompressString,    tsDecompressString,    getStatics_bin},
-  {TSDB_DATA_TYPE_TIMESTAMP, 9,  LONG_BYTES,   "TIMESTAMP",          tsCompressTimestamp, tsDecompressTimestamp, getStatics_i64},
-  {TSDB_DATA_TYPE_NCHAR,     5,  8,      "NCHAR",              tsCompressString,    tsDecompressString,    getStatics_nchr},
-  {TSDB_DATA_TYPE_UTINYINT,  16, CHAR_BYTES,   "TINYINT UNSIGNED",   tsCompressTinyint,   tsDecompressTinyint,   getStatics_u8},
-  {TSDB_DATA_TYPE_USMALLINT, 17, SHORT_BYTES,  "SMALLINT UNSIGNED",  tsCompressSmallint,  tsDecompressSmallint,  getStatics_u16},
-  {TSDB_DATA_TYPE_UINT,      12, INT_BYTES,    "INT UNSIGNED",       tsCompressInt,       tsDecompressInt,       getStatics_u32},
-  {TSDB_DATA_TYPE_UBIGINT,   15, LONG_BYTES,   "BIGINT UNSIGNED",    tsCompressBigint,    tsDecompressBigint,    getStatics_u64},
+  {TSDB_DATA_TYPE_NULL,      6,  1,            "NOTYPE",             0,          0,              NULL,                NULL,                  NULL},
+  {TSDB_DATA_TYPE_BOOL,      4,  CHAR_BYTES,   "BOOL",               false,      true,           tsCompressBool,      tsDecompressBool,      getStatics_bool},
+  {TSDB_DATA_TYPE_TINYINT,   7,  CHAR_BYTES,   "TINYINT",            INT8_MIN,   INT8_MAX,       tsCompressTinyint,   tsDecompressTinyint,   getStatics_i8},
+  {TSDB_DATA_TYPE_SMALLINT,  8,  SHORT_BYTES,  "SMALLINT",           INT16_MIN,  INT16_MAX,      tsCompressSmallint,  tsDecompressSmallint,  getStatics_i16},
+  {TSDB_DATA_TYPE_INT,       3,  INT_BYTES,    "INT",                INT32_MIN,  INT32_MAX,      tsCompressInt,       tsDecompressInt,       getStatics_i32},
+  {TSDB_DATA_TYPE_BIGINT,    6,  LONG_BYTES,   "BIGINT",             INT64_MIN,  INT64_MAX,      tsCompressBigint,    tsDecompressBigint,    getStatics_i64},
+  {TSDB_DATA_TYPE_FLOAT,     5,  FLOAT_BYTES,  "FLOAT",              0,          0,              tsCompressFloat,     tsDecompressFloat,     getStatics_f},
+  {TSDB_DATA_TYPE_DOUBLE,    6,  DOUBLE_BYTES, "DOUBLE",             0,          0,              tsCompressDouble,    tsDecompressDouble,    getStatics_d},
+  {TSDB_DATA_TYPE_BINARY,    6,  0,            "BINARY",             0,          0,              tsCompressString,    tsDecompressString,    getStatics_bin},
+  {TSDB_DATA_TYPE_TIMESTAMP, 9,  LONG_BYTES,   "TIMESTAMP",          INT64_MIN,  INT64_MAX,      tsCompressTimestamp, tsDecompressTimestamp, getStatics_i64},
+  {TSDB_DATA_TYPE_NCHAR,     5,  8,            "NCHAR",              0,          0,              tsCompressString,    tsDecompressString,    getStatics_nchr},
+  {TSDB_DATA_TYPE_UTINYINT,  16, CHAR_BYTES,   "TINYINT UNSIGNED",   0,          UINT8_MAX,      tsCompressTinyint,   tsDecompressTinyint,   getStatics_u8},
+  {TSDB_DATA_TYPE_USMALLINT, 17, SHORT_BYTES,  "SMALLINT UNSIGNED",  0,          UINT16_MAX,     tsCompressSmallint,  tsDecompressSmallint,  getStatics_u16},
+  {TSDB_DATA_TYPE_UINT,      12, INT_BYTES,    "INT UNSIGNED",       0,          UINT32_MAX,     tsCompressInt,       tsDecompressInt,       getStatics_u32},
+  {TSDB_DATA_TYPE_UBIGINT,   15, LONG_BYTES,   "BIGINT UNSIGNED",    0,          UINT64_MAX,     tsCompressBigint,    tsDecompressBigint,    getStatics_u64},
 };
 
 char tTokenTypeSwitcher[13] = {
@@ -560,65 +560,50 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
   }
 }
 
-int8_t getInt8Val(void *s) {
-  return (int8_t)GET_INT8_VAL(s);
-}
-uint8_t getUint8Val(void *s) {
-  return (uint8_t)GET_INT8_VAL(s);
-}
-int16_t getInt16Val(void *s) {
-  return (int16_t)GET_INT16_VAL(s);
-}
-uint16_t getUint16Val(void *s) {
-  return (uint16_t)GET_INT16_VAL(s);
-}
-int32_t getInt32Val(void *s) {
-  return (int32_t)GET_INT32_VAL(s);
-}
-uint32_t getUint32Val(void *s) {
-  return (uint32_t)GET_INT32_VAL(s);
-}
-int64_t getInt64Val(void *s) {
-  return (int64_t)GET_INT64_VAL(s);
-}
-uint64_t getUint64Val(void *s) {
-  return (uint64_t)GET_INT64_VAL(s);
-}
-float getFloatVal(void *s) {
-  return GET_FLOAT_VAL(s);
-}
-double getDoubleVal(void *s) {
-  return GET_DOUBLE_VAL(s);
-}
-void setInt8Val(void *d, void *s) {
-  *((int8_t *)d) = (int8_t)GET_INT8_VAL(s);
-}
-void setUint8Val(void *d, void *s) {
-  *((uint8_t *)d) = GET_INT8_VAL(s);
-}
-void setInt16Val(void *d, void *s) {
-  *((int16_t *)d) = (int16_t)GET_INT16_VAL(s);
-}
-void setUint16Val(void *d, void *s) {
-  *((uint16_t *)d) = GET_INT16_VAL(s);
-}
-void setInt32Val(void *d, void *s) {
-  *((int32_t *)d) = GET_INT32_VAL(s);
-}
-void setUint32Val(void *d, void *s) {
-  *((uint32_t *)d) = GET_INT32_VAL(s);
-}
-void setInt64Val(void *d, void *s) {
-  *((int64_t *)d) = GET_INT64_VAL(s);
-}
-void setUint64Val(void *d, void *s) {
-  *((uint64_t *)d) = GET_INT64_VAL(s);
-}
-void setFloatVal(void *d, void *s) {
-  SET_FLOAT_VAL(d, GET_FLOAT_VAL(s));
-}
-void setDoubleVal(void *d, void *s) {
-  SET_DOUBLE_VAL(d, GET_DOUBLE_VAL(s));
+void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type) {
+  if (optr == TSDB_BINARY_OP_ADD) {
+    switch (type) {
+      case TSDB_DATA_TYPE_TINYINT:
+        *((int8_t *)dst) = GET_INT8_VAL(s1) + GET_INT8_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        *((uint8_t *)dst) = GET_UINT8_VAL(s1) + GET_UINT8_VAL(s2);        
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        *((int16_t *)dst) = GET_INT16_VAL(s1) + GET_INT16_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        *((uint16_t *)dst) = GET_UINT16_VAL(s1) + GET_UINT16_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        *((int32_t *)dst) = GET_INT32_VAL(s1) + GET_INT32_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        *((uint32_t *)dst) = GET_UINT32_VAL(s1) + GET_UINT32_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_BIGINT:
+        *((int64_t *)dst) = GET_INT64_VAL(s1) + GET_INT64_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        *((uint64_t *)dst) = GET_UINT64_VAL(s1) + GET_UINT64_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        *((int64_t *)dst) = GET_INT64_VAL(s1) + GET_INT64_VAL(s2);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        SET_FLOAT_VAL(dst, GET_FLOAT_VAL(s1) + GET_FLOAT_VAL(s2));
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        SET_DOUBLE_VAL(dst, GET_DOUBLE_VAL(s1) + GET_DOUBLE_VAL(s2));
+        break;
+      default: {
+        assert(0);
+        break;
+      }
+    }
+  } else {
+    assert(0);
+  }
 }
 
 

src/common/src/tvariant.c

@@ -184,7 +184,7 @@ void tVariantDestroy(tVariant *pVar) {
   }
 
   // NOTE: this is only for string array
-  if (pVar->nType == TSDB_DATA_TYPE_ARRAY) {
+  if (pVar->nType == TSDB_DATA_TYPE_POINTER_ARRAY) {
     size_t num = taosArrayGetSize(pVar->arr);
     for(size_t i = 0; i < num; i++) {
       void* p = taosArrayGetP(pVar->arr, i);
@@ -192,6 +192,9 @@ void tVariantDestroy(tVariant *pVar) {
     }
     taosArrayDestroy(pVar->arr);
     pVar->arr = NULL;
+  } else if (pVar->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
+    taosArrayDestroy(pVar->arr);
+    pVar->arr = NULL;
   }
 }
 
@@ -220,7 +223,7 @@ void tVariantAssign(tVariant *pDst, const tVariant *pSrc) {
 
   if (IS_NUMERIC_TYPE(pSrc->nType) || (pSrc->nType == TSDB_DATA_TYPE_BOOL)) {
     pDst->i64 = pSrc->i64;
-  } else if (pSrc->nType == TSDB_DATA_TYPE_ARRAY) {  // this is only for string array
+  } else if (pSrc->nType == TSDB_DATA_TYPE_POINTER_ARRAY) {  // this is only for string array
     size_t num = taosArrayGetSize(pSrc->arr);
     pDst->arr = taosArrayInit(num, sizeof(char*));
     for(size_t i = 0; i < num; i++) {
@@ -228,9 +231,18 @@ void tVariantAssign(tVariant *pDst, const tVariant *pSrc) {
       char* n = strdup(p);
       taosArrayPush(pDst->arr, &n);
     }
+  } else if (pSrc->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
+      size_t num = taosArrayGetSize(pSrc->arr);
+      pDst->arr = taosArrayInit(num, sizeof(int64_t));
+      pDst->nLen = pSrc->nLen;
+      assert(pSrc->nLen == num);
+      for(size_t i = 0; i < num; i++) {
+        int64_t *p = taosArrayGet(pSrc->arr, i);
+        taosArrayPush(pDst->arr, p);
+      }
   }
 
-  if (pDst->nType != TSDB_DATA_TYPE_ARRAY) {
+  if (pDst->nType != TSDB_DATA_TYPE_POINTER_ARRAY && pDst->nType != TSDB_DATA_TYPE_VALUE_ARRAY) {
     pDst->nLen = tDataTypes[pDst->nType].bytes;
   }
 }

src/inc/taoserror.h

@@ -260,6 +260,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW       TAOS_DEF_ERROR_CODE(0, 0x070A)  //"Too many time window in query")
 #define TSDB_CODE_QRY_NOT_ENOUGH_BUFFER         TAOS_DEF_ERROR_CODE(0, 0x070B)  //"Query buffer limit has reached")
 #define TSDB_CODE_QRY_INCONSISTAN               TAOS_DEF_ERROR_CODE(0, 0x070C)  //"File inconsistency in replica")
+#define TSDB_CODE_QRY_INVALID_TIME_CONDITION    TAOS_DEF_ERROR_CODE(0, 0x070D)  //"invalid time condition")
 
 
 // grant

src/inc/ttype.h

@@ -29,7 +29,8 @@ typedef struct tstr {
 #define IS_VAR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
 // this data type is internally used only in 'in' query to hold the values
-#define TSDB_DATA_TYPE_ARRAY      (1000)
+#define TSDB_DATA_TYPE_POINTER_ARRAY      (1000)
+#define TSDB_DATA_TYPE_VALUE_ARRAY      (1001)
 
 #define GET_TYPED_DATA(_v, _finalType, _type, _data) \
   do {                                               \
@@ -161,6 +162,8 @@ typedef struct tDataTypeDescriptor {
   int16_t nameLen;
   int32_t bytes;
   char *  name;
+  int64_t minValue;
+  int64_t maxValue;
   int (*compFunc)(const char *const input, int inputSize, const int nelements, char *const output, int outputSize,
                   char algorithm, char *const buffer, int bufferSize);
   int (*decompFunc)(const char *const input, int compressedSize, const int nelements, char *const output,
@@ -180,6 +183,7 @@ void *getNullValue(int32_t type);
 
 void assignVal(char *val, const char *src, int32_t len, int32_t type);
 void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf);
+void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type);
 
 int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bool issigned);
 

src/query/inc/qFilter.h

@@ -41,30 +41,50 @@ enum {
   MR_OPT_TS = 1,
 };
 
+enum {
+  RA_EXCLUDE = 1,
+  RA_NULL    = 2,
+};
+
 typedef struct OptrStr {
   uint16_t optr;
   char    *str;
 } OptrStr;
 
+typedef struct SFilterColRange {  
+  uint16_t idx;  //column field idx
+  int64_t s;
+  int64_t e;
+} SFilterColRange;
+
 typedef struct SFilterRange {
-  struct SFilterRange*   prev;
-  struct SFilterRange*   next;
+  char sflag;
+  char eflag;
   int64_t s;
   int64_t e;
 } SFilterRange;
 
+
+typedef struct SFilterRangeNode {
+  struct SFilterRangeNode*   prev;
+  struct SFilterRangeNode*   next;
+  SFilterRange ra;
+} SFilterRangeNode;
+
 typedef struct SFilterRMCtx {
   int32_t type;
   int32_t options;
   int8_t  status;
   __compar_fn_t pCompareFunc;
-  SFilterRange *rs;
+  SFilterRangeNode *rf;        //freed
+  SFilterRangeNode *rs;
 } SFilterRMCtx ;
 
 typedef struct SFilterField {
   uint16_t type;
   void*    desc;
   void*    data;
+  int64_t  range[];
 } SFilterField;
 
 typedef struct SFilterFields {
@@ -106,14 +126,23 @@ typedef struct SFilterInfo {
   uint8_t      *unitFlags;  // got result
 } SFilterInfo;
 
+#define COL_FIELD_SIZE (sizeof(SFilterField) + 2 * sizeof(int64_t))
+
+#define FILTER_NO_MERGE_DATA_TYPE(t) ((t) == TSDB_DATA_TYPE_BINARY || (t) == TSDB_DATA_TYPE_NCHAR)
+#define FILTER_NO_MERGE_OPTR(o) ((o) == TSDB_RELATION_ISNULL || (o) == TSDB_RELATION_NOTNULL)
+
+#define MR_EMPTY_RES(ctx) (ctx->rs == NULL)
+
 #define MR_GET_FLAG(st, f) (st & f)
 #define MR_SET_FLAG(st, f) st |= (f)
 
-#define GEN_RANGE(r, t, s, e) do { r = calloc(1, sizeof(SFilterRange)); assignVal((char*)&(r)->s, s, 0, t); assignVal((char*)&(r)->e, e, 0, t); } while (0)
-#define FREE_RANGE(rs, r) do { if (r->prev) { r->prev->next = r->next; } else { rs = r->next;} if (r->next) { r->next->prev = r->prev; } free(r); } while (0)
-#define FREE_FROM_RANGE(rs, r) do { if (r->prev) { r->prev->next = NULL; } else { rs = NULL;} while (r) {SFilterRange *n = r->next; free(r); r = n; } } while (0)
-#define INSERT_RANGE(rs, r, t, s, e) do { SFilterRange *n = calloc(1, sizeof(SFilterRange)); assignVal((char*)&n->s, s, 0, t); assignVal((char*)&n->e, e, 0, t); n->prev = r->prev; r->prev = n; if (r->prev) { r->prev->next = n; } else { rs->next = n; } n->next = r; } while (0)
-#define APPEND_RANGE(r, t, s, e) do { SFilterRange *n = calloc(1, sizeof(SFilterRange)); assignVal((char*)&n->s, s, 0, t); assignVal((char*)&n->e, e, 0, t); n->prev = r; r->next = n; } while (0)
+#define SIMPLE_COPY_VALUES(dst, src) *((int64_t *)dst) = *((int64_t *)src)
+
+#define RESET_RANGE(ctx, r) do { r->next = ctx->rf; ctx->rf = r; } while (0)
+#define FREE_RANGE(ctx, r) do { if (r->prev) { r->prev->next = r->next; } else { ctx->rs = r->next;} if (r->next) { r->next->prev = r->prev; } RESET_RANGE(ctx, r); } while (0)
+#define FREE_FROM_RANGE(ctx, r) do { if (r->prev) { r->prev->next = NULL; } else { ctx->rs = NULL;} while (r) {SFilterRangeNode *n = r->next; RESET_RANGE(ctx, r); r = n; } } while (0)
+#define INSERT_RANGE(ctx, r, t, s, e) do { SFilterRangeNode *n = filterNewRange(ctx, t, s, e); n->prev = r->prev; if (r->prev) { r->prev->next = n; } else { ctx->rs = n; } r->prev = n; n->next = r; } while (0)
+#define APPEND_RANGE(ctx, r, t, s, e) do { SFilterRangeNode *n = filterNewRange(ctx, t, s, e); n->prev = r; if (r) { r->next = n; } else { ctx->rs = n; } } while (0)
 
 #define ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { return _code; } } while (0)
 #define ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); return _code; } } while (0)
@@ -121,6 +150,7 @@ typedef struct SFilterInfo {
 
 #define CHK_RETV(c) do { if (c) { return; } } while (0)
 #define CHK_RET(c, r) do { if (c) { return r; } } while (0)
+#define CHK_JMP(c) do { if (c) { goto _err_return; } } while (0)
 #define CHK_LRETV(c,...) do { if (c) { qError(__VA_ARGS__); return; } } while (0)
 #define CHK_LRET(c, r,...) do { if (c) { qError(__VA_ARGS__); return r; } } while (0)
 
@@ -130,7 +160,13 @@ typedef struct SFilterInfo {
 #define FILTER_GET_VAL_FIELD_TYPE(fi) (((tVariant *)((fi)->desc))->nType)
 #define FILTER_GET_VAL_FIELD_DATA(fi) ((fi)->data)
 
-
+#define FILTER_GROUP_UNIT(i, g, uid) ((i)->units[(g)->unitIdxs[uid]])
+#define FILTER_UNIT_LEFT_FIELD(i, u) FILTER_GET_FIELD(i, (u)->left)
+#define FILTER_UNIT_RIGHT_FIELD(i, u) FILTER_GET_FIELD(i, (u)->right)
+#define FILTER_UNIT_DATA_TYPE(i, u) FILTER_GET_COL_FIELD_TYPE(FILTER_UNIT_LEFT_FIELD(i, u))
+#define FILTER_UNIT_VAL(i, u) FILTER_GET_VAL_FIELD_DATA(FILTER_UNIT_RIGHT_FIELD(i, u))
+#define FILTER_UNIT_COL_IDX(u) ((u)->left.idx)
+#define FILTER_UNIT_OPTR(u) ((u)->compare.optr)
 
 #define FILTER_UNIT_CLR_F(i) memset((i)->unitFlags, 0, (i)->unitNum * sizeof(*info->unitFlags)) 
 #define FILTER_UNIT_SET_F(i, idx) (i)->unitFlags[idx] = 1
@@ -149,7 +185,7 @@ extern int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr);
 extern int32_t filterGetMergeRangeNum(void* h, int32_t* num);
 extern int32_t filterGetMergeRangeRes(void* h, void *s, void* e);
 extern int32_t filterFreeMergeRange(void* h);
-
+extern int32_t filterGetTimeRange(SFilterInfo *info, STimeWindow *win);
 #ifdef __cplusplus
 }
 #endif

src/query/src/qExecutor.c

@@ -6966,7 +6966,10 @@ int32_t createQueryFilter(char *data, uint16_t len, SFilterInfo** pFilters) {
     return TSDB_CODE_QRY_APP_ERROR;
   }
 
-  return filterInitFromTree(expr, pFilters);
+  int32_t ret = filterInitFromTree(expr, pFilters);
+  tExprTreeDestroy(expr, NULL);
+
+  return ret;
 }
 
 
@@ -7284,10 +7287,6 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
   }
 
   doUpdateExprColumnIndex(pQueryAttr);
-  int32_t ret = createFilterInfo(pQueryAttr, pQInfo->qId);
-  if (ret != TSDB_CODE_SUCCESS) {
-    goto _cleanup;
-  }
 
   if (pQueryAttr->fillType != TSDB_FILL_NONE) {
     pQueryAttr->fillVal = malloc(sizeof(int64_t) * pQueryAttr->numOfOutput);

src/query/src/qSqlParser.c

@@ -401,6 +401,9 @@ tSqlExpr *tSqlExprClone(tSqlExpr *pSrc) {
     pExpr->pRight = tSqlExprClone(pSrc->pRight);
   }
 
+  memset(&pExpr->value, 0, sizeof(pExpr->value));
+  tVariantAssign(&pExpr->value, &pSrc->value);
+
   //we don't clone pParam now because clone is only used for between/and
   assert(pSrc->pParam == NULL);
   return pExpr;

src/query/src/queryMain.c

@@ -188,6 +188,8 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
     taosArrayDestroy(param.pGroupbyExpr->columnInfo);
   }
 
+  tfree(param.colCond);
+  
   taosArrayDestroy(param.pTableIdList);
   param.pTableIdList = NULL;
 

src/query/tests/rangeMergeTest.cpp

@@ -14,81 +14,100 @@ namespace {
 
 void intDataTest() {
   printf("running %s\n", __FUNCTION__);
-  int32_t s0[3] = {-100, 1, 3};
-  int32_t e0[3] = {0   , 2, 4};
+  int32_t asize = 0;
+  int64_t *s =NULL;
+  int64_t *e =NULL;
+  int64_t s0[3] = {-100, 1, 3};
+  int64_t e0[3] = {0   , 2, 4};
   int64_t s1[3] = {INT64_MIN, 0 , 3};
   int64_t e1[3] = {100      , 50, 4};
   int64_t s2[5] = {1 , 3  , 10,30,70};
   int64_t e2[5] = {10, 100, 20,50,120};
   int64_t s3[3] = {1 , 20 , 5};
   int64_t e3[3] = {10, 100, 25};
+  int64_t s4[2] = {10, 0};
+  int64_t e4[2] = {20, 5};
+  int64_t s5[3] = {0, 6 ,7};
+  int64_t e5[5] = {4, 10,20};
 
-  int32_t rs0[3];
-  int32_t re0[3];
-  int64_t rs1[3];
-  int64_t re1[3];
-  int64_t rs2[5];
-  int64_t re2[5];
-  int64_t rs3[5];
-  int64_t re3[5];
+  int64_t rs[10];
+  int64_t re[10];
 
   int32_t num = 0;
-  
-  void *h = filterInitMergeRange(TSDB_DATA_TYPE_INT, 0);
-  for (int32_t i = 0; i < sizeof(s0)/sizeof(s0[0]); ++i) {
-    filterAddMergeRange(h, s0 + i, e0 + i, TSDB_RELATION_AND);
+
+  s = s0;
+  e = e0;
+  asize = sizeof(s0)/sizeof(s[0]);
+  void *h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 0);
   filterFreeMergeRange(h);
 
 
-
-  h = filterInitMergeRange(TSDB_DATA_TYPE_INT, 0);
-  for (int32_t i = 0; i < sizeof(s0)/sizeof(s0[0]); ++i) {
-    filterAddMergeRange(h, s0 + i, e0 + i, TSDB_RELATION_OR);
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 3);
-  filterGetMergeRangeRes(h, rs0, re0);
-  ASSERT_EQ(rs0[0], -100);
-  ASSERT_EQ(re0[0], 0);
-  ASSERT_EQ(rs0[1], 1);
-  ASSERT_EQ(re0[1], 2);
-  ASSERT_EQ(rs0[2], 3);
-  ASSERT_EQ(re0[2], 4);  
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], -100);
+  ASSERT_EQ(re[0], 0);
+  ASSERT_EQ(rs[1], 1);
+  ASSERT_EQ(re[1], 2);
+  ASSERT_EQ(rs[2], 3);
+  ASSERT_EQ(re[2], 4);  
   filterFreeMergeRange(h);
 
 
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, MR_OPT_TS);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
+  }
+  filterGetMergeRangeNum(h, &num);
+  ASSERT_EQ(num, 1);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], -100);
+  ASSERT_EQ(re[0], 4);
+  filterFreeMergeRange(h);
+
 
+  s = s1;
+  e = e1;
+  asize = sizeof(s1)/sizeof(s[0]);
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s1)/sizeof(s1[0]); ++i) {
-    filterAddMergeRange(h, s1 + i, e1 + i, TSDB_RELATION_AND);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 1);
-  filterGetMergeRangeRes(h, rs1, re1);
-  ASSERT_EQ(rs1[0], 3);
-  ASSERT_EQ(re1[0], 4);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 3);
+  ASSERT_EQ(re[0], 4);
   filterFreeMergeRange(h);
 
 
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s1)/sizeof(s1[0]); ++i) {
-    filterAddMergeRange(h, s1 + i, e1 + i, TSDB_RELATION_OR);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 1);
-  filterGetMergeRangeRes(h, rs1, re1);
-  ASSERT_EQ(rs1[0], INT64_MIN);
-  ASSERT_EQ(re1[0], 100);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], INT64_MIN);
+  ASSERT_EQ(re[0], 100);
   filterFreeMergeRange(h);
 
 
-
+  s = s2;
+  e = e2;
+  asize = sizeof(s2)/sizeof(s[0]);
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
-    filterAddMergeRange(h, s2 + i, e2 + i, TSDB_RELATION_AND);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 0);
@@ -96,21 +115,21 @@ void intDataTest() {
 
 
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
-    filterAddMergeRange(h, s2 + i, e2 + i, TSDB_RELATION_OR);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 1);
-  filterGetMergeRangeRes(h, rs2, re2);
-  ASSERT_EQ(rs2[0], 1);
-  ASSERT_EQ(re2[0], 120);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 1);
+  ASSERT_EQ(re[0], 120);
   filterFreeMergeRange(h);
 
 
 
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
-    filterAddMergeRange(h, s2 + i, e2 + i, i % 2 ? TSDB_RELATION_OR : TSDB_RELATION_AND);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, i % 2 ? TSDB_RELATION_OR : TSDB_RELATION_AND);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 0);
@@ -118,21 +137,23 @@ void intDataTest() {
 
 
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
-    filterAddMergeRange(h, s2 + i, e2 + i, i % 2 ? TSDB_RELATION_AND : TSDB_RELATION_OR);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, i % 2 ? TSDB_RELATION_AND : TSDB_RELATION_OR);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 1);
-  filterGetMergeRangeRes(h, rs2, re2);
-  ASSERT_EQ(rs2[0], 70);
-  ASSERT_EQ(re2[0], 120);  
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 70);
+  ASSERT_EQ(re[0], 120);  
   filterFreeMergeRange(h);
 
 
-
+  s = s3;
+  e = e3;
+  asize = sizeof(s3)/sizeof(s[0]);
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s3)/sizeof(s3[0]); ++i) {
-    filterAddMergeRange(h, s3 + i, e3 + i, TSDB_RELATION_AND);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 0);
@@ -140,17 +161,82 @@ void intDataTest() {
 
 
   h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
-  for (int32_t i = 0; i < sizeof(s3)/sizeof(s3[0]); ++i) {
-    filterAddMergeRange(h, s3 + i, e3 + i, TSDB_RELATION_OR);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
   }
   filterGetMergeRangeNum(h, &num);
   ASSERT_EQ(num, 1);
-  filterGetMergeRangeRes(h, rs3, re3);
-  ASSERT_EQ(rs3[0], 1);
-  ASSERT_EQ(re3[0], 100);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 1);
+  ASSERT_EQ(re[0], 100);
+  filterFreeMergeRange(h);
+
+
+
+
+  s = s4;
+  e = e4;
+  asize = sizeof(s4)/sizeof(s[0]);
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
+  }
+  filterGetMergeRangeNum(h, &num);
+  ASSERT_EQ(num, 0);
+  filterFreeMergeRange(h);
+
+
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
+  }
+  filterGetMergeRangeNum(h, &num);
+  ASSERT_EQ(num, 2);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 0);
+  ASSERT_EQ(re[0], 5);
+  ASSERT_EQ(rs[1], 10);
+  ASSERT_EQ(re[1], 20);
+  filterFreeMergeRange(h);
+
+
+  s = s5;
+  e = e5;
+  asize = sizeof(s5)/sizeof(s[0]);
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
+  }
+  filterGetMergeRangeNum(h, &num);
+  ASSERT_EQ(num, 0);
+  filterFreeMergeRange(h);
+
+
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
+  }
+  filterGetMergeRangeNum(h, &num);
+  ASSERT_EQ(num, 2);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 0);
+  ASSERT_EQ(re[0], 4);
+  ASSERT_EQ(rs[1], 6);
+  ASSERT_EQ(re[1], 20);
   filterFreeMergeRange(h);
 
 
+  h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
+  for (int32_t i = 0; i < asize; ++i) {
+    filterAddMergeRange(h, s + i, e + i, (i == (asize -1)) ? TSDB_RELATION_AND : TSDB_RELATION_OR);
+  }
+  filterGetMergeRangeNum(h, &num);
+  ASSERT_EQ(num, 1);
+  filterGetMergeRangeRes(h, rs, re);
+  ASSERT_EQ(rs[0], 7);
+  ASSERT_EQ(re[0], 10);
+  filterFreeMergeRange(h);
+
 
 }
 

src/util/src/terror.c

@@ -268,6 +268,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_IN_EXEC,                  "Multiple retrieval of
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW,      "Too many time window in query")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_ENOUGH_BUFFER,        "Query buffer limit has reached")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN,              "File inconsistance in replica")
+TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_TIME_CONDITION,   "One valid time range condition expected")
 
 
 // grant

tests/script/general/parser/condition.sim

@@ -1527,12 +1527,109 @@ sql_error select ts,c1,c7 from stb1 where ts != '2021-05-05 18:19:27'
 sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' or ts < '2021-05-05 18:19:02.000';
 sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' and ts > '2021-05-05 18:19:20.000' and ts != '2021-05-05 18:19:22.000';
 sql_error select * from stb1 where ts2 like '2021-05-05%';
+sql_error select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts < '2021-05-05 18:19:02';
+sql_error select ts,c1,c2 from stb1 where (ts > '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:05.000') and ts > '2021-05-05 18:19:01.000' and ts < '2021-05-05 18:19:27.000';
+sql_error select ts,c1,c2 from stb1 where (ts > '2021-05-05 18:19:20.000' or ts < '2021-05-05 18:19:05.000') and ts != '2021-05-05 18:19:25.000';
+sql_error select ts,c1,c2 from stb1 where ((ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:15.000' and ts <= '2021-05-05 18:19:20.000') or (ts >= '2021-05-05 18:19:11.000' and ts <= '2021-05-05 18:19:14.000'));
+sql_error select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:24.000';
+sql_error select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' and ts < '2021-05-05 18:19:10.000';
+
+sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:25.000';
+if $rows != 29 then
+  return -1
+endi
 
-sql select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts < '2021-05-05 18:19:02';
-if $rows != 0 then
+sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' and ts < '2021-05-05 18:19:26.000';
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:25.000@ then
+  return -1
+endi
+sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:28.000';
+if $rows != 29 then
+  return -1
+endi
+sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts > '2021-05-05 18:19:27.000';
+if $rows != 4 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:25.000@ then
+  return -1
+endi
+if $data10 != @21-05-05 18:19:26.000@ then
+  return -1
+endi
+if $data20 != @21-05-05 18:19:27.000@ then
+  return -1
+endi
+if $data30 != @21-05-05 18:19:28.000@ then
+  return -1
+endi
+
+sql select ts,c1,c2 from stb1 where ts > '2021-05-05 18:19:20.000' or ts < '2021-05-05 18:19:05.000' or ts != '2021-05-05 18:19:25.000';
+if $rows != 29 then
+  return -1
+endi
+
+sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts <> '2021-05-05 18:19:25.000';
+if $rows != 29 then
+  return -1
+endi
+
+sql select ts,c1,c2 from stb1 where ((ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.999') or (ts >= '2021-05-05 18:19:15.000' and ts <= '2021-05-05 18:19:20.000') or (ts >= '2021-05-05 18:19:11.000' and ts <= '2021-05-05 18:19:14.999'));
+if $rows != 16 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:05.000@ then
+  return -1
+endi
+
+sql select ts,c1,c2 from stb1 where (ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:12.000' and ts <= '2021-05-05 18:19:14.000') or (ts >= '2021-05-05 18:19:08.000' and ts <= '2021-05-05 18:19:17.000');
+if $rows != 13 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:05.000@ then
   return -1
 endi
 
+sql  select ts,c1,c2 from stb1 where (ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:02.000' and ts <= '2021-05-05 18:19:03.000') or (ts >= '2021-05-05 18:19:01.000' and ts <= '2021-05-05 18:19:08.000');
+if $rows != 10 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:01.000@ then
+  return -1
+endi
+
+sql  select ts,c1,c2 from stb1 where ((ts >= '2021-05-05 18:19:08.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:02.000' and ts <= '2021-05-05 18:19:03.000') or (ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:06.000') or (ts >= '2021-05-05 18:19:03.000' and ts <= '2021-05-05 18:19:12.000')) and (ts >= '2021-05-05 18:19:10.000');
+if $rows != 3 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:10.000@ then
+  return -1
+endi
+if $data10 != @21-05-05 18:19:11.000@ then
+  return -1
+endi
+if $data20 != @21-05-05 18:19:12.000@ then
+  return -1
+endi
+
+sql select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:25.000' and ts != '2021-05-05 18:19:18';
+if $rows != 3 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:26.000@ then
+  return -1
+endi
+if $data10 != @21-05-05 18:19:27.000@ then
+  return -1
+endi
+if $data20 != @21-05-05 18:19:28.000@ then
+  return -1
+endi
+
+
 sql select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts > '2021-05-05 18:19:25';
 if $rows != 3 then
   return -1
@@ -1858,6 +1955,20 @@ if $data00 != @21-05-05 18:19:21.000@ then
   return -1
 endi
 
+sql select * from stb1 where c1!=31 and c1 !=32 and c1 <> 63 and c1 <>1 and c1 <> 21 and c1 <> 2 and c7 <> true and c8 <> '3' and c9 <> '4' and c2<>13 and c3 <> 23 and c4 <> 33 and c5 <> 34 and c6 <> 43 and c2 <> 53 and t1 <> 5 and t2 <>4;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != @21-05-05 18:19:07.000@ then
+  return -1
+endi
+if $data10 != @21-05-05 18:19:11.000@ then
+  return -1
+endi
+if $data20 != @21-05-05 18:19:27.000@ then
+  return -1
+endi
+
 
 print "column&join test"
 sql_error select tb1.ts,tb1.c1,tb2_1.u1 from tb1, tb2_1 where tb1.ts=tb2_1.ts or tb1.c1 > 0;