support like

src/client/src/tscSQLParser.c

@@ -185,10 +185,12 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType)
       break;
     }  
 
+    uint32_t tType = pSub->token.type;
     toTSDBType(pSub->token.type);  
 
     tVariant var;  
     tVariantCreate(&var, &pSub->token); 
+    pSub->token.type = tType;
     if (type == TSDB_DATA_TYPE_BOOL || type == TSDB_DATA_TYPE_TINYINT || type == TSDB_DATA_TYPE_SMALLINT 
          || type == TSDB_DATA_TYPE_BIGINT || type == TSDB_DATA_TYPE_INT) {
       tbufWriteInt64(&bw, var.i64);        
@@ -3465,44 +3467,28 @@ enum {
   TSQL_EXPR_TBNAME = 8,
 };
 
-static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SColumnIndex* pIndex, tSqlExpr* pExpr, int32_t sqlOptr) {
+static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SColumnIndex* pIndex, tSqlExpr* pExpr, int32_t sqlOptr) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pIndex->tableIndex);
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
   SSchema*    pSchema = tscGetTableColumnSchema(pTableMeta, pIndex->columnIndex);
-
+  int32_t     ret = 0;
   const char* msg1 = "non binary column not support like operator";
   const char* msg2 = "binary column not support this operator";  
   const char* msg3 = "bool column not support this operator";
 
   SColumn* pColumn = tscColumnListInsert(pQueryInfo->colList, pIndex->columnIndex, pTableMeta->id.uid, pSchema);
-  SColumnFilterInfo* pColFilter = NULL;
 
   /*
    * in case of TK_AND filter condition, we first find the corresponding column and build the query condition together
    * the already existed condition.
    */
-  if (sqlOptr == TK_AND) {
+  if (sqlOptr != TK_AND && sqlOptr != TK_OR) {
-    // this is a new filter condition on this column
-    if (pColumn->info.flist.numOfFilters == 0) {
-      pColFilter = addColumnFilterInfo(&pColumn->info.flist);
-    } else {  // update the existed column filter information, find the filter info here
-      pColFilter = &pColumn->info.flist.filterInfo[0];
-    }
-
-    if (pColFilter == NULL) {
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-  } else if (sqlOptr == TK_OR) {
-    // TODO fixme: failed to invalid the filter expression: "col1 = 1 OR col2 = 2"
-    pColFilter = addColumnFilterInfo(&pColumn->info.flist);
-    if (pColFilter == NULL) {
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-  } else {  // error;
     return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
+  SColumnFilterInfo* pColFilter = calloc(1, sizeof(SColumnFilterInfo));
+
   pColFilter->filterstr =
       ((pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) ? 1 : 0);
 
@@ -3513,17 +3499,20 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
       && pExpr->tokenId != TK_NOTNULL
       && pExpr->tokenId != TK_LIKE
       && pExpr->tokenId != TK_IN) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      goto _err_ret;
     }
   } else {
     if (pExpr->tokenId == TK_LIKE) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      goto _err_ret;
     }
     
     if (pSchema->type == TSDB_DATA_TYPE_BOOL) {
       int32_t t = pExpr->tokenId;
       if (t != TK_EQ && t != TK_NE && t != TK_NOTNULL && t != TK_ISNULL && t != TK_IN) {
-        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        goto _err_ret;
       }
     }
   }
@@ -3532,7 +3521,12 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
   pColumn->tableUid = pTableMeta->id.uid;
 
   STableComInfo tinfo = tscGetTableInfo(pTableMeta);
-  return doExtractColumnFilterInfo(pCmd, pQueryInfo, tinfo.precision, pColFilter, pSchema->type, pExpr);
+  ret = doExtractColumnFilterInfo(pCmd, pQueryInfo, tinfo.precision, pColFilter, pSchema->type, pExpr);
+
+_err_ret:
+  freeColumnFilterInfo(pColFilter, 1);
+  
+  return ret;
 }
 
 static int32_t getTablenameCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pTableCond, SStringBuilder* sb) {
@@ -3626,25 +3620,25 @@ static int32_t getColQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlEx
 }
 
 
-static int32_t getColumnQueryCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, int32_t relOptr) {
+static int32_t checkColumnQueryCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, int32_t relOptr) {
   if (pExpr == NULL) {
     return TSDB_CODE_SUCCESS;
   }
 
   if (!tSqlExprIsParentOfLeaf(pExpr)) {  // internal node
-    int32_t ret = getColumnQueryCondInfo(pCmd, pQueryInfo, pExpr->pLeft, pExpr->tokenId);
+    int32_t ret = checkColumnQueryCondInfo(pCmd, pQueryInfo, pExpr->pLeft, pExpr->tokenId);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
 
-    return getColumnQueryCondInfo(pCmd, pQueryInfo, pExpr->pRight, pExpr->tokenId);
+    return checkColumnQueryCondInfo(pCmd, pQueryInfo, pExpr->pRight, pExpr->tokenId);
   } else {  // handle leaf node
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
-    return extractColumnFilterInfo(pCmd, pQueryInfo, &index, pExpr, relOptr);
+    return checkColumnFilterInfo(pCmd, pQueryInfo, &index, pExpr, relOptr);
   }
 }
 
@@ -4050,7 +4044,7 @@ static int32_t validateNullExpr(tSqlExpr* pExpr, char* msgBuf) {
 // check for like expression
 static int32_t validateLikeExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t index, char* msgBuf) {
   const char* msg1 = "wildcard string should be less than 20 characters";
-  const char* msg2 = "illegal column name";
+  const char* msg2 = "illegal column type for like";
 
   tSqlExpr* pLeft  = pExpr->pLeft;
   tSqlExpr* pRight = pExpr->pRight;
@@ -4433,36 +4427,9 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
   return TSDB_CODE_SUCCESS;
 }
 
-static bool validateFilterExpr(SQueryInfo* pQueryInfo) {
-  SArray* pColList = pQueryInfo->colList;
-  
-  size_t num = taosArrayGetSize(pColList);
-  
-  for (int32_t i = 0; i < num; ++i) {
-    SColumn* pCol = taosArrayGetP(pColList, i);
-
-    for (int32_t j = 0; j < pCol->info.flist.numOfFilters; ++j) {
-      SColumnFilterInfo* pColFilter = &pCol->info.flist.filterInfo[j];
-      int32_t            lowerOptr = pColFilter->lowerRelOptr;
-      int32_t            upperOptr = pColFilter->upperRelOptr;
-
-      if ((lowerOptr == TSDB_RELATION_GREATER_EQUAL || lowerOptr == TSDB_RELATION_GREATER) &&
-          (upperOptr == TSDB_RELATION_LESS_EQUAL || upperOptr == TSDB_RELATION_LESS)) {
-        continue;
-      }
-
-      // there must be at least two range, not support yet.
-      if (lowerOptr * upperOptr != TSDB_RELATION_INVALID) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
 
 static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr) {
-  const char* msg0 = "invalid timestamp";
+  const char* msg0 = "invalid timestamp or operator for timestamp";
   const char* msg1 = "only one time stamp window allowed";
   int32_t code = 0;
 
@@ -4844,7 +4811,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
   }
 
   const char* msg1 = "invalid expression";
-  const char* msg2 = "invalid filter expression";
+//  const char* msg2 = "invalid filter expression";
 
   int32_t ret = TSDB_CODE_SUCCESS;
 
@@ -4887,16 +4854,16 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
     goto PARSE_WHERE_EXIT;
   }
 
+  // 5. other column query condition
+  if ((ret = checkColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pColumnCond, TK_AND)) != TSDB_CODE_SUCCESS) {
+    goto PARSE_WHERE_EXIT;
+  }
+
   if ((ret = getColQueryCondExpr(&pSql->cmd, pQueryInfo, &condExpr.pColumnCond)) != TSDB_CODE_SUCCESS) {
     goto PARSE_WHERE_EXIT;
   }
 
 
-  // 5. other column query condition
-  if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pColumnCond, TK_AND)) != TSDB_CODE_SUCCESS) {
-    goto PARSE_WHERE_EXIT;
-  }
-
   // 6. join condition
   if ((ret = getJoinCondInfo(&pSql->cmd, pQueryInfo, condExpr.pJoinExpr)) != TSDB_CODE_SUCCESS) {
     goto PARSE_WHERE_EXIT;
@@ -4911,10 +4878,10 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
     goto PARSE_WHERE_EXIT;
   }
 
-  if (!validateFilterExpr(pQueryInfo)) {
+  //if (!validateFilterExpr(pQueryInfo)) {
-    ret = invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
+  //  ret = invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
-    goto PARSE_WHERE_EXIT;
+  //  goto PARSE_WHERE_EXIT;
-  }
+  //}
 
   //doAddJoinTagsColumnsIntoTagList(&pSql->cmd, pQueryInfo, &condExpr);
   if (condExpr.tsJoin) {
@@ -4945,7 +4912,7 @@ int32_t getTimeRange(STimeWindow* win, tSqlExpr* pRight, int32_t optr, int16_t t
    * filter primary ts filter expression like:
    * where ts in ('2015-12-12 4:8:12')
    */
-  if (pRight->tokenId == TK_SET || optr == TK_IN) {
+  if (pRight->tokenId == TK_SET || optr == TK_IN || optr == TK_NE) {
     return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 

src/client/src/tscServer.c

@@ -882,10 +882,11 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pQueryMsg->tableCols[i].colId = htons(pCol->colId);
     pQueryMsg->tableCols[i].bytes = htons(pCol->bytes);
     pQueryMsg->tableCols[i].type  = htons(pCol->type);
-    pQueryMsg->tableCols[i].flist.numOfFilters = htons(pCol->flist.numOfFilters);
+    //pQueryMsg->tableCols[i].flist.numOfFilters = htons(pCol->flist.numOfFilters);
+    pQueryMsg->tableCols[i].flist.numOfFilters = 0;
 
     // append the filter information after the basic column information
-    serializeColFilterInfo(pCol->flist.filterInfo, pCol->flist.numOfFilters, &pMsg);
+    //serializeColFilterInfo(pCol->flist.filterInfo, pCol->flist.numOfFilters, &pMsg);
   }
 
   if (pQueryInfo->colCond && taosArrayGetSize(pQueryInfo->colCond) > 0) {

src/kit/shell/src/shellEngine.c

@@ -248,7 +248,7 @@ int32_t shellRunCommand(TAOS* con, char* command) {
 
     if (quote == c) {
       quote = 0;
-    } else if (c == '\'' || c == '"') {
+    } else if (quote == 0 && (c == '\'' || c == '"')) {
       quote = c;
     }
 

src/query/src/qExecutor.c

@@ -6445,7 +6445,7 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
     pColInfo->colId = htons(pColInfo->colId);
     pColInfo->type = htons(pColInfo->type);
     pColInfo->bytes = htons(pColInfo->bytes);
-    pColInfo->flist.numOfFilters = htons(pColInfo->flist.numOfFilters);
+    pColInfo->flist.numOfFilters = 0;
 
     if (!isValidDataType(pColInfo->type)) {
       qDebug("qmsg:%p, invalid data type in source column, index:%d, type:%d", pQueryMsg, col, pColInfo->type);
@@ -6453,6 +6453,7 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
       goto _cleanup;
     }
 
+/*
     int32_t numOfFilters = pColInfo->flist.numOfFilters;
     if (numOfFilters > 0) {
       pColInfo->flist.filterInfo = calloc(numOfFilters, sizeof(SColumnFilterInfo));
@@ -6466,6 +6467,7 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
     if (code != TSDB_CODE_SUCCESS) {
       goto _cleanup;
     }
+*/    
   }
 
   if (pQueryMsg->colCondLen > 0) {

src/query/src/qFilter.c

@@ -334,7 +334,7 @@ int32_t filterInitValFieldData(SFilterInfo *info) {
       fi->data = calloc(1, sizeof(int64_t));
     }
 
-    ERR_LRET(tVariantDump(var, (char*)fi->data, type, false), "dump type[%d] failed", type);
+    ERR_LRET(tVariantDump(var, (char*)fi->data, type, true), "dump type[%d] failed", type);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -402,8 +402,18 @@ bool filterExecute(SFilterInfo *info, int32_t numOfRows, int8_t* p) {
           SFilterField *left = FILTER_GET_FIELD(info, unit->left);
           SFilterField *right = FILTER_GET_FIELD(info, unit->right);
 
-          ures = filterDoCompare(unit, FILTER_GET_COL_FIELD_DATA(left, i), FILTER_GET_VAL_FIELD_DATA(right));
+          if (isNull(FILTER_GET_COL_FIELD_DATA(left, i), FILTER_GET_COL_FIELD_TYPE(left))) {
-
+            ures = unit->compare.optr == TSDB_RELATION_ISNULL ? true : false;
+          } else {
+            if (unit->compare.optr == TSDB_RELATION_NOTNULL) {
+              ures = true;
+            } else if (unit->compare.optr == TSDB_RELATION_ISNULL) {
+              ures = false;
+            } else {
+              ures = filterDoCompare(unit, FILTER_GET_COL_FIELD_DATA(left, i), FILTER_GET_VAL_FIELD_DATA(right));
+            }
+          }
+          
           FILTER_UNIT_SET_R(info, uidx, ures);
           FILTER_UNIT_SET_F(info, uidx);
         }