From d65b541bbf59e16cfc24ccaf3e311b5d106fb4fb Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Tue, 2 Mar 2021 19:18:13 +0800
Subject: [PATCH 01/19] support having

---
 src/client/inc/tsclient.h     |   1 +
 src/client/src/tscSQLParser.c | 283 ++++++++++++++++++++++++++++++----
 src/client/src/tscUtil.c      |   4 +
 src/inc/ttokendef.h           |   2 +
 src/query/inc/qSqlparser.h    |   3 +-
 src/query/inc/sql.y           |   4 +-
 src/query/src/qParserImpl.c   |   6 +-
 src/query/src/sql.c           |   4 +-
 8 files changed, 267 insertions(+), 40 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 8f76f812ac..f3bdbe2e84 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -121,6 +121,7 @@ typedef struct SInternalField {
   bool            visible;
   SExprInfo      *pArithExprInfo;
   SSqlExpr       *pSqlExpr;
+  SColumn        *pFieldFilters;
 } SInternalField;
 
 typedef struct SFieldInfo {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index b2c1a594a1..9656aca2a7 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1031,6 +1031,41 @@ static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd) {
   return true;
 }
 
+static void exchangeExpr(tSQLExpr* pExpr) {
+  tSQLExpr* pLeft = pExpr->pLeft;
+  tSQLExpr* pRight = pExpr->pRight;
+
+  if ((pRight->nSQLOptr == TK_ID || (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) && 
+     (pLeft->nSQLOptr == TK_INTEGER || pLeft->nSQLOptr == TK_FLOAT || pLeft->nSQLOptr == TK_STRING || pLeft->nSQLOptr == TK_BOOL)) {
+    /*
+     * exchange value of the left handside and the value of the right-handside
+     * to make sure that the value of filter expression always locates in
+     * right-handside and
+     * the column-id/function is at the left handside.
+     */
+    uint32_t optr = 0;
+    switch (pExpr->nSQLOptr) {
+      case TK_LE:
+        optr = TK_GE;
+        break;
+      case TK_LT:
+        optr = TK_GT;
+        break;
+      case TK_GT:
+        optr = TK_LT;
+        break;
+      case TK_GE:
+        optr = TK_LE;
+        break;
+      default:
+        optr = pExpr->nSQLOptr;
+    }
+
+    pExpr->nSQLOptr = optr;
+    SWAP(pExpr->pLeft, pExpr->pRight, void*);
+  }
+}
+
 static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd) {
   assert(pTagsList != NULL);
 
@@ -3062,6 +3097,214 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd)
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t handleExprInHavingClause(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);
+
+  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);
+  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) {
+    // this is a new filter condition on this column
+    if (pColumn->numOfFilters == 0) {
+      pColFilter = addColumnFilterInfo(pColumn);
+    } else {  // update the existed column filter information, find the filter info here
+      pColFilter = &pColumn->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);
+    if (pColFilter == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+  } else {  // error;
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
+  pColFilter->filterstr =
+      ((pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) ? 1 : 0);
+
+  if (pColFilter->filterstr) {
+    if (pExpr->nSQLOptr != TK_EQ
+      && pExpr->nSQLOptr != TK_NE
+      && pExpr->nSQLOptr != TK_ISNULL
+      && pExpr->nSQLOptr != TK_NOTNULL
+      && pExpr->nSQLOptr != TK_LIKE
+      ) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    }
+  } else {
+    if (pExpr->nSQLOptr == TK_LIKE) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    
+    if (pSchema->type == TSDB_DATA_TYPE_BOOL) {
+      if (pExpr->nSQLOptr != TK_EQ && pExpr->nSQLOptr != TK_NE) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      }
+    }
+  }
+
+  pColumn->colIndex = *pIndex;
+  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pIndex, pExpr);
+}
+
+int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr** pExpr, int32_t parentOptr) {
+  if (pExpr == NULL || (*pExpr) == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  const char* msg1 = "invalid having clause";
+
+  tSQLExpr* pLeft = (*pExpr)->pLeft;
+  tSQLExpr* pRight = (*pExpr)->pRight;
+
+  if ((*pExpr)->nSQLOptr == TK_AND || (*pExpr)->nSQLOptr == TK_OR) {
+    int32_t ret = getHavingExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, (*pExpr)->nSQLOptr);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+
+    return getHavingExpr(pCmd, pQueryInfo, &(*pExpr)->pRight, (*pExpr)->nSQLOptr);
+  }
+
+  if ((pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE) && 
+    (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (pLeft->nSQLOptr >= TK_BOOL
+    && pLeft->nSQLOptr <= TK_BINARY
+    && pRight->nSQLOptr >= TK_BOOL
+    && pRight->nSQLOptr <= TK_BINARY) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  exchangeExpr(*pExpr);
+
+  pLeft = (*pExpr)->pLeft;
+  pRight = (*pExpr)->pRight;
+
+  if (!(pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (!(pRight->nSQLOptr >= TK_BOOL && pRight->nSQLOptr <= TK_BINARY)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if ((*pExpr)->nSQLOptr >= TK_BITAND) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (pLeft->pParam == NULL || pLeft->pParam->nExpr < 1) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
+    tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
+    if (pParamElem->pNode->nSQLOptr != TK_ALL && pParamElem->pNode->nSQLOptr != TK_ID) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    
+    SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+    if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    
+    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    
+    if (index.columnIndex <= 0 || 
+      index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+  }
+
+  tSqlExprItem item = {.pNode = pLeft, .aliasName = NULL, .distinct = false};
+
+  int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+
+  // ADD TRUE FOR TEST
+  if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
+  int32_t slot = tscNumOfFields(pQueryInfo) - 1;
+  SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
+  
+  if (pInfo->pFieldFilters == NULL) {
+    SColumn* pFieldFilters = calloc(1, sizeof(SColumn));
+    if (pFieldFilters == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+    
+    pInfo->pFieldFilters = pFieldFilters;
+  }
+
+  return handleExprInHavingClause(pCmd, pQueryInfo, pInfo->pFieldFilters, pExpr, parentOptr);
+}
+
+
+
+int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, SSqlCmd* pCmd) {
+  const char* msg1 = "having only works with group by";
+  //const char* msg2 = "invalid column name in having clause";
+  //const char* msg3 = "columns from one table allowed as having columns";
+  //const char* msg4 = "no tag allowed in having clause";
+  const char* msg5 = "invalid expression in having clause";
+
+/*  
+  const char* msg1 = "too many columns in group by clause";
+  const char* msg4 = "join query does not support group by";
+  const char* msg7 = "not support group by expression";
+  const char* msg8 = "not allowed column type for group by";
+  const char* msg9 = "tags not allowed for table query";
+*/
+
+  // todo : handle two tables situation
+  //STableMetaInfo* pTableMetaInfo = NULL;
+
+  if (pExpr == NULL || (*pExpr) == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (pQueryInfo->groupbyExpr.numOfGroupCols <= 0) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if ((*pExpr)->pLeft == NULL || (*pExpr)->pRight == NULL) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+  }
+
+  if (pQueryInfo->colList == NULL) {
+    pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
+  }
+
+  int32_t ret = 0;
+  
+  if ((ret = getHavingExpr(pCmd, pQueryInfo, pExpr, TK_AND)) != TSDB_CODE_SUCCESS) {
+    return ret;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 static SColumnFilterInfo* addColumnFilterInfo(SColumn* pColumn) {
   if (pColumn == NULL) {
     return NULL;
@@ -3715,40 +3958,7 @@ static bool isValidExpr(tSQLExpr* pLeft, tSQLExpr* pRight, int32_t optr) {
   return true;
 }
 
-static void exchangeExpr(tSQLExpr* pExpr) {
-  tSQLExpr* pLeft = pExpr->pLeft;
-  tSQLExpr* pRight = pExpr->pRight;
 
-  if (pRight->nSQLOptr == TK_ID && (pLeft->nSQLOptr == TK_INTEGER || pLeft->nSQLOptr == TK_FLOAT ||
-                                    pLeft->nSQLOptr == TK_STRING || pLeft->nSQLOptr == TK_BOOL)) {
-    /*
-     * exchange value of the left handside and the value of the right-handside
-     * to make sure that the value of filter expression always locates in
-     * right-handside and
-     * the column-id is at the left handside.
-     */
-    uint32_t optr = 0;
-    switch (pExpr->nSQLOptr) {
-      case TK_LE:
-        optr = TK_GE;
-        break;
-      case TK_LT:
-        optr = TK_GT;
-        break;
-      case TK_GT:
-        optr = TK_LT;
-        break;
-      case TK_GE:
-        optr = TK_LE;
-        break;
-      default:
-        optr = pExpr->nSQLOptr;
-    }
-
-    pExpr->nSQLOptr = optr;
-    SWAP(pExpr->pLeft, pExpr->pRight, void*);
-  }
-}
 
 static bool validateJoinExprNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SColumnIndex* pLeftIndex) {
   const char* msg1 = "illegal column name";
@@ -6729,7 +6939,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
    */
   if (pQuerySql->from == NULL) {
     assert(pQuerySql->fillType == NULL && pQuerySql->pGroupby == NULL && pQuerySql->pWhere == NULL &&
-           pQuerySql->pSortOrder == NULL);
+           pQuerySql->pSortOrder == NULL && pQuerySql->pHaving == NULL);
     return doLocalQueryProcess(pCmd, pQueryInfo, pQuerySql);
   }
 
@@ -6817,6 +7027,11 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
+  // parse the having clause in the first place
+  if (parseHavingClause(pQueryInfo, &pQuerySql->pHaving, pCmd) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
   // set where info
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index cfa73b969d..ef5e9170da 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1061,6 +1061,10 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
 
       tfree(pInfo->pArithExprInfo);
     }
+
+    if (pInfo->pFieldFilters != NULL) {
+      tscColumnDestroy(pInfo->pFieldFilters);
+    }
   }
   
   taosArrayDestroy(pFieldInfo->internalField);
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index 8bb9cde935..bf72a15ce2 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -233,6 +233,8 @@
 
 
 
+
+
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
 #define TK_ILLEGAL                        302
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index bcc876c953..8efaa4cb21 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -71,6 +71,7 @@ typedef struct SQuerySQL {
   SLimitVal            slimit;       // group limit offset [optional]
   SArray *             fillType;     // fill type[optional], SArray<tVariantListItem>
   SStrToken            selectToken;  // sql string
+  struct tSQLExpr *    pHaving;      // having clause [optional]
 } SQuerySQL;
 
 typedef struct SCreatedTableInfo {
@@ -242,7 +243,7 @@ void tSqlExprListDestroy(tSQLExprList *pList);
 
 SQuerySQL *tSetQuerySqlElems(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
                              SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
-                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
+                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit, tSQLExpr *pHaving);
 
 SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type);
 
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index 8a01a736b7..7d81d4279b 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -437,7 +437,7 @@ tagitem(A) ::= PLUS(X) FLOAT(Y).  {
 %type select {SQuerySQL*}
 %destructor select {doDestroyQuerySql($$);}
 select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
-  A = tSetQuerySqlElems(&T, W, X, Y, P, Z, &K, &S, F, &L, &G);
+  A = tSetQuerySqlElems(&T, W, X, Y, P, Z, &K, &S, F, &L, &G, N);
 }
 
 %type union {SSubclauseInfo*}
@@ -455,7 +455,7 @@ cmd ::= union(X). { setSqlInfo(pInfo, X, NULL, TSDB_SQL_SELECT); }
 // select server_version(), select client_version(),
 // select server_state();
 select(A) ::= SELECT(T) selcollist(W). {
-  A = tSetQuerySqlElems(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  A = tSetQuerySqlElems(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 // selcollist is a list of expressions that are to become the return
diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c
index 2416250dce..658815adcf 100644
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -531,7 +531,7 @@ void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
  */
 SQuerySQL *tSetQuerySqlElems(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
                              SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
-                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit) {
+                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit, tSQLExpr *pHaving) {
   assert(pSelection != NULL);
 
   SQuerySQL *pQuery = calloc(1, sizeof(SQuerySQL));
@@ -543,6 +543,7 @@ SQuerySQL *tSetQuerySqlElems(SStrToken *pSelectToken, tSQLExprList *pSelection,
   pQuery->pGroupby = pGroupby;
   pQuery->pSortOrder = pSortOrder;
   pQuery->pWhere = pWhere;
+  pQuery->pHaving = pHaving;
 
   if (pLimit != NULL) {
     pQuery->limit = *pLimit;
@@ -589,6 +590,9 @@ void doDestroyQuerySql(SQuerySQL *pQuerySql) {
 
   tSqlExprDestroy(pQuerySql->pWhere);
   pQuerySql->pWhere = NULL;
+
+  tSqlExprDestroy(pQuerySql->pHaving);
+  pQuerySql->pHaving = NULL;
   
   taosArrayDestroyEx(pQuerySql->pSortOrder, freeVariant);
   pQuerySql->pSortOrder = NULL;
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 2b1109688d..15a642bed5 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -2864,7 +2864,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 147: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy522, yymsp[-9].minor.yy247, yymsp[-8].minor.yy326, yymsp[-4].minor.yy247, yymsp[-3].minor.yy247, &yymsp[-7].minor.yy430, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy247, &yymsp[0].minor.yy204, &yymsp[-1].minor.yy204);
+  yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy522, yymsp[-9].minor.yy247, yymsp[-8].minor.yy326, yymsp[-4].minor.yy247, yymsp[-3].minor.yy247, &yymsp[-7].minor.yy430, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy247, &yymsp[0].minor.yy204, &yymsp[-1].minor.yy204, yymsp[-2].minor.yy326);
 }
   yymsp[-11].minor.yy114 = yylhsminor.yy114;
         break;
@@ -2888,7 +2888,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 153: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy522, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy522, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
   yymsp[-1].minor.yy114 = yylhsminor.yy114;
         break;

From 984e037e672ed2f23a3f0734f819f0811c65f014 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Wed, 3 Mar 2021 16:54:41 +0800
Subject: [PATCH 02/19] support having

---
 src/client/inc/tsclient.h      |  17 +-
 src/client/src/tscLocalMerge.c |  20 ++
 src/client/src/tscSQLParser.c  | 480 ++++++++++++++++++---------------
 src/client/src/tscUtil.c       |  32 ++-
 src/query/inc/qSqlparser.h     |   2 +
 src/query/src/qParserImpl.c    |  52 ++++
 6 files changed, 369 insertions(+), 234 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index f3bdbe2e84..aa0f1c9cff 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -116,13 +116,6 @@ typedef struct SColumnIndex {
   int16_t columnIndex;
 } SColumnIndex;
 
-typedef struct SInternalField {
-  TAOS_FIELD      field;
-  bool            visible;
-  SExprInfo      *pArithExprInfo;
-  SSqlExpr       *pSqlExpr;
-  SColumn        *pFieldFilters;
-} SInternalField;
 
 typedef struct SFieldInfo {
   int16_t      numOfOutput;   // number of column in result
@@ -136,6 +129,15 @@ typedef struct SColumn {
   SColumnFilterInfo *filterInfo;
 } SColumn;
 
+typedef struct SInternalField {
+  TAOS_FIELD      field;
+  bool            visible;
+  SExprInfo      *pArithExprInfo;
+  SSqlExpr       *pSqlExpr;
+  tSQLExpr       *pExpr;          //used for having parse 
+  SColumn        *pFieldFilters;  //having filter info
+} SInternalField;
+
 typedef struct SCond {
   uint64_t uid;
   int32_t  len;  // length of tag query condition data
@@ -228,6 +230,7 @@ typedef struct SQueryInfo {
   int32_t          round;         // 0/1/....
   int32_t          bufLen;
   char*            buf;
+  int32_t          havingFieldNum;
 } SQueryInfo;
 
 typedef struct {
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 23fb0ab67c..61d90598b4 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -1229,6 +1229,24 @@ static bool saveGroupResultInfo(SSqlObj *pSql) {
   return false;
 }
 
+int32_t doHavingFilter(SQueryInfo* pQueryInfo) {
+  if (pQueryInfo->havingFieldNum <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  size_t numOfOutput = tscNumOfFields(pQueryInfo);
+  for(int32_t i = 0; i < numOfOutput; ++i) {
+    SColumn* pFieldFilters = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i)->pFieldFilters;
+    if (pFieldFilters != NULL) {
+      continue;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
 /**
  *
  * @param pSql
@@ -1269,6 +1287,8 @@ bool genFinalResults(SSqlObj *pSql, SLocalMerger *pLocalMerge, bool noMoreCurren
     doArithmeticCalculate(pQueryInfo, pResBuf, pModel->rowSize, pLocalMerge->finalModel->rowSize);
   }
 
+  doHavingFilter(pQueryInfo);
+
   // no interval query, no fill operation
   if (pQueryInfo->interval.interval == 0 || pQueryInfo->fillType == TSDB_FILL_NONE) {
     genFinalResWithoutFill(pRes, pLocalMerge, pQueryInfo);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 9656aca2a7..588e9b18aa 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -3097,213 +3097,6 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd)
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t handleExprInHavingClause(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);
-
-  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);
-  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) {
-    // this is a new filter condition on this column
-    if (pColumn->numOfFilters == 0) {
-      pColFilter = addColumnFilterInfo(pColumn);
-    } else {  // update the existed column filter information, find the filter info here
-      pColFilter = &pColumn->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);
-    if (pColFilter == NULL) {
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-  } else {  // error;
-    return TSDB_CODE_TSC_INVALID_SQL;
-  }
-
-  pColFilter->filterstr =
-      ((pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) ? 1 : 0);
-
-  if (pColFilter->filterstr) {
-    if (pExpr->nSQLOptr != TK_EQ
-      && pExpr->nSQLOptr != TK_NE
-      && pExpr->nSQLOptr != TK_ISNULL
-      && pExpr->nSQLOptr != TK_NOTNULL
-      && pExpr->nSQLOptr != TK_LIKE
-      ) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
-    }
-  } else {
-    if (pExpr->nSQLOptr == TK_LIKE) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
-    
-    if (pSchema->type == TSDB_DATA_TYPE_BOOL) {
-      if (pExpr->nSQLOptr != TK_EQ && pExpr->nSQLOptr != TK_NE) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
-      }
-    }
-  }
-
-  pColumn->colIndex = *pIndex;
-  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pIndex, pExpr);
-}
-
-int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr** pExpr, int32_t parentOptr) {
-  if (pExpr == NULL || (*pExpr) == NULL) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  const char* msg1 = "invalid having clause";
-
-  tSQLExpr* pLeft = (*pExpr)->pLeft;
-  tSQLExpr* pRight = (*pExpr)->pRight;
-
-  if ((*pExpr)->nSQLOptr == TK_AND || (*pExpr)->nSQLOptr == TK_OR) {
-    int32_t ret = getHavingExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, (*pExpr)->nSQLOptr);
-    if (ret != TSDB_CODE_SUCCESS) {
-      return ret;
-    }
-
-    return getHavingExpr(pCmd, pQueryInfo, &(*pExpr)->pRight, (*pExpr)->nSQLOptr);
-  }
-
-  if ((pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE) && 
-    (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if (pLeft->nSQLOptr >= TK_BOOL
-    && pLeft->nSQLOptr <= TK_BINARY
-    && pRight->nSQLOptr >= TK_BOOL
-    && pRight->nSQLOptr <= TK_BINARY) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  exchangeExpr(*pExpr);
-
-  pLeft = (*pExpr)->pLeft;
-  pRight = (*pExpr)->pRight;
-
-  if (!(pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if (!(pRight->nSQLOptr >= TK_BOOL && pRight->nSQLOptr <= TK_BINARY)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if ((*pExpr)->nSQLOptr >= TK_BITAND) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if (pLeft->pParam == NULL || pLeft->pParam->nExpr < 1) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
-    tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
-    if (pParamElem->pNode->nSQLOptr != TK_ALL && pParamElem->pNode->nSQLOptr != TK_ID) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
-    
-    SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-    if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
-    
-    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
-    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    
-    if (index.columnIndex <= 0 || 
-      index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
-  }
-
-  tSqlExprItem item = {.pNode = pLeft, .aliasName = NULL, .distinct = false};
-
-  int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
-
-  // ADD TRUE FOR TEST
-  if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
-  }
-
-  int32_t slot = tscNumOfFields(pQueryInfo) - 1;
-  SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
-  
-  if (pInfo->pFieldFilters == NULL) {
-    SColumn* pFieldFilters = calloc(1, sizeof(SColumn));
-    if (pFieldFilters == NULL) {
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-    
-    pInfo->pFieldFilters = pFieldFilters;
-  }
-
-  return handleExprInHavingClause(pCmd, pQueryInfo, pInfo->pFieldFilters, pExpr, parentOptr);
-}
-
-
-
-int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, SSqlCmd* pCmd) {
-  const char* msg1 = "having only works with group by";
-  //const char* msg2 = "invalid column name in having clause";
-  //const char* msg3 = "columns from one table allowed as having columns";
-  //const char* msg4 = "no tag allowed in having clause";
-  const char* msg5 = "invalid expression in having clause";
-
-/*  
-  const char* msg1 = "too many columns in group by clause";
-  const char* msg4 = "join query does not support group by";
-  const char* msg7 = "not support group by expression";
-  const char* msg8 = "not allowed column type for group by";
-  const char* msg9 = "tags not allowed for table query";
-*/
-
-  // todo : handle two tables situation
-  //STableMetaInfo* pTableMetaInfo = NULL;
-
-  if (pExpr == NULL || (*pExpr) == NULL) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (pQueryInfo->groupbyExpr.numOfGroupCols <= 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if ((*pExpr)->pLeft == NULL || (*pExpr)->pRight == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
-  }
-
-  if (pQueryInfo->colList == NULL) {
-    pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
-  }
-
-  int32_t ret = 0;
-  
-  if ((ret = getHavingExpr(pCmd, pQueryInfo, pExpr, TK_AND)) != TSDB_CODE_SUCCESS) {
-    return ret;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
 
 static SColumnFilterInfo* addColumnFilterInfo(SColumn* pColumn) {
   if (pColumn == NULL) {
@@ -3328,15 +3121,11 @@ static SColumnFilterInfo* addColumnFilterInfo(SColumn* pColumn) {
 }
 
 static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SColumnFilterInfo* pColumnFilter,
-                                         SColumnIndex* columnIndex, tSQLExpr* pExpr) {
+                                         int16_t colType, tSQLExpr* pExpr) {
   const char* msg = "not supported filter condition";
 
   tSQLExpr*       pRight = pExpr->pRight;
-  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, columnIndex->tableIndex);
 
-  SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex->columnIndex);
-
-  int16_t colType = pSchema->type;
   if (colType >= TSDB_DATA_TYPE_TINYINT && colType <= TSDB_DATA_TYPE_BIGINT) {
     colType = TSDB_DATA_TYPE_BIGINT;
   } else if (colType == TSDB_DATA_TYPE_FLOAT || colType == TSDB_DATA_TYPE_DOUBLE) {
@@ -3649,7 +3438,10 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
   }
 
   pColumn->colIndex = *pIndex;
-  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pIndex, pExpr);
+
+  int16_t colType = pSchema->type;
+  
+  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, colType, pExpr);
 }
 
 static void relToString(tSQLExpr* pExpr, char** str) {
@@ -6901,6 +6693,259 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
     return TSDB_CODE_SUCCESS;
 }
 
+
+ int32_t tscInsertExprFields(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SInternalField** interField) {
+  tSqlExprItem item = {.pNode = pExpr, .aliasName = NULL, .distinct = false};
+
+  int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+
+  // ADD TRUE FOR TEST
+  if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
+  ++pQueryInfo->havingFieldNum;
+
+  int32_t slot = tscNumOfFields(pQueryInfo) - 1;
+  SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
+  pInfo->visible = false;
+  pInfo->pExpr = pExpr;
+  
+  if (pInfo->pFieldFilters == NULL) {
+    SColumn* pFieldFilters = calloc(1, sizeof(SColumn));
+    if (pFieldFilters == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+    
+    pInfo->pFieldFilters = pFieldFilters;
+  }
+
+  *interField = pInfo;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SInternalField** pField) {
+  SInternalField* pInfo = NULL;
+
+  for (int32_t i = pQueryInfo->havingFieldNum - 1; i >= 0; --i) {
+    pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
+
+    if (0 == tSqlExprCompare(pInfo->pExpr, pExpr)) {
+      *pField = pInfo;
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+
+  int32_t ret = tscInsertExprFields(pCmd, pQueryInfo, pExpr, &pInfo);
+  if (ret) {
+    return ret;
+  }
+  
+  *pField = pInfo;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
+static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, int32_t sqlOptr) {
+  const char* msg1 = "non binary column not support like operator";
+  const char* msg2 = "invalid operator for binary column in having clause";  
+  const char* msg3 = "invalid operator for bool column in having clause";
+
+  SColumn* pColumn = NULL;
+  SColumnFilterInfo* pColFilter = NULL;
+  SInternalField* pInfo = 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) {
+    int32_t ret = tscGetExprFilters(pCmd, pQueryInfo, pExpr->pLeft, &pInfo);
+    if (ret) {
+      return ret;
+    }
+
+    pColumn = pInfo->pFieldFilters;
+    
+    // this is a new filter condition on this column
+    if (pColumn->numOfFilters == 0) {
+      pColFilter = addColumnFilterInfo(pColumn);
+    } else {  // update the existed column filter information, find the filter info here
+      pColFilter = &pColumn->filterInfo[0];
+    }
+
+    if (pColFilter == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+  } else if (sqlOptr == TK_OR) {
+    int32_t ret = tscInsertExprFields(pCmd, pQueryInfo, pExpr->pLeft, &pInfo);
+    if (ret) {
+      return ret;
+    }
+  
+    // TODO fixme: failed to invalid the filter expression: "col1 = 1 OR col2 = 2"
+    pColFilter = addColumnFilterInfo(pColumn);
+    if (pColFilter == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+  } else {  // error;
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
+  pColFilter->filterstr =
+      ((pInfo->field.type == TSDB_DATA_TYPE_BINARY || pInfo->field.type == TSDB_DATA_TYPE_NCHAR) ? 1 : 0);
+
+  if (pColFilter->filterstr) {
+    if (pExpr->nSQLOptr != TK_EQ
+      && pExpr->nSQLOptr != TK_NE
+      && pExpr->nSQLOptr != TK_ISNULL
+      && pExpr->nSQLOptr != TK_NOTNULL
+      && pExpr->nSQLOptr != TK_LIKE
+      ) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    }
+  } else {
+    if (pExpr->nSQLOptr == TK_LIKE) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    
+    if (pInfo->field.type == TSDB_DATA_TYPE_BOOL) {
+      if (pExpr->nSQLOptr != TK_EQ && pExpr->nSQLOptr != TK_NE) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      }
+    }
+  }
+
+  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pInfo->field.type, pExpr);
+}
+
+int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, int32_t parentOptr) {
+  if (pExpr == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  const char* msg1 = "invalid having clause";
+
+  tSQLExpr* pLeft = pExpr->pLeft;
+  tSQLExpr* pRight = pExpr->pRight;
+
+  if (pExpr->nSQLOptr == TK_AND || pExpr->nSQLOptr == TK_OR) {
+    int32_t ret = getHavingExpr(pCmd, pQueryInfo, pExpr->pLeft, pExpr->nSQLOptr);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+
+    return getHavingExpr(pCmd, pQueryInfo, pExpr->pRight, pExpr->nSQLOptr);
+  }
+
+  if ((pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE) && 
+    (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (pLeft->nSQLOptr >= TK_BOOL
+    && pLeft->nSQLOptr <= TK_BINARY
+    && pRight->nSQLOptr >= TK_BOOL
+    && pRight->nSQLOptr <= TK_BINARY) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  exchangeExpr(pExpr);
+
+  pLeft = pExpr->pLeft;
+  pRight = pExpr->pRight;
+
+  if (!(pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (!(pRight->nSQLOptr >= TK_BOOL && pRight->nSQLOptr <= TK_BINARY)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (pExpr->nSQLOptr >= TK_BITAND) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (pLeft->pParam == NULL || pLeft->pParam->nExpr < 1) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
+    tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
+    if (pParamElem->pNode->nSQLOptr != TK_ALL && pParamElem->pNode->nSQLOptr != TK_ID) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    
+    SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+    if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    
+    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    
+    if (index.columnIndex <= 0 || 
+      index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+  }
+
+  return handleExprInHavingClause(pCmd, pQueryInfo, pExpr, parentOptr);
+}
+
+
+
+int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd) {
+  const char* msg1 = "having only works with group by";
+  //const char* msg2 = "invalid column name in having clause";
+  //const char* msg3 = "columns from one table allowed as having columns";
+  //const char* msg4 = "no tag allowed in having clause";
+  const char* msg5 = "invalid expression in having clause";
+
+/*  
+  const char* msg1 = "too many columns in group by clause";
+  const char* msg4 = "join query does not support group by";
+  const char* msg7 = "not support group by expression";
+  const char* msg8 = "not allowed column type for group by";
+  const char* msg9 = "tags not allowed for table query";
+*/
+
+  // todo : handle two tables situation
+  //STableMetaInfo* pTableMetaInfo = NULL;
+
+  if (pExpr == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (pQueryInfo->groupbyExpr.numOfGroupCols <= 0) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
+  if (pExpr->pLeft == NULL || pExpr->pRight == NULL) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+  }
+
+  if (pQueryInfo->colList == NULL) {
+    pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
+  }
+
+  int32_t ret = 0;
+  
+  if ((ret = getHavingExpr(pCmd, pQueryInfo, pExpr, TK_AND)) != TSDB_CODE_SUCCESS) {
+    return ret;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
+
+
 int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
   assert(pQuerySql != NULL && (pQuerySql->from == NULL || taosArrayGetSize(pQuerySql->from) > 0));
 
@@ -7028,7 +7073,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
   }
 
   // parse the having clause in the first place
-  if (parseHavingClause(pQueryInfo, &pQuerySql->pHaving, pCmd) != TSDB_CODE_SUCCESS) {
+  if (parseHavingClause(pQueryInfo, pQuerySql->pHaving, pCmd) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
@@ -7261,3 +7306,10 @@ bool hasNormalColumnFilter(SQueryInfo* pQueryInfo) {
   return false;
 }
 
+
+
+
+
+
+
+
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index ef5e9170da..e0b3e8a565 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -956,6 +956,7 @@ SInternalField* tscFieldInfoAppend(SFieldInfo* pFieldInfo, TAOS_FIELD* pField) {
     .pSqlExpr = NULL,
     .pArithExprInfo = NULL,
     .visible = true,
+    .pFieldFilters = NULL,
   };
 
   info.field = *pField;
@@ -968,6 +969,7 @@ SInternalField* tscFieldInfoInsert(SFieldInfo* pFieldInfo, int32_t index, TAOS_F
       .pSqlExpr = NULL,
       .pArithExprInfo = NULL,
       .visible = true,
+      .pFieldFilters = NULL,
   };
 
   info.field = *field;
@@ -1041,6 +1043,22 @@ int32_t tscGetResRowLength(SArray* pExprList) {
   return size;
 }
 
+static void destroyFilterInfo(SColumnFilterInfo* pFilterInfo, int32_t numOfFilters) {
+  for(int32_t i = 0; i < numOfFilters; ++i) {
+    if (pFilterInfo[i].filterstr) {
+      tfree(pFilterInfo[i].pz);
+    }
+  }
+  
+  tfree(pFilterInfo);
+}
+
+static void tscColumnDestroy(SColumn* pCol) {
+  destroyFilterInfo(pCol->filterInfo, pCol->numOfFilters);
+  free(pCol);
+}
+
+
 void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
   if (pFieldInfo == NULL) {
     return;
@@ -1298,15 +1316,7 @@ SColumn* tscColumnListInsert(SArray* pColumnList, SColumnIndex* pColIndex) {
   return taosArrayGetP(pColumnList, i);
 }
 
-static void destroyFilterInfo(SColumnFilterInfo* pFilterInfo, int32_t numOfFilters) {
-  for(int32_t i = 0; i < numOfFilters; ++i) {
-    if (pFilterInfo[i].filterstr) {
-      tfree(pFilterInfo[i].pz);
-    }
-  }
-  
-  tfree(pFilterInfo);
-}
+
 
 SColumn* tscColumnClone(const SColumn* src) {
   assert(src != NULL);
@@ -1323,10 +1333,6 @@ SColumn* tscColumnClone(const SColumn* src) {
   return dst;
 }
 
-static void tscColumnDestroy(SColumn* pCol) {
-  destroyFilterInfo(pCol->filterInfo, pCol->numOfFilters);
-  free(pCol);
-}
 
 void tscColumnListCopy(SArray* dst, const SArray* src, int16_t tableIndex) {
   assert(src != NULL && dst != NULL);
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index 8efaa4cb21..08becde20a 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -233,6 +233,8 @@ SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t s
 
 tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType);
 
+int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right);
+
 tSQLExpr *tSqlExprClone(tSQLExpr *pSrc);
 
 void tSqlExprDestroy(tSQLExpr *pExpr);
diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c
index 658815adcf..029af0dcbb 100644
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -290,6 +290,58 @@ tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
 }
 
 
+static FORCE_INLINE int32_t tStrTokenCompare(SStrToken* left, SStrToken* right) {
+  return (left->type == right->type && left->n == right->n && strncasecmp(left->z, right->z, left->n) == 0) ? 0 : 1;
+}
+
+
+int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right) {
+  if (left->nSQLOptr != right->nSQLOptr) {
+    return 1;
+  }
+
+  if ((left->pLeft && right->pLeft == NULL) 
+    || (left->pLeft == NULL && right->pLeft)
+    || (left->pRight && right->pRight == NULL) 
+    || (left->pRight == NULL && right->pRight)
+    || (left->pParam && right->pParam == NULL) 
+    || (left->pParam == NULL && right->pParam)) {
+    return 1;
+  }
+
+  if (tVariantCompare(&left->val, &right->val)) {
+    return 1;
+  }
+
+  if (tStrTokenCompare(&left->colInfo, &right->colInfo)) {
+    return 1;
+  }
+
+  if (left->pParam && left->pParam->nExpr != right->pParam->nExpr) {
+    return 1;
+  }
+  
+  for (int32_t i = 0; i < right->pParam->nExpr; i++) {
+    tSQLExpr* pSubLeft = left->pParam->a[i].pNode;
+    tSQLExpr* pSubRight = right->pParam->a[i].pNode;
+  
+    if (tSqlExprCompare(pSubLeft, pSubRight)) {
+      return 1;
+    }
+  }
+
+  if (left->pLeft && tSqlExprCompare(left->pLeft, right->pLeft)) {
+    return 1;
+  }
+
+  if (left->pRight && tSqlExprCompare(left->pRight, right->pRight)) {
+    return 1;
+  }
+
+  return 0;
+}
+
+
 
 tSQLExpr *tSqlExprClone(tSQLExpr *pSrc) {
   tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));

From a18b6723d3bd33ae591412b6db0b0fcfbda3d888 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 4 Mar 2021 10:03:41 +0800
Subject: [PATCH 03/19] support having

---
 src/query/src/qExecutor.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index f8119b0d4a..7d171dff9a 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -213,6 +213,10 @@ bool doFilterData(SQuery *pQuery, int32_t elemPos) {
   return true;
 }
 
+bool doFilterDataOnce() {
+
+}
+
 int64_t getNumOfResult(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
   bool    hasMainFunction = hasMainOutput(pQuery);

From a83cbb75d63d170e6012b635775161d19fe6ad28 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 4 Mar 2021 19:34:09 +0800
Subject: [PATCH 04/19] support having

---
 src/client/inc/tsclient.h      |  9 +++-
 src/client/src/tscLocalMerge.c | 78 +++++++++++++++++++++++++++++++---
 src/client/src/tscSQLParser.c  | 53 ++++++++++++++++++++---
 src/client/src/tscUtil.c       |  3 +-
 src/query/src/qExecutor.c      |  3 --
 src/query/src/qParserImpl.c    |  4 ++
 6 files changed, 133 insertions(+), 17 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index aa0f1c9cff..11b40326b9 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -129,13 +129,18 @@ typedef struct SColumn {
   SColumnFilterInfo *filterInfo;
 } SColumn;
 
+typedef struct SExprFilter {
+  tSQLExpr       *pExpr;     //used for having parse
+  SArray         *fp;
+  SColumn        *pFilters;  //having filter info
+}SExprFilter;
+
 typedef struct SInternalField {
   TAOS_FIELD      field;
   bool            visible;
   SExprInfo      *pArithExprInfo;
   SSqlExpr       *pSqlExpr;
-  tSQLExpr       *pExpr;          //used for having parse 
-  SColumn        *pFieldFilters;  //having filter info
+  SExprFilter    *pFieldFilters;
 } SInternalField;
 
 typedef struct SCond {
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 61d90598b4..2b7a70de04 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -22,6 +22,7 @@
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
+#include "qutil.h"
 
 typedef struct SCompareParam {
   SLocalDataSource **pLocalData;
@@ -1229,18 +1230,71 @@ static bool saveGroupResultInfo(SSqlObj *pSql) {
   return false;
 }
 
-int32_t doHavingFilter(SQueryInfo* pQueryInfo) {
+
+bool doFilterFieldData(SQueryInfo* pQueryInfo, char *input, tFilePage* pOutput, SExprFilter* pFieldFilters, int16_t type, bool* notSkipped) {
+  bool qualified = false;
+  
+  for(int32_t k = 0; k < pFieldFilters->pFilters->numOfFilters; ++k) {
+    __filter_func_t fp = taosArrayGetP(pFieldFilters->fp, k);
+    SColumnFilterElem filterElem = {.filterInfo = pFieldFilters->pFilters->filterInfo[k]};
+    
+    bool isnull = isNull(input, type);
+    if (isnull) {
+      if (fp == isNullOperator) {
+        qualified = true;
+        break;
+      } else {
+        continue;
+      }
+    } else {
+      if (fp == notNullOperator) {
+        qualified = true;
+        break;
+      } else if (fp == isNullOperator) {
+        continue;
+      }
+    }
+
+    if (fp(&filterElem, input, input, type)) {
+      qualified = true;
+      break;
+    }
+  }
+
+  *notSkipped = qualified;
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t doHavingFilter(SQueryInfo* pQueryInfo, tFilePage* pOutput, bool* notSkipped) {
+  *notSkipped = true;
+  
   if (pQueryInfo->havingFieldNum <= 0) {
     return TSDB_CODE_SUCCESS;
   }
 
+  //int32_t exprNum  = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+
   size_t numOfOutput = tscNumOfFields(pQueryInfo);
   for(int32_t i = 0; i < numOfOutput; ++i) {
-    SColumn* pFieldFilters = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i)->pFieldFilters;
-    if (pFieldFilters != NULL) {
+    SInternalField* pInterField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
+    SExprFilter* pFieldFilters = pInterField->pFieldFilters;
+
+    if (pFieldFilters == NULL) {
       continue;
     }
-  }
+
+    int32_t type = pInterField->field.type;
+
+    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
+    char* pInput = pOutput->data + pOutput->num* pExpr->offset;
+    
+    doFilterFieldData(pQueryInfo, pInput, pOutput, pFieldFilters, type, notSkipped);
+    if (!notSkipped) {
+      return TSDB_CODE_SUCCESS;
+    }
+  } 
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1287,7 +1341,21 @@ bool genFinalResults(SSqlObj *pSql, SLocalMerger *pLocalMerge, bool noMoreCurren
     doArithmeticCalculate(pQueryInfo, pResBuf, pModel->rowSize, pLocalMerge->finalModel->rowSize);
   }
 
-  doHavingFilter(pQueryInfo);
+  bool notSkipped = true;
+  
+  doHavingFilter(pQueryInfo, pResBuf, &notSkipped);
+
+  if (!notSkipped) {
+    pRes->numOfRows = 0;
+    pLocalMerge->discard = !noMoreCurrentGroupRes;
+
+    if (pLocalMerge->discard) {
+      SColumnModel *pInternModel = pLocalMerge->pDesc->pColumnModel;
+      tColModelAppend(pInternModel, pLocalMerge->discardData, pLocalMerge->pTempBuffer->data, 0, 1, 1);
+    }    
+    
+    return notSkipped;
+  }
 
   // no interval query, no fill operation
   if (pQueryInfo->interval.interval == 0 || pQueryInfo->fillType == TSDB_FILL_NONE) {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 588e9b18aa..0443c3cc5d 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -34,6 +34,7 @@
 #include "tstoken.h"
 #include "tstrbuild.h"
 #include "ttokendef.h"
+#include "qutil.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
 
@@ -6709,17 +6710,26 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
   int32_t slot = tscNumOfFields(pQueryInfo) - 1;
   SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
   pInfo->visible = false;
-  pInfo->pExpr = pExpr;
   
   if (pInfo->pFieldFilters == NULL) {
-    SColumn* pFieldFilters = calloc(1, sizeof(SColumn));
+    SExprFilter* pFieldFilters = calloc(1, sizeof(SExprFilter));
     if (pFieldFilters == NULL) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
-    
+
+    SColumn* pFilters = calloc(1, sizeof(SColumn));
+    if (pFilters == NULL) {
+      tfree(pFieldFilters);
+      
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+
+    pFieldFilters->pFilters = pFilters;
     pInfo->pFieldFilters = pFieldFilters;
   }
 
+  pInfo->pFieldFilters->pExpr = pExpr;
+
   *interField = pInfo;
 
   return TSDB_CODE_SUCCESS;
@@ -6731,7 +6741,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr
   for (int32_t i = pQueryInfo->havingFieldNum - 1; i >= 0; --i) {
     pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
 
-    if (0 == tSqlExprCompare(pInfo->pExpr, pExpr)) {
+    if (pInfo->pFieldFilters && 0 == tSqlExprCompare(pInfo->pFieldFilters->pExpr, pExpr)) {
       *pField = pInfo;
       return TSDB_CODE_SUCCESS;
     }
@@ -6747,7 +6757,33 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t genExprFilter(SExprFilter    * exprFilter) {
+  exprFilter->fp = taosArrayInit(4, sizeof(__filter_func_t));
+  if (exprFilter->fp == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
 
+  for (int32_t i = 0; i < exprFilter->pFilters->numOfFilters; ++i) {
+    SColumnFilterInfo *filterInfo = &exprFilter->pFilters->filterInfo[i];
+
+    int32_t lower = filterInfo->lowerRelOptr;
+    int32_t upper = filterInfo->upperRelOptr;
+    if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) {
+      tscError("invalid rel optr");
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    __filter_func_t ffp = getFilterOperator(lower, upper);
+    if (ffp == NULL) {
+      tscError("invalid filter info");
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    taosArrayPush(exprFilter->fp, &ffp);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
 
 static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, int32_t sqlOptr) {
   const char* msg1 = "non binary column not support like operator";
@@ -6768,7 +6804,7 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
       return ret;
     }
 
-    pColumn = pInfo->pFieldFilters;
+    pColumn = pInfo->pFieldFilters->pFilters;
     
     // this is a new filter condition on this column
     if (pColumn->numOfFilters == 0) {
@@ -6819,7 +6855,12 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
     }
   }
 
-  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pInfo->field.type, pExpr);
+  int32_t ret = doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pInfo->field.type, pExpr);
+  if (ret) {
+    return ret; 
+  }
+  
+  return genExprFilter(pInfo->pFieldFilters);
 }
 
 int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, int32_t parentOptr) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index e0b3e8a565..e725d0df1a 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1081,7 +1081,8 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
     }
 
     if (pInfo->pFieldFilters != NULL) {
-      tscColumnDestroy(pInfo->pFieldFilters);
+      tscColumnDestroy(pInfo->pFieldFilters->pFilters);
+      tfree(pInfo->pFieldFilters);
     }
   }
   
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 7d171dff9a..05572acefd 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -213,9 +213,6 @@ bool doFilterData(SQuery *pQuery, int32_t elemPos) {
   return true;
 }
 
-bool doFilterDataOnce() {
-
-}
 
 int64_t getNumOfResult(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c
index 029af0dcbb..551a55999b 100644
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -296,6 +296,10 @@ static FORCE_INLINE int32_t tStrTokenCompare(SStrToken* left, SStrToken* right)
 
 
 int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right) {
+  if ((left == NULL && right) || (left && right == NULL)) {
+    return 1;
+  }
+  
   if (left->nSQLOptr != right->nSQLOptr) {
     return 1;
   }

From e8eb77b85632171b552a3718772fb62a8e01eae0 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 5 Mar 2021 19:00:27 +0800
Subject: [PATCH 05/19] support having

---
 src/client/src/tscLocalMerge.c |  2 +-
 src/client/src/tscSQLParser.c  | 90 ++++++++++++++++++----------------
 2 files changed, 49 insertions(+), 43 deletions(-)

diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 2b7a70de04..9d69e53566 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -1291,7 +1291,7 @@ int32_t doHavingFilter(SQueryInfo* pQueryInfo, tFilePage* pOutput, bool* notSkip
     char* pInput = pOutput->data + pOutput->num* pExpr->offset;
     
     doFilterFieldData(pQueryInfo, pInput, pOutput, pFieldFilters, type, notSkipped);
-    if (!notSkipped) {
+    if (*notSkipped == false) {
       return TSDB_CODE_SUCCESS;
     }
   } 
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index df811721d9..57399a0590 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -6912,27 +6912,29 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  if (pLeft->pParam == NULL || pLeft->pParam->nExpr < 1) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
+  //if (pLeft->pParam == NULL || pLeft->pParam->nExpr < 1) {
+  //  return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  //}
 
-  for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
-    tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
-    if (pParamElem->pNode->nSQLOptr != TK_ALL && pParamElem->pNode->nSQLOptr != TK_ID) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
-    
-    SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-    if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
-    
-    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
-    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    
-    if (index.columnIndex <= 0 || 
-      index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  if (pLeft->pParam) {
+    for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
+      tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
+      if (pParamElem->pNode->nSQLOptr != TK_ALL && pParamElem->pNode->nSQLOptr != TK_ID) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+      
+      SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+      if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+      
+      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
+      STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+      
+      if (index.columnIndex <= 0 || 
+        index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
     }
   }
 
@@ -6941,23 +6943,10 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
 
 
 
-int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd) {
+int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd, bool isSTable, int32_t joinQuery, int32_t intervalQuery) {
   const char* msg1 = "having only works with group by";
-  //const char* msg2 = "invalid column name in having clause";
-  //const char* msg3 = "columns from one table allowed as having columns";
-  //const char* msg4 = "no tag allowed in having clause";
-  const char* msg5 = "invalid expression in having clause";
-
-/*  
-  const char* msg1 = "too many columns in group by clause";
-  const char* msg4 = "join query does not support group by";
-  const char* msg7 = "not support group by expression";
-  const char* msg8 = "not allowed column type for group by";
-  const char* msg9 = "tags not allowed for table query";
-*/
-
-  // todo : handle two tables situation
-  //STableMetaInfo* pTableMetaInfo = NULL;
+  const char* msg2 = "functions can not be mixed up";
+  const char* msg3 = "invalid expression in having clause";
 
   if (pExpr == NULL) {
     return TSDB_CODE_SUCCESS;
@@ -6968,7 +6957,7 @@ int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd
   }
 
   if (pExpr->pLeft == NULL || pExpr->pRight == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
   }
 
   if (pQueryInfo->colList == NULL) {
@@ -6981,6 +6970,23 @@ int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd
     return ret;
   }
 
+  //REDO function check
+  if (!functionCompatibleCheck(pQueryInfo, joinQuery, intervalQuery)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+  }
+
+  /*
+   * transfer sql functions that need secondary merge into another format
+   * in dealing with super table queries such as: count/first/last
+   */
+  if (isSTable) {
+    tscTansformFuncForSTableQuery(pQueryInfo);
+
+    if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
+      return TSDB_CODE_TSC_INVALID_SQL;
+    }
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -7114,11 +7120,6 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
-  // parse the having clause in the first place
-  if (parseHavingClause(pQueryInfo, pQuerySql->pHaving, pCmd) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
-  }
-
   // set where info
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
 
@@ -7161,6 +7162,11 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
     }
   }
 
+  // parse the having clause in the first place
+  if (parseHavingClause(pQueryInfo, pQuerySql->pHaving, pCmd, isSTable, joinQuery, intervalQuery) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
   // no result due to invalid query time range
   if (pQueryInfo->window.skey > pQueryInfo->window.ekey) {
     pQueryInfo->command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;

From 4b824dde0b61af7490c3ac894d8949a80b458679 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Mon, 8 Mar 2021 15:25:07 +0800
Subject: [PATCH 06/19] fix bug

---
 src/client/inc/tsclient.h      |  1 +
 src/client/src/tscLocalMerge.c |  3 +--
 src/client/src/tscSQLParser.c  | 10 ++++++++--
 src/query/src/qParserImpl.c    | 16 +++++++++-------
 4 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 6ddb61477f..d36ecc54c5 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -131,6 +131,7 @@ typedef struct SColumn {
 
 typedef struct SExprFilter {
   tSQLExpr       *pExpr;     //used for having parse
+  SSqlExpr       *pSqlExpr;
   SArray         *fp;
   SColumn        *pFilters;  //having filter info
 }SExprFilter;
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 9d69e53566..9870830d2e 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -1287,8 +1287,7 @@ int32_t doHavingFilter(SQueryInfo* pQueryInfo, tFilePage* pOutput, bool* notSkip
 
     int32_t type = pInterField->field.type;
 
-    SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
-    char* pInput = pOutput->data + pOutput->num* pExpr->offset;
+    char* pInput = pOutput->data + pOutput->num* pFieldFilters->pSqlExpr->offset;
     
     doFilterFieldData(pQueryInfo, pInput, pOutput, pFieldFilters, type, notSkipped);
     if (*notSkipped == false) {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 57399a0590..accfc01b07 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -6708,6 +6708,9 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
 
   ++pQueryInfo->havingFieldNum;
 
+  size_t n = tscSqlExprNumOfExprs(pQueryInfo);
+  SSqlExpr* pSqlExpr = tscSqlExprGet(pQueryInfo, n - 1);
+
   int32_t slot = tscNumOfFields(pQueryInfo) - 1;
   SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
   pInfo->visible = false;
@@ -6726,6 +6729,7 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
     }
 
     pFieldFilters->pFilters = pFilters;
+    pFieldFilters->pSqlExpr = pSqlExpr;
     pInfo->pFieldFilters = pFieldFilters;
   }
 
@@ -6740,7 +6744,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr
   SInternalField* pInfo = NULL;
 
   for (int32_t i = pQueryInfo->havingFieldNum - 1; i >= 0; --i) {
-    pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
+    pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, pQueryInfo->fieldsInfo.numOfOutput - 1 - i);
 
     if (pInfo->pFieldFilters && 0 == tSqlExprCompare(pInfo->pFieldFilters->pExpr, pExpr)) {
       *pField = pInfo;
@@ -6818,10 +6822,12 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
   } else if (sqlOptr == TK_OR) {
-    int32_t ret = tscInsertExprFields(pCmd, pQueryInfo, pExpr->pLeft, &pInfo);
+    int32_t ret = tscGetExprFilters(pCmd, pQueryInfo, pExpr->pLeft, &pInfo);
     if (ret) {
       return ret;
     }
+
+    pColumn = pInfo->pFieldFilters->pFilters;
   
     // TODO fixme: failed to invalid the filter expression: "col1 = 1 OR col2 = 2"
     pColFilter = addColumnFilterInfo(pColumn);
diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c
index 551a55999b..ccfe15a20b 100644
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -324,13 +324,15 @@ int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right) {
   if (left->pParam && left->pParam->nExpr != right->pParam->nExpr) {
     return 1;
   }
-  
-  for (int32_t i = 0; i < right->pParam->nExpr; i++) {
-    tSQLExpr* pSubLeft = left->pParam->a[i].pNode;
-    tSQLExpr* pSubRight = right->pParam->a[i].pNode;
-  
-    if (tSqlExprCompare(pSubLeft, pSubRight)) {
-      return 1;
+
+  if (right->pParam && left->pParam) {
+    for (int32_t i = 0; i < right->pParam->nExpr; i++) {
+      tSQLExpr* pSubLeft = left->pParam->a[i].pNode;
+      tSQLExpr* pSubRight = right->pParam->a[i].pNode;
+    
+      if (tSqlExprCompare(pSubLeft, pSubRight)) {
+        return 1;
+      }
     }
   }
 

From 9a5b1debb4e87e7700708f19381449a1467c520b Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Wed, 10 Mar 2021 10:31:25 +0800
Subject: [PATCH 07/19] fix bug

---
 src/client/src/tscSQLParser.c | 40 ++++++++++++-----------------------
 src/query/src/qAggMain.c      | 12 +++++------
 2 files changed, 20 insertions(+), 32 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index accfc01b07..d02598d85f 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1644,18 +1644,6 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
-  /*
-   * transfer sql functions that need secondary merge into another format
-   * in dealing with super table queries such as: count/first/last
-   */
-  if (isSTable) {
-    tscTansformFuncForSTableQuery(pQueryInfo);
-
-    if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
-    }
-  }
-
   return TSDB_CODE_SUCCESS;
 }
 
@@ -5968,7 +5956,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
   
     if (TSDB_COL_IS_TAG(pColIndex->flag)) {
       SColumnIndex index = {.tableIndex = pQueryInfo->groupbyExpr.tableIndex, .columnIndex = colIndex};
-      SSqlExpr* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
+      SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, size - pQueryInfo->havingFieldNum, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
       
       memset(pExpr->aliasName, 0, sizeof(pExpr->aliasName));
       tstrncpy(pExpr->aliasName, name, sizeof(pExpr->aliasName));
@@ -5977,7 +5965,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
 
       // NOTE: tag column does not add to source column list
       SColumnList ids = getColumnList(1, 0, pColIndex->colIndex);
-      insertResultField(pQueryInfo, (int32_t)size, &ids, bytes, (int8_t)type, name, pExpr);
+      insertResultField(pQueryInfo, (int32_t)size - pQueryInfo->havingFieldNum, &ids, bytes, (int8_t)type, name, pExpr);
     } else {
       // if this query is "group by" normal column, interval is not allowed
       if (pQueryInfo->interval.interval > 0) {
@@ -6981,18 +6969,6 @@ int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
-  /*
-   * transfer sql functions that need secondary merge into another format
-   * in dealing with super table queries such as: count/first/last
-   */
-  if (isSTable) {
-    tscTansformFuncForSTableQuery(pQueryInfo);
-
-    if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
-    }
-  }
-
   return TSDB_CODE_SUCCESS;
 }
 
@@ -7173,6 +7149,18 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
+  /*
+   * transfer sql functions that need secondary merge into another format
+   * in dealing with super table queries such as: count/first/last
+   */
+  if (isSTable) {
+    tscTansformFuncForSTableQuery(pQueryInfo);
+  
+    if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
+      return TSDB_CODE_TSC_INVALID_SQL;
+    }
+  }
+
   // no result due to invalid query time range
   if (pQueryInfo->window.skey > pQueryInfo->window.ekey) {
     pQueryInfo->command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index f99fe3f072..ef296ab0fb 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -4655,12 +4655,12 @@ static void sumrate_finalizer(SQLFunctionCtx *pCtx) {
 int32_t functionCompatList[] = {
     // count,   sum,      avg,       min,      max,    stddev,    percentile,   apercentile, first,   last
     1,          1,        1,         1,        1,      1,          1,           1,           1,      1,
-    // last_row,top,      bottom,    spread,   twa,    leastsqr,   ts,          ts_dummy, tag_dummy, ts_z
-    4,         -1,       -1,         1,        1,      1,          1,           1,        1,     -1,
-    //  tag,    colprj,   tagprj,    arithmetic, diff, first_dist, last_dist,   interp    rate    irate
-    1,          1,        1,         1,       -1,      1,          1,           5,        1,      1,
-    // sum_rate, sum_irate, avg_rate, avg_irate
-    1,          1,        1,         1,
+    // last_row,top,      bottom,    spread,   twa,    leastsqr,   ts,          ts_dummy,  tag_dummy, ts_z
+    4,         -1,       -1,         1,        1,      1,          1,           1,         1,     -1,
+    //  tag,    colprj,   tagprj,    arithmetic, diff, first_dist, last_dist,   stddev_dst, interp    rate 
+    1,          1,        1,         1,       -1,      1,          1,           1,          5,        1,  
+    // irate   sum_rate, sum_irate, avg_rate, avg_irate
+    1,          1,        1,         1,        1
 };
 
 SAggFunctionInfo aAggs[] = {{

From 0cfb65a89f8ce22eac9d66beb0a600842c77b067 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 11 Mar 2021 11:19:06 +0800
Subject: [PATCH 08/19] fix bug; add cases

---
 src/client/src/tscSQLParser.c | 59 ++++++++++++++++++++++++++---------
 1 file changed, 45 insertions(+), 14 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index d02598d85f..4e0d2a05b6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1576,7 +1576,7 @@ bool isValidDistinctSql(SQueryInfo* pQueryInfo) {
 int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSelection, bool isSTable, bool joinQuery, bool intervalQuery) {
   assert(pSelection != NULL && pCmd != NULL);
 
-  const char* msg2 = "functions can not be mixed up";
+  const char* msg2 = "functions or others can not be mixed up";
   const char* msg3 = "not support query expression";
   const char* msg5 = "invalid function name";
   const char* msg6 = "only support distinct one tag";
@@ -2926,6 +2926,23 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
   return false;
 }
 
+static bool groupbyTagsOrNull(SQueryInfo* pQueryInfo) {
+  if (pQueryInfo->groupbyExpr.columnInfo == NULL ||
+    taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo) == 0) {
+    return true;
+  }
+
+  size_t s = taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo);
+  for (int32_t i = 0; i < s; i++) {
+    SColIndex* colIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, i);
+    if (colIndex->flag != TSDB_COL_TAG) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool intervalQuery) {
   int32_t startIdx = 0;
 
@@ -2942,7 +2959,7 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool
 
   int32_t factor = functionCompatList[tscSqlExprGet(pQueryInfo, startIdx)->functionId];
 
-  if (tscSqlExprGet(pQueryInfo, 0)->functionId == TSDB_FUNC_LAST_ROW && (joinQuery || intervalQuery)) {
+  if (tscSqlExprGet(pQueryInfo, 0)->functionId == TSDB_FUNC_LAST_ROW && (joinQuery || intervalQuery || !groupbyTagsOrNull(pQueryInfo))) {
     return false;
   }
 
@@ -2970,7 +2987,7 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool
       }
     }
 
-    if (functionId == TSDB_FUNC_LAST_ROW && (joinQuery || intervalQuery)) {
+    if (functionId == TSDB_FUNC_LAST_ROW && (joinQuery || intervalQuery || !groupbyTagsOrNull(pQueryInfo))) {
       return false;
     }
   }
@@ -6877,6 +6894,10 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
     return getHavingExpr(pCmd, pQueryInfo, pExpr->pRight, pExpr->nSQLOptr);
   }
 
+  if (pLeft == NULL || pRight == NULL) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
   if ((pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE) && 
     (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -6913,21 +6934,31 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
   if (pLeft->pParam) {
     for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
       tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
-      if (pParamElem->pNode->nSQLOptr != TK_ALL && pParamElem->pNode->nSQLOptr != TK_ID) {
+      if (pParamElem->pNode->nSQLOptr != TK_ALL && 
+          pParamElem->pNode->nSQLOptr != TK_ID &&
+          pParamElem->pNode->nSQLOptr != TK_STRING &&
+          pParamElem->pNode->nSQLOptr != TK_INTEGER &&
+          pParamElem->pNode->nSQLOptr != TK_FLOAT) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
       
-      SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-      if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
+      if (pParamElem->pNode->nSQLOptr == TK_ID && (pParamElem->pNode->colInfo.z == NULL && pParamElem->pNode->colInfo.n == 0)) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
-      
-      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
-      STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-      
-      if (index.columnIndex <= 0 || 
-        index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+
+      if (pParamElem->pNode->nSQLOptr == TK_ID) {
+        SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+        if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
+          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        }
+        
+        STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
+        STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+        
+        if (index.columnIndex <= 0 || 
+          index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
+          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        }
       }
     }
   }
@@ -6939,7 +6970,7 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
 
 int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd, bool isSTable, int32_t joinQuery, int32_t intervalQuery) {
   const char* msg1 = "having only works with group by";
-  const char* msg2 = "functions can not be mixed up";
+  const char* msg2 = "functions or others can not be mixed up";
   const char* msg3 = "invalid expression in having clause";
 
   if (pExpr == NULL) {

From a19ed6e956c7d345d41941bf605c69a3fba5ae6b Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 11 Mar 2021 11:20:17 +0800
Subject: [PATCH 09/19] add case

---
 tests/script/general/parser/having.sim | 1841 ++++++++++++++++++++++++
 1 file changed, 1841 insertions(+)
 create mode 100644 tests/script/general/parser/having.sim

diff --git a/tests/script/general/parser/having.sim b/tests/script/general/parser/having.sim
new file mode 100644
index 0000000000..2e95664d31
--- /dev/null
+++ b/tests/script/general/parser/having.sim
@@ -0,0 +1,1841 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
+system sh/exec.sh -n dnode1 -s start
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+$db = testdb
+
+sql create database $db
+sql use $db
+
+sql create stable st2 (ts timestamp, f1 int, f2 float, f3 double, f4 bigint, f5 smallint, f6 tinyint, f7 bool, f8 binary(10), f9 nchar(10)) tags (id1 int, id2 float, id3 nchar(10), id4 double, id5 smallint, id6 bigint, id7 binary(10))
+
+sql create table tb1 using st2 tags (1,1.0,"1",1.0,1,1,"1");
+sql create table tb2 using st2 tags (2,2.0,"2",2.0,2,2,"2");
+sql create table tb3 using st2 tags (3,3.0,"3",3.0,3,3,"3");
+sql create table tb4 using st2 tags (4,4.0,"4",4.0,4,4,"4");
+ 
+sql insert into tb1 values (now-200s,1,1.0,1.0,1,1,1,true ,"1","1")
+sql insert into tb1 values (now-150s,1,1.0,1.0,1,1,1,false,"1","1")
+sql insert into tb1 values (now-100s,2,2.0,2.0,2,2,2,true ,"2","2")
+sql insert into tb1 values (now-50s ,2,2.0,2.0,2,2,2,false,"2","2")
+sql insert into tb1 values (now     ,3,3.0,3.0,3,3,3,true ,"3","3")
+sql insert into tb1 values (now+50s ,3,3.0,3.0,3,3,3,false,"3","3")
+sql insert into tb1 values (now+100s,4,4.0,4.0,4,4,4,true ,"4","4")
+sql insert into tb1 values (now+150s,4,4.0,4.0,4,4,4,false,"4","4")
+
+
+sql select count(*),f1 from st2 group by f1 having count(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 2 then 
+  return -1
+endi
+if $data01 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data20 != 2 then 
+  return -1
+endi
+if $data21 != 3 then 
+  return -1
+endi
+if $data30 != 2 then 
+  return -1
+endi
+if $data31 != 4 then 
+  return -1
+endi
+
+
+
+
+sql select count(*),f1 from st2 group by f1 having count(*) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 2 then 
+  return -1
+endi
+if $data01 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data20 != 2 then 
+  return -1
+endi
+if $data21 != 3 then 
+  return -1
+endi
+if $data30 != 2 then 
+  return -1
+endi
+if $data31 != 4 then 
+  return -1
+endi
+
+
+sql select count(*),f1 from st2 group by f1 having count(f2) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 2 then 
+  return -1
+endi
+if $data01 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data20 != 2 then 
+  return -1
+endi
+if $data21 != 3 then 
+  return -1
+endi
+if $data30 != 2 then 
+  return -1
+endi
+if $data31 != 4 then 
+  return -1
+endi
+
+sql_error select top(f1,2) from st2 group by f1 having count(f2) > 0;
+
+sql select last(f1) from st2 group by f1 having count(f2) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data20 != 3 then 
+  return -1
+endi
+if $data30 != 4 then 
+  return -1
+endi
+
+sql_error select top(f1,2) from st2 group by f1 having count(f2) > 0;
+
+sql_error select top(f1,2) from st2 group by f1 having count(f2) > 0;
+
+sql_error select top(f1,2) from st2 group by f1 having avg(f1) > 0;
+
+sql select avg(f1),count(f1) from st2 group by f1 having avg(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+
+
+sql select avg(f1),count(f1) from st2 group by f1 having avg(f1) > 2 and sum(f1) > 0;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having avg(f1) > 2 and sum(f1) > 0;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 6 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having avg(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 6 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 2 and sum(f1) < 6;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having 1 <= sum(f1) and 5 >= sum(f1);
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1),twa(f1) from st2 group by tbname having twa(f1) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.500000000 then 
+  return -1
+endi
+if $data01 != 8 then 
+  return -1
+endi
+if $data02 != 20 then 
+  return -1
+endi
+if $data04 != tb1 then 
+  return -1
+endi
+
+sql_error select avg(f1),count(f1),sum(f1),twa(f1) from st2 group by f1 having twa(f1) > 0;
+
+sql select avg(f1),count(f1),sum(f1),twa(f1) from st2 group by tbname having sum(f1) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.500000000 then 
+  return -1
+endi
+if $data01 != 8 then 
+  return -1
+endi
+if $data02 != 20 then 
+  return -1
+endi
+if $data04 != tb1 then 
+  return -1
+endi
+
+sql_error select avg(f1),count(f1),sum(f1),twa(f1) from st2 group by f1 having sum(f1) > 0;
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 3;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+if $data10 != 3.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 6 then 
+  return -1
+endi
+if $data20 != 4.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 8 then 
+  return -1
+endi
+
+###########and issue
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 3 and sum(f1) > 1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 3 or sum(f1) > 1;
+if $rows != 4 then 
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 3 or sum(f1) > 4;
+if $rows != 3 then 
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+if $data10 != 3.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 6 then 
+  return -1
+endi
+if $data20 != 4.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 8 then 
+  return -1
+endi
+
+############or issue
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having sum(f1) > 3 or avg(f1) > 4;
+if $rows != 0 then                                                                                                                                                                             
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having (sum(f1) > 3);
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+
+sql_error select avg(f1),count(f1),sum(f1) from st2 group by f1 having (sum(*) > 3);
+
+sql select avg(f1),count(f1),sum(f1) from st2 group by f1 having (sum(st2.f1) > 3);
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1) from st2 group by f1 having (sum(st2.f1) > 3);
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1),stddev(f1) from st2 group by f1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then                                                                                                                                                                           
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 4 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 6 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 2 then
+  return -1
+endi
+if $data32 != 8 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+if $data34 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having (stddev(st2.f1) > 3);
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having (stddev(st2.f1) < 1);
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 4 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 6 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data31 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data32 != 8 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data33 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having (LEASTSQUARES(f1) < 1);
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having LEASTSQUARES(f1) < 1;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having LEASTSQUARES(f1,1,1) < 1;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having LEASTSQUARES(f1,1,1) > 2;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from st2 group by f1 having LEASTSQUARES(f1,1,1) > 2;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from st2 group by f1 having sum(f1) > 2;
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1) from st2 group by f1 having min(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 6 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi                                                                                                                                                                                           
+if $data11 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data12 != 8 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data13 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi  
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1) from st2 group by f1 having min(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 6 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 3 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 8 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 4 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1) from st2 group by f1 having max(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 6 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 3 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 8 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 4 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1) from st2 group by f1 having max(f1) != 2;
+if $rows != 3 then                                                                                                                                                                             
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data00 != 1.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data01 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data02 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data04 != 1 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data05 != 1 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1                                                                                                                                                                                    
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 3 then
+  return -1
+endi
+if $data15 != 3 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1                                                                                                                                                                                    
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 4 then
+  return -1
+endi
+if $data25 != 4 then
+  return -1
+endi
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1) from st2 group by f1 having first(f1) != 2;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 1 then
+  return -1
+endi
+if $data05 != 1 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1                                                                                                                                                                                    
+endi
+if $data14 != 3 then
+  return -1
+endi
+if $data15 != 3 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 4 then
+  return -1
+endi
+if $data25 != 4 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi 
+
+
+
+sql select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1) from st2 group by f1 having first(f1) != 2;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 1 then
+  return -1
+endi
+if $data05 != 1 then
+  return -1
+endi
+if $data06 != 1 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 3 then
+  return -1
+endi
+if $data15 != 3 then
+  return -1
+endi
+if $data16 != 3 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 4 then
+  return -1
+endi
+if $data25 != 4 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi  
+if $data26 != 4 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi  
+
+
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1) from st2 group by f1 having top(f1,1);
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1) from st2 group by f1 having top(f1,1) > 1;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1) from st2 group by f1 having bottom(f1,1) > 1;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1),top(f1,1),bottom(f1,1) from st2 group by f1 having bottom(f1,1) > 1;
+
+sql_error select avg(f1),count(st2.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1),top(f1,1),bottom(f1,1) from st2 group by f1 having sum(f1) > 1;
+
+sql_error select PERCENTILE(f1) from st2 group by f1 having sum(f1) > 1;
+
+sql_error select PERCENTILE(f1,20) from st2 group by f1 having sum(f1) > 1;
+
+sql select aPERCENTILE(f1,20) from st2 group by f1 having sum(f1) > 1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+
+sql select aPERCENTILE(f1,20) from st2 group by f1 having apercentile(f1,1) > 1;
+if $rows != 3 then                                                                                                                                                                             
+  return -1
+endi
+if $data00 != 2.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data10 != 3.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data20 != 4.000000000 then
+  return -1                                                                                                                                                                                    
+endi 
+
+sql select aPERCENTILE(f1,20) from st2 group by f1 having apercentile(f1,1) > 1 and apercentile(f1,1) < 50;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+
+sql select aPERCENTILE(f1,20) from st2 group by f1 having apercentile(f1,1) > 1 and apercentile(f1,1) < 3;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+
+sql select aPERCENTILE(f1,20) from st2 group by f1 having apercentile(f1,1) > 1 and apercentile(f1,3) < 3;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+
+sql_error select aPERCENTILE(f1,20) from st2 group by f1 having apercentile(1) > 1;
+
+sql_error select aPERCENTILE(f1,20),LAST_ROW(f1) from st2 group by f1 having apercentile(1) > 1;
+
+sql_error select aPERCENTILE(f1,20),LAST_ROW(f1) from st2 group by f1 having apercentile(f1,1) > 1;
+
+sql_error select sum(f1) from st2 group by f1 having last_row(f1) > 1;
+
+sql_error select avg(f1) from st2 group by f1 having diff(f1) > 0;
+
+sql_error select avg(f1),diff(f1) from st2 group by f1 having avg(f1) > 0;
+
+sql_error select avg(f1),diff(f1) from st2 group by f1 having spread(f2) > 0;
+
+sql select avg(f1) from st2 group by f1 having spread(f2) > 0;
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1) from st2 group by f1 having spread(f2) = 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi 
+if $data30 != 4.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f2) from st2 group by f1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) = 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi 
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi 
+if $data10 != 2.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+if $data32 != 0.000000000 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) != 0;
+if $rows != 0 then                                                                                                                                                                             
+  return -1                                                                                                                                                                                    
+endi 
+
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) + 1 > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) + 1;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) + sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) + sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) - sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) * sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) / sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) > sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) 0 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) + 0 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) - f1 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) - id1 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) > id1 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) > id1 and sum(f1) > 1;
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) > 2 and sum(f1) > 1;
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) = 0 and sum(f1) > 1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+if $data32 != 0.000000000 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by f1 having spread(f1) = 0 and avg(f1) > 1;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by c1 having spread(f1) = 0 and avg(f1) > 1;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by id1 having avg(id1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 group by id1 having avg(f1) > id1;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1),avg(id1) from st2 group by id1 having avg(f1) > id1;
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by id1 having avg(f1) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.500000000 then
+  return -1
+endi
+if $data01 != 3.000000000 then
+  return -1
+endi
+if $data02 != 3.000000000 then
+  return -1
+endi      
+if $data03 != 3.000000000 then
+  return -1
+endi
+if $data04 != 1 then          
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 group by id1 having avg(f1) < 2;
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f1 > 0 group by f1 having avg(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+if $data32 != 0.000000000 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f1 > 2 group by f1 having avg(f1) > 0;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 2 group by f1 having avg(f1) > 0;
+if $rows != 2 then                                                                                                                                                                             
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f3 > 2 group by f1 having avg(f1) > 0;
+if $rows != 2 then                                                                                                                                                                             
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having avg(f1) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having avg(ts) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having avg(f7) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having avg(f8) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having avg(f9) > 0;
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having count(f9) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+
+sql_error select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having last(f9) > 0;
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having last(f2) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 3 group by f1 having last(f3) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 1 group by f1 having last(f3) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 1 group by f1 having last(f4) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 1 group by f1 having last(f5) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 1 group by f1 having last(f6) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+
+sql_error select avg(f1),spread(f1,f2,st2.f1),f1,f2 from st2 where f2 > 1 group by f1 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1),f1,f6 from st2 where f2 > 1 group by f1 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1),f1,f6 from st2 where f2 > 1 group by f1,f2 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1),f1,f6 from st2 where f2 > 1 group by f1,id1 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,st2.f1),f1,f6 from st2 where f2 > 1 group by id1 having last(f6) > 0;
+
+sql select avg(f1),spread(f1,f2,st2.f1) from st2 where f2 > 1 group by id1 having last(f6) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2.000000000 then
+  return -1
+endi
+if $data02 != 2.000000000 then
+  return -1
+endi
+if $data03 != 2.000000000 then
+  return -1
+endi
+if $data04 != 1 then
+  return -1
+endi
+
+sql_error select top(f1,2) from tb1 group by f1 having count(f1) > 0;
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

From f0a32e5c3f0a6324cddcf9bd6dd78bc1157dd3b1 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 11 Mar 2021 16:49:57 +0800
Subject: [PATCH 10/19] pass expr filter to taosd

---
 src/client/inc/tsclient.h     | 30 ++++++-------
 src/client/src/tscSQLParser.c |  1 +
 src/client/src/tscServer.c    | 36 ++++++++++++++++
 src/inc/taosmsg.h             | 60 ++++++++++++++------------
 src/query/src/qExecutor.c     | 79 ++++++++++++++++++++++++++++++++++-
 5 files changed, 164 insertions(+), 42 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index d36ecc54c5..2466262e7b 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -96,20 +96,6 @@ typedef struct STableMetaInfo {
   SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
 } STableMetaInfo;
 
-/* the structure for sql function in select clause */
-typedef struct SSqlExpr {
-  char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
-  SColIndex colInfo;
-  uint64_t  uid;            // refactor use the pointer
-  int16_t   functionId;     // function id in aAgg array
-  int16_t   resType;        // return value type
-  int16_t   resBytes;       // length of return value
-  int32_t   interBytes;     // inter result buffer size
-  int16_t   numOfParams;    // argument value of each function
-  tVariant  param[3];       // parameters are not more than 3
-  int32_t   offset;         // sub result column value of arithmetic expression.
-  int16_t   resColId;       // result column id
-} SSqlExpr;
 
 typedef struct SColumnIndex {
   int16_t tableIndex;
@@ -129,6 +115,22 @@ typedef struct SColumn {
   SColumnFilterInfo *filterInfo;
 } SColumn;
 
+/* the structure for sql function in select clause */
+typedef struct SSqlExpr {
+  char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
+  SColIndex colInfo;
+  uint64_t  uid;            // refactor use the pointer
+  int16_t   functionId;     // function id in aAgg array
+  int16_t   resType;        // return value type
+  int16_t   resBytes;       // length of return value
+  int32_t   interBytes;     // inter result buffer size
+  int16_t   numOfParams;    // argument value of each function
+  tVariant  param[3];       // parameters are not more than 3
+  int32_t   offset;         // sub result column value of arithmetic expression.
+  int16_t   resColId;       // result column id
+  SColumn  *pFilter;        // expr filter
+} SSqlExpr;
+
 typedef struct SExprFilter {
   tSQLExpr       *pExpr;     //used for having parse
   SSqlExpr       *pSqlExpr;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 4e0d2a05b6..0ea053e8ea 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -6735,6 +6735,7 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
 
     pFieldFilters->pFilters = pFilters;
     pFieldFilters->pSqlExpr = pSqlExpr;
+    pSqlExpr->pFilter = pFilters;
     pInfo->pFieldFilters = pFieldFilters;
   }
 
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index d005eaf75c..6f72f1a079 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -838,8 +838,44 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pSqlFuncExpr->functionId  = htons(pExpr->functionId);
     pSqlFuncExpr->numOfParams = htons(pExpr->numOfParams);
     pSqlFuncExpr->resColId    = htons(pExpr->resColId);
+    if (pExpr->pFilter && pExpr->pFilter->numOfFilters > 0) {
+      pSqlFuncExpr->filterNum    = htonl(pExpr->pFilter->numOfFilters);
+    } else {
+      pSqlFuncExpr->filterNum = 0;
+    }
+
     pMsg += sizeof(SSqlFuncMsg);
 
+    if (pSqlFuncExpr->filterNum) {
+      pMsg += sizeof(SColumnFilterInfo) * pExpr->pFilter->numOfFilters;
+
+      // append the filter information after the basic column information
+      for (int32_t f = 0; f < pExpr->pFilter->numOfFilters; ++f) {
+        SColumnFilterInfo *pColFilter = &pExpr->pFilter->filterInfo[f];
+
+        SColumnFilterInfo *pFilterMsg = &pSqlFuncExpr->filterInfo[f];
+        pFilterMsg->filterstr = htons(pColFilter->filterstr);
+
+        if (pColFilter->filterstr) {
+          pFilterMsg->len = htobe64(pColFilter->len);
+          memcpy(pMsg, (void *)pColFilter->pz, (size_t)(pColFilter->len + 1));
+          pMsg += (pColFilter->len + 1);  // append the additional filter binary info
+        } else {
+          pFilterMsg->lowerBndi = htobe64(pColFilter->lowerBndi);
+          pFilterMsg->upperBndi = htobe64(pColFilter->upperBndi);
+        }
+
+        pFilterMsg->lowerRelOptr = htons(pColFilter->lowerRelOptr);
+        pFilterMsg->upperRelOptr = htons(pColFilter->upperRelOptr);
+
+        if (pColFilter->lowerRelOptr == TSDB_RELATION_INVALID && pColFilter->upperRelOptr == TSDB_RELATION_INVALID) {
+          tscError("invalid filter info");
+          return TSDB_CODE_TSC_INVALID_SQL;
+        }
+      }
+    }
+
+
     for (int32_t j = 0; j < pExpr->numOfParams; ++j) {
       // todo add log
       pSqlFuncExpr->arg[j].argType = htons((uint16_t)pExpr->param[j].nType);
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 721b9ca605..33d5421a28 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -390,33 +390,6 @@ typedef struct SColIndex {
   char     name[TSDB_COL_NAME_LEN];
 } SColIndex;
 
-/* sql function msg, to describe the message to vnode about sql function
- * operations in select clause */
-typedef struct SSqlFuncMsg {
-  int16_t functionId;
-  int16_t numOfParams;
-  int16_t resColId;      // result column id, id of the current output column
-
-  SColIndex colInfo;
-  struct ArgElem {
-    int16_t argType;
-    int16_t argBytes;
-    union {
-      double  d;
-      int64_t i64;
-      char *  pz;
-    } argValue;
-  } arg[3];
-} SSqlFuncMsg;
-
-typedef struct SExprInfo {
-  SSqlFuncMsg base;
-  struct tExprNode* pExpr;
-  int16_t     bytes;
-  int16_t     type;
-  int32_t     interBytes;
-  int64_t     uid;
-} SExprInfo;
 
 typedef struct SColumnFilterInfo {
   int16_t lowerRelOptr;
@@ -439,6 +412,39 @@ typedef struct SColumnFilterInfo {
   };
 } SColumnFilterInfo;
 
+/* sql function msg, to describe the message to vnode about sql function
+ * operations in select clause */
+typedef struct SSqlFuncMsg {
+  int16_t functionId;
+  int16_t numOfParams;
+  int16_t resColId;      // result column id, id of the current output column
+
+  SColIndex colInfo;
+  struct ArgElem {
+    int16_t argType;
+    int16_t argBytes;
+    union {
+      double  d;
+      int64_t i64;
+      char *  pz;
+    } argValue;
+  } arg[3];
+
+  int32_t filterNum;
+  SColumnFilterInfo filterInfo[];
+} SSqlFuncMsg;
+
+
+typedef struct SExprInfo {
+  SSqlFuncMsg base;
+  SColumnFilterInfo * pFilter;
+  struct tExprNode* pExpr;
+  int16_t     bytes;
+  int16_t     type;
+  int32_t     interBytes;
+  int64_t     uid;
+} SExprInfo;
+
 /*
  * for client side struct, we only need the column id, type, bytes are not necessary
  * But for data in vnode side, we need all the following information.
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 05572acefd..0f82f87082 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -6120,9 +6120,35 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
     pExprMsg->functionId    = htons(pExprMsg->functionId);
     pExprMsg->numOfParams   = htons(pExprMsg->numOfParams);
     pExprMsg->resColId      = htons(pExprMsg->resColId);
+    pExprMsg->filterNum     = htonl(pExprMsg->filterNum);
 
     pMsg += sizeof(SSqlFuncMsg);
 
+    SColumnFilterInfo* pExprFilterInfo = pExprMsg->filterInfo;
+
+    pMsg += sizeof(SColumnFilterInfo) * pExprMsg->filterNum;
+
+    for (int32_t f = 0; f < pExprMsg->filterNum; ++f) {
+      SColumnFilterInfo *pFilterMsg = (SColumnFilterInfo *)pExprFilterInfo;
+
+      pFilterMsg->filterstr = htons(pFilterMsg->filterstr);
+
+      if (pFilterMsg->filterstr) {
+        pFilterMsg->len = htobe64(pFilterMsg->len);
+
+        pFilterMsg->pz = (int64_t)pMsg;
+        pMsg += (pFilterMsg->len + 1);
+      } else {
+        pFilterMsg->lowerBndi = htobe64(pFilterMsg->lowerBndi);
+        pFilterMsg->upperBndi = htobe64(pFilterMsg->upperBndi);
+      }
+
+      pFilterMsg->lowerRelOptr = htons(pFilterMsg->lowerRelOptr);
+      pFilterMsg->upperRelOptr = htons(pFilterMsg->upperRelOptr);
+
+      pExprFilterInfo++;
+    }
+
     for (int32_t j = 0; j < pExprMsg->numOfParams; ++j) {
       pExprMsg->arg[j].argType = htons(pExprMsg->arg[j].argType);
       pExprMsg->arg[j].argBytes = htons(pExprMsg->arg[j].argBytes);
@@ -6304,6 +6330,42 @@ _cleanup:
   return code;
 }
 
+int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int32_t filterNum) {
+  if (filterNum <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  *dst = calloc(filterNum, sizeof(*src));
+  if (*dst == NULL) {
+    return TSDB_CODE_QRY_OUT_OF_MEMORY;
+  }
+
+  memcpy(*dst, src, sizeof(*src) * filterNum);
+  
+  for (int32_t i = 0; i < filterNum; i++) {
+    if (dst[i]->filterstr && dst[i]->len > 0) {
+      void *pz = calloc(1, dst[i]->len + 1); 
+    
+      if (pz == NULL) {
+        if (i == 0) {
+          free(*dst);
+        } else {
+          freeColumnFilterInfo(*dst, i);
+        }
+
+        return TSDB_CODE_QRY_OUT_OF_MEMORY;
+      }
+
+      memcpy(pz, (void *)src->pz, src->len + 1);
+
+      dst[i]->pz = (int64_t)pz;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 static int32_t buildArithmeticExprFromMsg(SExprInfo *pArithExprInfo, SQueryTableMsg *pQueryMsg) {
   qDebug("qmsg:%p create arithmetic expr from binary", pQueryMsg);
 
@@ -6396,6 +6458,13 @@ int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutpu
         type  = s->type;
         bytes = s->bytes;
       }
+
+      if (pExprs[i].base.filterNum > 0) {
+        int32_t ret = cloneExprFilterInfo(&pExprs[i].pFilter, pExprMsg[i]->filterInfo, pExprMsg[i]->filterNum);
+        if (ret) {
+          return ret;
+        }
+      }
     }
 
     int32_t param = (int32_t)pExprs[i].base.arg[0].argValue.i64;
@@ -6770,6 +6839,10 @@ _cleanup_query:
       tExprTreeDestroy(pExprInfo->pExpr, NULL);
       pExprInfo->pExpr = NULL;
     }
+
+    if (pExprInfo->pFilter) {
+      freeColumnFilterInfo(pExprInfo->pFilter, pExprInfo->base.filterNum);
+    }
   }
 
   tfree(pExprs);
@@ -6850,7 +6923,7 @@ void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters) {
     }
 
     for (int32_t i = 0; i < numOfFilters; i++) {
-      if (pFilter[i].filterstr) {
+      if (pFilter[i].filterstr && pFilter[i].pz) {
         free((void*)(pFilter[i].pz));
       }
     }
@@ -6892,6 +6965,10 @@ static void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr) {
     if (pExprInfo[i].pExpr != NULL) {
       tExprTreeDestroy(pExprInfo[i].pExpr, NULL);
     }
+
+    if (pExprInfo[i].pFilter) {
+      freeColumnFilterInfo(pExprInfo[i].pFilter, pExprInfo[i].base.filterNum);
+    }
   }
 
   tfree(pExprInfo);

From 2eb7174f762a09e6631a7a28d1d0906c6ac926ef Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 26 Mar 2021 19:29:42 +0800
Subject: [PATCH 11/19] refact code

---
 src/client/inc/tsclient.h     |   2 +-
 src/client/src/tscSQLParser.c | 131 +++++++++++++---------------------
 src/inc/ttokendef.h           |   1 +
 src/query/inc/qSqlparser.h    |  11 ++-
 src/query/inc/sql.y           |   2 +-
 src/query/src/qSqlParser.c    |  19 ++---
 src/query/src/sql.c           |   2 +-
 7 files changed, 70 insertions(+), 98 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 446658e38b..8983365e58 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -132,7 +132,7 @@ typedef struct SSqlExpr {
 } SSqlExpr;
 
 typedef struct SExprFilter {
-  tSQLExpr       *pExpr;     //used for having parse
+  tSqlExpr       *pExpr;     //used for having parse
   SSqlExpr       *pSqlExpr;
   SArray         *fp;
   SColumn        *pFilters;  //having filter info
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index efd3c7bb93..14691decec 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1098,40 +1098,6 @@ static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd) {
   return true;
 }
 
-static void exchangeExpr(tSQLExpr* pExpr) {
-  tSQLExpr* pLeft = pExpr->pLeft;
-  tSQLExpr* pRight = pExpr->pRight;
-
-  if ((pRight->nSQLOptr == TK_ID || (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) && 
-     (pLeft->nSQLOptr == TK_INTEGER || pLeft->nSQLOptr == TK_FLOAT || pLeft->nSQLOptr == TK_STRING || pLeft->nSQLOptr == TK_BOOL)) {
-    /*
-     * exchange value of the left handside and the value of the right-handside
-     * to make sure that the value of filter expression always locates in
-     * right-handside and
-     * the column-id/function is at the left handside.
-     */
-    uint32_t optr = 0;
-    switch (pExpr->nSQLOptr) {
-      case TK_LE:
-        optr = TK_GE;
-        break;
-      case TK_LT:
-        optr = TK_GT;
-        break;
-      case TK_GT:
-        optr = TK_LT;
-        break;
-      case TK_GE:
-        optr = TK_LE;
-        break;
-      default:
-        optr = pExpr->nSQLOptr;
-    }
-
-    pExpr->nSQLOptr = optr;
-    SWAP(pExpr->pLeft, pExpr->pRight, void*);
-  }
-}
 
 static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd) {
   assert(pTagsList != NULL);
@@ -3118,6 +3084,7 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
 
   tSqlExpr*       pRight = pExpr->pRight;
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, columnIndex->tableIndex);
+  SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex->columnIndex);
 
   int16_t colType = pSchema->type;
 
@@ -3324,10 +3291,8 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
   }
 
   pColumn->colIndex = *pIndex;
-
-  int16_t colType = pSchema->type;
   
-  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, colType, pExpr);
+  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pIndex, pExpr);
 }
 
 static int32_t getTablenameCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pTableCond, SStringBuilder* sb) {
@@ -6766,7 +6731,7 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
 }
 
 
- int32_t tscInsertExprFields(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SInternalField** interField) {
+ int32_t tscInsertExprFields(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SInternalField** interField) {
   tSqlExprItem item = {.pNode = pExpr, .aliasName = NULL, .distinct = false};
 
   int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
@@ -6811,7 +6776,7 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SInternalField** pField) {
+int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SInternalField** pField) {
   SInternalField* pInfo = NULL;
 
   for (int32_t i = pQueryInfo->havingFieldNum - 1; i >= 0; --i) {
@@ -6861,7 +6826,7 @@ static int32_t genExprFilter(SExprFilter    * exprFilter) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, int32_t sqlOptr) {
+static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, int32_t sqlOptr) {
   const char* msg1 = "non binary column not support like operator";
   const char* msg2 = "invalid operator for binary column in having clause";  
   const char* msg3 = "invalid operator for bool column in having clause";
@@ -6913,27 +6878,32 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
       ((pInfo->field.type == TSDB_DATA_TYPE_BINARY || pInfo->field.type == TSDB_DATA_TYPE_NCHAR) ? 1 : 0);
 
   if (pColFilter->filterstr) {
-    if (pExpr->nSQLOptr != TK_EQ
-      && pExpr->nSQLOptr != TK_NE
-      && pExpr->nSQLOptr != TK_ISNULL
-      && pExpr->nSQLOptr != TK_NOTNULL
-      && pExpr->nSQLOptr != TK_LIKE
+    if (pExpr->tokenId != TK_EQ
+      && pExpr->tokenId != TK_NE
+      && pExpr->tokenId != TK_ISNULL
+      && pExpr->tokenId != TK_NOTNULL
+      && pExpr->tokenId != TK_LIKE
       ) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } else {
-    if (pExpr->nSQLOptr == TK_LIKE) {
+    if (pExpr->tokenId == TK_LIKE) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
     
     if (pInfo->field.type == TSDB_DATA_TYPE_BOOL) {
-      if (pExpr->nSQLOptr != TK_EQ && pExpr->nSQLOptr != TK_NE) {
+      if (pExpr->tokenId != TK_EQ && pExpr->tokenId != TK_NE) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
     }
   }
 
-  int32_t ret = doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pInfo->field.type, pExpr);
+  SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+  if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
+
+  int32_t ret = doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, &index, pExpr);
   if (ret) {
     return ret; 
   }
@@ -6941,38 +6911,30 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
   return genExprFilter(pInfo->pFieldFilters);
 }
 
-int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, int32_t parentOptr) {
+int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, int32_t parentOptr) {
   if (pExpr == NULL) {
     return TSDB_CODE_SUCCESS;
   }
 
   const char* msg1 = "invalid having clause";
 
-  tSQLExpr* pLeft = pExpr->pLeft;
-  tSQLExpr* pRight = pExpr->pRight;
+  tSqlExpr* pLeft = pExpr->pLeft;
+  tSqlExpr* pRight = pExpr->pRight;
 
-  if (pExpr->nSQLOptr == TK_AND || pExpr->nSQLOptr == TK_OR) {
-    int32_t ret = getHavingExpr(pCmd, pQueryInfo, pExpr->pLeft, pExpr->nSQLOptr);
+  if (pExpr->tokenId == TK_AND || pExpr->tokenId == TK_OR) {
+    int32_t ret = getHavingExpr(pCmd, pQueryInfo, pExpr->pLeft, pExpr->tokenId);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
 
-    return getHavingExpr(pCmd, pQueryInfo, pExpr->pRight, pExpr->nSQLOptr);
+    return getHavingExpr(pCmd, pQueryInfo, pExpr->pRight, pExpr->tokenId);
   }
 
   if (pLeft == NULL || pRight == NULL) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  if ((pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE) && 
-    (pRight->nSQLOptr >= TK_COUNT && pRight->nSQLOptr <= TK_AVG_IRATE)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if (pLeft->nSQLOptr >= TK_BOOL
-    && pLeft->nSQLOptr <= TK_BINARY
-    && pRight->nSQLOptr >= TK_BOOL
-    && pRight->nSQLOptr <= TK_BINARY) {
+  if (pLeft->type == pRight->type) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
@@ -6981,15 +6943,16 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
   pLeft = pExpr->pLeft;
   pRight = pExpr->pRight;
 
-  if (!(pLeft->nSQLOptr >= TK_COUNT && pLeft->nSQLOptr <= TK_AVG_IRATE)) {
+
+  if (pLeft->type != SQL_NODE_SQLFUNCTION) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+  
+  if (pRight->type != SQL_NODE_VALUE) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  if (!(pRight->nSQLOptr >= TK_BOOL && pRight->nSQLOptr <= TK_BINARY)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  }
-
-  if (pExpr->nSQLOptr >= TK_BITAND) {
+  if (pExpr->tokenId >= TK_BITAND) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
@@ -6998,21 +6961,22 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
   //}
 
   if (pLeft->pParam) {
-    for (int32_t i = 0; i < pLeft->pParam->nExpr; i++) {
-      tSqlExprItem* pParamElem = &(pLeft->pParam->a[i]);
-      if (pParamElem->pNode->nSQLOptr != TK_ALL && 
-          pParamElem->pNode->nSQLOptr != TK_ID &&
-          pParamElem->pNode->nSQLOptr != TK_STRING &&
-          pParamElem->pNode->nSQLOptr != TK_INTEGER &&
-          pParamElem->pNode->nSQLOptr != TK_FLOAT) {
+    size_t size = taosArrayGetSize(pLeft->pParam);
+    for (int32_t i = 0; i < size; i++) {
+      tSqlExprItem* pParamElem = taosArrayGet(pLeft->pParam, i);
+      if (pParamElem->pNode->tokenId != TK_ALL && 
+          pParamElem->pNode->tokenId != TK_ID &&
+          pParamElem->pNode->tokenId != TK_STRING &&
+          pParamElem->pNode->tokenId != TK_INTEGER &&
+          pParamElem->pNode->tokenId != TK_FLOAT) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
       
-      if (pParamElem->pNode->nSQLOptr == TK_ID && (pParamElem->pNode->colInfo.z == NULL && pParamElem->pNode->colInfo.n == 0)) {
+      if (pParamElem->pNode->tokenId == TK_ID && (pParamElem->pNode->colInfo.z == NULL && pParamElem->pNode->colInfo.n == 0)) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      if (pParamElem->pNode->nSQLOptr == TK_ID) {
+      if (pParamElem->pNode->tokenId == TK_ID) {
         SColumnIndex index = COLUMN_INDEX_INITIALIZER;
         if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -7029,12 +6993,17 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSQLExpr* pExpr, in
     }
   }
 
+  pLeft->functionId = isValidFunction(pLeft->operand.z, pLeft->operand.n);
+  if (pLeft->functionId < 0) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+  }
+
   return handleExprInHavingClause(pCmd, pQueryInfo, pExpr, parentOptr);
 }
 
 
 
-int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd, bool isSTable, int32_t joinQuery, int32_t intervalQuery) {
+int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* pCmd, bool isSTable, int32_t joinQuery, int32_t timeWindowQuery) {
   const char* msg1 = "having only works with group by";
   const char* msg2 = "functions or others can not be mixed up";
   const char* msg3 = "invalid expression in having clause";
@@ -7062,7 +7031,7 @@ int32_t parseHavingClause(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SSqlCmd* pCmd
   }
 
   //REDO function check
-  if (!functionCompatibleCheck(pQueryInfo, joinQuery, intervalQuery)) {
+  if (!functionCompatibleCheck(pQueryInfo, joinQuery, timeWindowQuery)) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
@@ -7239,7 +7208,7 @@ int32_t doValidateSqlNode(SSqlObj* pSql, SQuerySqlNode* pQuerySqlNode, int32_t i
   }
 
   // parse the having clause in the first place
-  if (parseHavingClause(pQueryInfo, pQuerySql->pHaving, pCmd, isSTable, joinQuery, intervalQuery) != TSDB_CODE_SUCCESS) {
+  if (parseHavingClause(pQueryInfo, pQuerySqlNode->pHaving, pCmd, isSTable, joinQuery, timeWindowQuery) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index 4039d63485..7acfb569f3 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -208,6 +208,7 @@
 
 
 
+
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
 #define TK_ILLEGAL                        302
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index cb27bc8e2d..c5ee172c40 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -98,7 +98,7 @@ typedef struct SQuerySqlNode {
   SLimitVal          limit;        // limit offset [optional]
   SLimitVal          slimit;       // group limit offset [optional]
   SStrToken          sqlstr;       // sql string in select clause
-  struct tSQLExpr *    pHaving;      // having clause [optional]
+  struct tSqlExpr   *pHaving;      // having clause [optional]
 } SQuerySqlNode;
 
 typedef struct STableNamePair {
@@ -118,7 +118,6 @@ typedef struct SFromInfo {
     SArray          *tableList;   // SArray<STableNamePair>
   };
 } SFromInfo;
->>>>>>> develop
 
 typedef struct SCreatedTableInfo {
   SStrToken          name;        // table name token
@@ -255,11 +254,11 @@ SArray *tVariantListAppend(SArray *pList, tVariant *pVar, uint8_t sortOrder);
 SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int32_t index);
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 
-tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType);
+tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType);
 
-int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right);
+int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right);
 
-tSQLExpr *tSqlExprClone(tSQLExpr *pSrc);
+tSqlExpr *tSqlExprClone(tSqlExpr *pSrc);
 SFromInfo *setTableNameList(SFromInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
 SFromInfo *setSubquery(SFromInfo* pFromInfo, SQuerySqlNode *pSqlNode);
 void      *destroyFromInfo(SFromInfo* pFromInfo);
@@ -279,7 +278,7 @@ void      tSqlExprListDestroy(SArray *pList);
 
 SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelectList, SFromInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *ps,
-                                SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pgLimit, tSQLExpr *pHaving);
+                                SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pgLimit, tSqlExpr *pHaving);
 
 SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type);
 
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index 4b88427ba0..f76c534da1 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -471,7 +471,7 @@ cmd ::= union(X). { setSqlInfo(pInfo, X, NULL, TSDB_SQL_SELECT); }
 // select client_version()
 // select server_state()
 select(A) ::= SELECT(T) selcollist(W). {
-  A = tSetQuerySqlNode(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  A = tSetQuerySqlNode(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 // selcollist is a list of expressions that are to become the return
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index f82cfefc88..53c30565c0 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -310,12 +310,12 @@ static FORCE_INLINE int32_t tStrTokenCompare(SStrToken* left, SStrToken* right)
 }
 
 
-int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right) {
+int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
   if ((left == NULL && right) || (left && right == NULL)) {
     return 1;
   }
   
-  if (left->nSQLOptr != right->nSQLOptr) {
+  if (left->type != right->type) {
     return 1;
   }
 
@@ -328,7 +328,7 @@ int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right) {
     return 1;
   }
 
-  if (tVariantCompare(&left->val, &right->val)) {
+  if (tVariantCompare(&left->value, &right->value)) {
     return 1;
   }
 
@@ -336,14 +336,17 @@ int32_t tSqlExprCompare(tSQLExpr *left, tSQLExpr *right) {
     return 1;
   }
 
-  if (left->pParam && left->pParam->nExpr != right->pParam->nExpr) {
+  size_t size = taosArrayGetSize(right->pParam);
+  if (left->pParam && taosArrayGetSize(left->pParam) != size) {
     return 1;
   }
 
   if (right->pParam && left->pParam) {
-    for (int32_t i = 0; i < right->pParam->nExpr; i++) {
-      tSQLExpr* pSubLeft = left->pParam->a[i].pNode;
-      tSQLExpr* pSubRight = right->pParam->a[i].pNode;
+    for (int32_t i = 0; i < size; i++) {      
+      tSqlExprItem* pLeftElem = taosArrayGet(left->pParam, i);
+      tSqlExpr* pSubLeft = pLeftElem->pNode;
+      tSqlExprItem* pRightElem = taosArrayGet(left->pParam, i);
+      tSqlExpr* pSubRight = pRightElem->pNode;
     
       if (tSqlExprCompare(pSubLeft, pSubRight)) {
         return 1;
@@ -690,7 +693,7 @@ void tSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
 SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelectList, SFromInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
                                 SSessionWindowVal *pSession, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
-                                SLimitVal *psLimit, tSQLExpr *pHaving) {
+                                SLimitVal *psLimit, tSqlExpr *pHaving) {
   assert(pSelectList != NULL);
 
   SQuerySqlNode *pSqlNode = calloc(1, sizeof(SQuerySqlNode));
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 8992e960d0..0e1916bc8b 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -2905,7 +2905,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 161: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy254 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy429, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy254 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy429, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
   yymsp[-1].minor.yy254 = yylhsminor.yy254;
         break;

From 22882196c36321ccdf155fdf6078117e7d94c152 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Mon, 29 Mar 2021 17:36:57 +0800
Subject: [PATCH 12/19] fix bug

---
 src/client/src/tscSQLParser.c | 17 +++++---------
 src/client/src/tscServer.c    |  2 +-
 src/query/src/qExecutor.c     | 42 +++++++++++++++++++++++++++++++++++
 src/query/src/qSqlParser.c    | 17 ++++++++++----
 4 files changed, 61 insertions(+), 17 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 14691decec..3455395481 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -3079,14 +3079,10 @@ static SColumnFilterInfo* addColumnFilterInfo(SColumn* pColumn) {
 }
 
 static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SColumnFilterInfo* pColumnFilter,
-                                         SColumnIndex* columnIndex, tSqlExpr* pExpr) {
+                                         int16_t colType, tSqlExpr* pExpr) {
   const char* msg = "not supported filter condition";
 
   tSqlExpr*       pRight = pExpr->pRight;
-  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, columnIndex->tableIndex);
-  SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex->columnIndex);
-
-  int16_t colType = pSchema->type;
 
   if (colType >= TSDB_DATA_TYPE_TINYINT && colType <= TSDB_DATA_TYPE_BIGINT) {
     colType = TSDB_DATA_TYPE_BIGINT;
@@ -3291,8 +3287,10 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
   }
 
   pColumn->colIndex = *pIndex;
+
+  int16_t colType = pSchema->type;
   
-  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pIndex, pExpr);
+  return doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, colType, pExpr);
 }
 
 static int32_t getTablenameCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pTableCond, SStringBuilder* sb) {
@@ -6898,12 +6896,7 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
     }
   }
 
-  SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-  if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
-  }
-
-  int32_t ret = doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, &index, pExpr);
+  int32_t ret = doExtractColumnFilterInfo(pCmd, pQueryInfo, pColFilter, pInfo->field.type, pExpr);
   if (ret) {
     return ret; 
   }
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 29274b36ea..24d7e19c85 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -862,7 +862,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pSqlFuncExpr->functionId  = htons(pExpr->functionId);
     pSqlFuncExpr->numOfParams = htons(pExpr->numOfParams);
     pSqlFuncExpr->resColId    = htons(pExpr->resColId);
-    if (pExpr->pFilter && pExpr->pFilter->numOfFilters > 0) {
+    if (pTableMeta->tableType != TSDB_SUPER_TABLE && pExpr->pFilter && pExpr->pFilter->numOfFilters > 0) {
       pSqlFuncExpr->filterNum    = htonl(pExpr->pFilter->numOfFilters);
     } else {
       pSqlFuncExpr->filterNum = 0;
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index e9361ba0cf..5a00a3ac45 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -200,6 +200,7 @@ static bool isPointInterpoQuery(SQuery *pQuery);
 static void setResultBufSize(SQuery* pQuery, SRspResultInfo* pResultInfo);
 static void setCtxTagForJoin(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, SExprInfo* pExprInfo, void* pTable);
 static void setParamForStableStddev(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExpr);
+static void setParamForStableStddevByColData(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExpr, char* val, int16_t bytes);
 static void doSetTableGroupOutputBuf(SQueryRuntimeEnv* pRuntimeEnv, SResultRowInfo* pResultRowInfo,
                                      SQLFunctionCtx* pCtx, int32_t* rowCellInfoOffset, int32_t numOfOutput,
                                      int32_t groupIndex);
@@ -1330,6 +1331,7 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SGroupbyOperatorInfo *pIn
   SColumnInfoData* pColInfoData = taosArrayGet(pSDataBlock->pDataBlock, pInfo->colIndex);
   int16_t          bytes = pColInfoData->info.bytes;
   int16_t          type = pColInfoData->info.type;
+  SQuery    *pQuery = pRuntimeEnv->pQuery;
 
   if (type == TSDB_DATA_TYPE_FLOAT || type == TSDB_DATA_TYPE_DOUBLE) {
     qError("QInfo:%"PRIu64" group by not supported on double/float columns, abort", GET_QID(pRuntimeEnv));
@@ -1350,6 +1352,10 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SGroupbyOperatorInfo *pIn
 
       memcpy(pInfo->prevData, val, bytes);
 
+      if (pQuery->stableQuery && pQuery->stabledev && (pRuntimeEnv->prevResult != NULL)) {
+        setParamForStableStddevByColData(pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput, pOperator->pExpr, val, bytes);
+      }
+
       int32_t ret =
           setGroupResultOutputBuf(pRuntimeEnv, pInfo, pOperator->numOfOutput, val, type, bytes, item->groupIndex);
       if (ret != TSDB_CODE_SUCCESS) {  // null data, too many state code
@@ -3396,6 +3402,42 @@ void setParamForStableStddev(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx
 
 }
 
+void setParamForStableStddevByColData(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExpr, char* val, int16_t bytes) {
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+
+  int32_t numOfExprs = pQuery->numOfOutput;
+  for(int32_t i = 0; i < numOfExprs; ++i) {
+    SExprInfo* pExprInfo = &(pExpr[i]);
+    if (pExprInfo->base.functionId != TSDB_FUNC_STDDEV_DST) {
+      continue;
+    }
+
+    SSqlFuncMsg* pFuncMsg = &pExprInfo->base;
+
+    pCtx[i].param[0].arr = NULL;
+    pCtx[i].param[0].nType = TSDB_DATA_TYPE_INT;  // avoid freeing the memory by setting the type to be int
+
+    // TODO use hash to speedup this loop
+    int32_t numOfGroup = (int32_t)taosArrayGetSize(pRuntimeEnv->prevResult);
+    for (int32_t j = 0; j < numOfGroup; ++j) {
+      SInterResult* p = taosArrayGet(pRuntimeEnv->prevResult, j);
+      if (bytes == 0 || memcmp(p->tags, val, bytes) == 0) {
+        int32_t numOfCols = (int32_t)taosArrayGetSize(p->pResult);
+        for (int32_t k = 0; k < numOfCols; ++k) {
+          SStddevInterResult* pres = taosArrayGet(p->pResult, k);
+          if (pres->colId == pFuncMsg->colInfo.colId) {
+            pCtx[i].param[0].arr = pres->pResult;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+}
+
+
+
 /*
  * There are two cases to handle:
  *
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index 53c30565c0..25fa8465b1 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -319,6 +319,14 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
     return 1;
   }
 
+  if (left->tokenId != right->tokenId) {
+    return 1;
+  }
+
+  if (left->functionId != right->functionId) {
+    return 1;
+  }
+
   if ((left->pLeft && right->pLeft == NULL) 
     || (left->pLeft == NULL && right->pLeft)
     || (left->pRight && right->pRight == NULL) 
@@ -336,12 +344,13 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
     return 1;
   }
 
-  size_t size = taosArrayGetSize(right->pParam);
-  if (left->pParam && taosArrayGetSize(left->pParam) != size) {
-    return 1;
-  }
 
   if (right->pParam && left->pParam) {
+    size_t size = taosArrayGetSize(right->pParam);
+    if (left->pParam && taosArrayGetSize(left->pParam) != size) {
+      return 1;
+    }
+
     for (int32_t i = 0; i < size; i++) {      
       tSqlExprItem* pLeftElem = taosArrayGet(left->pParam, i);
       tSqlExpr* pSubLeft = pLeftElem->pNode;

From a5b4ae69451a727388174e67e42bb94e7c25333b Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Tue, 30 Mar 2021 19:39:48 +0800
Subject: [PATCH 13/19] support child table having query

---
 src/client/src/tscLocalMerge.c               |    4 +-
 src/query/inc/qExecutor.h                    |    8 +
 src/query/src/qExecutor.c                    |  202 +-
 tests/script/general/parser/having_child.sim | 1839 ++++++++++++++++++
 4 files changed, 2048 insertions(+), 5 deletions(-)
 create mode 100644 tests/script/general/parser/having_child.sim

diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 65fa825a27..60eb0c9226 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -1235,7 +1235,7 @@ static bool saveGroupResultInfo(SSqlObj *pSql) {
 }
 
 
-bool doFilterFieldData(SQueryInfo* pQueryInfo, char *input, tFilePage* pOutput, SExprFilter* pFieldFilters, int16_t type, bool* notSkipped) {
+bool doFilterFieldData(char *input, SExprFilter* pFieldFilters, int16_t type, bool* notSkipped) {
   bool qualified = false;
   
   for(int32_t k = 0; k < pFieldFilters->pFilters->numOfFilters; ++k) {
@@ -1293,7 +1293,7 @@ int32_t doHavingFilter(SQueryInfo* pQueryInfo, tFilePage* pOutput, bool* notSkip
 
     char* pInput = pOutput->data + pOutput->num* pFieldFilters->pSqlExpr->offset;
     
-    doFilterFieldData(pQueryInfo, pInput, pOutput, pFieldFilters, type, notSkipped);
+    doFilterFieldData(pInput, pFieldFilters, type, notSkipped);
     if (*notSkipped == false) {
       return TSDB_CODE_SUCCESS;
     }
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 5ff574ec67..d528362e95 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -189,6 +189,8 @@ typedef struct SQuery {
   bool             stabledev;        // super table stddev query
   int32_t          interBufSize;     // intermediate buffer sizse
 
+  int32_t          havingNum;        // having expr number
+
   SOrderVal        order;
   int16_t          numOfCols;
   int16_t          numOfTags;
@@ -284,6 +286,7 @@ enum OPERATOR_TYPE_E {
   OP_Fill              = 13,
   OP_MultiTableAggregate     = 14,
   OP_MultiTableTimeInterval  = 15,
+  OP_Having            = 16,
 };
 
 typedef struct SOperatorInfo {
@@ -401,6 +404,11 @@ typedef struct SOffsetOperatorInfo {
   int64_t offset;
 } SOffsetOperatorInfo;
 
+typedef struct SHavingOperatorInfo {  
+  SArray* fp;
+} SHavingOperatorInfo;
+
+
 typedef struct SFillOperatorInfo {
   SFillInfo   *pFillInfo;
   SSDataBlock *pRes;
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 5a00a3ac45..71bc4913e0 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -181,6 +181,7 @@ static SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntime
 static SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 static SOperatorInfo* createTagScanOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput);
 static SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
+static SOperatorInfo* createHavingOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 
 static void destroyBasicOperatorInfo(void* param, int32_t numOfOutput);
 static void destroySFillOperatorInfo(void* param, int32_t numOfOutput);
@@ -1819,6 +1820,10 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
     }
   }
 
+  if (pQuery->havingNum > 0) {
+    pRuntimeEnv->proot = createHavingOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQuery->pExpr1, pQuery->numOfOutput);
+  }
+
   if (pQuery->limit.offset > 0) {
     pRuntimeEnv->proot = createOffsetOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot);
   }
@@ -4653,6 +4658,111 @@ static SSDataBlock* doOffset(void* param) {
   }
 }
 
+
+bool doFilterData(SColumnInfoData* p, int32_t rid, SColumnFilterElem *filterElem, __filter_func_t fp) {
+  char* input = p->pData + p->info.bytes * rid;
+  bool isnull = isNull(input, p->info.type);
+  if (isnull) {
+    return (fp == isNullOperator) ? true : false;
+  } else {
+    if (fp == notNullOperator) {
+      return true;
+    } else if (fp == isNullOperator) {
+      return false;
+    }
+  }
+  
+  if (fp(filterElem, input, input, p->info.type)) {
+    return true;
+  }
+
+  return false;
+}
+
+
+void doHavingImpl(SOperatorInfo *pOperator, SSDataBlock *pBlock) {
+  SHavingOperatorInfo* pInfo = pOperator->info;
+  int32_t f = 0;
+  int32_t allQualified = 1;
+  int32_t exprQualified = 0;
+  
+  for (int32_t r = 0; r < pBlock->info.rows; ++r) {
+    allQualified = 1;
+    
+    for (int32_t i = 0; i < pOperator->numOfOutput; ++i) {
+      SExprInfo* pExprInfo = &(pOperator->pExpr[i]);
+      if (pExprInfo->pFilter == NULL) {
+        continue;
+      }
+      
+      SArray* es = taosArrayGetP(pInfo->fp, i);
+      assert(es);
+
+      size_t fpNum = taosArrayGetSize(es);
+      
+      exprQualified = 0;
+      for (int32_t m = 0; m < fpNum; ++m) {
+        __filter_func_t fp = taosArrayGetP(es, m);
+
+        assert(fp);
+      
+        //SColIndex* colIdx = &pExprInfo->base.colInfo;
+        SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, i);
+
+        SColumnFilterElem filterElem = {.filterInfo = *pExprInfo->pFilter};
+        
+        if (doFilterData(p, r, &filterElem, fp)) {
+          exprQualified = 1;
+          break;
+        }
+      }
+
+      if (exprQualified == 0) {
+        allQualified = 0;
+        break;
+      }
+    }
+
+    if (allQualified == 0) {
+      continue;
+    }
+    
+    for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
+      SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
+    
+      int16_t bytes = pColInfoData->info.bytes;
+      memmove(pColInfoData->pData + f * bytes, pColInfoData->pData + bytes * r, bytes);
+    }
+
+    ++f;
+  }
+  
+  pBlock->info.rows = f;
+}
+
+static SSDataBlock* doHaving(void* param) {
+  SOperatorInfo *pOperator = (SOperatorInfo *)param;
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
+
+  while (1) {
+    SSDataBlock *pBlock = pOperator->upstream->exec(pOperator->upstream);
+    if (pBlock == NULL) {
+      setQueryStatus(pRuntimeEnv, QUERY_COMPLETED);
+      pOperator->status = OP_EXEC_DONE;
+      return NULL;
+    }
+    
+    doHavingImpl(pOperator, pBlock);
+
+    return pBlock;
+  }
+}
+
+
 static SSDataBlock* doIntervalAgg(void* param) {
   SOperatorInfo* pOperator = (SOperatorInfo*) param;
   if (pOperator->status == OP_EXEC_DONE) {
@@ -5003,6 +5113,13 @@ static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput) {
   pInfo->pRes = destroyOutputBuf(pInfo->pRes);
 }
 
+static void destroyHavingOperatorInfo(void* param, int32_t numOfOutput) {
+  SHavingOperatorInfo* pInfo = (SHavingOperatorInfo*) param;
+  if (pInfo->fp) {
+    taosArrayDestroy(pInfo->fp);
+  }
+}
+
 SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
   SAggOperatorInfo* pInfo = calloc(1, sizeof(SAggOperatorInfo));
 
@@ -5059,6 +5176,81 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
   return pOperator;
 }
 
+
+int32_t initFilterFp(SExprInfo* pExpr, int32_t numOfOutput, SArray** fps) {
+  __filter_func_t fp = NULL;
+
+  *fps = taosArrayInit(numOfOutput, sizeof(SArray*));
+  if (*fps == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  for (int32_t i = 0; i < numOfOutput; ++i) {
+    SExprInfo* pExprInfo = &(pExpr[i]);
+    SColIndex* colIdx = &pExprInfo->base.colInfo;
+
+    if (pExprInfo->pFilter == NULL || !TSDB_COL_IS_NORMAL_COL(colIdx->flag)) {
+      taosArrayPush(*fps, &fp);
+      
+      continue;
+    }
+
+    int32_t filterNum = pExprInfo->base.filterNum;
+    SColumnFilterInfo *filterInfo = pExprInfo->pFilter;
+
+    SArray* es = taosArrayInit(filterNum, sizeof(__filter_func_t));
+
+    for (int32_t j = 0; j < filterNum; ++j) {      
+      int32_t lower = filterInfo->lowerRelOptr;
+      int32_t upper = filterInfo->upperRelOptr;
+      if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) {
+        qError("invalid rel optr");
+        return TSDB_CODE_QRY_APP_ERROR;
+      }
+
+      __filter_func_t ffp = getFilterOperator(lower, upper);
+      if (ffp == NULL) {
+        qError("invalid filter info");
+        return TSDB_CODE_QRY_APP_ERROR;
+      }
+      
+      taosArrayPush(es, &ffp);
+      
+      filterInfo += 1;
+    }
+
+    taosArrayPush(*fps, &es);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+SOperatorInfo* createHavingOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
+  SHavingOperatorInfo* pInfo = calloc(1, sizeof(SHavingOperatorInfo));
+
+  initFilterFp(pExpr, numOfOutput, &pInfo->fp);
+
+  assert(pInfo->fp);
+  
+  SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
+
+  pOperator->name         = "HavingOperator";
+  pOperator->operatorType = OP_Having;
+  pOperator->blockingOptr = false;
+  pOperator->status       = OP_IN_EXECUTING;
+  pOperator->numOfOutput  = numOfOutput;
+  pOperator->pExpr        = pExpr;
+  pOperator->upstream     = upstream;
+  pOperator->exec         = doHaving;
+  pOperator->info         = pInfo;
+  pOperator->pRuntimeEnv  = pRuntimeEnv;
+  pOperator->cleanup      = destroyHavingOperatorInfo;
+
+  return pOperator;
+}
+
+
+
 SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream) {
   SLimitOperatorInfo* pInfo = calloc(1, sizeof(SLimitOperatorInfo));
   pInfo->limit = pRuntimeEnv->pQuery->limit.limit;
@@ -5856,8 +6048,8 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int
   memcpy(*dst, src, sizeof(*src) * filterNum);
   
   for (int32_t i = 0; i < filterNum; i++) {
-    if (dst[i]->filterstr && dst[i]->len > 0) {
-      void *pz = calloc(1, dst[i]->len + 1); 
+    if ((*dst)[i].filterstr && dst[i]->len > 0) {
+      void *pz = calloc(1, (*dst)[i].len + 1); 
     
       if (pz == NULL) {
         if (i == 0) {
@@ -5871,7 +6063,7 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int
 
       memcpy(pz, (void *)src->pz, src->len + 1);
 
-      dst[i]->pz = (int64_t)pz;
+      (*dst)[i].pz = (int64_t)pz;
     }
   }
 
@@ -6288,6 +6480,10 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SSqlGroupbyExpr* pGroupbyExpr
     if (TSDB_COL_IS_TAG(pExprs[col].base.colInfo.flag)) {
       pQuery->tagLen += pExprs[col].bytes;
     }
+
+    if (pExprs[col].pFilter) {
+      ++pQuery->havingNum;
+    }
   }
 
   doUpdateExprColumnIndex(pQuery);
diff --git a/tests/script/general/parser/having_child.sim b/tests/script/general/parser/having_child.sim
new file mode 100644
index 0000000000..f9c554aeab
--- /dev/null
+++ b/tests/script/general/parser/having_child.sim
@@ -0,0 +1,1839 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
+system sh/exec.sh -n dnode1 -s start
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+$db = testdb
+
+sql create database $db
+sql use $db
+
+sql create stable st2 (ts timestamp, f1 int, f2 float, f3 double, f4 bigint, f5 smallint, f6 tinyint, f7 bool, f8 binary(10), f9 nchar(10)) tags (id1 int, id2 float, id3 nchar(10), id4 double, id5 smallint, id6 bigint, id7 binary(10))
+
+sql create table tb1 using st2 tags (1,1.0,"1",1.0,1,1,"1");
+sql create table tb2 using st2 tags (2,2.0,"2",2.0,2,2,"2");
+sql create table tb3 using st2 tags (3,3.0,"3",3.0,3,3,"3");
+sql create table tb4 using st2 tags (4,4.0,"4",4.0,4,4,"4");
+ 
+sql insert into tb1 values (now-200s,1,1.0,1.0,1,1,1,true ,"1","1")
+sql insert into tb1 values (now-150s,1,1.0,1.0,1,1,1,false,"1","1")
+sql insert into tb1 values (now-100s,2,2.0,2.0,2,2,2,true ,"2","2")
+sql insert into tb1 values (now-50s ,2,2.0,2.0,2,2,2,false,"2","2")
+sql insert into tb1 values (now     ,3,3.0,3.0,3,3,3,true ,"3","3")
+sql insert into tb1 values (now+50s ,3,3.0,3.0,3,3,3,false,"3","3")
+sql insert into tb1 values (now+100s,4,4.0,4.0,4,4,4,true ,"4","4")
+sql insert into tb1 values (now+150s,4,4.0,4.0,4,4,4,false,"4","4")
+
+
+sql select count(*),f1 from tb1 group by f1 having count(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 2 then 
+  return -1
+endi
+if $data01 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data20 != 2 then 
+  return -1
+endi
+if $data21 != 3 then 
+  return -1
+endi
+if $data30 != 2 then 
+  return -1
+endi
+if $data31 != 4 then 
+  return -1
+endi
+
+
+sql select count(*),f1 from tb1 group by f1 having count(*) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 2 then 
+  return -1
+endi
+if $data01 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data20 != 2 then 
+  return -1
+endi
+if $data21 != 3 then 
+  return -1
+endi
+if $data30 != 2 then 
+  return -1
+endi
+if $data31 != 4 then 
+  return -1
+endi
+
+
+sql select count(*),f1 from tb1 group by f1 having count(f2) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 2 then 
+  return -1
+endi
+if $data01 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data20 != 2 then 
+  return -1
+endi
+if $data21 != 3 then 
+  return -1
+endi
+if $data30 != 2 then 
+  return -1
+endi
+if $data31 != 4 then 
+  return -1
+endi
+
+sql_error select top(f1,2) from tb1 group by f1 having count(f2) > 0;
+
+sql select last(f1) from tb1 group by f1 having count(f2) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1 then 
+  return -1
+endi
+if $data10 != 2 then 
+  return -1
+endi
+if $data20 != 3 then 
+  return -1
+endi
+if $data30 != 4 then 
+  return -1
+endi
+
+sql_error select top(f1,2) from tb1 group by f1 having count(f2) > 0;
+
+sql_error select top(f1,2) from tb1 group by f1 having count(f2) > 0;
+
+sql_error select top(f1,2) from tb1 group by f1 having avg(f1) > 0;
+
+sql select avg(f1),count(f1) from tb1 group by f1 having avg(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+
+
+sql select avg(f1),count(f1) from tb1 group by f1 having avg(f1) > 2 and sum(f1) > 0;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having avg(f1) > 2 and sum(f1) > 0;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 6 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having avg(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 6 then 
+  return -1
+endi
+if $data10 != 4.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 2 and sum(f1) < 6;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having 1 <= sum(f1) and 5 >= sum(f1);
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+
+sql_error select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by tbname having twa(f1) > 0;
+
+sql select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by f1 having twa(f1) > 3;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 8 then 
+  return -1
+endi
+if $data03 != 4.000000000 then 
+  return -1
+endi
+
+sql_error select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by tbname having sum(f1) > 0;
+
+sql select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by f1 having sum(f1) = 4;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+if $data03 != 2.000000000 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+if $data10 != 3.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 6 then 
+  return -1
+endi
+if $data20 != 4.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 8 then 
+  return -1
+endi
+
+###########and issue
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 and sum(f1) > 1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 or sum(f1) > 1;
+if $rows != 4 then 
+  return -1
+endi
+if $data00 != 1.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 2 then 
+  return -1
+endi
+if $data10 != 2.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 4 then 
+  return -1
+endi
+if $data20 != 3.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 6 then 
+  return -1
+endi
+if $data30 != 4.000000000 then 
+  return -1
+endi
+if $data31 != 2 then 
+  return -1
+endi
+if $data32 != 8 then 
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 or sum(f1) > 4;
+if $rows != 3 then 
+  return -1
+endi
+if $data00 != 2.000000000 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 4 then 
+  return -1
+endi
+if $data10 != 3.000000000 then 
+  return -1
+endi
+if $data11 != 2 then 
+  return -1
+endi
+if $data12 != 6 then 
+  return -1
+endi
+if $data20 != 4.000000000 then 
+  return -1
+endi
+if $data21 != 2 then 
+  return -1
+endi
+if $data22 != 8 then 
+  return -1
+endi
+
+############or issue
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 or avg(f1) > 4;
+if $rows != 0 then                                                                                                                                                                             
+  return -1
+endi
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having (sum(f1) > 3);
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+
+sql_error select avg(f1),count(f1),sum(f1) from tb1 group by f1 having (sum(*) > 3);
+
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having (sum(tb1.f1) > 3);
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1) from tb1 group by f1 having (sum(tb1.f1) > 3);
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),stddev(f1) from tb1 group by f1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then                                                                                                                                                                           
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 4 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 6 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 2 then
+  return -1
+endi
+if $data32 != 8 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+if $data34 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having (stddev(tb1.f1) > 3);
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having (stddev(tb1.f1) < 1);
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 4 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 6 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data31 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data32 != 8 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data33 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having (LEASTSQUARES(f1) < 1);
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1) < 1;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) < 1;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having sum(f1) > 2;
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having min(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 6 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi                                                                                                                                                                                           
+if $data11 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data12 != 8 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data13 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi  
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1) from tb1 group by f1 having min(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 6 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 3 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 8 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 4 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1) from tb1 group by f1 having max(f1) > 2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 6 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 3 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 8 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 4 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1) from tb1 group by f1 having max(f1) != 2;
+if $rows != 3 then                                                                                                                                                                             
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data00 != 1.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data01 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data02 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data04 != 1 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data05 != 1 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1                                                                                                                                                                                    
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 3 then
+  return -1
+endi
+if $data15 != 3 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1                                                                                                                                                                                    
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 4 then
+  return -1
+endi
+if $data25 != 4 then
+  return -1
+endi
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1) from tb1 group by f1 having first(f1) != 2;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 1 then
+  return -1
+endi
+if $data05 != 1 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1                                                                                                                                                                                    
+endi
+if $data14 != 3 then
+  return -1
+endi
+if $data15 != 3 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 4 then
+  return -1
+endi
+if $data25 != 4 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi 
+
+
+
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1) from tb1 group by f1 having first(f1) != 2;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 2 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data04 != 1 then
+  return -1
+endi
+if $data05 != 1 then
+  return -1
+endi
+if $data06 != 1 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 2 then
+  return -1
+endi
+if $data12 != 6 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data14 != 3 then
+  return -1
+endi
+if $data15 != 3 then
+  return -1
+endi
+if $data16 != 3 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 2 then
+  return -1
+endi
+if $data22 != 8 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data24 != 4 then
+  return -1
+endi
+if $data25 != 4 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi  
+if $data26 != 4 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi  
+
+
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1) from tb1 group by f1 having top(f1,1);
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1) from tb1 group by f1 having top(f1,1) > 1;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1) from tb1 group by f1 having bottom(f1,1) > 1;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1),top(f1,1),bottom(f1,1) from tb1 group by f1 having bottom(f1,1) > 1;
+
+sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f1),last(f1),top(f1,1),bottom(f1,1) from tb1 group by f1 having sum(f1) > 1;
+
+sql_error select PERCENTILE(f1) from tb1 group by f1 having sum(f1) > 1;
+
+sql_error select PERCENTILE(f1,20) from tb1 group by f1 having sum(f1) > 1;
+
+sql select aPERCENTILE(f1,20) from tb1 group by f1 having sum(f1) > 1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+
+sql select aPERCENTILE(f1,20) from tb1 group by f1 having apercentile(f1,1) > 1;
+if $rows != 3 then                                                                                                                                                                             
+  return -1
+endi
+if $data00 != 2.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data10 != 3.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data20 != 4.000000000 then
+  return -1                                                                                                                                                                                    
+endi 
+
+sql select aPERCENTILE(f1,20) from tb1 group by f1 having apercentile(f1,1) > 1 and apercentile(f1,1) < 50;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+
+sql select aPERCENTILE(f1,20) from tb1 group by f1 having apercentile(f1,1) > 1 and apercentile(f1,1) < 3;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+
+sql select aPERCENTILE(f1,20) from tb1 group by f1 having apercentile(f1,1) > 1 and apercentile(f1,3) < 3;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+
+sql_error select aPERCENTILE(f1,20) from tb1 group by f1 having apercentile(1) > 1;
+
+sql_error select aPERCENTILE(f1,20),LAST_ROW(f1) from tb1 group by f1 having apercentile(1) > 1;
+
+sql_error select aPERCENTILE(f1,20),LAST_ROW(f1) from tb1 group by f1 having apercentile(f1,1) > 1;
+
+sql_error select sum(f1) from tb1 group by f1 having last_row(f1) > 1;
+
+sql_error select avg(f1) from tb1 group by f1 having diff(f1) > 0;
+
+sql_error select avg(f1),diff(f1) from tb1 group by f1 having avg(f1) > 0;
+
+sql_error select avg(f1),diff(f1) from tb1 group by f1 having spread(f2) > 0;
+
+sql select avg(f1) from tb1 group by f1 having spread(f2) > 0;
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1) from tb1 group by f1 having spread(f2) = 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi 
+if $data30 != 4.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f2) from tb1 group by f1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) = 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi 
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi 
+if $data10 != 2.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then                                                                                                                                                                 
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+if $data32 != 0.000000000 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) != 0;
+if $rows != 0 then                                                                                                                                                                             
+  return -1                                                                                                                                                                                    
+endi 
+
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + 1 > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + 1;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) - sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) * sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) / sum(f1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) 0 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + 0 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) - f1 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) - id1 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > id1 and sum(f1);
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > id1 and sum(f1) > 1;
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > 2 and sum(f1) > 1;
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) = 0 and sum(f1) > 1;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+if $data32 != 0.000000000 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) = 0 and avg(f1) > 1;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by c1 having spread(f1) = 0 and avg(f1) > 1;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(id1) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) > id1;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1),avg(id1) from tb1 group by id1 having avg(f1) > id1;
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.500000000 then
+  return -1
+endi
+if $data01 != 3.000000000 then
+  return -1
+endi
+if $data02 != 3.000000000 then
+  return -1
+endi      
+if $data03 != 3.000000000 then
+  return -1
+endi
+if $data04 != 1 then          
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) < 2;
+if $rows != 0 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f1 > 0 group by f1 having avg(f1) > 0;
+if $rows != 4 then
+  return -1
+endi
+if $data00 != 1.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 2.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 3.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+if $data30 != 4.000000000 then
+  return -1
+endi
+if $data31 != 0.000000000 then
+  return -1
+endi
+if $data32 != 0.000000000 then
+  return -1
+endi
+if $data33 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f1 > 2 group by f1 having avg(f1) > 0;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 2 group by f1 having avg(f1) > 0;
+if $rows != 2 then                                                                                                                                                                             
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f3 > 2 group by f1 having avg(f1) > 0;
+if $rows != 2 then                                                                                                                                                                             
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 4.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f1) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(ts) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f7) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f8) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f9) > 0;
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having count(f9) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having last(f9) > 0;
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having last(f2) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having last(f3) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 4.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then                                                                                                                                                                 
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f3) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f4) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f5) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f6) > 0;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 0.000000000 then
+  return -1
+endi
+if $data02 != 0.000000000 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
+  return -1
+endi
+if $data20 != 4.000000000 then
+  return -1
+endi
+if $data21 != 0.000000000 then
+  return -1
+endi
+if $data22 != 0.000000000 then
+  return -1
+endi
+if $data23 != 0.000000000 then
+  return -1
+endi
+
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f2 from tb1 where f2 > 1 group by f1 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1,f2 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1,id1 having last(f6) > 0;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by id1 having last(f6) > 0;
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by id1 having last(f6) > 0;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 3.000000000 then
+  return -1
+endi
+if $data01 != 2.000000000 then
+  return -1
+endi
+if $data02 != 2.000000000 then
+  return -1
+endi
+if $data03 != 2.000000000 then
+  return -1
+endi
+if $data04 != 1 then
+  return -1
+endi
+
+sql_error select top(f1,2) from tb1 group by f1 having count(f1) > 0;
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

From 71badf8c85fe832ce578d6e835cb96225954a9a0 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 1 Apr 2021 16:41:21 +0800
Subject: [PATCH 14/19] fix filter error

---
 src/query/src/qExecutor.c                    |  4 +-
 tests/script/general/parser/having_child.sim | 94 +++++++++++++++-----
 2 files changed, 76 insertions(+), 22 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 71bc4913e0..d6ce220548 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -4709,7 +4709,7 @@ void doHavingImpl(SOperatorInfo *pOperator, SSDataBlock *pBlock) {
         //SColIndex* colIdx = &pExprInfo->base.colInfo;
         SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, i);
 
-        SColumnFilterElem filterElem = {.filterInfo = *pExprInfo->pFilter};
+        SColumnFilterElem filterElem = {.filterInfo = pExprInfo->pFilter[m]};
         
         if (doFilterData(p, r, &filterElem, fp)) {
           exprQualified = 1;
@@ -5205,12 +5205,14 @@ int32_t initFilterFp(SExprInfo* pExpr, int32_t numOfOutput, SArray** fps) {
       int32_t upper = filterInfo->upperRelOptr;
       if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) {
         qError("invalid rel optr");
+        taosArrayDestroy(es);
         return TSDB_CODE_QRY_APP_ERROR;
       }
 
       __filter_func_t ffp = getFilterOperator(lower, upper);
       if (ffp == NULL) {
         qError("invalid filter info");
+        taosArrayDestroy(es);
         return TSDB_CODE_QRY_APP_ERROR;
       }
       
diff --git a/tests/script/general/parser/having_child.sim b/tests/script/general/parser/having_child.sim
index f9c554aeab..1f29a63b91 100644
--- a/tests/script/general/parser/having_child.sim
+++ b/tests/script/general/parser/having_child.sim
@@ -769,7 +769,46 @@ sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 ha
 
 sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
 
-sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having sum(f1) > 2;
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having sum(f1) > 2;
+if $rows != 3 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
+if $data01 != 2 then
+  return -1
+endi
+if $data02 != 4 then
+  return -1
+endi
+if $data03 != 0.000000000 then
+  return -1
+endi
+if $data10 != 3.000000000 then
+  return -1
+endi                                                                                                                                                                                           
+if $data11 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data12 != 6 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi
+if $data13 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi 
+if $data20 != 4.000000000 then
+  return -1
+endi                                                                                                                                                                                           
+if $data21 != 2 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi                                                                                                                                                                                           
+if $data22 != 8 then                                                                                                                                                                           
+  return -1                                                                                                                                                                                    
+endi
+if $data23 != 0.000000000 then                                                                                                                                                                 
+  return -1                                                                                                                                                                                    
+endi
 
 sql select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having min(f1) > 2;
 if $rows != 2 then
@@ -1072,7 +1111,13 @@ sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),min(f1),max(f1),first(f
 
 sql_error select PERCENTILE(f1) from tb1 group by f1 having sum(f1) > 1;
 
-sql_error select PERCENTILE(f1,20) from tb1 group by f1 having sum(f1) > 1;
+sql select PERCENTILE(f1,20) from tb1 group by f1 having sum(f1) = 4;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 2.000000000 then
+  return -1
+endi
 
 sql select aPERCENTILE(f1,20) from tb1 group by f1 having sum(f1) > 1;
 if $rows != 4 then
@@ -1396,30 +1441,28 @@ sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f
 
 sql_error select avg(f1),spread(f1,f2,tb1.f1),avg(id1) from tb1 group by id1 having avg(f1) > id1;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) > 0;
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) > 0;
+
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having avg(f1) > 0 and avg(f1) = 3;
 if $rows != 1 then
   return -1
 endi
-if $data00 != 2.500000000 then
+if $data00 != 3.000000000 then
   return -1
 endi
-if $data01 != 3.000000000 then
+if $data01 != 0.000000000 then
   return -1
 endi
-if $data02 != 3.000000000 then
+if $data02 != 0.000000000 then
   return -1
 endi      
-if $data03 != 3.000000000 then
-  return -1
-endi
-if $data04 != 1 then          
+if $data03 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) < 2;
-if $rows != 0 then
-  return -1
-endi
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having avg(f1) < 0 and avg(f1) = 3;
+
+sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) < 2;
 
 sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f1 > 0 group by f1 having avg(f1) > 0;
 if $rows != 4 then
@@ -1814,23 +1857,32 @@ sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group
 
 sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by id1 having last(f6) > 0;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by id1 having last(f6) > 0;
-if $rows != 1 then
+sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 and f2 < 4 group by f1 having last(f6) > 0;
+if $rows != 2 then
   return -1
 endi
-if $data00 != 3.000000000 then
+if $data00 != 2.000000000 then
   return -1
 endi
-if $data01 != 2.000000000 then
+if $data01 != 0.000000000 then
   return -1
 endi
-if $data02 != 2.000000000 then
+if $data02 != 0.000000000 then
   return -1
 endi
-if $data03 != 2.000000000 then
+if $data03 != 0.000000000 then
   return -1
 endi
-if $data04 != 1 then
+if $data10 != 3.000000000 then
+  return -1
+endi
+if $data11 != 0.000000000 then
+  return -1
+endi
+if $data12 != 0.000000000 then
+  return -1
+endi
+if $data13 != 0.000000000 then
   return -1
 endi
 

From af7b50c43966c43e49619292414d5f4ea2a80b44 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 1 Apr 2021 16:59:39 +0800
Subject: [PATCH 15/19] fix issue

---
 src/client/src/tscLocalMerge.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 60eb0c9226..fb23c6e6dd 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -22,7 +22,7 @@
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
-#include "qutil.h"
+#include "qUtil.h"
 
 typedef struct SCompareParam {
   SLocalDataSource **pLocalData;

From c507d0c2e22bd56adf01d779f147bcf548492aca Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 1 Apr 2021 17:03:36 +0800
Subject: [PATCH 16/19] fix bug

---
 src/client/src/tscSQLParser.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 3455395481..0d3f9e1984 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -34,7 +34,7 @@
 #include "tstoken.h"
 #include "tstrbuild.h"
 #include "ttokendef.h"
-#include "qutil.h"
+#include "qUtil.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
 

From 2df1702dae2500f85f68bb644f717ba24378e18a Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 2 Apr 2021 10:12:35 +0800
Subject: [PATCH 17/19] fix compile error in arm64

---
 src/inc/taosmsg.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index e590fdbcbb..d7ac7dd277 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -448,13 +448,13 @@ typedef struct SSqlFuncMsg {
 
 
 typedef struct SExprInfo {
-  SSqlFuncMsg base;
   SColumnFilterInfo * pFilter;
   struct tExprNode* pExpr;
   int16_t     bytes;
   int16_t     type;
   int32_t     interBytes;
   int64_t     uid;
+  SSqlFuncMsg base;
 } SExprInfo;
 
 /*

From 83fef54bc261d0fd58b353673b3401433762b5f8 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 2 Apr 2021 11:36:11 +0800
Subject: [PATCH 18/19] fix windows compile error

---
 src/client/src/tscSQLParser.c | 1 +
 src/query/src/qExecutor.c     | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 4448f0379b..067533c678 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7446,3 +7446,4 @@ bool hasNormalColumnFilter(SQueryInfo* pQueryInfo) {
 
 
 
+
\ No newline at end of file
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index d6ce220548..a75a22d016 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -6051,7 +6051,7 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int
   
   for (int32_t i = 0; i < filterNum; i++) {
     if ((*dst)[i].filterstr && dst[i]->len > 0) {
-      void *pz = calloc(1, (*dst)[i].len + 1); 
+      void *pz = calloc(1, (size_t)(*dst)[i].len + 1); 
     
       if (pz == NULL) {
         if (i == 0) {
@@ -6063,7 +6063,7 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int
         return TSDB_CODE_QRY_OUT_OF_MEMORY;
       }
 
-      memcpy(pz, (void *)src->pz, src->len + 1);
+      memcpy(pz, (void *)src->pz, (size_t)src->len + 1);
 
       (*dst)[i].pz = (int64_t)pz;
     }

From 855c5b0ec1a101485593e90ea61fba47b7a4f26a Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 2 Apr 2021 11:43:46 +0800
Subject: [PATCH 19/19] fix windows compile error

---
 src/client/src/tscSQLParser.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 067533c678..6de315d992 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -6020,7 +6020,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
   
     if (TSDB_COL_IS_TAG(pColIndex->flag)) {
       SColumnIndex index = {.tableIndex = pQueryInfo->groupbyExpr.tableIndex, .columnIndex = colIndex};
-      SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, size - pQueryInfo->havingFieldNum, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
+      SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, (int32_t)size - pQueryInfo->havingFieldNum, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
       
       memset(pExpr->aliasName, 0, sizeof(pExpr->aliasName));
       tstrncpy(pExpr->aliasName, name, sizeof(pExpr->aliasName));
@@ -6773,7 +6773,7 @@ static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
   ++pQueryInfo->havingFieldNum;
 
   size_t n = tscSqlExprNumOfExprs(pQueryInfo);
-  SSqlExpr* pSqlExpr = tscSqlExprGet(pQueryInfo, n - 1);
+  SSqlExpr* pSqlExpr = tscSqlExprGet(pQueryInfo, (int32_t)n - 1);
 
   int32_t slot = tscNumOfFields(pQueryInfo) - 1;
   SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
@@ -7446,4 +7446,3 @@ bool hasNormalColumnFilter(SQueryInfo* pQueryInfo) {
 
 
 
-
\ No newline at end of file