diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 4dd0327a82df45afdfd986c06527caaf76cac73f..f6c4595933cd961f9453cbb936f7012aacff7a7c 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -145,6 +145,8 @@ static int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo);
 static tSqlExpr* extractExprForSTable(SSqlCmd* pCmd, tSqlExpr** pExpr, SQueryInfo* pQueryInfo, int32_t tableIndex);
 static void convertWhereStringCharset(tSqlExpr* pRight);
 
+static bool isLogicalOperator(tSqlExpr* pExpr);
+static bool isComparisonOperator(tSqlExpr* pExpr);
 int validateTableName(char *tblName, int len, SStrToken* psTblToken, bool *dbIncluded);
 
 static bool isTimeWindowQuery(SQueryInfo* pQueryInfo) {
@@ -284,6 +286,16 @@ static uint8_t convertRelationalOperator(SStrToken *pToken) {
       return TSDB_BINARY_OP_REMAINDER;
     case TK_BITAND:
       return TSDB_BINARY_OP_BITAND;
+    case TK_BITOR:
+      return TSDB_BINARY_OP_BITOR;
+    case TK_BITXOR:
+      return TSDB_BINARY_OP_BITXOR;
+    case TK_BITNOT:
+      return TSDB_BINARY_OP_BITNOT;
+    case TK_LSHIFT:
+      return TSDB_BINARY_OP_LSHIFT;
+    case TK_RSHIFT:
+      return TSDB_BINARY_OP_RSHIFT;
     case TK_LIKE:
       return TSDB_RELATION_LIKE;
     case TK_MATCH:
@@ -4274,15 +4286,10 @@ static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCol
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
   SSchema*    pSchema = tscGetTableColumnSchema(pTableMeta, pIndex->columnIndex);
-  int32_t     ret = 0;
+  int32_t     ret = TSDB_CODE_SUCCESS;
   const char* msg1 = "non binary column not support like/match operator";
   const char* msg3 = "bool column not support this operator";
   const char* msg4 = "primary key not support this operator";
-
-  SColumn* pColumn = tscColumnListInsert(pQueryInfo->colList, pIndex->columnIndex, pTableMeta->id.uid, pSchema);
-
-  pColumn->info.flist.numOfFilters++;
-  
   /*
    * in case of TK_AND filter condition, we first find the corresponding column and build the query condition together
    * the already existed condition.
@@ -4296,8 +4303,8 @@ static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCol
   pColFilter->filterstr =
       ((pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) ? 1 : 0);
 
-  if (!pColFilter->filterstr) {
-    if (pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_MATCH || pExpr->tokenId == TK_NMATCH) {
+  if (!pColFilter->filterstr && tSqlExprIsParentOfLeaf(pExpr)) {
+     if (pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_MATCH || pExpr->tokenId == TK_NMATCH) {
       ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       goto _err_ret;
     }
@@ -4310,11 +4317,10 @@ static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCol
       }
     }
   }
-
-  pColumn->columnIndex = pIndex->columnIndex;
-  pColumn->tableUid = pTableMeta->id.uid;
-  if (pColumn->columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX && pExpr->tokenId == TK_IN) {
-     return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
+  if (pIndex->columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX && pTableMeta->id.uid == TK_IN
+      && tSqlExprIsParentOfLeaf(pExpr)) {
+     ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
+     goto _err_ret;
   }
 
   STableComInfo tinfo = tscGetTableInfo(pTableMeta);
@@ -4326,8 +4332,32 @@ _err_ret:
   return ret;
 }
 
+static int32_t addAllColumn(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, uint32_t conTokenId,
+                            SColumnIndex* pIndex) {
+  int32_t ret = TSDB_CODE_SUCCESS;
+
+  if(!tSqlExprIsLeaf(pExpr) || pExpr->tokenId == TK_ARROW) {
+    ret = addAllColumn(pCmd, pQueryInfo, pExpr->pLeft, conTokenId, pIndex);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+    return addAllColumn(pCmd, pQueryInfo, pExpr->pRight, conTokenId, pIndex);
+  } else if (pExpr->tokenId == TK_ID) {
+    if (getColumnIndexByName(&pExpr->columnName, pQueryInfo, pIndex, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pIndex->tableIndex);
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, pIndex->columnIndex);
+    SColumn* pColumn = tscColumnListInsert(pQueryInfo->colList, pIndex->columnIndex, pTableMeta->id.uid, pSchema);
+    pColumn->info.flist.numOfFilters++;
+  }
+  return ret;
+}
+
 static int32_t getColQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr) {
   int32_t ret = TSDB_CODE_SUCCESS;
+  const char* msg6 = "illegal condition expression";
   
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
     tSqlExpr* p1 = extractExprForSTable(pCmd, pExpr, pQueryInfo, i);
@@ -4339,7 +4369,18 @@ static int32_t getColQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlEx
 
     SArray* colList = taosArrayInit(10, sizeof(SColIndex));  
     ret = exprTreeFromSqlExpr(pCmd, &p, p1, pQueryInfo, colList, NULL);
+    size_t colNum = taosArrayGetSize(colList);
+    for (int32_t k = 0; k < colNum; k++) {
+      SColIndex* pColIndex = taosArrayGet(colList, k);
+      if (TSDB_COL_IS_TAG(pColIndex->flag)) {
+        ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        break;
+      }
+    }
     taosArrayDestroy(&colList);
+    if (ret == TSDB_CODE_SUCCESS) {
+      ret = exprTreeValidateTree(tscGetErrorMsgPayload(pCmd), p);
+    }
 
     SBufferWriter bw = tbufInitWriter(NULL, false);
 
@@ -4387,7 +4428,7 @@ static int32_t checkColumnQueryCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
   }
   pQueryInfo->onlyHasTagCond &= false;
 
-  if (!tSqlExprIsParentOfLeaf(pExpr)) {  // internal node
+  if (isLogicalOperator(pExpr)) {  // internal node
     int32_t ret = checkColumnQueryCondInfo(pCmd, pQueryInfo, pExpr->pLeft, pExpr->tokenId);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
@@ -4396,12 +4437,10 @@ static int32_t checkColumnQueryCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
     return checkColumnQueryCondInfo(pCmd, pQueryInfo, pExpr->pRight, pExpr->tokenId);
   } else {  // handle leaf node
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-    if (getColumnIndexByName(&pExpr->pLeft->columnName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_OPERATION;
-    }
-
+    addAllColumn(pCmd, pQueryInfo, pExpr, pExpr->tokenId, &index);
     return checkColumnFilterInfo(pCmd, pQueryInfo, &index, pExpr, relOptr);
   }
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr) {
@@ -4678,19 +4717,23 @@ static int32_t validateSQLExprItemOperatorExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, S
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;
   }
+
   int32_t rightHeight = 0;
-  ret = validateSQLExprItem(pCmd, pExpr->pRight, pQueryInfo, pList, &rightType, &uidRight, &rightHeight);
-  if (ret != TSDB_CODE_SUCCESS) {
-    return ret;
-  }
+  if (pExpr->tokenId != TK_BITNOT) {
+    ret = validateSQLExprItem(pCmd, pExpr->pRight, pQueryInfo, pList, &rightType, &uidRight, &rightHeight);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
 
-  if (uidLeft != uidRight && uidLeft != 0 && uidRight != 0) {
-    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    if (uidLeft != uidRight && uidLeft != 0 && uidRight != 0) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
   }
+
   *uid = uidLeft;
 
-  *height = (leftHeight > rightHeight) ? leftHeight + 1 : rightHeight+1;
-  {
+  *height = (leftHeight > rightHeight) ? leftHeight + 1 : rightHeight + 1;
+  if (pExpr->tokenId != TK_BITNOT) {
     if (leftType == SQLEXPR_TYPE_UNASSIGNED || rightType == SQLEXPR_TYPE_UNASSIGNED) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "invalid operand expression");
     }
@@ -4726,8 +4769,15 @@ static int32_t validateSQLExprItemOperatorExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, S
                pExpr->tokenId == TK_MATCH || pExpr->tokenId == TK_NMATCH ||
                pExpr->tokenId == TK_CONTAINS || pExpr->tokenId == TK_IN) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "unsupported filtering operations");
+    } else if (pExpr->tokenId == TK_LSHIFT || pExpr->tokenId == TK_RSHIFT) {
+      if (rightType != SQLEXPR_TYPE_VALUE) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "non numeric right operand");
+      }
     }
+  } else {
+    *type = SQLEXPR_TYPE_SCALAR;
   }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -5137,6 +5187,38 @@ void convertWhereStringCharset(tSqlExpr* pRight){
   free(newData);
 }
 
+static int32_t handleColumnInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SColumnIndex* index) {
+  const char* msg2 = "illegal column name";
+  int32_t ret = TSDB_CODE_SUCCESS;
+  if (pExpr == NULL) {
+    return ret;
+  } else if (!tSqlExprIsLeaf(pExpr)) {
+    if (isComparisonOperator(pExpr)) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+    ret = handleColumnInQueryCond(pCmd, pQueryInfo, pExpr->pLeft, index);
+    if( ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+    ret = handleColumnInQueryCond(pCmd, pQueryInfo, pExpr->pRight, index);
+    return ret;
+  }
+
+  SStrToken* colName = NULL;
+  if (pExpr->tokenId == TK_ARROW) {
+    colName = &(pExpr->pLeft->columnName);
+  } else if (pExpr->tokenId == TK_ID) {
+    colName = &(pExpr->columnName);
+  }
+  
+  if (colName) {
+    if (getColumnIndexByName(colName, pQueryInfo, index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
+      ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    }
+  }
+  return ret;
+}
+
 static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SCondExpr* pCondExpr,
                                      int32_t* type, int32_t* tbIdx, int32_t parentOptr, tSqlExpr** columnExpr,
                                      tSqlExpr** tsExpr, bool joinQuery) {
@@ -5144,7 +5226,6 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
   const char* msg2 = "illegal column name";
   const char* msg4 = "too many join tables";
   const char* msg5 = "not support ordinary column join";
-  const char* msg6 = "illegal condition expression";
 
   tSqlExpr* pLeft  = (*pExpr)->pLeft;
   tSqlExpr* pRight = (*pExpr)->pRight;
@@ -5158,14 +5239,23 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
   int32_t ret = TSDB_CODE_SUCCESS;
 
   SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-  if (getColumnIndexByName(colName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
-    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+  if (!tSqlExprIsParentOfLeaf(*pExpr)) {
+    ret = handleColumnInQueryCond(pCmd, pQueryInfo, pLeft, &index);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+    ret = handleColumnInQueryCond(pCmd, pQueryInfo, pRight, &index);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+  } else {
+    if (getColumnIndexByName(colName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    }
   }
 
   *tbIdx = index.tableIndex;
 
-  assert(tSqlExprIsParentOfLeaf(*pExpr));
-
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
 
@@ -5194,7 +5284,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
   }
 
   if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP && index.columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX) {  // query on time range
-    if (!validateJoinExprNode(pCmd, pQueryInfo, *pExpr, &index)) {
+    if (!tSqlExprIsParentOfLeaf(*pExpr) || !validateJoinExprNode(pCmd, pQueryInfo, *pExpr, &index)) {
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
@@ -5316,8 +5406,6 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
     if (pRight->tokenId == TK_ID) {
       if (joinQuery) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5); // other column cannot be served as the join column
-      } else {
-        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
     }
 
@@ -5368,7 +5456,7 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
   int32_t leftTbIdx = 0;
   int32_t rightTbIdx = 0;
 
-  if (!tSqlExprIsParentOfLeaf(*pExpr)) {
+  if (isLogicalOperator(*pExpr)) {
     ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, pCondExpr, type ? &leftType : NULL, &leftTbIdx, (*pExpr)->tokenId, &columnLeft, &tsLeft, joinQuery);
     if (ret != TSDB_CODE_SUCCESS) {
       goto err_ret;
@@ -5429,6 +5517,11 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
     goto err_ret;
   }
 
+  if (!tSqlExprIsLeaf((*pExpr)->pRight) ) {
+    ret = TSDB_CODE_TSC_INVALID_OPERATION;
+    goto err_ret;
+  }
+
   ret = handleExprInQueryCond(pCmd, pQueryInfo, pExpr, pCondExpr, type, tbIdx, parentOptr, columnExpr, tsExpr, joinQuery);
   if (ret) {
     goto err_ret;
@@ -5451,19 +5544,21 @@ static void doExtractExprForSTable(SSqlCmd* pCmd, tSqlExpr** pExpr, SQueryInfo*
     return;
   }
   
-  if (tSqlExprIsParentOfLeaf(*pExpr)) {
+  if (!isLogicalOperator(*pExpr)) {
     tSqlExpr* pLeft = (*pExpr)->pLeft;
 
-    SColumnIndex index = COLUMN_INDEX_INITIALIZER;
-    if(pLeft->tokenId == TK_ARROW) {
-      pLeft = pLeft->pLeft;
-    }
-    if (getColumnIndexByName(&pLeft->columnName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
-      return;
-    }
+    if (pLeft->tokenId == TK_ARROW || pLeft->tokenId == TK_ID) {
+      SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+      if(pLeft->tokenId == TK_ARROW) {
+        pLeft = pLeft->pLeft;
+      }
+      if (getColumnIndexByName(&pLeft->columnName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
+        return;
+      }
 
-    if (index.tableIndex != tableIndex) {
-      return;
+      if (index.tableIndex != tableIndex) {
+        return;
+      }
     }
 
     *pOut = *pExpr;
@@ -5686,7 +5781,6 @@ static void doAddJoinTagsColumnsIntoTagList(SSqlCmd* pCmd, SQueryInfo* pQueryInf
 */
 
 static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
-  const char *msg1 = "invalid tag operator";
   const char* msg2 = "not supported filter condition";
   
   do {
@@ -5706,10 +5800,6 @@ static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
     if (p->_node.pRight && (retVal = validateTagCondExpr(pCmd, p->_node.pRight)) != TSDB_CODE_SUCCESS) {
       return retVal;
     }
-
-    if (IS_ARITHMETIC_OPTR(p->_node.optr)) {
-      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
-    }
     
     if (!IS_RELATION_OPTR(p->_node.optr)) {
       break;
@@ -5771,8 +5861,13 @@ static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
   return TSDB_CODE_SUCCESS;
 }
 
+bool isTablename(char* colName) {
+   return (strlen(colName) == strlen(TSQL_TBNAME_L) && strncasecmp(TSQL_TBNAME_L, colName, strlen(TSQL_TBNAME_L)) == 0);
+}
+
 static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondExpr* pCondExpr) {
   int32_t ret = TSDB_CODE_SUCCESS;
+  const char* msg6 = "illegal condition expression";
 
   if (pCondExpr->pTagCond == NULL) {
     return ret;
@@ -5788,6 +5883,17 @@ static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondE
   
     SArray* colList = taosArrayInit(10, sizeof(SColIndex));
     ret = exprTreeFromSqlExpr(pCmd, &p, p1, pQueryInfo, colList, NULL);
+    size_t colNum = taosArrayGetSize(colList);
+    for (int32_t k = 0; k < colNum; k++) {
+      SColIndex* pColIndex = taosArrayGet(colList, k);
+      if (TSDB_COL_IS_NORMAL_COL(pColIndex->flag) && !isTablename(pColIndex->name)) {
+        ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        break;
+      }
+    }
+    if (ret == TSDB_CODE_SUCCESS) {
+      ret = exprTreeValidateTree(tscGetErrorMsgPayload(pCmd), p);
+    }
     //if (ret == TSDB_CODE_SUCCESS) {
     //  ret = filterInitFromTree(p, &pQueryInfo->tagFilter, (int32_t)taosArrayGetSize(colList), NULL);
     //}
@@ -10279,23 +10385,6 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
       }
     }
 
-    if (pSqlExpr->tokenId == TK_BITAND && pSqlExpr->pLeft != NULL && pSqlExpr->pRight != NULL) {
-      // for example: col type is "bool" but expr "col & 1" received
-      uint8_t colType = pLeft->pSchema->type;
-      SStrToken *exprToken = &pSqlExpr->pRight->exprToken;
-      if (pSqlExpr->pLeft->type == SQL_NODE_TABLE_COLUMN && pSqlExpr->pRight->type == SQL_NODE_VALUE) {
-        if (colType == TSDB_DATA_TYPE_BOOL) {
-          if ((exprToken->n != 4 || strncasecmp(exprToken->z, "true", 4)) && (exprToken->n != 5 || strncasecmp(exprToken->z, "false", 5))) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-        } else if (IS_SIGNED_NUMERIC_TYPE(colType) || IS_UNSIGNED_NUMERIC_TYPE(colType)) {
-          if ((exprToken->n == 4 && strncasecmp(exprToken->z, "true", 4) == 0) || (exprToken->n == 5 || strncasecmp(exprToken->z, "false", 5) == 0)) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-        }
-      }
-    }
-
     if (pSqlExpr->pRight != NULL) {
       int32_t ret = exprTreeFromSqlExpr(pCmd, &pRight, pSqlExpr->pRight, pQueryInfo, pCols, uid);
       if (ret != TSDB_CODE_SUCCESS) {
@@ -10334,8 +10423,11 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
           pLeft = pLeft->_node.pLeft;
         }
         if (pRight->pVal->nType == TSDB_DATA_TYPE_BOOL && pLeft->nodeType == TSQL_NODE_COL) {
-          if (((*pExpr)->_node.optr != TSDB_BINARY_OP_BITAND && pLeft->pSchema->type == TSDB_DATA_TYPE_BOOL) ||
-              pLeft->pSchema->type == TSDB_DATA_TYPE_JSON) {
+          if ((((*pExpr)->_node.optr != TSDB_BINARY_OP_BITAND || (*pExpr)->_node.optr != TSDB_BINARY_OP_BITOR ||
+                (*pExpr)->_node.optr != TSDB_BINARY_OP_BITXOR || (*pExpr)->_node.optr != TSDB_BINARY_OP_BITNOT ||
+                (*pExpr)->_node.optr != TSDB_BINARY_OP_LSHIFT || (*pExpr)->_node.optr != TSDB_BINARY_OP_RSHIFT) &&
+              pLeft->pSchema->type == TSDB_DATA_TYPE_BOOL) || pLeft->pSchema->type == TSDB_DATA_TYPE_JSON)
+          {
             return TSDB_CODE_TSC_INVALID_OPERATION;
           }
         }
@@ -10444,3 +10536,35 @@ void normalizeSqlNode(SSqlNode* pSqlNode, const char* dbName) {
 }
 
 #endif
+
+bool isLogicalOperator(tSqlExpr* pExpr) {
+  if (pExpr->tokenId == TK_AND || pExpr->tokenId == TK_OR) {
+    return true;
+  }
+  return false;
+}
+
+bool isComparisonOperator(tSqlExpr* pExpr) {
+ switch (pExpr->tokenId) {
+    case TK_EQ:
+    case TK_NE:
+    case TK_ISNULL:
+    case TK_NOTNULL:
+    case  TK_IS:
+    case  TK_LIKE:
+    case  TK_MATCH:
+    case  TK_NMATCH:
+    case  TK_CONTAINS:
+    case  TK_GLOB:
+    case  TK_BETWEEN:
+    case  TK_IN:
+    case  TK_GT:
+    case  TK_GE:
+    case  TK_LT:
+    case  TK_LE:
+      return true;
+    default:
+      return false;
+  }
+  return false;
+}
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index ec4f2c1daf4cd35a984f7e2f2cf4dab8f47659f8..bfb9c5d3d2c6484605e2dd399bcfa7f5efc98207 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1004,7 +1004,7 @@ static void doSetupSDataBlock(SSqlRes* pRes, SSDataBlock* pBlock, void* pFilterI
     filterConverNcharColumns(pFilterInfo, pBlock->info.rows, &gotNchar);
     int8_t* p = NULL;
     //bool all = doFilterDataBlock(pFilterInfo, numOfFilterCols, pBlock->info.rows, p);
-    bool all = filterExecute(pFilterInfo, pBlock->info.rows, &p, NULL, 0);
+    bool all = filterExecute(pFilterInfo, pBlock->info.rows, &p, NULL, (int16_t)taosArrayGetSize(pBlock->pDataBlock));
     if (gotNchar) {
       filterFreeNcharColumns(pFilterInfo);
     }
diff --git a/src/common/src/tarithoperator.c b/src/common/src/tarithoperator.c
index 6144105378dc90d4470aea0d1e4c3aa1489a1660..bf0b9a2235271ba88503ad6f880d97c34e9b8971 100644
--- a/src/common/src/tarithoperator.c
+++ b/src/common/src/tarithoperator.c
@@ -403,267 +403,461 @@ void vectorRemainder(void *left, int32_t len1, int32_t _left_type, void *right,
   }
 }
 
+typedef int64_t (*_arithmetic_getVectorBigintValue_fn_t)(void *src, int32_t index);
+
+int64_t getVectorBigintValue_BOOL(void *src, int32_t index) {
+  return (int64_t)*((bool *)src + index);
+}
+int64_t getVectorBigintValue_TINYINT(void *src, int32_t index) {
+  return (int64_t)*((int8_t *)src + index);
+}
+int64_t getVectorBigintValue_UTINYINT(void *src, int32_t index) {
+  return (int64_t)*((uint8_t *)src + index);
+}
+int64_t getVectorBigintValue_SMALLINT(void *src, int32_t index) {
+  return (int64_t)*((int16_t *)src + index);
+}
+int64_t getVectorBigintValue_USMALLINT(void *src, int32_t index) {
+  return (int64_t)*((uint16_t *)src + index);
+}
+int64_t getVectorBigintValue_INT(void *src, int32_t index) {
+  return (int64_t)*((int32_t *)src + index);
+}
+int64_t getVectorBigintValue_UINT(void *src, int32_t index) {
+  return (int64_t)*((uint32_t *)src + index);
+}
+int64_t getVectorBigintValue_BIGINT(void *src, int32_t index) {
+  return (int64_t)*((int64_t *)src + index);
+}
+int64_t getVectorBigintValue_UBIGINT(void *src, int32_t index) {
+  return (int64_t)*((uint64_t *)src + index);
+}
+
+_arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFn(int32_t srcType) {
+  _arithmetic_getVectorBigintValue_fn_t p = NULL;
+  if (srcType==TSDB_DATA_TYPE_BOOL) {
+    p = getVectorBigintValue_BOOL;
+  } else if (srcType==TSDB_DATA_TYPE_TINYINT) {
+    p = getVectorBigintValue_TINYINT;
+  } else if (srcType==TSDB_DATA_TYPE_UTINYINT) {
+    p = getVectorBigintValue_UTINYINT;
+  } else if (srcType==TSDB_DATA_TYPE_SMALLINT) {
+    p = getVectorBigintValue_SMALLINT;
+  } else if (srcType==TSDB_DATA_TYPE_USMALLINT) {
+    p = getVectorBigintValue_USMALLINT;
+  }else if (srcType==TSDB_DATA_TYPE_INT) {
+    p = getVectorBigintValue_INT;
+  } else if (srcType==TSDB_DATA_TYPE_UINT) {
+    p = getVectorBigintValue_UINT;
+  } else if (srcType==TSDB_DATA_TYPE_BIGINT) {
+    p = getVectorBigintValue_BIGINT;
+  } else if (srcType==TSDB_DATA_TYPE_UBIGINT) {
+    p = getVectorBigintValue_UBIGINT;
+  } else {
+    assert(0);
+  }
+  return p;
+}
+
 void vectorBitand(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
-  int32_t i = (_ord == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
-  int32_t step = (_ord == TSDB_ORDER_ASC) ? 1 : -1;
-  char *output = out;
+  int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
+  int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
+  double *output=(double*)out;
   _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
   _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
+  _arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(_left_type);
+  _arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(_right_type);
 
-  if (len1 == (len2)) {
-    for (; i >= 0 && i < (len2); i += step) {
-      if (isNull(getVectorValueAddrFnLeft(left, i), _left_type) || isNull(getVectorValueAddrFnRight(right, i), _right_type)) {
-        switch (_left_type) {
-        case TSDB_DATA_TYPE_BOOL:
-            *(bool *) output = TSDB_DATA_BOOL_NULL;
-            output += sizeof(bool);
-            break;
-        case TSDB_DATA_TYPE_TINYINT:
-            *(int8_t *) output = TSDB_DATA_TINYINT_NULL;
-            output += sizeof(int8_t);
-            break;
-        case TSDB_DATA_TYPE_SMALLINT:
-            *(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
-            output += sizeof(int16_t);
-            break;
-        case TSDB_DATA_TYPE_INT:
-            *(int32_t *) output = TSDB_DATA_INT_NULL;
-            output += sizeof(int32_t);
-            break;
-        case TSDB_DATA_TYPE_BIGINT:
-            *(int64_t *) output = TSDB_DATA_BIGINT_NULL;
-            output += sizeof(int64_t);
-            break;
-
-        case TSDB_DATA_TYPE_UTINYINT:
-            *(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
-            output += sizeof(int8_t);
-            break;
-        case TSDB_DATA_TYPE_USMALLINT:
-            *(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
-            output += sizeof(int16_t);
-            break;
-        case TSDB_DATA_TYPE_UINT:
-            *(uint32_t *) output = TSDB_DATA_UINT_NULL;
-            output += sizeof(int32_t);
-            break;
-        case TSDB_DATA_TYPE_UBIGINT:
-            *(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
-            output += sizeof(int64_t);
-            break;
-        }
+  if ((len1) == (len2)) {
+    for (; i < (len2) && i >= 0; i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,i) & getVectorBigintValueFnRight(right,i);
+    }
+  } else if ((len1) == 1) {
+    for (; i >= 0 && i < (len2); i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,0) & getVectorBigintValueFnRight(right,i);
+    }
+  } else if ((len2) == 1) {
+    for (; i >= 0 && i < (len1); i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,i) & getVectorBigintValueFnRight(right,0);
+    }
+  }
+}
+
+void vectorBitor(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
+  int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
+  int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
+  double *output=(double*)out;
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
+  _arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(_left_type);
+  _arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(_right_type);
+
+  if ((len1) == (len2)) {
+    for (; i < (len2) && i >= 0; i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,i) | getVectorBigintValueFnRight(right,i);
+    }
+  } else if ((len1) == 1) {
+    for (; i >= 0 && i < (len2); i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,0) | getVectorBigintValueFnRight(right,i);
+    }
+  } else if ((len2) == 1) {
+    for (; i >= 0 && i < (len1); i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,i) | getVectorBigintValueFnRight(right,0);
+    }
+  }
+}
+
+void vectorBitxor(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
+  int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
+  int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
+  double *output=(double*)out;
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
+  _arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(_left_type);
+  _arithmetic_getVectorBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(_right_type);
+
+  if ((len1) == (len2)) {
+    for (; i < (len2) && i >= 0; i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,i) ^ getVectorBigintValueFnRight(right,i);
+    }
+  } else if ((len1) == 1) {
+    for (; i >= 0 && i < (len2); i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
+        SET_BIGINT_NULL(output);
+        continue;
+      }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,0) ^ getVectorBigintValueFnRight(right,i);
+    }
+  } else if ((len2) == 1) {
+    for (; i >= 0 && i < (len1); i += step, output += 1) {
+      if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
+        SET_BIGINT_NULL(output);
         continue;
       }
+      *(int64_t *) output = getVectorBigintValueFnLeft(left,i) ^ getVectorBigintValueFnRight(right,0);
+    }
+  }
+}
+
+void vectorBitnot(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
+  int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
+  int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
+  char *output = (char *) out;
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
 
+  for (; i < (len1) && i >= 0; i += step) {
+    if (isNull(getVectorValueAddrFnLeft(left,i), _left_type)) {
       switch (_left_type) {
       case TSDB_DATA_TYPE_BOOL:
-          *(bool *) output = (*((bool *) left + i)) & (*((bool *) right + i));
-          output += sizeof(bool);
-          break;
+        *(bool *) output = TSDB_DATA_BOOL_NULL;
+        output += sizeof(bool);
+        break;
       case TSDB_DATA_TYPE_TINYINT:
-          *(int8_t *) output = (*((int8_t *) left + i)) & (*((int8_t *) right + i));
-          output += sizeof(int8_t);
-          break;
+        *(int8_t *) output = TSDB_DATA_TINYINT_NULL;
+        output += sizeof(int8_t);
+        break;
       case TSDB_DATA_TYPE_SMALLINT:
-          *(int16_t *) output = (*((int16_t *) left + i)) & (*((int16_t *) right + i));
-          output += sizeof(int16_t);
-          break;
+        *(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
+        output += sizeof(int16_t);
+        break;
       case TSDB_DATA_TYPE_INT:
-          *(int32_t *) output = (*((int32_t *) left + i)) & (*((int32_t *) right + i));
-          output += sizeof(int32_t);
-          break;
+        *(int32_t *) output = TSDB_DATA_INT_NULL;
+        output += sizeof(int32_t);
+        break;
       case TSDB_DATA_TYPE_BIGINT:
-          *(int64_t *) output = (*((int64_t *) left + i)) & (*((int64_t *) right + i));
-          output += sizeof(int64_t);
-          break;
+        *(int64_t *) output = TSDB_DATA_BIGINT_NULL;
+        output += sizeof(int64_t);
+        break;
 
       case TSDB_DATA_TYPE_UTINYINT:
-          *(uint8_t *) output = (*((uint8_t *) left + i)) & (*((uint8_t *) right + i));
-          output += sizeof(int8_t);
-          break;
+        *(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
+        output += sizeof(int8_t);
+        break;
       case TSDB_DATA_TYPE_USMALLINT:
-          *(uint16_t *) output = (*((uint16_t *) left + i)) & (*((uint16_t *) right + i));
-          output += sizeof(int16_t);
-          break;
+        *(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
+        output += sizeof(int16_t);
+        break;
       case TSDB_DATA_TYPE_UINT:
-          *(uint32_t *) output = (*((uint32_t *) left + i)) & (*((uint32_t *) right + i));
-          output += sizeof(int32_t);
-          break;
+        *(uint32_t *) output = TSDB_DATA_UINT_NULL;
+        output += sizeof(int32_t);
+        break;
       case TSDB_DATA_TYPE_UBIGINT:
-          *(uint64_t *) output = (*((uint64_t *) left + i)) & (*((uint64_t *) right + i));
-          output += sizeof(int64_t);
-          break;
+        *(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
+        output += sizeof(int64_t);
+        break;
       }
+
+      continue;
     }
-  } else if (len1 == 1) {
-    for (; i >= 0 && i < (len2); i += step) {
-      if (isNull(getVectorValueAddrFnLeft(left, 0), _left_type) || isNull(getVectorValueAddrFnRight(right, i), _right_type)) {
-        switch (_left_type) {
-        case TSDB_DATA_TYPE_BOOL:
-            *(bool *) output = TSDB_DATA_BOOL_NULL;
-            output += sizeof(bool);
-            break;
-        case TSDB_DATA_TYPE_TINYINT:
-            *(int8_t *) output = TSDB_DATA_TINYINT_NULL;
-            output += sizeof(int8_t);
-            break;
-        case TSDB_DATA_TYPE_SMALLINT:
-            *(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
-            output += sizeof(int16_t);
-            break;
-        case TSDB_DATA_TYPE_INT:
-            *(int32_t *) output = TSDB_DATA_INT_NULL;
-            output += sizeof(int32_t);
-            break;
-        case TSDB_DATA_TYPE_BIGINT:
-            *(int64_t *) output = TSDB_DATA_BIGINT_NULL;
-            output += sizeof(int64_t);
-            break;
-
-        case TSDB_DATA_TYPE_UTINYINT:
-            *(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
-            output += sizeof(int8_t);
-            break;
-        case TSDB_DATA_TYPE_USMALLINT:
-            *(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
-            output += sizeof(int16_t);
-            break;
-        case TSDB_DATA_TYPE_UINT:
-            *(uint32_t *) output = TSDB_DATA_UINT_NULL;
-            output += sizeof(int32_t);
-            break;
-        case TSDB_DATA_TYPE_UBIGINT:
-            *(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
-            output += sizeof(int64_t);
-            break;
-        }
-        continue;
+
+    switch (_left_type) {
+    case TSDB_DATA_TYPE_BOOL:
+      if (*((bool *)left + i)) {
+        *(bool *)output = 0;
+      } else {
+        *(bool *)output = 1;
       }
+      output += sizeof(bool);
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      *(int8_t *) output = ~(*((int8_t *) left + i));
+      output += sizeof(int8_t);
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      *(int16_t *) output = ~(*((int16_t *) left + i));
+      output += sizeof(int16_t);
+      break;
+    case TSDB_DATA_TYPE_INT:
+      *(int32_t *) output = ~(*((int32_t *) left + i));
+      output += sizeof(int32_t);
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      *(int64_t *) output = ~(*((int64_t *) left + i));
+      output += sizeof(int64_t);
+      break;
+
+    case TSDB_DATA_TYPE_UTINYINT:
+      *(uint8_t *) output = ~(*((uint8_t *) left + i));
+      output += sizeof(int8_t);
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      *(uint16_t *) output = ~(*((uint16_t *) left + i));
+      output += sizeof(int16_t);
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      *(uint32_t *) output = ~(*((uint32_t *) left + i));
+      output += sizeof(int32_t);
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      *(uint64_t *) output = ~(*((uint64_t *) left + i));
+      output += sizeof(int64_t);
+      break;
+    }
+  }
+}
+
+void vectorLshift(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
+  int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
+  int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
+
+  // the right operand is a number
+  if (len2 != 1) {
+    return;
+  }
 
+  char *output = (char *) out;
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
+
+  for (; i < (len1) && i >= 0; i += step) {
+    if (isNull(getVectorValueAddrFnLeft(left,i), _left_type)) {
       switch (_left_type) {
       case TSDB_DATA_TYPE_BOOL:
-          *(bool *) output = (*(bool *) left) & (*((bool *) right + i));
-          output += sizeof(bool);
-          break;
+        *(bool *) output = TSDB_DATA_BOOL_NULL;
+        output += sizeof(bool);
+        break;
       case TSDB_DATA_TYPE_TINYINT:
-          *(int8_t *) output = (*(int8_t *) left) & (*((int8_t *) right + i));
-          output += sizeof(int8_t);
-          break;
+        *(int8_t *) output = TSDB_DATA_TINYINT_NULL;
+        output += sizeof(int8_t);
+        break;
       case TSDB_DATA_TYPE_SMALLINT:
-          *(int16_t *) output = (*(int16_t *) left) & (*((int16_t *) right + i));
-          output += sizeof(int16_t);
-          break;
+        *(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
+        output += sizeof(int16_t);
+        break;
       case TSDB_DATA_TYPE_INT:
-          *(int32_t *) output = (*(int32_t *) left) & (*((int32_t *) right + i));
-          output += sizeof(int32_t);
-          break;
+        *(int32_t *) output = TSDB_DATA_INT_NULL;
+        output += sizeof(int32_t);
+        break;
       case TSDB_DATA_TYPE_BIGINT:
-          *(int64_t *) output = (*(int64_t *) left) & (*((int64_t *) right + i));
-          output += sizeof(int64_t);
-          break;
+        *(int64_t *) output = TSDB_DATA_BIGINT_NULL;
+        output += sizeof(int64_t);
+        break;
 
       case TSDB_DATA_TYPE_UTINYINT:
-          *(uint8_t *) output = (*(uint8_t *) left) & (*((uint8_t *) right + i));
-          output += sizeof(int8_t);
-          break;
+        *(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
+        output += sizeof(int8_t);
+        break;
       case TSDB_DATA_TYPE_USMALLINT:
-          *(uint16_t *) output = (*(uint16_t *) left) & (*((uint16_t *) right + i));
-          output += sizeof(int16_t);
-          break;
+        *(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
+        output += sizeof(int16_t);
+        break;
       case TSDB_DATA_TYPE_UINT:
-          *(uint32_t *) output = (*(uint32_t *) left) & (*((uint32_t *) right + i));
-          output += sizeof(int32_t);
-          break;
+        *(uint32_t *) output = TSDB_DATA_UINT_NULL;
+        output += sizeof(int32_t);
+        break;
       case TSDB_DATA_TYPE_UBIGINT:
-          *(uint64_t *) output = (*(uint64_t *) left) & (*((uint64_t *) right + i));
-          output += sizeof(int64_t);
-          break;
+        *(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
+        output += sizeof(int64_t);
+        break;
       }
+
+      continue;
     }
-  } else if ((len2) == 1) {
-    for (; i >= 0 && i < len1; i += step) {
-      if (isNull(getVectorValueAddrFnLeft(left, i), _left_type) || isNull(getVectorValueAddrFnRight(right, 0), _right_type)) {
-        switch (_left_type) {
-        case TSDB_DATA_TYPE_BOOL:
-            *(bool *) output = TSDB_DATA_BOOL_NULL;
-            output += sizeof(bool);
-            break;
-        case TSDB_DATA_TYPE_TINYINT:
-            *(int8_t *) output = TSDB_DATA_TINYINT_NULL;
-            output += sizeof(int8_t);
-            break;
-        case TSDB_DATA_TYPE_SMALLINT:
-            *(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
-            output += sizeof(int16_t);
-            break;
-        case TSDB_DATA_TYPE_INT:
-            *(int32_t *) output = TSDB_DATA_INT_NULL;
-            output += sizeof(int32_t);
-            break;
-        case TSDB_DATA_TYPE_BIGINT:
-            *(int64_t *) output = TSDB_DATA_BIGINT_NULL;
-            output += sizeof(int64_t);
-            break;
-
-        case TSDB_DATA_TYPE_UTINYINT:
-            *(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
-            output += sizeof(int8_t);
-            break;
-        case TSDB_DATA_TYPE_USMALLINT:
-            *(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
-            output += sizeof(int16_t);
-            break;
-        case TSDB_DATA_TYPE_UINT:
-            *(uint32_t *) output = TSDB_DATA_UINT_NULL;
-            output += sizeof(int32_t);
-            break;
-        case TSDB_DATA_TYPE_UBIGINT:
-            *(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
-            output += sizeof(int64_t);
-            break;
-        }
-        continue;
-      }
 
+    switch (_left_type) {
+    case TSDB_DATA_TYPE_BOOL:
+      *(bool *)output = 0;
+      output += sizeof(bool);
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      *(int8_t *) output = *((int8_t *) left + i) << *(int8_t *) right;
+      output += sizeof(int8_t);
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      *(int16_t *) output = *((int16_t *) left + i) << *(int16_t *) right;
+      output += sizeof(int16_t);
+      break;
+    case TSDB_DATA_TYPE_INT:
+      *(int32_t *) output = *((int32_t *) left + i) << *(int32_t *) right;
+      output += sizeof(int32_t);
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      *(int64_t *) output = *((int64_t *) left + i) << *(int64_t *) right;
+      output += sizeof(int64_t);
+      break;
+
+    case TSDB_DATA_TYPE_UTINYINT:
+      *(uint8_t *) output = *((uint8_t *) left + i) << *(uint8_t *) right;
+      output += sizeof(int8_t);
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      *(uint16_t *) output = *((uint16_t *) left + i) << *(uint16_t *) right;
+      output += sizeof(int16_t);
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      *(uint32_t *) output = *((uint32_t *) left + i) << *(uint32_t *) right;
+      output += sizeof(int32_t);
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      *(uint64_t *) output = *((uint64_t *) left + i) << *(uint64_t *) right;
+      output += sizeof(int64_t);
+      break;
+    }
+  }
+}
+
+void vectorRshift(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
+  int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
+  int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
+
+  // the right operand is a number
+  if (len2 != 1) {
+    return;
+  }
+
+  char *output = (char *) out;
+  _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
+
+  for (; i < (len1) && i >= 0; i += step) {
+    if (isNull(getVectorValueAddrFnLeft(left,i), _left_type)) {
       switch (_left_type) {
       case TSDB_DATA_TYPE_BOOL:
-          *(bool *) output = (*((bool *) left + i)) & (*(bool *) right);
-          output += sizeof(bool);
-          break;
+        *(bool *) output = TSDB_DATA_BOOL_NULL;
+        output += sizeof(bool);
+        break;
       case TSDB_DATA_TYPE_TINYINT:
-          *(int8_t *) output = (*((int8_t *) left + i)) & (*(int8_t *) right);
-          output += sizeof(int8_t);
-          break;
+        *(int8_t *) output = TSDB_DATA_TINYINT_NULL;
+        output += sizeof(int8_t);
+        break;
       case TSDB_DATA_TYPE_SMALLINT:
-          *(int16_t *) output = (*((int16_t *) left + i)) & (*(int16_t *) right);
-          output += sizeof(int16_t);
-          break;
+        *(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
+        output += sizeof(int16_t);
+        break;
       case TSDB_DATA_TYPE_INT:
-          *(int32_t *) output = (*((int32_t *) left + i)) & (*(int32_t *) right);
-          output += sizeof(int32_t);
-          break;
+        *(int32_t *) output = TSDB_DATA_INT_NULL;
+        output += sizeof(int32_t);
+        break;
       case TSDB_DATA_TYPE_BIGINT:
-          *(int64_t *) output = (*((int64_t *) left + i)) & (*(int64_t *) right);
-          output += sizeof(int64_t);
-          break;
+        *(int64_t *) output = TSDB_DATA_BIGINT_NULL;
+        output += sizeof(int64_t);
+        break;
 
       case TSDB_DATA_TYPE_UTINYINT:
-          *(uint8_t *) output = (*((uint8_t *) left + i)) & (*(uint8_t *) right);
-          output += sizeof(int8_t);
-          break;
+        *(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
+        output += sizeof(int8_t);
+        break;
       case TSDB_DATA_TYPE_USMALLINT:
-          *(uint16_t *) output = (*((uint16_t *) left + i)) & (*(uint16_t *) right);
-          output += sizeof(int16_t);
-          break;
+        *(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
+        output += sizeof(int16_t);
+        break;
       case TSDB_DATA_TYPE_UINT:
-          *(uint32_t *) output = (*((uint32_t *) left + i)) & (*(uint32_t *) right);
-          output += sizeof(int32_t);
-          break;
+        *(uint32_t *) output = TSDB_DATA_UINT_NULL;
+        output += sizeof(int32_t);
+        break;
       case TSDB_DATA_TYPE_UBIGINT:
-          *(uint64_t *) output = (*((uint64_t *) left + i)) & (*(uint64_t *) right);
-          output += sizeof(int64_t);
-          break;
+        *(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
+        output += sizeof(int64_t);
+        break;
       }
+
+      continue;
+    }
+
+    switch (_left_type) {
+    case TSDB_DATA_TYPE_BOOL:
+      *(bool *)output = 0;
+      output += sizeof(bool);
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      *(int8_t *) output = *((int8_t *) left + i) >> *(int8_t *) right;
+      output += sizeof(int8_t);
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      *(int16_t *) output = *((int16_t *) left + i) >> *(int16_t *) right;
+      output += sizeof(int16_t);
+      break;
+    case TSDB_DATA_TYPE_INT:
+      *(int32_t *) output = *((int32_t *) left + i) >> *(int32_t *) right;
+      output += sizeof(int32_t);
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      *(int64_t *) output = *((int64_t *) left + i) >> *(int64_t *) right;
+      output += sizeof(int64_t);
+      break;
+
+    case TSDB_DATA_TYPE_UTINYINT:
+      *(uint8_t *) output = *((uint8_t *) left + i) >> *(uint8_t *) right;
+      output += sizeof(int8_t);
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      *(uint16_t *) output = *((uint16_t *) left + i) >> *(uint16_t *) right;
+      output += sizeof(int16_t);
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      *(uint32_t *) output = *((uint32_t *) left + i) >> *(uint32_t *) right;
+      output += sizeof(int32_t);
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      *(uint64_t *) output = *((uint64_t *) left + i) >> *(uint64_t *) right;
+      output += sizeof(int64_t);
+      break;
     }
   }
 }
@@ -682,6 +876,16 @@ _arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) {
       return vectorRemainder;
     case TSDB_BINARY_OP_BITAND:
       return vectorBitand;
+    case TSDB_BINARY_OP_BITOR:
+      return vectorBitor;
+    case TSDB_BINARY_OP_BITXOR:
+      return vectorBitxor;
+    case TSDB_BINARY_OP_BITNOT:
+      return vectorBitnot;
+    case TSDB_BINARY_OP_LSHIFT:
+      return vectorLshift;
+    case TSDB_BINARY_OP_RSHIFT:
+      return vectorRshift;
     default:
       assert(0);
       return NULL;
diff --git a/src/common/src/texpr.c b/src/common/src/texpr.c
index b764ffbb012d98408b333d147ca0c40a95c6bcdc..f43d28aac79fc0bf4e05be27475c3e1c29493819 100644
--- a/src/common/src/texpr.c
+++ b/src/common/src/texpr.c
@@ -88,7 +88,6 @@ int32_t exprTreeValidateFunctionNode(char* msgbuf, tExprNode *pExpr) {
 int32_t exprTreeValidateExprNode(tExprNode *pExpr) {
   int16_t leftType = pExpr->_node.pLeft->resultType;
   int16_t rightType = pExpr->_node.pRight->resultType;
-  int16_t resultType = leftType;
 
   if (pExpr->_node.optr == TSDB_BINARY_OP_ADD || pExpr->_node.optr == TSDB_BINARY_OP_SUBTRACT ||
       pExpr->_node.optr == TSDB_BINARY_OP_MULTIPLY || pExpr->_node.optr == TSDB_BINARY_OP_DIVIDE ||
@@ -99,171 +98,31 @@ int32_t exprTreeValidateExprNode(tExprNode *pExpr) {
     pExpr->resultType = TSDB_DATA_TYPE_DOUBLE;
     pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
     return TSDB_CODE_SUCCESS;
-  } else if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND) {
-    if ((leftType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(leftType) && !IS_UNSIGNED_NUMERIC_TYPE(leftType)) ||
-        (rightType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(rightType) && !IS_UNSIGNED_NUMERIC_TYPE(rightType)))
-    {
+  } else if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND || pExpr->_node.optr == TSDB_BINARY_OP_BITOR ||
+             pExpr->_node.optr == TSDB_BINARY_OP_BITXOR || pExpr->_node.optr == TSDB_BINARY_OP_LSHIFT ||
+             pExpr->_node.optr == TSDB_BINARY_OP_RSHIFT)
+  {
+    if (!IS_NUMERIC_TYPE(leftType) || !IS_NUMERIC_TYPE(rightType)) {
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
-
-    uint8_t schemaType;
-    // now leftType and rightType are both numeric
-    if (pExpr->_node.pLeft->nodeType == TSQL_NODE_COL && pExpr->_node.pRight->nodeType == TSQL_NODE_COL) {
-      if (leftType != rightType) {
-        return TSDB_CODE_TSC_INVALID_OPERATION;
-      }
-    } else if (pExpr->_node.pLeft->nodeType == TSQL_NODE_COL) {
-      if (pExpr->_node.pRight->nodeType != TSQL_NODE_VALUE) {
-        return TSDB_CODE_TSC_INVALID_OPERATION;
-      } else {
-        schemaType = pExpr->_node.pLeft->pSchema->type;
-        int64_t sVal = pExpr->_node.pRight->pVal->i64;
-        uint64_t uVal = pExpr->_node.pRight->pVal->u64;
-
-        switch (schemaType) {
-        case TSDB_DATA_TYPE_BOOL:
-          if ((pExpr->_node.pRight->pVal->nType != TSDB_DATA_TYPE_BOOL) ||
-              (pExpr->_node.pRight->pVal->i64 != 0 &&
-               pExpr->_node.pRight->pVal->i64 != 1 &&
-               pExpr->_node.pRight->pVal->i64 != TSDB_DATA_BOOL_NULL))
-          {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_TINYINT:
-          if (sVal < -128 || sVal > 127) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_SMALLINT:
-          if (sVal < -32768 || sVal > 32767) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_INT:
-          if (sVal < INT32_MIN || sVal > INT32_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_BIGINT:
-          if (sVal < INT64_MIN || sVal > INT64_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_UTINYINT:
-          if (uVal > 255) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_USMALLINT:
-          if (uVal > 65535) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_UINT:
-          if (uVal > UINT32_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        case TSDB_DATA_TYPE_UBIGINT:
-          if (uVal > UINT64_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          break;
-        }
-
-        pExpr->_node.pRight->pSchema->type = schemaType;
-        pExpr->_node.pRight->pVal->nType = schemaType;
-
-        pExpr->_node.pRight->resultType = schemaType;
-        pExpr->_node.pRight->resultBytes = tDataTypes[schemaType].bytes;
-      }
-    } else {
-      if (pExpr->_node.pLeft->nodeType != TSQL_NODE_VALUE) {
-        return TSDB_CODE_TSC_INVALID_OPERATION;
-      } else {
-        schemaType = pExpr->_node.pRight->pSchema->type;
-        int64_t sVal = pExpr->_node.pLeft->pVal->i64;
-        uint64_t uVal = pExpr->_node.pLeft->pVal->u64;
-        switch (schemaType) {
-        case TSDB_DATA_TYPE_BOOL:
-          if ((pExpr->_node.pLeft->pVal->nType != TSDB_DATA_TYPE_BOOL) ||
-              (pExpr->_node.pLeft->pVal->i64 != 0 &&
-               pExpr->_node.pLeft->pVal->i64 != 1 &&
-               pExpr->_node.pLeft->pVal->i64 != TSDB_DATA_BOOL_NULL))
-          {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 1;
-          break;
-        case TSDB_DATA_TYPE_TINYINT:
-          if (sVal < -128 || sVal > 127) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 1;
-          break;
-        case TSDB_DATA_TYPE_SMALLINT:
-          if (sVal < -32768 || sVal > 32767) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 2;
-          break;
-        case TSDB_DATA_TYPE_INT:
-          if (sVal < INT32_MIN || sVal > INT32_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 4;
-          break;
-        case TSDB_DATA_TYPE_BIGINT:
-          if (sVal < INT64_MIN || sVal > INT64_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 8;
-          break;
-        case TSDB_DATA_TYPE_UTINYINT:
-          if (uVal > 255) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 1;
-          break;
-        case TSDB_DATA_TYPE_USMALLINT:
-          if (uVal > 65535) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 2;
-          break;
-        case TSDB_DATA_TYPE_UINT:
-          if (uVal > UINT32_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 4;
-          break;
-        case TSDB_DATA_TYPE_UBIGINT:
-          if (uVal > UINT64_MAX) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
-          }
-          pExpr->_node.pLeft->pVal->nLen = 8;
-          break;
-        }
-
-        pExpr->_node.pLeft->pSchema->type = schemaType;
-        pExpr->_node.pLeft->pVal->nType = schemaType;
-
-        pExpr->_node.pLeft->resultType = schemaType;
-        pExpr->_node.pLeft->resultBytes = tDataTypes[schemaType].bytes;
-      }
-
-      resultType = schemaType;
+    if (IS_FLOAT_TYPE(leftType) || IS_FLOAT_TYPE(rightType)) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
-
-    if (resultType == TSDB_DATA_TYPE_BOOL) {
-      pExpr->resultType = TSDB_DATA_TYPE_BOOL;
-      pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
+    if (pExpr->_node.optr == TSDB_BINARY_OP_LSHIFT || pExpr->_node.optr == TSDB_BINARY_OP_RSHIFT) {
+      pExpr->resultType = leftType;
+      pExpr->resultBytes = tDataTypes[leftType].bytes;
     } else {
-      pExpr->resultType = resultType;
-      pExpr->resultBytes = tDataTypes[resultType].bytes;
+      pExpr->resultType = TSDB_DATA_TYPE_BIGINT;
+      pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
     }
     return TSDB_CODE_SUCCESS;
+  } else if (pExpr->_node.optr == TSDB_BINARY_OP_BITNOT) {
+    if (!IS_NUMERIC_TYPE(leftType) || IS_FLOAT_TYPE(leftType)) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+    pExpr->resultType = leftType;
+    pExpr->resultBytes = tDataTypes[leftType].bytes;
+    return TSDB_CODE_SUCCESS;
   } else {
     return TSDB_CODE_SUCCESS;
   }
@@ -647,6 +506,9 @@ void exprTreeExprNodeTraverse(tExprNode *pExpr, int32_t numOfRows, tExprOperandI
 
     rightType = pRight->pSchema->type;
     rightNum = numOfRows;    
+  } else if (pRight->nodeType == TSQL_NODE_DUMMY) {
+    /* BITNOT */
+    rightNum = 0;
   } else {
     assert(pRight->nodeType == TSQL_NODE_VALUE);
     rightIn = (char *)&pRight->pVal->i64;
@@ -661,7 +523,10 @@ void exprTreeExprNodeTraverse(tExprNode *pExpr, int32_t numOfRows, tExprOperandI
   if(leftType == TSDB_DATA_TYPE_TIMESTAMP || rightType == TSDB_DATA_TYPE_TIMESTAMP) {
     output->type = TSDB_DATA_TYPE_BIGINT;
   } else {
-    if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND) {
+    if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND || pExpr->_node.optr == TSDB_BINARY_OP_BITOR ||
+        pExpr->_node.optr == TSDB_BINARY_OP_BITXOR || pExpr->_node.optr == TSDB_BINARY_OP_BITNOT ||
+        pExpr->_node.optr == TSDB_BINARY_OP_LSHIFT || pExpr->_node.optr == TSDB_BINARY_OP_RSHIFT)
+    {
       output->type = leftType; // rightType must be the same as leftType
     } else {
       output->type = TSDB_DATA_TYPE_DOUBLE;
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index f78156ba4e953f3c902f7e5f17e53ab70b50a6b4..ba85401936c584b4b2bc45e1b83717f16a441ec4 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -177,10 +177,15 @@ do { \
 #define TSDB_BINARY_OP_DIVIDE     33
 #define TSDB_BINARY_OP_REMAINDER  34
 #define TSDB_BINARY_OP_BITAND     35
+#define TSDB_BINARY_OP_BITOR      36
+#define TSDB_BINARY_OP_BITXOR     37
+#define TSDB_BINARY_OP_BITNOT     38
+#define TSDB_BINARY_OP_LSHIFT     39
+#define TSDB_BINARY_OP_RSHIFT     40
 
 
 #define IS_RELATION_OPTR(op) (((op) >= TSDB_RELATION_LESS) && ((op) < TSDB_RELATION_IN))
-#define IS_ARITHMETIC_OPTR(op) (((op) >= TSDB_BINARY_OP_ADD) && ((op) <= TSDB_BINARY_OP_BITAND))
+#define IS_ARITHMETIC_OPTR(op) (((op) >= TSDB_BINARY_OP_ADD) && ((op) <= TSDB_BINARY_OP_RSHIFT))
 
 #define TS_PATH_DELIMITER_LEN     1
 
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index 7d721d21a0b85bb3e7119977f74f3e05e69cc361..a57e295c7322d4ed0b9a9c701a6b61f0534b6357 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -50,172 +50,173 @@
 #define TK_LE                              32
 #define TK_BITAND                          33
 #define TK_BITOR                           34
-#define TK_LSHIFT                          35
-#define TK_RSHIFT                          36
-#define TK_PLUS                            37
-#define TK_MINUS                           38
-#define TK_DIVIDE                          39
-#define TK_TIMES                           40
-#define TK_STAR                            41
-#define TK_SLASH                           42
-#define TK_REM                             43
-#define TK_UMINUS                          44
-#define TK_UPLUS                           45
-#define TK_BITNOT                          46
-#define TK_ARROW                           47
-#define TK_SHOW                            48
-#define TK_DATABASES                       49
-#define TK_TOPICS                          50
-#define TK_FUNCTIONS                       51
-#define TK_MNODES                          52
-#define TK_DNODES                          53
-#define TK_ACCOUNTS                        54
-#define TK_USERS                           55
-#define TK_MODULES                         56
-#define TK_QUERIES                         57
-#define TK_CONNECTIONS                     58
-#define TK_STREAMS                         59
-#define TK_VARIABLES                       60
-#define TK_SCORES                          61
-#define TK_GRANTS                          62
-#define TK_VNODES                          63
-#define TK_DOT                             64
-#define TK_CREATE                          65
-#define TK_TABLE                           66
-#define TK_STABLE                          67
-#define TK_DATABASE                        68
-#define TK_TABLES                          69
-#define TK_STABLES                         70
-#define TK_VGROUPS                         71
-#define TK_DROP                            72
-#define TK_TOPIC                           73
-#define TK_FUNCTION                        74
-#define TK_DNODE                           75
-#define TK_USER                            76
-#define TK_ACCOUNT                         77
-#define TK_USE                             78
-#define TK_DESCRIBE                        79
-#define TK_DESC                            80
-#define TK_ALTER                           81
-#define TK_PASS                            82
-#define TK_PRIVILEGE                       83
-#define TK_LOCAL                           84
-#define TK_COMPACT                         85
-#define TK_LP                              86
-#define TK_RP                              87
-#define TK_IF                              88
-#define TK_EXISTS                          89
-#define TK_AS                              90
-#define TK_OUTPUTTYPE                      91
-#define TK_AGGREGATE                       92
-#define TK_BUFSIZE                         93
-#define TK_PPS                             94
-#define TK_TSERIES                         95
-#define TK_DBS                             96
-#define TK_STORAGE                         97
-#define TK_QTIME                           98
-#define TK_CONNS                           99
-#define TK_STATE                          100
-#define TK_COMMA                          101
-#define TK_KEEP                           102
-#define TK_CACHE                          103
-#define TK_REPLICA                        104
-#define TK_QUORUM                         105
-#define TK_DAYS                           106
-#define TK_MINROWS                        107
-#define TK_MAXROWS                        108
-#define TK_BLOCKS                         109
-#define TK_CTIME                          110
-#define TK_WAL                            111
-#define TK_FSYNC                          112
-#define TK_COMP                           113
-#define TK_PRECISION                      114
-#define TK_UPDATE                         115
-#define TK_CACHELAST                      116
-#define TK_PARTITIONS                     117
-#define TK_UNSIGNED                       118
-#define TK_TAGS                           119
-#define TK_USING                          120
-#define TK_NULL                           121
-#define TK_NOW                            122
-#define TK_VARIABLE                       123
-#define TK_SELECT                         124
-#define TK_UNION                          125
-#define TK_ALL                            126
-#define TK_DISTINCT                       127
-#define TK_FROM                           128
-#define TK_RANGE                          129
-#define TK_INTERVAL                       130
-#define TK_EVERY                          131
-#define TK_SESSION                        132
-#define TK_STATE_WINDOW                   133
-#define TK_FILL                           134
-#define TK_SLIDING                        135
-#define TK_ORDER                          136
-#define TK_BY                             137
-#define TK_ASC                            138
-#define TK_GROUP                          139
-#define TK_HAVING                         140
-#define TK_LIMIT                          141
-#define TK_OFFSET                         142
-#define TK_SLIMIT                         143
-#define TK_SOFFSET                        144
-#define TK_WHERE                          145
-#define TK_RESET                          146
-#define TK_QUERY                          147
-#define TK_SYNCDB                         148
-#define TK_ADD                            149
-#define TK_COLUMN                         150
-#define TK_MODIFY                         151
-#define TK_TAG                            152
-#define TK_CHANGE                         153
-#define TK_SET                            154
-#define TK_KILL                           155
-#define TK_CONNECTION                     156
-#define TK_STREAM                         157
-#define TK_COLON                          158
-#define TK_ABORT                          159
-#define TK_AFTER                          160
-#define TK_ATTACH                         161
-#define TK_BEFORE                         162
-#define TK_BEGIN                          163
-#define TK_CASCADE                        164
-#define TK_CLUSTER                        165
-#define TK_CONFLICT                       166
-#define TK_COPY                           167
-#define TK_DEFERRED                       168
-#define TK_DELIMITERS                     169
-#define TK_DETACH                         170
-#define TK_EACH                           171
-#define TK_END                            172
-#define TK_EXPLAIN                        173
-#define TK_FAIL                           174
-#define TK_FOR                            175
-#define TK_IGNORE                         176
-#define TK_IMMEDIATE                      177
-#define TK_INITIALLY                      178
-#define TK_INSTEAD                        179
-#define TK_KEY                            180
-#define TK_OF                             181
-#define TK_RAISE                          182
-#define TK_REPLACE                        183
-#define TK_RESTRICT                       184
-#define TK_ROW                            185
-#define TK_STATEMENT                      186
-#define TK_TRIGGER                        187
-#define TK_VIEW                           188
-#define TK_IPTOKEN                        189
-#define TK_SEMI                           190
-#define TK_NONE                           191
-#define TK_PREV                           192
-#define TK_LINEAR                         193
-#define TK_IMPORT                         194
-#define TK_TBNAME                         195
-#define TK_JOIN                           196
-#define TK_INSERT                         197
-#define TK_INTO                           198
-#define TK_VALUES                         199
-#define TK_FILE                           200
+#define TK_BITXOR                          35
+#define TK_LSHIFT                          36
+#define TK_RSHIFT                          37
+#define TK_PLUS                            38
+#define TK_MINUS                           39
+#define TK_DIVIDE                          40
+#define TK_TIMES                           41
+#define TK_STAR                            42
+#define TK_SLASH                           43
+#define TK_REM                             44
+#define TK_UMINUS                          45
+#define TK_UPLUS                           46
+#define TK_BITNOT                          47
+#define TK_ARROW                           48
+#define TK_SHOW                            49
+#define TK_DATABASES                       50
+#define TK_TOPICS                          51
+#define TK_FUNCTIONS                       52
+#define TK_MNODES                          53
+#define TK_DNODES                          54
+#define TK_ACCOUNTS                        55
+#define TK_USERS                           56
+#define TK_MODULES                         57
+#define TK_QUERIES                         58
+#define TK_CONNECTIONS                     59
+#define TK_STREAMS                         60
+#define TK_VARIABLES                       61
+#define TK_SCORES                          62
+#define TK_GRANTS                          63
+#define TK_VNODES                          64
+#define TK_DOT                             65
+#define TK_CREATE                          66
+#define TK_TABLE                           67
+#define TK_STABLE                          68
+#define TK_DATABASE                        69
+#define TK_TABLES                          70
+#define TK_STABLES                         71
+#define TK_VGROUPS                         72
+#define TK_DROP                            73
+#define TK_TOPIC                           74
+#define TK_FUNCTION                        75
+#define TK_DNODE                           76
+#define TK_USER                            77
+#define TK_ACCOUNT                         78
+#define TK_USE                             79
+#define TK_DESCRIBE                        80
+#define TK_DESC                            81
+#define TK_ALTER                           82
+#define TK_PASS                            83
+#define TK_PRIVILEGE                       84
+#define TK_LOCAL                           85
+#define TK_COMPACT                         86
+#define TK_LP                              87
+#define TK_RP                              88
+#define TK_IF                              89
+#define TK_EXISTS                          90
+#define TK_AS                              91
+#define TK_OUTPUTTYPE                      92
+#define TK_AGGREGATE                       93
+#define TK_BUFSIZE                         94
+#define TK_PPS                             95
+#define TK_TSERIES                         96
+#define TK_DBS                             97
+#define TK_STORAGE                         98
+#define TK_QTIME                           99
+#define TK_CONNS                          100
+#define TK_STATE                          101
+#define TK_COMMA                          102
+#define TK_KEEP                           103
+#define TK_CACHE                          104
+#define TK_REPLICA                        105
+#define TK_QUORUM                         106
+#define TK_DAYS                           107
+#define TK_MINROWS                        108
+#define TK_MAXROWS                        109
+#define TK_BLOCKS                         110
+#define TK_CTIME                          111
+#define TK_WAL                            112
+#define TK_FSYNC                          113
+#define TK_COMP                           114
+#define TK_PRECISION                      115
+#define TK_UPDATE                         116
+#define TK_CACHELAST                      117
+#define TK_PARTITIONS                     118
+#define TK_UNSIGNED                       119
+#define TK_TAGS                           120
+#define TK_USING                          121
+#define TK_NULL                           122
+#define TK_NOW                            123
+#define TK_VARIABLE                       124
+#define TK_SELECT                         125
+#define TK_UNION                          126
+#define TK_ALL                            127
+#define TK_DISTINCT                       128
+#define TK_FROM                           129
+#define TK_RANGE                          130
+#define TK_INTERVAL                       131
+#define TK_EVERY                          132
+#define TK_SESSION                        133
+#define TK_STATE_WINDOW                   134
+#define TK_FILL                           135
+#define TK_SLIDING                        136
+#define TK_ORDER                          137
+#define TK_BY                             138
+#define TK_ASC                            139
+#define TK_GROUP                          140
+#define TK_HAVING                         141
+#define TK_LIMIT                          142
+#define TK_OFFSET                         143
+#define TK_SLIMIT                         144
+#define TK_SOFFSET                        145
+#define TK_WHERE                          146
+#define TK_RESET                          147
+#define TK_QUERY                          148
+#define TK_SYNCDB                         149
+#define TK_ADD                            150
+#define TK_COLUMN                         151
+#define TK_MODIFY                         152
+#define TK_TAG                            153
+#define TK_CHANGE                         154
+#define TK_SET                            155
+#define TK_KILL                           156
+#define TK_CONNECTION                     157
+#define TK_STREAM                         158
+#define TK_COLON                          159
+#define TK_ABORT                          160
+#define TK_AFTER                          161
+#define TK_ATTACH                         162
+#define TK_BEFORE                         163
+#define TK_BEGIN                          164
+#define TK_CASCADE                        165
+#define TK_CLUSTER                        166
+#define TK_CONFLICT                       167
+#define TK_COPY                           168
+#define TK_DEFERRED                       169
+#define TK_DELIMITERS                     170
+#define TK_DETACH                         171
+#define TK_EACH                           172
+#define TK_END                            173
+#define TK_EXPLAIN                        174
+#define TK_FAIL                           175
+#define TK_FOR                            176
+#define TK_IGNORE                         177
+#define TK_IMMEDIATE                      178
+#define TK_INITIALLY                      179
+#define TK_INSTEAD                        180
+#define TK_KEY                            181
+#define TK_OF                             182
+#define TK_RAISE                          183
+#define TK_REPLACE                        184
+#define TK_RESTRICT                       185
+#define TK_ROW                            186
+#define TK_STATEMENT                      187
+#define TK_TRIGGER                        188
+#define TK_VIEW                           189
+#define TK_IPTOKEN                        190
+#define TK_SEMI                           191
+#define TK_NONE                           192
+#define TK_PREV                           193
+#define TK_LINEAR                         194
+#define TK_IMPORT                         195
+#define TK_TBNAME                         196
+#define TK_JOIN                           197
+#define TK_INSERT                         198
+#define TK_INTO                           199
+#define TK_VALUES                         200
+#define TK_FILE                           201
 
 
 #define TK_SPACE                          300
diff --git a/src/inc/ttype.h b/src/inc/ttype.h
index 1b7d07262e50da893e1bc3009df94b49ee306637..ff7d6e58355018fe0a05f9c44ee2a28215318452 100644
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
@@ -289,6 +289,7 @@ void* getDataMax(int32_t type);
 int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bool issigned);
 
 #define SET_DOUBLE_NULL(v) (*(uint64_t *)(v) = TSDB_DATA_DOUBLE_NULL)
+#define SET_BIGINT_NULL(v) (*(int64_t *)(v) = TSDB_DATA_BIGINT_NULL)
 
 #ifdef __cplusplus
 }
diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c
index c54cd9fa75331419efeeee8c36e5a93f1a4faaf9..bc9e5761915dc4c74520ca526c761495c1af507f 100644
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -244,22 +244,34 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
   int64_t   st, et;
   wordexp_t full_path;
   char *    sptr = NULL;
+  char *    tmp = NULL;
   char *    cptr = NULL;
   char *    fname = NULL;
   bool      printMode = false;
 
-  if ((sptr = tstrstr(command, ">>", true)) != NULL) {
-    cptr = tstrstr(command, ";", true);
-    if (cptr != NULL) {
-      *cptr = '\0';
-    }
+  sptr = command;
+  while ((sptr = tstrstr(sptr, ">>", true)) != NULL) {
+    // find the last ">>" if any
+    tmp = sptr;
+    sptr += 2;
+  }
 
-    if (wordexp(sptr + 2, &full_path, 0) != 0) {
-      fprintf(stderr, "ERROR: invalid filename: %s\n", sptr + 2);
-      return;
+  sptr = tmp;
+
+  if (sptr != NULL) {
+    if (regex_match(sptr + 2, "^\\s*[0-9]+\\s*[\\>|\\<|\\<=|\\>=|=|!=]\\s*.*;\\s*$", REG_EXTENDED | REG_ICASE) == 0) {
+      cptr = tstrstr(command, ";", true);
+      if (cptr != NULL) {
+        *cptr = '\0';
+      }
+
+      if (wordexp(sptr + 2, &full_path, 0) != 0) {
+        fprintf(stderr, "ERROR: invalid filename: %s\n", sptr + 2);
+        return;
+      }
+      *sptr = '\0';
+      fname = full_path.we_wordv[0];
     }
-    *sptr = '\0';
-    fname = full_path.we_wordv[0];
   }
 
   if ((sptr = tstrstr(command, "\\G", true)) != NULL) {
diff --git a/src/query/inc/qFilter.h b/src/query/inc/qFilter.h
index fe9ef0f47f1e4cf353f9dfbd0e9956e7690debfe..c1e2a745f93523e92eb305816172746df9edfc81 100644
--- a/src/query/inc/qFilter.h
+++ b/src/query/inc/qFilter.h
@@ -39,10 +39,11 @@ extern "C" {
 enum {
   FLD_TYPE_COLUMN = 1,
   FLD_TYPE_VALUE = 2,  
-  FLD_TYPE_MAX = 3,
-  FLD_DESC_NO_FREE = 4,
-  FLD_DATA_NO_FREE = 8,
-  FLD_DATA_IS_HASH = 16,
+  FLD_TYPE_EXPR = 3,
+  FLD_TYPE_MAX = 4,
+  FLD_DESC_NO_FREE = 16,
+  FLD_DATA_NO_FREE = 32,
+  FLD_DATA_IS_HASH = 64,
 };
 
 enum {
@@ -182,6 +183,7 @@ typedef struct SFilterGroupCtx {
   uint32_t         colNum;
   uint32_t        *colIdx;
   SFilterColInfo  *colInfo;
+  bool             hasExpr;
 } SFilterGroupCtx;
 
 typedef struct SFilterColCtx {
@@ -206,6 +208,8 @@ typedef struct SFilterComUnit {
   void *colData;
   void *valData;
   void *valData2;
+  void *expr;
+  void *exprData;
   uint16_t colId;
   uint16_t dataSize;
   uint8_t dataType;
@@ -289,7 +293,10 @@ typedef struct SFilterInfo {
 #define FILTER_GET_VAL_FIELD_TYPE(fi) (((tVariant *)((fi)->desc))->nType)
 #define FILTER_GET_VAL_FIELD_DATA(fi) ((char *)(fi)->data)
 #define FILTER_GET_JSON_VAL_FIELD_DATA(fi) ((char *)(fi)->desc)
-#define FILTER_GET_TYPE(fl) ((fl) & FLD_TYPE_MAX)
+#define FILTER_GET_TYPE(fl) ((fl) & 0xF)
+#define FILTER_GET_FIELD_DESC(fi) ((fi)->desc)
+#define FILTER_GET_EXPR_TYPE(i, id) (((tExprNode*)(FILTER_GET_FIELD_DESC(FILTER_GET_FIELD(i, id))))->resultType)
+#define FILTER_GET_EXPR_SIZE(i, id) (((tExprNode*)(FILTER_GET_FIELD_DESC(FILTER_GET_FIELD(i, id))))->resultBytes)
 
 #define FILTER_GROUP_UNIT(i, g, uid) ((i)->units + (g)->unitIdxs[uid])
 #define FILTER_UNIT_LEFT_FIELD(i, u) FILTER_GET_FIELD(i, (u)->left)
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index ca7bf9c6c18b951b70ac2eb34644c57304ffd775..e35354c50428d39fdf104a3b629d8e7e19c47d03 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -13,7 +13,7 @@
 %right NOT.
 %left EQ NE ISNULL NOTNULL IS LIKE MATCH NMATCH CONTAINS GLOB BETWEEN IN.
 %left GT GE LT LE.
-%left BITAND BITOR LSHIFT RSHIFT.
+%left BITAND BITOR BITXOR LSHIFT RSHIFT.
 %left PLUS MINUS.
 %left DIVIDE TIMES.
 %left STAR SLASH REM.
@@ -787,6 +787,11 @@ expr(A) ::= expr(X) STAR  expr(Y).   {A = tSqlExprCreate(X, Y, TK_STAR);  }
 expr(A) ::= expr(X) SLASH expr(Y).   {A = tSqlExprCreate(X, Y, TK_DIVIDE);}
 expr(A) ::= expr(X) REM   expr(Y).   {A = tSqlExprCreate(X, Y, TK_REM);   }
 expr(A) ::= expr(X) BITAND expr(Y).  {A = tSqlExprCreate(X, Y, TK_BITAND);}
+expr(A) ::= expr(X) BITOR expr(Y).   {A = tSqlExprCreate(X, Y, TK_BITOR); }
+expr(A) ::= expr(X) BITXOR expr(Y).  {A = tSqlExprCreate(X, Y, TK_BITXOR);}
+expr(A) ::= BITNOT expr(X).          {A = tSqlExprCreate(X, NULL, TK_BITNOT);}
+expr(A) ::= expr(X) LSHIFT expr(Y).  {A = tSqlExprCreate(X, Y, TK_LSHIFT);}
+expr(A) ::= expr(X) RSHIFT expr(Y).  {A = tSqlExprCreate(X, Y, TK_RSHIFT);}
 
 // like expression
 expr(A) ::= expr(X) LIKE expr(Y).    {A = tSqlExprCreate(X, Y, TK_LIKE);  }
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index c9b0e7f7aeaec7fec1494053245e0666f85ff9a3..554de3e33a27355cf27ea4ec077b7dde9dddebe0 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -3155,6 +3155,10 @@ void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFi
 FORCE_INLINE int32_t getColumnDataFromId(void *param, int32_t id, void **data) {
   int32_t numOfCols = ((SColumnDataParam *)param)->numOfCols;
   SArray* pDataBlock = ((SColumnDataParam *)param)->pDataBlock;
+  if (id == INT32_MAX) {
+    *data = pDataBlock;
+    return TSDB_CODE_SUCCESS;
+  }
   
   for (int32_t j = 0; j < numOfCols; ++j) {
     SColumnInfoData* pColInfo = taosArrayGet(pDataBlock, j);
diff --git a/src/query/src/qFilter.c b/src/query/src/qFilter.c
index 6b0720a8dbdce8096edf71c6968052fb6a2784c1..585e9eab091b4bddb6972df2748ba5aaf94e6a31 100644
--- a/src/query/src/qFilter.c
+++ b/src/query/src/qFilter.c
@@ -54,11 +54,16 @@ static FORCE_INLINE int32_t filterFieldValDescCompare(const void *desc1, const v
   return tVariantCompare(val1, val2);
 }
 
+static FORCE_INLINE int32_t filterExprCompare(const void *desc1, const void *desc2) {
+  return -1;
+}
+
 
 filter_desc_compare_func gDescCompare [FLD_TYPE_MAX] = {
   NULL,
   filterFieldColDescCompare,
-  filterFieldValDescCompare
+  filterFieldValDescCompare,
+  filterExprCompare
 };
 
 bool filterRangeCompGi (const void *minv, const void *maxv, const void *minr, const void *maxr, __compar_fn_t cfunc) {
@@ -833,7 +838,7 @@ int32_t filterAddField(SFilterInfo *info, void *desc, void **data, int32_t type,
     info->fields[type].fields[idx].desc = desc;
     info->fields[type].fields[idx].data = data ? *data : NULL;
 
-    if (type == FLD_TYPE_COLUMN) {
+    if (type == FLD_TYPE_COLUMN || type == FLD_TYPE_EXPR) {
       FILTER_SET_FLAG(info->fields[type].fields[idx].flag, FLD_DATA_NO_FREE);
     }
 
@@ -873,7 +878,8 @@ static FORCE_INLINE int32_t filterAddColFieldFromField(SFilterInfo *info, SFilte
 
 int32_t filterAddFieldFromNode(SFilterInfo *info, tExprNode *node, SFilterFieldId *fid) {
   CHK_LRET(node == NULL, TSDB_CODE_QRY_APP_ERROR, "empty node");
-  CHK_RET(node->nodeType != TSQL_NODE_COL && node->nodeType != TSQL_NODE_VALUE, TSDB_CODE_QRY_APP_ERROR);
+  CHK_RET(node->nodeType != TSQL_NODE_COL && node->nodeType != TSQL_NODE_VALUE
+          &&node->nodeType != TSQL_NODE_EXPR, TSDB_CODE_QRY_APP_ERROR);
 
   int32_t type;
   void *v;
@@ -882,6 +888,9 @@ int32_t filterAddFieldFromNode(SFilterInfo *info, tExprNode *node, SFilterFieldI
     type = FLD_TYPE_COLUMN;
     v = node->pSchema;
     node->pSchema = NULL;
+  } else if (node->nodeType == TSQL_NODE_EXPR) {
+    type = FLD_TYPE_EXPR;
+    v = node;
   } else {
     type = FLD_TYPE_VALUE;
     v = node->pVal;
@@ -933,9 +942,11 @@ int32_t filterAddUnit(SFilterInfo *info, uint8_t optr, SFilterFieldId *left, SFi
   }
   
   SFilterField *col = FILTER_UNIT_LEFT_FIELD(info, u);
-  assert(FILTER_GET_FLAG(col->flag, FLD_TYPE_COLUMN));
-  
-  info->units[info->unitNum].compare.type = FILTER_GET_COL_FIELD_TYPE(col);
+  if (FILTER_GET_TYPE(col->flag) == FLD_TYPE_COLUMN) {
+    info->units[info->unitNum].compare.type = FILTER_GET_COL_FIELD_TYPE(col);
+  } else {
+    info->units[info->unitNum].compare.type = (uint8_t)FILTER_GET_EXPR_TYPE(info, u->left);
+  }
 
   *uidx = info->unitNum;
 
@@ -1188,7 +1199,7 @@ static int32_t filterDealJson(SFilterInfo *info, tExprNode* tree, tExprNode** pL
     jsonKeyMd5((*pLeft)->_node.pRight->pVal->pz, (*pLeft)->_node.pRight->pVal->nLen, keyMd5);
     memcpy(schema->name, keyMd5, TSDB_MAX_JSON_KEY_MD5_LEN);
     (*pLeft) = (*pLeft)->_node.pLeft;   // -> operation use left as input
-  }else if(((*pLeft)->pSchema->type == TSDB_DATA_TYPE_JSON) &&
+  }else if((*pLeft)->nodeType == TSQL_NODE_COL && ((*pLeft)->pSchema->type == TSDB_DATA_TYPE_JSON) &&
       (tree->_node.optr == TSDB_RELATION_ISNULL || tree->_node.optr == TSDB_RELATION_NOTNULL)){
     SSchema* schema = (*pLeft)->pSchema;
     char    keyMd5[TSDB_MAX_JSON_KEY_MD5_LEN] = {0};
@@ -1212,7 +1223,16 @@ int32_t filterAddGroupUnitFromNode(SFilterInfo *info, tExprNode* tree, SArray *g
   if((ret = filterDealJson(info, tree, &pLeft)) != TSDB_CODE_SUCCESS) return ret;
   SFilterFieldId left = {0}, right = {0};
   filterAddFieldFromNode(info, pLeft, &left);
-  uint8_t type = FILTER_GET_COL_FIELD_TYPE(FILTER_GET_FIELD(info, left));
+  if (pLeft->nodeType != TSQL_NODE_VALUE && pLeft->nodeType != TSQL_NODE_COL) {
+    tree->_node.pLeft = NULL;
+  }
+
+  uint8_t type;
+  if (left.type == FLD_TYPE_EXPR) {
+    type = (uint8_t)FILTER_GET_EXPR_TYPE(info, left);
+  } else {
+    type = FILTER_GET_COL_FIELD_TYPE(FILTER_GET_FIELD(info, left));
+  }
   int32_t len = 0;
   uint32_t uidx = 0;
 
@@ -1576,6 +1596,9 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options)
         char str[512] = {0};
         
         SFilterField *left = FILTER_UNIT_LEFT_FIELD(info, unit);
+        if (FILTER_GET_TYPE(left->flag) == FLD_TYPE_EXPR) {
+          continue;
+        }
         SSchema *sch = left->desc;
         if (unit->compare.optr >= TSDB_RELATION_INVALID && unit->compare.optr <= TSDB_RELATION_CONTAINS){
           len = sprintf(str, "UNIT[%d] => [%d][%s]  %s  [", i, sch->colId, sch->name, gOptrStr[unit->compare.optr].str);
@@ -1751,6 +1774,9 @@ void filterFreeField(SFilterField* field, int32_t type) {
   if (!FILTER_GET_FLAG(field->flag, FLD_DESC_NO_FREE)) {
     if (type == FLD_TYPE_VALUE) {
       tVariantDestroy(field->desc);
+    } else if (type == FLD_TYPE_EXPR) {
+      tExprTreeDestroy(field->desc, NULL);
+      field->desc = NULL;
     }
     
     tfree(field->desc);
@@ -2100,20 +2126,30 @@ _return:
 
 int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx** gRes, int32_t* gResNum) {
   bool empty = false;
+  if (info->fields[FLD_TYPE_COLUMN].num == 0) {
+    return TSDB_CODE_SUCCESS;
+  }
   uint32_t *colIdx = malloc(info->fields[FLD_TYPE_COLUMN].num * sizeof(uint32_t));
   uint32_t colIdxi = 0;
   uint32_t gResIdx = 0;
+  bool hasExpr = false;
   
   for (uint32_t i = 0; i < info->groupNum; ++i) {
     SFilterGroup* g = info->groups + i;
 
     gRes[gResIdx] = calloc(1, sizeof(SFilterGroupCtx));
     gRes[gResIdx]->colInfo = calloc(info->fields[FLD_TYPE_COLUMN].num, sizeof(SFilterColInfo));
+    gRes[gResIdx]->hasExpr = false;
     colIdxi = 0;
     empty = false;
     
     for (uint32_t j = 0; j < g->unitNum; ++j) {
       SFilterUnit* u = FILTER_GROUP_UNIT(info, g, j);
+      if(u->left.type == FLD_TYPE_EXPR) {
+        gRes[gResIdx]->hasExpr = true;
+        hasExpr = true;
+        continue;
+      }
       uint32_t cidx = FILTER_UNIT_COL_IDX(u);
 
       if (gRes[gResIdx]->colInfo[cidx].info == NULL) {
@@ -2160,6 +2196,9 @@ int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx** gRes, int32_t
     ++gResIdx;
   }
 
+  if (hasExpr) {
+    FILTER_CLR_FLAG(info->status, FI_STATUS_REWRITE);
+  }
   tfree(colIdx);
 
   *gResNum = gResIdx;
@@ -2174,6 +2213,10 @@ int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx** gRes, int32_t
 void filterCheckColConflict(SFilterGroupCtx* gRes1, SFilterGroupCtx* gRes2, bool *conflict) {
   uint32_t idx1 = 0, idx2 = 0, m = 0, n = 0;
   bool equal = false;
+  if (gRes1->hasExpr || gRes2->hasExpr) {
+    *conflict = true;
+    return;
+  }
   
   for (; m < gRes1->colNum; ++m) {
     idx1 = gRes1->colIdx[m];
@@ -2646,7 +2689,12 @@ int32_t filterGenerateComInfo(SFilterInfo *info) {
     info->cunits[i].rfunc = filterGetRangeCompFuncFromOptrs(unit->compare.optr, unit->compare.optr2);
     info->cunits[i].optr = FILTER_UNIT_OPTR(unit);
     info->cunits[i].colData = NULL;
-    info->cunits[i].colId = FILTER_UNIT_COL_ID(info, unit);
+    info->cunits[i].expr = NULL;
+    if (unit->left.type == FLD_TYPE_COLUMN) {
+      info->cunits[i].colId = FILTER_UNIT_COL_ID(info, unit);
+    } else if (unit->left.type == FLD_TYPE_EXPR) {
+      info->cunits[i].expr = FILTER_GET_FIELD_DESC(FILTER_GET_FIELD(info, unit->left));
+    }
     
     if (unit->right.type == FLD_TYPE_VALUE) {
       if(FILTER_UNIT_DATA_TYPE(unit) == TSDB_DATA_TYPE_JSON){   // json value is tVariant
@@ -2662,8 +2710,12 @@ int32_t filterGenerateComInfo(SFilterInfo *info) {
     } else {
       info->cunits[i].valData2 = info->cunits[i].valData;
     }
-    
-    info->cunits[i].dataSize = FILTER_UNIT_COL_SIZE(info, unit);
+
+    if (unit->left.type == FLD_TYPE_COLUMN) {
+      info->cunits[i].dataSize = FILTER_UNIT_COL_SIZE(info, unit);
+    } else {
+      info->cunits[i].dataSize = FILTER_GET_EXPR_SIZE(info, unit->left);
+    }
     info->cunits[i].dataType = FILTER_UNIT_DATA_TYPE(unit);
   }
   
@@ -2673,8 +2725,14 @@ int32_t filterGenerateComInfo(SFilterInfo *info) {
 int32_t filterUpdateComUnits(SFilterInfo *info) {
   for (uint32_t i = 0; i < info->unitNum; ++i) {
     SFilterUnit *unit = &info->units[i];
-
-    info->cunits[i].colData = FILTER_UNIT_COL_DATA(info, unit, 0);
+    if (unit->left.type == FLD_TYPE_EXPR) {
+      SFilterField *t = FILTER_UNIT_LEFT_FIELD(info, unit);
+      info->cunits[i].colData = NULL;
+      info->cunits[i].exprData = t->data;
+    } else {
+      info->cunits[i].colData = FILTER_UNIT_COL_DATA(info, unit, 0);
+      info->cunits[i].exprData = NULL;
+    }
   }
 
   return TSDB_CODE_SUCCESS;
@@ -2923,6 +2981,11 @@ bool filterExecuteBasedOnStatisImpl(void *pinfo, int32_t numOfRows, int8_t** p,
 
 
 int32_t filterExecuteBasedOnStatis(SFilterInfo *info, int32_t numOfRows, int8_t** p, SDataStatis *statis, int16_t numOfCols, bool* all) {
+  for (uint32_t i = 0; i < info->unitNum; ++i) {
+    if(info->cunits[i].expr) {
+      return 1;
+    }
+  }
   if (statis && numOfRows >= FILTER_RM_UNIT_MIN_ROWS) {    
     info->blkFlag = 0;
     
@@ -2953,6 +3016,20 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
+char *getExprColumnData(void *param, const char* name, int32_t colId) {
+  void *data = NULL;
+  getColumnDataFromId(param, colId, &data);
+  return (char *) data;
+}
+
+void* filterExprTraverse (SFilterInfo *info, int32_t numOfRows, int16_t numOfCols) {
+  tExprOperandInfo output;
+  output.data = malloc(sizeof(int64_t) * numOfRows);
+  SSDataBlock* pBlock = (SSDataBlock*) info->cunits[0].exprData;
+  SColumnDataParam param = {.numOfCols = numOfCols, .pDataBlock = (SArray*)pBlock};
+  exprTreeNodeTraverse(info->cunits[0].expr, numOfRows, &output, &param, TSDB_ORDER_ASC, getExprColumnData);
+  return output.data;
+}
 
 static FORCE_INLINE bool filterExecuteImplAll(void *info, int32_t numOfRows, int8_t** p, SDataStatis *statis, int16_t numOfCols) {
   return true;
@@ -2963,18 +3040,26 @@ static FORCE_INLINE bool filterExecuteImplEmpty(void *info, int32_t numOfRows, i
 static FORCE_INLINE bool filterExecuteImplIsNull(void *pinfo, int32_t numOfRows, int8_t** p, SDataStatis *statis, int16_t numOfCols) {
   SFilterInfo *info = (SFilterInfo *)pinfo;
   bool all = true;
+  char *exprData = NULL;
+  uint32_t uidx = info->groups[0].unitIdxs[0];
+  void *colData = NULL;
 
   if (filterExecuteBasedOnStatis(info, numOfRows, p, statis, numOfCols, &all) == 0) {
     return all;
   }
 
+  if (info->cunits[0].expr) {
+    exprData = filterExprTraverse(info, numOfRows, numOfCols);
+  } else {
+    exprData = info->cunits[uidx].colData;
+  }
+
   if (*p == NULL) {
     *p = calloc(numOfRows, sizeof(int8_t));
   }
   
   for (int32_t i = 0; i < numOfRows; ++i) {
-    uint32_t uidx = info->groups[0].unitIdxs[0];
-    void *colData = (char *)info->cunits[uidx].colData + info->cunits[uidx].dataSize * i;
+    colData = (char *)exprData + info->cunits[uidx].dataSize * i;
     if(info->cunits[uidx].dataType == TSDB_DATA_TYPE_JSON){
       if (!colData){  // for json->'key' is null
         (*p)[i] = 1;
@@ -2992,23 +3077,35 @@ static FORCE_INLINE bool filterExecuteImplIsNull(void *pinfo, int32_t numOfRows,
     }    
   }
 
+  if (info->cunits[0].expr) {
+    tfree(exprData);
+  }
+
   return all;
 }
 static FORCE_INLINE bool filterExecuteImplNotNull(void *pinfo, int32_t numOfRows, int8_t** p, SDataStatis *statis, int16_t numOfCols) {
   SFilterInfo *info = (SFilterInfo *)pinfo;
   bool all = true;
+  char *exprData = NULL;
+  uint32_t uidx = info->groups[0].unitIdxs[0];
+  void *colData = NULL;
 
   if (filterExecuteBasedOnStatis(info, numOfRows, p, statis, numOfCols, &all) == 0) {
     return all;
   }
 
+  if (info->cunits[0].expr) {
+    exprData = filterExprTraverse(info, numOfRows, numOfCols);
+  } else {
+    exprData = info->cunits[uidx].colData;
+  }
+
   if (*p == NULL) {
     *p = calloc(numOfRows, sizeof(int8_t));
   }
   
   for (int32_t i = 0; i < numOfRows; ++i) {
-    uint32_t uidx = info->groups[0].unitIdxs[0];
-    void *colData = (char *)info->cunits[uidx].colData + info->cunits[uidx].dataSize * i;
+    colData = (char *)exprData + info->cunits[uidx].dataSize * i;
 
     if(info->cunits[uidx].dataType == TSDB_DATA_TYPE_JSON){
       if (!colData) {   // for json->'key' is not null
@@ -3028,6 +3125,10 @@ static FORCE_INLINE bool filterExecuteImplNotNull(void *pinfo, int32_t numOfRows
     }
   }
 
+  if (info->cunits[0].expr) {
+    tfree(exprData);
+  }
+
   return all;
 }
 
@@ -3081,11 +3182,16 @@ bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, int8_t** p, SDataSta
   void *valData = info->cunits[0].valData;
   void *valData2 = info->cunits[0].valData2;
   __compar_fn_t func = gDataCompare[info->cunits[0].func];
+  char *exprData = NULL;
 
   if (filterExecuteBasedOnStatis(info, numOfRows, p, statis, numOfCols, &all) == 0) {
     return all;
   }
 
+  if (info->cunits[0].expr) {
+    exprData = colData = filterExprTraverse(info, numOfRows, numOfCols);
+  }
+
   if (*p == NULL) {
     *p = calloc(numOfRows, sizeof(int8_t));
   }
@@ -3105,6 +3211,9 @@ bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, int8_t** p, SDataSta
     
     colData += dataSize;
   }
+  if (info->cunits[0].expr) {
+    tfree(exprData);
+  }
 
   return all;
 }
@@ -3112,18 +3221,26 @@ bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, int8_t** p, SDataSta
 bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, int8_t** p, SDataStatis *statis, int16_t numOfCols) {
   SFilterInfo *info = (SFilterInfo *)pinfo;
   bool all = true;
+  char *exprData = NULL;
+  uint32_t uidx = info->groups[0].unitIdxs[0];
+  void *colData = NULL;
 
   if (filterExecuteBasedOnStatis(info, numOfRows, p, statis, numOfCols, &all) == 0) {
     return all;
   }
   
+  if (info->cunits[0].expr) {
+    exprData = filterExprTraverse(info, numOfRows, numOfCols);
+  } else {
+    exprData = info->cunits[uidx].colData;
+  }
+
   if (*p == NULL) {
     *p = calloc(numOfRows, sizeof(int8_t));
   }
-  
+
   for (int32_t i = 0; i < numOfRows; ++i) {
-    uint32_t uidx = info->groups[0].unitIdxs[0];
-    void *colData = (char *)info->cunits[uidx].colData + info->cunits[uidx].dataSize * i;
+    colData = (char *)exprData + info->cunits[uidx].dataSize * i;
     if (colData == NULL || isNull(colData, info->cunits[uidx].dataType)) {
       (*p)[i] = 0;
       all = false;
@@ -3152,6 +3269,10 @@ bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, int8_t** p, SDataStat
     }
   }
 
+  if (info->cunits[0].expr) {
+    tfree(exprData);
+  }
+
   return all;
 }
 
@@ -3167,6 +3288,27 @@ bool filterExecuteImpl(void *pinfo, int32_t numOfRows, int8_t** p, SDataStatis *
     *p = calloc(numOfRows, sizeof(int8_t));
   }
   
+  SArray* tmpData = NULL;
+  for (uint32_t g = 0; g < info->groupNum; ++g) {
+    SFilterGroup *group = &info->groups[g];
+    for (uint32_t u = 0; u < group->unitNum; ++u) {
+      uint32_t uidx = group->unitIdxs[u];
+      SFilterComUnit *cunit = &info->cunits[uidx];
+      if (cunit->expr) {
+        if (!tmpData) {
+          tmpData = taosArrayInit(10, POINTER_BYTES);
+        }
+        tExprOperandInfo output;
+        output.data = malloc(sizeof(int64_t) * numOfRows);
+        taosArrayPush(tmpData, output.data);
+        SSDataBlock* pBlock = (SSDataBlock*) cunit->exprData;
+        SColumnDataParam param = {.numOfCols = numOfCols, .pDataBlock = (SArray*)pBlock};
+        exprTreeNodeTraverse(cunit->expr, numOfRows, &output, &param, TSDB_ORDER_ASC, getExprColumnData);
+        cunit->colData = (char *) output.data;
+      }
+    }
+  }
+
   for (int32_t i = 0; i < numOfRows; ++i) {
     //FILTER_UNIT_CLR_F(info);
   
@@ -3228,6 +3370,9 @@ bool filterExecuteImpl(void *pinfo, int32_t numOfRows, int8_t** p, SDataStatis *
     }    
   }
 
+  if (tmpData) {
+    taosArrayDestroy(&tmpData);
+  }
   return all;
 }
 
@@ -3317,7 +3462,8 @@ _return:
 
 int32_t filterSetColFieldData(SFilterInfo *info, void *param, filer_get_col_from_id fp) {
   CHK_LRET(info == NULL, TSDB_CODE_QRY_APP_ERROR, "info NULL");
-  CHK_LRET(info->fields[FLD_TYPE_COLUMN].num <= 0, TSDB_CODE_QRY_APP_ERROR, "no column fileds");
+  CHK_LRET(info->fields[FLD_TYPE_COLUMN].num <= 0 && info->fields[FLD_TYPE_EXPR].num <= 0,
+           TSDB_CODE_QRY_APP_ERROR, "no column fileds");
 
   if (FILTER_ALL_RES(info) || FILTER_EMPTY_RES(info)) {
     return TSDB_CODE_SUCCESS;
@@ -3330,6 +3476,11 @@ int32_t filterSetColFieldData(SFilterInfo *info, void *param, filer_get_col_from
     (*fp)(param, sch->colId, &fi->data);
   }
 
+   for (uint32_t i = 0; i < info->fields[FLD_TYPE_EXPR].num; ++i) {
+     SFilterField* fi = &info->fields[FLD_TYPE_EXPR].fields[i];
+     (*fp)(param, INT32_MAX, &fi->data);
+   }
+
   filterUpdateComUnits(info);
 
   return TSDB_CODE_SUCCESS;
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index 707be41c5842efe1810eb8a478e9e25ad402a8ba..a7170983405490a897458a644401ea1cf1a541bd 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -321,7 +321,9 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
   if ((pLeft != NULL && pRight != NULL) &&
       (optrType == TK_PLUS || optrType == TK_MINUS || optrType == TK_STAR || optrType == TK_DIVIDE || optrType == TK_REM ||
        optrType == TK_EQ || optrType == TK_NE || optrType == TK_LT || optrType == TK_GT || optrType == TK_LE || optrType == TK_GE ||
-       optrType == TK_AND || optrType == TK_OR)) {
+       optrType == TK_AND || optrType == TK_OR || optrType == TK_BITAND || optrType == TK_BITOR || optrType == TK_BITXOR ||
+       optrType == TK_LSHIFT || optrType == TK_RSHIFT))
+  {
     /*
      * if a exprToken is noted as the TK_TIMESTAMP, the time precision is microsecond
      * Otherwise, the time precision is adaptive, determined by the time precision from databases.
@@ -398,6 +400,61 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
           pExpr->value.i64 = (pLeft->value.i64 || pRight->value.i64) ? 1 : 0;
           break;
         }
+        case TK_BITAND: {
+          if (pLeft->tokenId == TK_BOOL || pRight->tokenId == TK_BOOL ||
+              pLeft->tokenId == TK_FLOAT || pRight->tokenId == TK_FLOAT ||
+              pLeft->tokenId == TK_TIMESTAMP || pRight->tokenId == TK_TIMESTAMP)
+          {
+            pExpr->value.i64 = TSDB_DATA_BIGINT_NULL;
+          } else {
+            pExpr->value.i64 = pLeft->value.i64 & pRight->value.i64;
+          }
+          break;
+        }
+        case TK_BITOR: {
+          if (pLeft->tokenId == TK_BOOL || pRight->tokenId == TK_BOOL ||
+              pLeft->tokenId == TK_FLOAT || pRight->tokenId == TK_FLOAT ||
+              pLeft->tokenId == TK_TIMESTAMP || pRight->tokenId == TK_TIMESTAMP)
+          {
+            pExpr->value.i64 = TSDB_DATA_BIGINT_NULL;
+          } else {
+            pExpr->value.i64 = pLeft->value.i64 | pRight->value.i64;
+          }
+          break;
+        }
+        case TK_BITXOR: {
+          if (pLeft->tokenId == TK_BOOL || pRight->tokenId == TK_BOOL ||
+              pLeft->tokenId == TK_FLOAT || pRight->tokenId == TK_FLOAT ||
+              pLeft->tokenId == TK_TIMESTAMP || pRight->tokenId == TK_TIMESTAMP)
+          {
+            pExpr->value.i64 = TSDB_DATA_BIGINT_NULL;
+          } else {
+            pExpr->value.i64 = pLeft->value.i64 ^ pRight->value.i64;
+          }
+          break;
+        }
+        case TK_LSHIFT: {
+          if (pLeft->tokenId == TK_BOOL || pRight->tokenId == TK_BOOL ||
+              pLeft->tokenId == TK_FLOAT || pRight->tokenId == TK_FLOAT ||
+              pLeft->tokenId == TK_TIMESTAMP || pRight->tokenId == TK_TIMESTAMP)
+          {
+            pExpr->value.i64 = TSDB_DATA_BIGINT_NULL;
+          } else {
+            pExpr->value.i64 = pLeft->value.i64 << pRight->value.i64;
+          }
+          break;
+        }
+        case TK_RSHIFT: {
+          if (pLeft->tokenId == TK_BOOL || pRight->tokenId == TK_BOOL ||
+              pLeft->tokenId == TK_FLOAT || pRight->tokenId == TK_FLOAT ||
+              pLeft->tokenId == TK_TIMESTAMP || pRight->tokenId == TK_TIMESTAMP)
+          {
+            pExpr->value.i64 = TSDB_DATA_BIGINT_NULL;
+          } else {
+            pExpr->value.i64 = pLeft->value.i64 >> pRight->value.i64;
+          }
+          break;
+        }
       }
 
       tSqlExprDestroy(pLeft);
@@ -509,6 +566,13 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
           pExpr->value.i64 = (left || right) ? 1 : 0;
           break;
         }
+        case TK_BITAND:
+        case TK_BITOR:
+        case TK_BITXOR:
+        case TK_LSHIFT:
+        case TK_RSHIFT:
+          pExpr->value.i64 = TSDB_DATA_DOUBLE_NULL;
+          break;
       }
 
       tSqlExprDestroy(pLeft);
@@ -542,6 +606,12 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
     }
 
     pExpr->pRight = pRight;
+
+    if (optrType == TK_BITNOT) {
+      pExpr->exprToken.z = pLeft->exprToken.z - 1;
+      pExpr->exprToken.n = pLeft->exprToken.n + 1;
+      pExpr->exprToken.type = pLeft->exprToken.type;
+    }
   }
 
   return pExpr;
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 4945f363930144e3df63a52a5e33be21e1957f2e..3e61b0559f1b6ad2fd7a1a595799d14153debf7c 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -97,30 +97,30 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 286
+#define YYNOCODE 287
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  SCreateAcctInfo yy31;
-  SSqlNode* yy86;
-  TAOS_FIELD yy103;
-  tVariant yy176;
-  tSqlExpr* yy226;
-  SWindowStateVal yy228;
-  SArray* yy231;
-  SCreatedTableInfo yy306;
-  int32_t yy310;
-  SSessionWindowVal yy409;
-  SCreateTableSql* yy422;
-  SIntervalVal yy430;
-  SLimitVal yy444;
-  SRangeVal yy480;
-  SRelationInfo* yy484;
-  int yy502;
-  SCreateDbInfo yy532;
-  int64_t yy549;
+  int yy20;
+  SWindowStateVal yy32;
+  SCreateDbInfo yy42;
+  tSqlExpr* yy46;
+  SCreateAcctInfo yy55;
+  SLimitVal yy86;
+  SCreateTableSql* yy118;
+  TAOS_FIELD yy119;
+  int64_t yy129;
+  tVariant yy186;
+  SRelationInfo* yy192;
+  SCreatedTableInfo yy228;
+  SRangeVal yy229;
+  int32_t yy332;
+  SArray* yy373;
+  SIntervalVal yy376;
+  SSessionWindowVal yy435;
+  SSqlNode* yy564;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -130,17 +130,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             395
-#define YYNRULE              316
-#define YYNTOKEN             201
-#define YY_MAX_SHIFT         394
-#define YY_MIN_SHIFTREDUCE   619
-#define YY_MAX_SHIFTREDUCE   934
-#define YY_ERROR_ACTION      935
-#define YY_ACCEPT_ACTION     936
-#define YY_NO_ACTION         937
-#define YY_MIN_REDUCE        938
-#define YY_MAX_REDUCE        1253
+#define YYNSTATE             404
+#define YYNRULE              321
+#define YYNTOKEN             202
+#define YY_MAX_SHIFT         403
+#define YY_MIN_SHIFTREDUCE   629
+#define YY_MAX_SHIFTREDUCE   949
+#define YY_ERROR_ACTION      950
+#define YY_ACCEPT_ACTION     951
+#define YY_NO_ACTION         952
+#define YY_MIN_REDUCE        953
+#define YY_MAX_REDUCE        1273
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -206,320 +206,332 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (874)
+#define YY_ACTTAB_COUNT (922)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   216,  670,  252,  262,  261, 1169,   24, 1170,  314,  671,
- /*    10 */  1227,  870, 1229,  873,   38,   39, 1227,   42,   43,  393,
- /*    20 */   243,  265,   31,   30,   29,  214,  670,   41,  346,   46,
- /*    30 */    44,   47,   45,   32,  671, 1227,  215,   37,   36,  220,
- /*    40 */   706,   35,   34,   33,   38,   39, 1227,   42,   43, 1227,
- /*    50 */  1117,  265,   31,   30,   29,   60, 1092,   41,  346,   46,
- /*    60 */    44,   47,   45,   32,  212,  216,  754,   37,   36,  351,
- /*    70 */   221,   35,   34,   33, 1227, 1227, 1230, 1230,   38,   39,
- /*    80 */  1227,   42,   43,  936,  394,  265,   31,   30,   29,  162,
- /*    90 */    86,   41,  346,   46,   44,   47,   45,   32,  371,  370,
- /*   100 */   245,   37,   36,  222, 1090,   35,   34,   33,   38,   39,
- /*   110 */   250,   42,   43, 1227, 1093,  265,   31,   30,   29, 1114,
- /*   120 */    59,   41,  346,   46,   44,   47,   45,   32,  233,  877,
- /*   130 */    13,   37,   36, 1108,  102,   35,   34,   33, 1227,   38,
- /*   140 */    40, 1087,   42,   43,   60,   60,  265,   31,   30,   29,
- /*   150 */   288,  864,   41,  346,   46,   44,   47,   45,   32,  295,
- /*   160 */   294,  342,   37,   36,  105,  670,   35,   34,   33,   39,
- /*   170 */   280,   42,   43,  671,  884,  265,   31,   30,   29,  284,
- /*   180 */   283,   41,  346,   46,   44,   47,   45,   32,  258,  255,
- /*   190 */   256,   37,   36, 1090, 1090,   35,   34,   33,   68,  340,
- /*   200 */   388,  387,  339,  338,  337,  386,  336,  335,  334,  385,
- /*   210 */   333,  384,  383,  620,  621,  622,  623,  624,  625,  626,
- /*   220 */   627,  628,  629,  630,  631,  632,  633,  160,  869,  244,
- /*   230 */   872,   42,   43,  824,  825,  265,   31,   30,   29,  101,
- /*   240 */    85,   41,  346,   46,   44,   47,   45,   32,  392,  391,
- /*   250 */   647,   37,   36,   60,   87,   35,   34,   33,   25, 1055,
- /*   260 */  1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052,
- /*   270 */  1053, 1054, 1056, 1057, 1078,  226, 1218,  236,  879,  381,
- /*   280 */    92,  868,  228,  871,  345,  874, 1227, 1249,  145,  144,
- /*   290 */   143,  227,  103,  236,  879,  354,   92,  868,  358,  871,
- /*   300 */   257,  874, 1090,  296, 1093,   60,  344,   46,   44,   47,
- /*   310 */    45,   32, 1217,  241,  242,   37,   36,  348,   69,   35,
- /*   320 */    34,   33, 1227,  264,  177, 1076, 1077,   56, 1080,  241,
- /*   330 */   242,    5,   63,  187,   69,   35,   34,   33,  186,  112,
- /*   340 */   117,  108,  116,  304,  778,    6,  878,  775,  259,  776,
- /*   350 */   359,  777, 1093,  670, 1090,  297,  287,  329,   84, 1079,
- /*   360 */  1216,  671,   48,  389, 1024,  237,  129,  123,  134,  268,
- /*   370 */  1227,  318,   98,  133,   97,  139,  142,  132,   48,  270,
- /*   380 */   271,  207,  205,  203,  136, 1108, 1108,   80,  202,  149,
- /*   390 */   148,  147,  146,   68,  274,  388,  387,  880,  875,  876,
- /*   400 */   386,  812,  246,  247,  385,  815,  384,  383,  266,   60,
- /*   410 */    60,   60,   60,  880,  875,  876, 1063,   60, 1061, 1062,
- /*   420 */    37,   36,  239, 1064,   35,   34,   33, 1065,   81, 1066,
- /*   430 */  1067,   32, 1227,  300,  301,   37,   36,   60,   52,   35,
- /*   440 */    34,   33,  159,  157,  156,  986,  269,  342,  267,  106,
- /*   450 */   357,  356,  197,  131,  360,  361,  367,  368, 1090, 1090,
- /*   460 */  1090, 1090,  369,  779,  272,  381, 1090,  240,  218,  216,
- /*   470 */   219,  276,   60,  273,  223,  366,  365, 1227, 1227, 1227,
- /*   480 */  1227, 1230,  373,  217, 1227, 1081, 1090,  224,  225,  230,
- /*   490 */   231,  232,  229, 1227,  213,    1,  185, 1227, 1227, 1227,
- /*   500 */  1227, 1227, 1227,  275, 1227,  275,  275,  796, 1167,  275,
- /*   510 */  1168,  100,  844,   99,  183,  793,  184,  347,  248,  996,
- /*   520 */  1091, 1089,  987,  289,    3,  198,  197,   89,   90,  197,
- /*   530 */   299,  298,  821,  831,  832,  344,   77,   61,  350,  764,
- /*   540 */   321,  766,   10,  323,  765,   55,  164,   72,   49,  909,
- /*   550 */   881,  263,  317,   61,   61,   72,   83,  104,   72,  669,
- /*   560 */   349,  363,  362,    9,    9,  291,  291,   15, 1241,   14,
- /*   570 */   843, 1180,  122,    9,  121,   17, 1179,   16,  324,   78,
- /*   580 */   785,  783,  786,  784,   19,  253,   18,  128,  753,  127,
- /*   590 */  1176,  867,   21,  800,   20, 1175,  141,  140,  254,  372,
- /*   600 */    26,  285, 1109,  161, 1116, 1127, 1124, 1125,  292, 1129,
- /*   610 */   163,  168,  310,  179, 1159, 1158, 1157, 1156, 1088,  180,
- /*   620 */  1086,  158,  181,  182, 1001,  326,  811,  327,  328,  303,
- /*   630 */   331,  332,   70,  210,   66,  343,  249,  995,  305,  307,
- /*   640 */  1106,  169,  355, 1248,  319,  170,   82,  119, 1247,   79,
- /*   650 */    28,  171, 1244,  188,  364, 1240,  315,  172,  173,  125,
- /*   660 */   313,  311, 1239,  309, 1236,  189,  174,  306, 1021,   67,
- /*   670 */   175,   62,   71,  211,  302,  983,  330,  135,  981,  137,
- /*   680 */   138,  979,  978,  277,  200,  201,  975,  974,  973,  972,
- /*   690 */   971,  970,   27,  969,  204,  206,  965,  382,  963,  961,
- /*   700 */   208,  958,  209,  954,  130,  374,  290,   88,   93,  375,
- /*   710 */   308,  376,  377,  379,  378,  380,  390,  934,  238,  278,
- /*   720 */   279,  260,  325,  933,  281,  282,  932,  915,  234,  235,
- /*   730 */   914,  286,  291,  113, 1000,  999,  320,  114,   11,   91,
- /*   740 */   788,  293,   53,   94,  820,  977,  976,   75,  968,  192,
- /*   750 */   150,  151, 1022,  190,  194,  152,  191,  193,  195,  196,
- /*   760 */   967,    4,  153, 1059,  960, 1023,  178,  176,  959,   54,
- /*   770 */   818,  817,    2,  814,  813,   76,  167,  822,  165, 1069,
- /*   780 */   833,  166,  251,  827,   95,   64,  829,   96,  312,  349,
- /*   790 */   316,   12,   65,   50,   51,   22,   23,  322,  107,  105,
- /*   800 */    57,  109,  110,  684,   58,  719,  717,  111,  716,  715,
- /*   810 */   713,  712,  711,  708,  674,  341,  115,    7,  906,  904,
- /*   820 */   883,  907,  882,  905,  885,    8,  353,   61,  352,  118,
- /*   830 */    73,  756,  120,  782,   74,  124,  755,  781,  126,  752,
- /*   840 */   700,  698,  690,  696,  692,  694,  688,  686,  722,  721,
- /*   850 */   720,  718,  714,  710,  709,  199,  672,  637,  938,  937,
- /*   860 */   937,  937,  937,  937,  937,  937,  937,  937,  937,  937,
- /*   870 */   937,  937,  154,  155,
+ /*     0 */   221,  680,   65,  680,  261, 1184,  167, 1185,  323,  681,
+ /*    10 */  1247,  681, 1249,  716,   43,   44, 1132,   47,   48,  402,
+ /*    20 */   252,  274,   32,   31,   30,    3,  203,   46,  355,   51,
+ /*    30 */    49,   52,   50,   37,   36,   35,   34,   33,   42,   41,
+ /*    40 */    24,   65,   40,   39,   38,   43,   44,  254,   47,   48,
+ /*    50 */  1247, 1105,  274,   32,   31,   30,  398, 1039,   46,  355,
+ /*    60 */    51,   49,   52,   50,   37,   36,   35,   34,   33,   42,
+ /*    70 */    41,  219,  764,   40,   39,   38,  304,  303, 1107,   43,
+ /*    80 */    44, 1247,   47,   48,  305, 1129,  274,   32,   31,   30,
+ /*    90 */  1104,   91,   46,  355,   51,   49,   52,   50,   37,   36,
+ /*   100 */    35,   34,   33,   42,   41,  380,  379,   40,   39,   38,
+ /*   110 */    43,   44,   13,   47,   48, 1094,  107,  274,   32,   31,
+ /*   120 */    30, 1102,   64,   46,  355,   51,   49,   52,   50,   37,
+ /*   130 */    36,   35,   34,   33,   42,   41, 1001,  220,   40,   39,
+ /*   140 */    38,   43,   45,  202,   47,   48,  110, 1247,  274,   32,
+ /*   150 */    31,   30,  351,  874,   46,  355,   51,   49,   52,   50,
+ /*   160 */    37,   36,   35,   34,   33,   42,   41,  289,  267,   40,
+ /*   170 */    39,   38,   44, 1237,   47,   48,  293,  292,  274,   32,
+ /*   180 */    31,   30,  390, 1247,   46,  355,   51,   49,   52,   50,
+ /*   190 */    37,   36,   35,   34,   33,   42,   41,  680, 1269,   40,
+ /*   200 */    39,   38,   47,   48,  351,  681,  274,   32,   31,   30,
+ /*   210 */     1,  190,   46,  355,   51,   49,   52,   50,   37,   36,
+ /*   220 */    35,   34,   33,   42,   41,  111,  259,   40,   39,   38,
+ /*   230 */  1108,   73,  349,  397,  396,  348,  347,  346,  395,  345,
+ /*   240 */   344,  343,  394,  342,  393,  392,  630,  631,  632,  633,
+ /*   250 */   634,  635,  636,  637,  638,  639,  640,  641,  642,  643,
+ /*   260 */   165, 1096,  253, 1070, 1058, 1059, 1060, 1061, 1062, 1063,
+ /*   270 */  1064, 1065, 1066, 1067, 1068, 1069, 1071, 1072,   51,   49,
+ /*   280 */    52,   50,   37,   36,   35,   34,   33,   42,   41,   25,
+ /*   290 */  1123,   40,   39,   38,  245,  889,  327,  103,  878,  102,
+ /*   300 */   881,  298,  884,  108,  245,  889,  235,  255,  878, 1261,
+ /*   310 */   881,  788,  884,  237,  785,   66,  786,  306,  787,  150,
+ /*   320 */   149,  148,  236,  225,   42,   41,  363,   97,   40,   39,
+ /*   330 */    38,  250,  251, 1247,   97,  357, 1091, 1092,   61, 1095,
+ /*   340 */    29,  250,  251, 1195,  680,  822, 1194,  279,  280,  825,
+ /*   350 */    29,  271,  681,   37,   36,   35,   34,   33,   42,   41,
+ /*   360 */   834,  835,   40,   39,   38,   74,    5,   68,  192,   65,
+ /*   370 */   951,  403,   74,  191,  117,  122,  113,  121,  309,  310,
+ /*   380 */    53,   40,   39,   38,  134,  128,  139,  296,  262,   89,
+ /*   390 */    53,  138,  338,  144,  147,  137,  246,   65,  277,  212,
+ /*   400 */   210,  208,  141,   65,  283,  270,  207,  154,  153,  152,
+ /*   410 */   151,  880,  217,  883,  264,  890,  885,  886, 1105,  226,
+ /*   420 */  1123,  275, 1247,   65, 1250,  890,  885,  886,  136, 1247,
+ /*   430 */    57,  789,  281,  354, 1011,  227,   73,  297,  397,  396,
+ /*   440 */   390,  202,  265,  395,   65, 1247, 1105,  394,  367,  393,
+ /*   450 */   392, 1078, 1105, 1076, 1077,   65,  353,   65, 1079,  879,
+ /*   460 */    65,  882, 1080,  257, 1081, 1082,  221,  266,  368,   65,
+ /*   470 */    65, 1108, 1105,  273,  238,  278, 1247,  276, 1250,  366,
+ /*   480 */   365,  285,  221,  282, 1247,  375,  374,  268, 1182,  369,
+ /*   490 */  1183, 1108, 1247, 1105, 1250,    6,  401,  400,  657,  806,
+ /*   500 */   370,  182,  376,  239, 1105,  377, 1105,  240,  831, 1105,
+ /*   510 */   164,  162,  161, 1247,  378,  382,  241, 1247, 1105, 1105,
+ /*   520 */   313,  242,  169,  105, 1233,  104, 1247, 1232,  854, 1231,
+ /*   530 */   887, 1247,  248,  249, 1247,   90,  223, 1247,  360, 1247,
+ /*   540 */   224,  228, 1247, 1247,  222,  229, 1247,  230,  232,  233,
+ /*   550 */  1247, 1247,  234,  231, 1247, 1247,  218, 1247, 1247, 1247,
+ /*   560 */  1123,  284, 1247, 1247,  284,  284, 1247,  106,  284, 1093,
+ /*   570 */   803,   94,  188, 1002,   95,  189,  356,  256,  888, 1106,
+ /*   580 */   202,  841,   92,  308,  307,  810,  853,  842,  353,   82,
+ /*   590 */    85,  359,  774,  330,  776,   77,  332,   10,  272,  775,
+ /*   600 */    60,   54,  924,  891,  679,  326,   66,   66,   77,  300,
+ /*   610 */   109,   88,  300,   77,  358, 1191,    9,    9,    9, 1190,
+ /*   620 */    15,  127,   14,  126,   17,  263,   16,  795,  793,  796,
+ /*   630 */   794,   86,   83,  333,  372,  371,   19,  381,   18,  877,
+ /*   640 */   133,  294,  132,  763,  894,   21,  166,   20,  146,  145,
+ /*   650 */  1131,   26, 1124, 1142, 1139, 1140,  301, 1144,  168, 1174,
+ /*   660 */   173,  319,  184, 1173, 1172, 1171, 1103,  185, 1101,  186,
+ /*   670 */   187, 1016,  335,  163,  821,  312,  336,  337,  258,  340,
+ /*   680 */   341,   75,  215,   71,  352, 1010,  364, 1268,  314,  124,
+ /*   690 */  1121,  316,  174,   87,  328, 1267, 1264,  193,   84,  175,
+ /*   700 */   373, 1260,  130, 1259,   28, 1256,  194, 1036,   72,  324,
+ /*   710 */   176,  177,   67,  322,   76,  216,  320,  998,  318,  315,
+ /*   720 */   181,  179,  140,  996,  142,  143,  994,   27,  993,  311,
+ /*   730 */   286,  205,  206,  990,  989,  988,  987,  986,  985,  984,
+ /*   740 */   209,  211,  980,  978,  976,  339,  213,  973,  214,  969,
+ /*   750 */   391,  135,  383,  299,   93,   98,  317,  384,  385,  386,
+ /*   760 */   387,  388,  389,  247,  399,  269,  949,  334,  287,  288,
+ /*   770 */   948,  291,  290,  947,  930,  929,  295,  243, 1015, 1014,
+ /*   780 */   118,  119,  244,  300,  329,   11,   96,  798,  302,   58,
+ /*   790 */    99,  830,   80,  992,  197,  991,  196, 1037,  195,  198,
+ /*   800 */   199,  155,  200,  201,    4,    2,  156,  983, 1074,  157,
+ /*   810 */   982,  828,  158,  975,   59,  180,  178,  183, 1038,  974,
+ /*   820 */   827, 1084,  824,  823,   81,  172,  832,  170,  260,  843,
+ /*   830 */   171,   69,  837,  100,  358,  839,  101,  321,  325,   12,
+ /*   840 */    55,   70,   22,   23,  331,   56,  110,   62,  114,  115,
+ /*   850 */   112,  694,   63,  116,  729,  727,  726,  725,  723,  722,
+ /*   860 */   721,  718,  684,  350,  120,    7,  921,  919,  893,  922,
+ /*   870 */   892,  920,    8,  895,  362,  123,  361,   66,   78,  125,
+ /*   880 */   792,   79,  766,  791,  129,  131,  765,  762,  710,  708,
+ /*   890 */   700,  706,  702,  704,  698,  696,  732,  731,  730,  728,
+ /*   900 */   724,  720,  719,  204,  682,  647,  953,  952,  952,  952,
+ /*   910 */   952,  952,  952,  952,  952,  952,  952,  952,  952,  952,
+ /*   920 */   159,  160,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   272,    1,    1,  211,  211,  280,  272,  282,  283,    9,
- /*    10 */   282,    5,  284,    7,   14,   15,  282,   17,   18,  204,
- /*    20 */   205,   21,   22,   23,   24,  272,    1,   27,   28,   29,
- /*    30 */    30,   31,   32,   33,    9,  282,  272,   37,   38,  272,
- /*    40 */     5,   41,   42,   43,   14,   15,  282,   17,   18,  282,
- /*    50 */   204,   21,   22,   23,   24,  204,  254,   27,   28,   29,
- /*    60 */    30,   31,   32,   33,  272,  272,    5,   37,   38,   16,
- /*    70 */   272,   41,   42,   43,  282,  282,  284,  284,   14,   15,
- /*    80 */   282,   17,   18,  202,  203,   21,   22,   23,   24,  204,
- /*    90 */    90,   27,   28,   29,   30,   31,   32,   33,   37,   38,
- /*   100 */   249,   37,   38,  272,  253,   41,   42,   43,   14,   15,
- /*   110 */   250,   17,   18,  282,  254,   21,   22,   23,   24,  273,
- /*   120 */    90,   27,   28,   29,   30,   31,   32,   33,  272,  123,
- /*   130 */    86,   37,   38,  252,   90,   41,   42,   43,  282,   14,
- /*   140 */    15,  204,   17,   18,  204,  204,   21,   22,   23,   24,
- /*   150 */   269,   87,   27,   28,   29,   30,   31,   32,   33,  274,
- /*   160 */   275,   88,   37,   38,  120,    1,   41,   42,   43,   15,
- /*   170 */   147,   17,   18,    9,  121,   21,   22,   23,   24,  156,
- /*   180 */   157,   27,   28,   29,   30,   31,   32,   33,  251,  249,
- /*   190 */   249,   37,   38,  253,  253,   41,   42,   43,  102,  103,
- /*   200 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
- /*   210 */   114,  115,  116,   49,   50,   51,   52,   53,   54,   55,
- /*   220 */    56,   57,   58,   59,   60,   61,   62,   63,    5,   65,
- /*   230 */     7,   17,   18,  130,  131,   21,   22,   23,   24,  255,
- /*   240 */   212,   27,   28,   29,   30,   31,   32,   33,   69,   70,
- /*   250 */    71,   37,   38,  204,  270,   41,   42,   43,   48,  228,
- /*   260 */   229,  230,  231,  232,  233,  234,  235,  236,  237,  238,
- /*   270 */   239,  240,  241,  242,  246,   65,  272,    1,    2,   94,
- /*   280 */    86,    5,   72,    7,   25,    9,  282,  254,   78,   79,
- /*   290 */    80,   81,  212,    1,    2,   85,   86,    5,  249,    7,
- /*   300 */   250,    9,  253,  277,  254,  204,   47,   29,   30,   31,
- /*   310 */    32,   33,  272,   37,   38,   37,   38,   41,  124,   41,
- /*   320 */    42,   43,  282,   64,  259,  245,  246,  247,  248,   37,
- /*   330 */    38,   66,   67,   68,  124,   41,   42,   43,   73,   74,
- /*   340 */    75,   76,   77,  278,    2,   86,  123,    5,  250,    7,
- /*   350 */   249,    9,  254,    1,  253,  277,  146,   92,  148,    0,
- /*   360 */   272,    9,   86,  226,  227,  155,   66,   67,   68,   72,
- /*   370 */   282,  279,  280,   73,  282,   75,   76,   77,   86,   37,
- /*   380 */    38,   66,   67,   68,   84,  252,  252,  101,   73,   74,
- /*   390 */    75,   76,   77,  102,   72,  104,  105,  121,  122,  123,
- /*   400 */   109,    5,  269,  269,  113,    9,  115,  116,  211,  204,
- /*   410 */   204,  204,  204,  121,  122,  123,  228,  204,  230,  231,
- /*   420 */    37,   38,  272,  235,   41,   42,   43,  239,  142,  241,
- /*   430 */   242,   33,  282,   37,   38,   37,   38,  204,   86,   41,
- /*   440 */    42,   43,   66,   67,   68,  210,  149,   88,  151,  212,
- /*   450 */   153,  154,  217,   82,  249,  249,  249,  249,  253,  253,
- /*   460 */   253,  253,  249,  121,  122,   94,  253,  272,  272,  272,
- /*   470 */   272,  149,  204,  151,  272,  153,  154,  282,  282,  282,
- /*   480 */   282,  284,  249,  272,  282,  248,  253,  272,  272,  272,
- /*   490 */   272,  272,  272,  282,  272,  213,  214,  282,  282,  282,
- /*   500 */   282,  282,  282,  204,  282,  204,  204,   41,  280,  204,
- /*   510 */   282,  280,   80,  282,  215,  101,  215,  215,  122,  210,
- /*   520 */   215,  253,  210,   87,  208,  209,  217,   87,   87,  217,
- /*   530 */    37,   38,   87,   87,   87,   47,  101,  101,   25,   87,
- /*   540 */    87,   87,  128,   87,   87,   86,  101,  101,  101,   87,
- /*   550 */    87,    1,   64,  101,  101,  101,   86,  101,  101,   87,
- /*   560 */    47,   37,   38,  101,  101,  125,  125,  150,  254,  152,
- /*   570 */   138,  244,  150,  101,  152,  150,  244,  152,  119,  144,
- /*   580 */     5,    5,    7,    7,  150,  244,  152,  150,  118,  152,
- /*   590 */   244,   41,  150,  127,  152,  244,   82,   83,  244,  244,
- /*   600 */   271,  204,  252,  204,  204,  204,  204,  204,  252,  204,
- /*   610 */   204,  204,  204,  256,  281,  281,  281,  281,  252,  204,
- /*   620 */   204,   64,  204,  204,  204,  204,  123,  204,  204,  276,
- /*   630 */   204,  204,  204,  204,  204,  204,  276,  204,  276,  276,
- /*   640 */   268,  267,  204,  204,  136,  266,  141,  204,  204,  143,
- /*   650 */   140,  265,  204,  204,  204,  204,  139,  264,  263,  204,
- /*   660 */   134,  133,  204,  132,  204,  204,  262,  135,  204,  204,
- /*   670 */   261,  204,  204,  204,  129,  204,   93,  204,  204,  204,
- /*   680 */   204,  204,  204,  204,  204,  204,  204,  204,  204,  204,
- /*   690 */   204,  204,  145,  204,  204,  204,  204,  117,  204,  204,
- /*   700 */   204,  204,  204,  204,  100,   99,  206,  206,  206,   55,
- /*   710 */   206,   96,   98,   97,   59,   95,   88,    5,  206,  158,
- /*   720 */     5,  206,  206,    5,  158,    5,    5,  104,  206,  206,
- /*   730 */   103,  147,  125,  212,  216,  216,  119,  212,   86,  126,
- /*   740 */    87,  101,   86,  101,   87,  206,  206,  101,  206,  219,
- /*   750 */   207,  207,  225,  224,  220,  207,  223,  222,  221,  218,
- /*   760 */   206,  208,  207,  243,  206,  227,  257,  260,  206,  258,
- /*   770 */   123,  123,  213,    5,    5,   86,  101,   87,   86,  243,
- /*   780 */    87,   86,    1,   87,   86,  101,   87,   86,   86,   47,
- /*   790 */     1,   86,  101,   86,   86,  137,  137,  119,   82,  120,
- /*   800 */    91,   90,   74,    5,   91,    9,    5,   90,    5,    5,
- /*   810 */     5,    5,    5,    5,   89,   16,   82,   86,    9,    9,
- /*   820 */    87,    9,   87,    9,  121,   86,   63,  101,   28,  152,
- /*   830 */    17,    5,  152,  123,   17,  152,    5,  123,  152,   87,
- /*   840 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   850 */     5,    5,    5,    5,    5,  101,   89,   64,    0,  285,
- /*   860 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   870 */   285,  285,   22,   22,  285,  285,  285,  285,  285,  285,
- /*   880 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   890 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   900 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   910 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   920 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   930 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   940 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   950 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   960 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   970 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   980 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*   990 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1000 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1010 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1020 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1030 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1040 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1050 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1060 */   285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
- /*  1070 */   285,  285,  285,  285,  285,
+ /*     0 */   273,    1,  205,    1,    1,  281,  205,  283,  284,    9,
+ /*    10 */   283,    9,  285,    5,   14,   15,  205,   17,   18,  205,
+ /*    20 */   206,   21,   22,   23,   24,  209,  210,   27,   28,   29,
+ /*    30 */    30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
+ /*    40 */   273,  205,   42,   43,   44,   14,   15,  250,   17,   18,
+ /*    50 */   283,  254,   21,   22,   23,   24,  227,  228,   27,   28,
+ /*    60 */    29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
+ /*    70 */    39,  273,    5,   42,   43,   44,  275,  276,  255,   14,
+ /*    80 */    15,  283,   17,   18,  278,  274,   21,   22,   23,   24,
+ /*    90 */   254,   91,   27,   28,   29,   30,   31,   32,   33,   34,
+ /*   100 */    35,   36,   37,   38,   39,   38,   39,   42,   43,   44,
+ /*   110 */    14,   15,   87,   17,   18,    0,   91,   21,   22,   23,
+ /*   120 */    24,  205,   91,   27,   28,   29,   30,   31,   32,   33,
+ /*   130 */    34,   35,   36,   37,   38,   39,  211,  273,   42,   43,
+ /*   140 */    44,   14,   15,  218,   17,   18,  121,  283,   21,   22,
+ /*   150 */    23,   24,   89,   88,   27,   28,   29,   30,   31,   32,
+ /*   160 */    33,   34,   35,   36,   37,   38,   39,  148,  252,   42,
+ /*   170 */    43,   44,   15,  273,   17,   18,  157,  158,   21,   22,
+ /*   180 */    23,   24,   95,  283,   27,   28,   29,   30,   31,   32,
+ /*   190 */    33,   34,   35,   36,   37,   38,   39,    1,  255,   42,
+ /*   200 */    43,   44,   17,   18,   89,    9,   21,   22,   23,   24,
+ /*   210 */   214,  215,   27,   28,   29,   30,   31,   32,   33,   34,
+ /*   220 */    35,   36,   37,   38,   39,  213,  251,   42,   43,   44,
+ /*   230 */   255,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+ /*   240 */   112,  113,  114,  115,  116,  117,   50,   51,   52,   53,
+ /*   250 */    54,   55,   56,   57,   58,   59,   60,   61,   62,   63,
+ /*   260 */    64,  249,   66,  229,  230,  231,  232,  233,  234,  235,
+ /*   270 */   236,  237,  238,  239,  240,  241,  242,  243,   29,   30,
+ /*   280 */    31,   32,   33,   34,   35,   36,   37,   38,   39,   49,
+ /*   290 */   253,   42,   43,   44,    1,    2,  280,  281,    5,  283,
+ /*   300 */     7,   88,    9,  213,    1,    2,   66,  270,    5,  255,
+ /*   310 */     7,    2,    9,   73,    5,  102,    7,  278,    9,   79,
+ /*   320 */    80,   81,   82,  273,   38,   39,   86,   87,   42,   43,
+ /*   330 */    44,   38,   39,  283,   87,   42,  246,  247,  248,  249,
+ /*   340 */    47,   38,   39,  245,    1,    5,  245,   38,   39,    9,
+ /*   350 */    47,  212,    9,   33,   34,   35,   36,   37,   38,   39,
+ /*   360 */   131,  132,   42,   43,   44,  125,   67,   68,   69,  205,
+ /*   370 */   203,  204,  125,   74,   75,   76,   77,   78,   38,   39,
+ /*   380 */    87,   42,   43,   44,   67,   68,   69,  147,  245,  149,
+ /*   390 */    87,   74,   93,   76,   77,   78,  156,  205,   73,   67,
+ /*   400 */    68,   69,   85,  205,   73,  212,   74,   75,   76,   77,
+ /*   410 */    78,    5,  273,    7,  250,  122,  123,  124,  254,  273,
+ /*   420 */   253,  212,  283,  205,  285,  122,  123,  124,   83,  283,
+ /*   430 */    87,  122,  123,   25,  211,  273,  103,  270,  105,  106,
+ /*   440 */    95,  218,  250,  110,  205,  283,  254,  114,  250,  116,
+ /*   450 */   117,  229,  254,  231,  232,  205,   48,  205,  236,    5,
+ /*   460 */   205,    7,  240,  123,  242,  243,  273,  251,  250,  205,
+ /*   470 */   205,  255,  254,   65,  273,  150,  283,  152,  285,  154,
+ /*   480 */   155,  150,  273,  152,  283,  154,  155,  251,  281,  250,
+ /*   490 */   283,  255,  283,  254,  285,   87,   70,   71,   72,   42,
+ /*   500 */   250,  260,  250,  273,  254,  250,  254,  273,   88,  254,
+ /*   510 */    67,   68,   69,  283,  250,  250,  273,  283,  254,  254,
+ /*   520 */   279,  273,  102,  281,  273,  283,  283,  273,   81,  273,
+ /*   530 */   124,  283,  273,  273,  283,  213,  273,  283,   16,  283,
+ /*   540 */   273,  273,  283,  283,  273,  273,  283,  273,  273,  273,
+ /*   550 */   283,  283,  273,  273,  283,  283,  273,  283,  283,  283,
+ /*   560 */   253,  205,  283,  283,  205,  205,  283,  256,  205,  247,
+ /*   570 */   102,   88,  216,  211,   88,  216,  216,  270,  124,  216,
+ /*   580 */   218,   88,  271,   38,   39,  128,  139,   88,   48,  102,
+ /*   590 */   102,   25,   88,   88,   88,  102,   88,  129,    1,   88,
+ /*   600 */    87,  102,   88,   88,   88,   65,  102,  102,  102,  126,
+ /*   610 */   102,   87,  126,  102,   48,  245,  102,  102,  102,  245,
+ /*   620 */   151,  151,  153,  153,  151,  245,  153,    5,    5,    7,
+ /*   630 */     7,  143,  145,  120,   38,   39,  151,  245,  153,   42,
+ /*   640 */   151,  205,  153,  119,  122,  151,  205,  153,   83,   84,
+ /*   650 */   205,  272,  253,  205,  205,  205,  253,  205,  205,  282,
+ /*   660 */   205,  205,  257,  282,  282,  282,  253,  205,  205,  205,
+ /*   670 */   205,  205,  205,   65,  124,  277,  205,  205,  277,  205,
+ /*   680 */   205,  205,  205,  205,  205,  205,  205,  205,  277,  205,
+ /*   690 */   269,  277,  268,  142,  137,  205,  205,  205,  144,  267,
+ /*   700 */   205,  205,  205,  205,  141,  205,  205,  205,  205,  140,
+ /*   710 */   266,  265,  205,  135,  205,  205,  134,  205,  133,  136,
+ /*   720 */   261,  263,  205,  205,  205,  205,  205,  146,  205,  130,
+ /*   730 */   205,  205,  205,  205,  205,  205,  205,  205,  205,  205,
+ /*   740 */   205,  205,  205,  205,  205,   94,  205,  205,  205,  205,
+ /*   750 */   118,  101,  100,  207,  207,  207,  207,   56,   97,   99,
+ /*   760 */    60,   98,   96,  207,   89,  207,    5,  207,  159,    5,
+ /*   770 */     5,    5,  159,    5,  105,  104,  148,  207,  217,  217,
+ /*   780 */   213,  213,  207,  126,  120,   87,  127,   88,  102,   87,
+ /*   790 */   102,   88,  102,  207,  220,  207,  224,  226,  225,  223,
+ /*   800 */   221,  208,  222,  219,  209,  214,  208,  207,  244,  208,
+ /*   810 */   207,  124,  208,  207,  259,  262,  264,  258,  228,  207,
+ /*   820 */   124,  244,    5,    5,   87,  102,   88,   87,    1,   88,
+ /*   830 */    87,  102,   88,   87,   48,   88,   87,   87,    1,   87,
+ /*   840 */    87,  102,  138,  138,  120,   87,  121,   92,   91,   75,
+ /*   850 */    83,    5,   92,   91,    9,    5,    5,    5,    5,    5,
+ /*   860 */     5,    5,   90,   16,   83,   87,    9,    9,   88,    9,
+ /*   870 */    88,    9,   87,  122,   64,  153,   28,  102,   17,  153,
+ /*   880 */   124,   17,    5,  124,  153,  153,    5,   88,    5,    5,
+ /*   890 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+ /*   900 */     5,    5,    5,  102,   90,   65,    0,  286,  286,  286,
+ /*   910 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   920 */    22,   22,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   930 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   940 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   950 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   960 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   970 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   980 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*   990 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1000 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1010 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1020 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1030 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1040 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1050 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1060 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1070 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1080 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1090 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1100 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1110 */   286,  286,  286,  286,  286,  286,  286,  286,  286,  286,
+ /*  1120 */   286,  286,  286,  286,
 };
-#define YY_SHIFT_COUNT    (394)
+#define YY_SHIFT_COUNT    (403)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (858)
+#define YY_SHIFT_MAX      (906)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   210,   96,   96,  291,  291,   73,  276,  292,  292,  292,
- /*    10 */   352,   25,   25,   25,   25,   25,   25,   25,   25,   25,
- /*    20 */    25,   25,    1,    1,    0,  164,  292,  292,  292,  292,
- /*    30 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  292,
- /*    40 */   292,  292,  292,  292,  292,  292,  292,  292,  292,  342,
- /*    50 */   342,  342,  194,  194,  103,   25,  359,   25,   25,   25,
- /*    60 */    25,   25,  371,   73,    1,    1,  185,  185,   35,  874,
- /*    70 */   874,  874,  342,  342,  342,  396,  396,   61,   61,   61,
- /*    80 */    61,   61,   61,   61,   25,   25,   25,  466,   25,   25,
- /*    90 */    25,  194,  194,   25,   25,   25,   25,  432,  432,  432,
- /*   100 */   432,  414,  194,   25,   25,   25,   25,   25,   25,   25,
- /*   110 */    25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
- /*   120 */    25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
- /*   130 */    25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
- /*   140 */    25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
- /*   150 */    25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
- /*   160 */    25,  557,  557,  557,  503,  503,  503,  503,  557,  505,
- /*   170 */   506,  508,  510,  517,  526,  528,  531,  532,  545,  547,
- /*   180 */   557,  557,  557,  583,  583,  580,   73,   73,  557,  557,
- /*   190 */   604,  606,  654,  615,  614,  655,  616,  620,  580,   35,
- /*   200 */   557,  557,  628,  628,  557,  628,  557,  628,  557,  557,
- /*   210 */   874,  874,   30,   64,   94,   94,   94,  125,  154,  214,
- /*   220 */   278,  278,  278,  278,  278,  278,  265,  300,  315,  398,
- /*   230 */   398,  398,  398,  383,  297,  322,  259,   23,   44,  294,
- /*   240 */   294,    6,  223,  179,  376,  436,  440,  441,  493,  445,
- /*   250 */   446,  447,  488,  435,  286,  452,  453,  454,  456,  457,
- /*   260 */   459,  462,  463,  513,  550,   53,  472,  417,  422,  425,
- /*   270 */   575,  576,  524,  434,  437,  470,  442,  514,  712,  561,
- /*   280 */   715,  718,  566,  720,  721,  623,  627,  584,  607,  617,
- /*   290 */   652,  613,  653,  656,  640,  642,  657,  646,  647,  648,
- /*   300 */   768,  769,  689,  690,  692,  693,  695,  696,  675,  698,
- /*   310 */   699,  701,  781,  702,  684,  658,  742,  789,  691,  659,
- /*   320 */   705,  617,  707,  678,  708,  679,  716,  709,  711,  728,
- /*   330 */   798,  713,  717,  796,  801,  803,  804,  805,  806,  807,
- /*   340 */   808,  725,  799,  734,  809,  810,  731,  733,  735,  812,
- /*   350 */   814,  703,  739,  800,  763,  813,  677,  680,  726,  726,
- /*   360 */   726,  726,  710,  714,  817,  683,  686,  726,  726,  726,
- /*   370 */   826,  831,  752,  726,  835,  836,  837,  838,  839,  840,
- /*   380 */   841,  842,  843,  844,  845,  846,  847,  848,  849,  754,
- /*   390 */   767,  850,  851,  793,  858,
+ /*     0 */   240,  128,  128,  333,  333,   63,  293,  303,  303,  303,
+ /*    10 */   343,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+ /*    20 */     2,    2,    3,    3,    0,  196,  303,  303,  303,  303,
+ /*    30 */   303,  303,  303,  303,  303,  303,  303,  303,  303,  303,
+ /*    40 */   303,  303,  303,  303,  303,  303,  303,  303,  303,  303,
+ /*    50 */   303,  303,  303,  303,  309,  309,  309,  247,  247,  229,
+ /*    60 */     2,  115,    2,    2,    2,    2,    2,  345,   63,    3,
+ /*    70 */     3,   87,   87,    8,  922,  922,  922,  309,  309,  309,
+ /*    80 */   340,  340,   67,   67,   67,   67,   67,   67,   67,    2,
+ /*    90 */     2,    2,  457,    2,    2,    2,  247,  247,    2,    2,
+ /*   100 */     2,    2,  447,  447,  447,  447,  468,  247,    2,    2,
+ /*   110 */     2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+ /*   120 */     2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+ /*   130 */     2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+ /*   140 */     2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+ /*   150 */     2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+ /*   160 */     2,    2,    2,    2,    2,    2,  608,  608,  608,  550,
+ /*   170 */   550,  550,  550,  608,  551,  554,  557,  563,  569,  578,
+ /*   180 */   582,  585,  583,  599,  581,  608,  608,  608,  651,  651,
+ /*   190 */   632,   63,   63,  608,  608,  650,  652,  701,  661,  660,
+ /*   200 */   700,  663,  666,  632,    8,  608,  608,  675,  675,  608,
+ /*   210 */   675,  608,  675,  608,  608,  922,  922,   31,   65,   96,
+ /*   220 */    96,   96,  127,  157,  185,  249,  249,  249,  249,  249,
+ /*   230 */   249,  320,  320,  320,  320,  299,  317,  332,  286,  286,
+ /*   240 */   286,  286,  286,  325,  331,  408,   19,   25,  339,  339,
+ /*   250 */   406,  454,  426,  443,  213,  483,  486,  545,  420,  493,
+ /*   260 */   499,  540,  487,  488,  504,  505,  506,  508,  511,  513,
+ /*   270 */   514,  515,  566,  597,  522,  516,  469,  470,  473,  622,
+ /*   280 */   623,  596,  485,  489,  524,  494,  565,  761,  609,  764,
+ /*   290 */   765,  613,  766,  768,  669,  671,  628,  657,  664,  698,
+ /*   300 */   659,  699,  702,  686,  688,  703,  690,  687,  696,  817,
+ /*   310 */   818,  737,  738,  740,  741,  743,  744,  723,  746,  747,
+ /*   320 */   749,  827,  750,  729,  704,  786,  837,  739,  705,  752,
+ /*   330 */   664,  753,  724,  758,  725,  767,  755,  757,  774,  846,
+ /*   340 */   760,  762,  845,  850,  851,  852,  853,  854,  855,  856,
+ /*   350 */   772,  847,  781,  857,  858,  778,  780,  782,  860,  862,
+ /*   360 */   751,  785,  848,  810,  861,  722,  726,  775,  775,  775,
+ /*   370 */   775,  756,  759,  864,  731,  732,  775,  775,  775,  877,
+ /*   380 */   881,  799,  775,  883,  884,  885,  886,  887,  888,  889,
+ /*   390 */   890,  891,  892,  893,  894,  895,  896,  897,  801,  814,
+ /*   400 */   898,  899,  840,  906,
 };
-#define YY_REDUCE_COUNT (211)
-#define YY_REDUCE_MIN   (-275)
-#define YY_REDUCE_MAX   (562)
+#define YY_REDUCE_COUNT (216)
+#define YY_REDUCE_MIN   (-276)
+#define YY_REDUCE_MAX   (612)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -119,   31,   31,  188,  188,   80, -208, -207,  197, -272,
- /*    10 */  -115, -149,  -60,  -59,   49,  101,  205,  206,  207,  208,
- /*    20 */   213,  233, -275,   92, -154, -185, -266, -247, -236, -233,
- /*    30 */  -202, -169, -144,    4,   40,   88,  150,  195,  196,  198,
- /*    40 */   202,  211,  215,  216,  217,  218,  219,  220,  222, -140,
- /*    50 */    50,   98,  133,  134,   65,  -63,  237,  299,  301,  302,
- /*    60 */   305,  268,  235,   28,  228,  231,  309,  312,  137,  -16,
- /*    70 */   282,  316, -198,   33,  314,   26,   78,  327,  332,  341,
- /*    80 */   346,  351,  354,  355,  397,  399,  400,  329,  401,  402,
- /*    90 */   403,  350,  356,  405,  406,  407,  408,  333,  334,  335,
- /*   100 */   336,  357,  366,  415,  416,  418,  419,  420,  421,  423,
- /*   110 */   424,  426,  427,  428,  429,  430,  431,  433,  438,  439,
- /*   120 */   443,  444,  448,  449,  450,  451,  455,  458,  460,  461,
- /*   130 */   464,  465,  467,  468,  469,  471,  473,  474,  475,  476,
- /*   140 */   477,  478,  479,  480,  481,  482,  483,  484,  485,  486,
- /*   150 */   487,  489,  490,  491,  492,  494,  495,  496,  497,  498,
- /*   160 */   499,  500,  501,  502,  353,  360,  362,  363,  504,  372,
- /*   170 */   374,  379,  386,  393,  395,  404,  409,  507,  511,  509,
- /*   180 */   512,  515,  516,  518,  519,  520,  521,  525,  522,  523,
- /*   190 */   527,  529,  533,  530,  535,  534,  537,  541,  536,  538,
- /*   200 */   539,  540,  543,  544,  542,  548,  554,  555,  558,  562,
- /*   210 */   559,  553,
+ /*     0 */   167,   34,   34,  222,  222,   90,  139,  193,  209, -273,
+ /*    10 */  -199, -203,  164,  192,  198,  218,  239,  250,  252,  255,
+ /*    20 */   264,  265, -276,   16, -189, -186, -233, -202, -136, -100,
+ /*    30 */    50,  146,  162,  201,  230,  234,  243,  248,  251,  254,
+ /*    40 */   256,  259,  260,  263,  267,  268,  271,  272,  274,  275,
+ /*    50 */   276,  279,  280,  283,  -25,  216,  236,   37,  307,  241,
+ /*    60 */   -84,   12,  356,  359,  360,  363, -164,  -75,  322,  207,
+ /*    70 */   242,  223,  362, -171,  311,   -4, -184, -177,  -57,   54,
+ /*    80 */  -194,   39,   98,  101,  143,  370,  374,  380,  392,  436,
+ /*    90 */   441,  445,  379,  448,  449,  450,  399,  403,  452,  453,
+ /*   100 */   455,  456,  377,  381,  382,  383,  405,  413,  462,  463,
+ /*   110 */   464,  465,  466,  467,  471,  472,  474,  475,  476,  477,
+ /*   120 */   478,  479,  480,  481,  482,  484,  490,  491,  492,  495,
+ /*   130 */   496,  497,  498,  500,  501,  502,  503,  507,  509,  510,
+ /*   140 */   512,  517,  518,  519,  520,  521,  523,  525,  526,  527,
+ /*   150 */   528,  529,  530,  531,  532,  533,  534,  535,  536,  537,
+ /*   160 */   538,  539,  541,  542,  543,  544,  546,  547,  548,  398,
+ /*   170 */   401,  411,  414,  549,  421,  424,  432,  444,  446,  552,
+ /*   180 */   458,  553,  459,  555,  559,  556,  558,  560,  561,  562,
+ /*   190 */   564,  567,  568,  570,  575,  571,  573,  572,  574,  576,
+ /*   200 */   579,  580,  584,  577,  590,  586,  588,  593,  598,  600,
+ /*   210 */   601,  603,  604,  606,  612,  591,  595,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   935, 1058,  997, 1068,  984,  994, 1232, 1232, 1232, 1232,
- /*    10 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*    20 */   935,  935,  935,  935, 1118,  955,  935,  935,  935,  935,
- /*    30 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*    40 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*    50 */   935,  935,  935,  935, 1142,  935,  994,  935,  935,  935,
- /*    60 */   935,  935, 1004,  994,  935,  935, 1004, 1004,  935, 1113,
- /*    70 */  1042, 1060,  935,  935,  935,  935,  935,  935,  935,  935,
- /*    80 */   935,  935,  935,  935,  935,  935,  935, 1120, 1126, 1123,
- /*    90 */   935,  935,  935, 1128,  935,  935,  935, 1164, 1164, 1164,
- /*   100 */  1164, 1111,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   110 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   120 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   130 */   935,  935,  935,  935,  935,  982,  935,  980,  935,  935,
- /*   140 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   150 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   160 */   953,  957,  957,  957,  935,  935,  935,  935,  957, 1173,
- /*   170 */  1177, 1154, 1171, 1165, 1149, 1147, 1145, 1153, 1138, 1181,
- /*   180 */   957,  957,  957, 1002, 1002,  998,  994,  994,  957,  957,
- /*   190 */  1020, 1018, 1016, 1008, 1014, 1010, 1012, 1006,  985,  935,
- /*   200 */   957,  957,  992,  992,  957,  992,  957,  992,  957,  957,
- /*   210 */  1042, 1060, 1231,  935, 1182, 1172, 1231,  935, 1213, 1212,
- /*   220 */  1222, 1221, 1220, 1211, 1210, 1209,  935,  935,  935, 1205,
- /*   230 */  1208, 1207, 1206, 1219,  935,  935, 1184,  935,  935, 1215,
- /*   240 */  1214,  935,  935,  935,  935,  935,  935,  935, 1135,  935,
- /*   250 */   935,  935, 1160, 1178, 1174,  935,  935,  935,  935,  935,
- /*   260 */   935,  935,  935, 1185,  935,  935,  935,  935,  935,  935,
- /*   270 */   935,  935, 1099,  935,  935, 1070,  935,  935,  935,  935,
- /*   280 */   935,  935,  935,  935,  935,  935,  935,  935, 1110,  935,
- /*   290 */   935,  935,  935,  935, 1122, 1121,  935,  935,  935,  935,
- /*   300 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   310 */   935,  935,  935,  935, 1166,  935, 1161,  935, 1155,  935,
- /*   320 */   935, 1082,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   330 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   340 */   935,  935,  935,  935,  935,  935,  935,  935,  935,  935,
- /*   350 */   935,  935,  935,  935,  935,  935,  935,  935, 1250, 1245,
- /*   360 */  1246, 1243,  935,  935,  935,  935,  935, 1242, 1237, 1238,
- /*   370 */   935,  935,  935, 1235,  935,  935,  935,  935,  935,  935,
- /*   380 */   935,  935,  935,  935,  935,  935,  935,  935,  935, 1026,
- /*   390 */   935,  964,  962,  935,  935,
+ /*     0 */   950, 1073, 1012, 1083,  999, 1009, 1252, 1252, 1252, 1252,
+ /*    10 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*    20 */   950,  950,  950,  950, 1133,  970,  950,  950,  950,  950,
+ /*    30 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*    40 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*    50 */   950,  950,  950,  950,  950,  950,  950,  950,  950, 1157,
+ /*    60 */   950, 1009,  950,  950,  950,  950,  950, 1019, 1009,  950,
+ /*    70 */   950, 1019, 1019,  950, 1128, 1057, 1075,  950,  950,  950,
+ /*    80 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*    90 */   950,  950, 1135, 1141, 1138,  950,  950,  950, 1143,  950,
+ /*   100 */   950,  950, 1179, 1179, 1179, 1179, 1126,  950,  950,  950,
+ /*   110 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   120 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   130 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   140 */   997,  950,  995,  950,  950,  950,  950,  950,  950,  950,
+ /*   150 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   160 */   950,  950,  950,  950,  950,  968,  972,  972,  972,  950,
+ /*   170 */   950,  950,  950,  972, 1188, 1192, 1169, 1186, 1180, 1164,
+ /*   180 */  1162, 1160, 1168, 1153, 1196,  972,  972,  972, 1017, 1017,
+ /*   190 */  1013, 1009, 1009,  972,  972, 1035, 1033, 1031, 1023, 1029,
+ /*   200 */  1025, 1027, 1021, 1000,  950,  972,  972, 1007, 1007,  972,
+ /*   210 */  1007,  972, 1007,  972,  972, 1057, 1075, 1251,  950, 1197,
+ /*   220 */  1187, 1251,  950, 1228, 1227, 1242, 1241, 1240, 1226, 1225,
+ /*   230 */  1224, 1220, 1223, 1222, 1221,  950,  950,  950, 1239, 1238,
+ /*   240 */  1236, 1235, 1234,  950,  950, 1199,  950,  950, 1230, 1229,
+ /*   250 */   950,  950,  950,  950,  950,  950,  950, 1150,  950,  950,
+ /*   260 */   950, 1175, 1193, 1189,  950,  950,  950,  950,  950,  950,
+ /*   270 */   950,  950, 1200,  950,  950,  950,  950,  950,  950,  950,
+ /*   280 */   950, 1114,  950,  950, 1085,  950,  950,  950,  950,  950,
+ /*   290 */   950,  950,  950,  950,  950,  950,  950, 1125,  950,  950,
+ /*   300 */   950,  950,  950, 1137, 1136,  950,  950,  950,  950,  950,
+ /*   310 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   320 */   950,  950,  950, 1181,  950, 1176,  950, 1170,  950,  950,
+ /*   330 */  1097,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   340 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   350 */   950,  950,  950,  950,  950,  950,  950,  950,  950,  950,
+ /*   360 */   950,  950,  950,  950,  950,  950,  950, 1270, 1265, 1266,
+ /*   370 */  1263,  950,  950,  950,  950,  950, 1262, 1257, 1258,  950,
+ /*   380 */   950,  950, 1255,  950,  950,  950,  950,  950,  950,  950,
+ /*   390 */   950,  950,  950,  950,  950,  950,  950,  950, 1041,  950,
+ /*   400 */   979,  977,  950,  950,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -574,6 +586,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*         LE => nothing */
     0,  /*     BITAND => nothing */
     0,  /*      BITOR => nothing */
+    0,  /*     BITXOR => nothing */
     0,  /*     LSHIFT => nothing */
     0,  /*     RSHIFT => nothing */
     0,  /*       PLUS => nothing */
@@ -861,256 +874,257 @@ static const char *const yyTokenName[] = {
   /*   32 */ "LE",
   /*   33 */ "BITAND",
   /*   34 */ "BITOR",
-  /*   35 */ "LSHIFT",
-  /*   36 */ "RSHIFT",
-  /*   37 */ "PLUS",
-  /*   38 */ "MINUS",
-  /*   39 */ "DIVIDE",
-  /*   40 */ "TIMES",
-  /*   41 */ "STAR",
-  /*   42 */ "SLASH",
-  /*   43 */ "REM",
-  /*   44 */ "UMINUS",
-  /*   45 */ "UPLUS",
-  /*   46 */ "BITNOT",
-  /*   47 */ "ARROW",
-  /*   48 */ "SHOW",
-  /*   49 */ "DATABASES",
-  /*   50 */ "TOPICS",
-  /*   51 */ "FUNCTIONS",
-  /*   52 */ "MNODES",
-  /*   53 */ "DNODES",
-  /*   54 */ "ACCOUNTS",
-  /*   55 */ "USERS",
-  /*   56 */ "MODULES",
-  /*   57 */ "QUERIES",
-  /*   58 */ "CONNECTIONS",
-  /*   59 */ "STREAMS",
-  /*   60 */ "VARIABLES",
-  /*   61 */ "SCORES",
-  /*   62 */ "GRANTS",
-  /*   63 */ "VNODES",
-  /*   64 */ "DOT",
-  /*   65 */ "CREATE",
-  /*   66 */ "TABLE",
-  /*   67 */ "STABLE",
-  /*   68 */ "DATABASE",
-  /*   69 */ "TABLES",
-  /*   70 */ "STABLES",
-  /*   71 */ "VGROUPS",
-  /*   72 */ "DROP",
-  /*   73 */ "TOPIC",
-  /*   74 */ "FUNCTION",
-  /*   75 */ "DNODE",
-  /*   76 */ "USER",
-  /*   77 */ "ACCOUNT",
-  /*   78 */ "USE",
-  /*   79 */ "DESCRIBE",
-  /*   80 */ "DESC",
-  /*   81 */ "ALTER",
-  /*   82 */ "PASS",
-  /*   83 */ "PRIVILEGE",
-  /*   84 */ "LOCAL",
-  /*   85 */ "COMPACT",
-  /*   86 */ "LP",
-  /*   87 */ "RP",
-  /*   88 */ "IF",
-  /*   89 */ "EXISTS",
-  /*   90 */ "AS",
-  /*   91 */ "OUTPUTTYPE",
-  /*   92 */ "AGGREGATE",
-  /*   93 */ "BUFSIZE",
-  /*   94 */ "PPS",
-  /*   95 */ "TSERIES",
-  /*   96 */ "DBS",
-  /*   97 */ "STORAGE",
-  /*   98 */ "QTIME",
-  /*   99 */ "CONNS",
-  /*  100 */ "STATE",
-  /*  101 */ "COMMA",
-  /*  102 */ "KEEP",
-  /*  103 */ "CACHE",
-  /*  104 */ "REPLICA",
-  /*  105 */ "QUORUM",
-  /*  106 */ "DAYS",
-  /*  107 */ "MINROWS",
-  /*  108 */ "MAXROWS",
-  /*  109 */ "BLOCKS",
-  /*  110 */ "CTIME",
-  /*  111 */ "WAL",
-  /*  112 */ "FSYNC",
-  /*  113 */ "COMP",
-  /*  114 */ "PRECISION",
-  /*  115 */ "UPDATE",
-  /*  116 */ "CACHELAST",
-  /*  117 */ "PARTITIONS",
-  /*  118 */ "UNSIGNED",
-  /*  119 */ "TAGS",
-  /*  120 */ "USING",
-  /*  121 */ "NULL",
-  /*  122 */ "NOW",
-  /*  123 */ "VARIABLE",
-  /*  124 */ "SELECT",
-  /*  125 */ "UNION",
-  /*  126 */ "ALL",
-  /*  127 */ "DISTINCT",
-  /*  128 */ "FROM",
-  /*  129 */ "RANGE",
-  /*  130 */ "INTERVAL",
-  /*  131 */ "EVERY",
-  /*  132 */ "SESSION",
-  /*  133 */ "STATE_WINDOW",
-  /*  134 */ "FILL",
-  /*  135 */ "SLIDING",
-  /*  136 */ "ORDER",
-  /*  137 */ "BY",
-  /*  138 */ "ASC",
-  /*  139 */ "GROUP",
-  /*  140 */ "HAVING",
-  /*  141 */ "LIMIT",
-  /*  142 */ "OFFSET",
-  /*  143 */ "SLIMIT",
-  /*  144 */ "SOFFSET",
-  /*  145 */ "WHERE",
-  /*  146 */ "RESET",
-  /*  147 */ "QUERY",
-  /*  148 */ "SYNCDB",
-  /*  149 */ "ADD",
-  /*  150 */ "COLUMN",
-  /*  151 */ "MODIFY",
-  /*  152 */ "TAG",
-  /*  153 */ "CHANGE",
-  /*  154 */ "SET",
-  /*  155 */ "KILL",
-  /*  156 */ "CONNECTION",
-  /*  157 */ "STREAM",
-  /*  158 */ "COLON",
-  /*  159 */ "ABORT",
-  /*  160 */ "AFTER",
-  /*  161 */ "ATTACH",
-  /*  162 */ "BEFORE",
-  /*  163 */ "BEGIN",
-  /*  164 */ "CASCADE",
-  /*  165 */ "CLUSTER",
-  /*  166 */ "CONFLICT",
-  /*  167 */ "COPY",
-  /*  168 */ "DEFERRED",
-  /*  169 */ "DELIMITERS",
-  /*  170 */ "DETACH",
-  /*  171 */ "EACH",
-  /*  172 */ "END",
-  /*  173 */ "EXPLAIN",
-  /*  174 */ "FAIL",
-  /*  175 */ "FOR",
-  /*  176 */ "IGNORE",
-  /*  177 */ "IMMEDIATE",
-  /*  178 */ "INITIALLY",
-  /*  179 */ "INSTEAD",
-  /*  180 */ "KEY",
-  /*  181 */ "OF",
-  /*  182 */ "RAISE",
-  /*  183 */ "REPLACE",
-  /*  184 */ "RESTRICT",
-  /*  185 */ "ROW",
-  /*  186 */ "STATEMENT",
-  /*  187 */ "TRIGGER",
-  /*  188 */ "VIEW",
-  /*  189 */ "IPTOKEN",
-  /*  190 */ "SEMI",
-  /*  191 */ "NONE",
-  /*  192 */ "PREV",
-  /*  193 */ "LINEAR",
-  /*  194 */ "IMPORT",
-  /*  195 */ "TBNAME",
-  /*  196 */ "JOIN",
-  /*  197 */ "INSERT",
-  /*  198 */ "INTO",
-  /*  199 */ "VALUES",
-  /*  200 */ "FILE",
-  /*  201 */ "error",
-  /*  202 */ "program",
-  /*  203 */ "cmd",
-  /*  204 */ "ids",
-  /*  205 */ "dbPrefix",
-  /*  206 */ "cpxName",
-  /*  207 */ "ifexists",
-  /*  208 */ "alter_db_optr",
-  /*  209 */ "alter_topic_optr",
-  /*  210 */ "acct_optr",
-  /*  211 */ "exprlist",
-  /*  212 */ "ifnotexists",
-  /*  213 */ "db_optr",
-  /*  214 */ "topic_optr",
-  /*  215 */ "typename",
-  /*  216 */ "bufsize",
-  /*  217 */ "pps",
-  /*  218 */ "tseries",
-  /*  219 */ "dbs",
-  /*  220 */ "streams",
-  /*  221 */ "storage",
-  /*  222 */ "qtime",
-  /*  223 */ "users",
-  /*  224 */ "conns",
-  /*  225 */ "state",
-  /*  226 */ "intitemlist",
-  /*  227 */ "intitem",
-  /*  228 */ "keep",
-  /*  229 */ "cache",
-  /*  230 */ "replica",
-  /*  231 */ "quorum",
-  /*  232 */ "days",
-  /*  233 */ "minrows",
-  /*  234 */ "maxrows",
-  /*  235 */ "blocks",
-  /*  236 */ "ctime",
-  /*  237 */ "wal",
-  /*  238 */ "fsync",
-  /*  239 */ "comp",
-  /*  240 */ "prec",
-  /*  241 */ "update",
-  /*  242 */ "cachelast",
-  /*  243 */ "partitions",
-  /*  244 */ "signed",
-  /*  245 */ "create_table_args",
-  /*  246 */ "create_stable_args",
-  /*  247 */ "create_table_list",
-  /*  248 */ "create_from_stable",
-  /*  249 */ "columnlist",
-  /*  250 */ "tagitemlist",
-  /*  251 */ "tagNamelist",
-  /*  252 */ "select",
-  /*  253 */ "column",
-  /*  254 */ "tagitem",
-  /*  255 */ "selcollist",
-  /*  256 */ "from",
-  /*  257 */ "where_opt",
-  /*  258 */ "range_option",
-  /*  259 */ "interval_option",
-  /*  260 */ "sliding_opt",
-  /*  261 */ "session_option",
-  /*  262 */ "windowstate_option",
-  /*  263 */ "fill_opt",
-  /*  264 */ "groupby_opt",
-  /*  265 */ "having_opt",
-  /*  266 */ "orderby_opt",
-  /*  267 */ "slimit_opt",
-  /*  268 */ "limit_opt",
-  /*  269 */ "union",
-  /*  270 */ "sclp",
-  /*  271 */ "distinct",
-  /*  272 */ "expr",
-  /*  273 */ "as",
-  /*  274 */ "tablelist",
-  /*  275 */ "sub",
-  /*  276 */ "tmvar",
-  /*  277 */ "timestamp",
-  /*  278 */ "intervalKey",
-  /*  279 */ "sortlist",
-  /*  280 */ "item",
-  /*  281 */ "sortorder",
-  /*  282 */ "arrow",
-  /*  283 */ "grouplist",
-  /*  284 */ "expritem",
+  /*   35 */ "BITXOR",
+  /*   36 */ "LSHIFT",
+  /*   37 */ "RSHIFT",
+  /*   38 */ "PLUS",
+  /*   39 */ "MINUS",
+  /*   40 */ "DIVIDE",
+  /*   41 */ "TIMES",
+  /*   42 */ "STAR",
+  /*   43 */ "SLASH",
+  /*   44 */ "REM",
+  /*   45 */ "UMINUS",
+  /*   46 */ "UPLUS",
+  /*   47 */ "BITNOT",
+  /*   48 */ "ARROW",
+  /*   49 */ "SHOW",
+  /*   50 */ "DATABASES",
+  /*   51 */ "TOPICS",
+  /*   52 */ "FUNCTIONS",
+  /*   53 */ "MNODES",
+  /*   54 */ "DNODES",
+  /*   55 */ "ACCOUNTS",
+  /*   56 */ "USERS",
+  /*   57 */ "MODULES",
+  /*   58 */ "QUERIES",
+  /*   59 */ "CONNECTIONS",
+  /*   60 */ "STREAMS",
+  /*   61 */ "VARIABLES",
+  /*   62 */ "SCORES",
+  /*   63 */ "GRANTS",
+  /*   64 */ "VNODES",
+  /*   65 */ "DOT",
+  /*   66 */ "CREATE",
+  /*   67 */ "TABLE",
+  /*   68 */ "STABLE",
+  /*   69 */ "DATABASE",
+  /*   70 */ "TABLES",
+  /*   71 */ "STABLES",
+  /*   72 */ "VGROUPS",
+  /*   73 */ "DROP",
+  /*   74 */ "TOPIC",
+  /*   75 */ "FUNCTION",
+  /*   76 */ "DNODE",
+  /*   77 */ "USER",
+  /*   78 */ "ACCOUNT",
+  /*   79 */ "USE",
+  /*   80 */ "DESCRIBE",
+  /*   81 */ "DESC",
+  /*   82 */ "ALTER",
+  /*   83 */ "PASS",
+  /*   84 */ "PRIVILEGE",
+  /*   85 */ "LOCAL",
+  /*   86 */ "COMPACT",
+  /*   87 */ "LP",
+  /*   88 */ "RP",
+  /*   89 */ "IF",
+  /*   90 */ "EXISTS",
+  /*   91 */ "AS",
+  /*   92 */ "OUTPUTTYPE",
+  /*   93 */ "AGGREGATE",
+  /*   94 */ "BUFSIZE",
+  /*   95 */ "PPS",
+  /*   96 */ "TSERIES",
+  /*   97 */ "DBS",
+  /*   98 */ "STORAGE",
+  /*   99 */ "QTIME",
+  /*  100 */ "CONNS",
+  /*  101 */ "STATE",
+  /*  102 */ "COMMA",
+  /*  103 */ "KEEP",
+  /*  104 */ "CACHE",
+  /*  105 */ "REPLICA",
+  /*  106 */ "QUORUM",
+  /*  107 */ "DAYS",
+  /*  108 */ "MINROWS",
+  /*  109 */ "MAXROWS",
+  /*  110 */ "BLOCKS",
+  /*  111 */ "CTIME",
+  /*  112 */ "WAL",
+  /*  113 */ "FSYNC",
+  /*  114 */ "COMP",
+  /*  115 */ "PRECISION",
+  /*  116 */ "UPDATE",
+  /*  117 */ "CACHELAST",
+  /*  118 */ "PARTITIONS",
+  /*  119 */ "UNSIGNED",
+  /*  120 */ "TAGS",
+  /*  121 */ "USING",
+  /*  122 */ "NULL",
+  /*  123 */ "NOW",
+  /*  124 */ "VARIABLE",
+  /*  125 */ "SELECT",
+  /*  126 */ "UNION",
+  /*  127 */ "ALL",
+  /*  128 */ "DISTINCT",
+  /*  129 */ "FROM",
+  /*  130 */ "RANGE",
+  /*  131 */ "INTERVAL",
+  /*  132 */ "EVERY",
+  /*  133 */ "SESSION",
+  /*  134 */ "STATE_WINDOW",
+  /*  135 */ "FILL",
+  /*  136 */ "SLIDING",
+  /*  137 */ "ORDER",
+  /*  138 */ "BY",
+  /*  139 */ "ASC",
+  /*  140 */ "GROUP",
+  /*  141 */ "HAVING",
+  /*  142 */ "LIMIT",
+  /*  143 */ "OFFSET",
+  /*  144 */ "SLIMIT",
+  /*  145 */ "SOFFSET",
+  /*  146 */ "WHERE",
+  /*  147 */ "RESET",
+  /*  148 */ "QUERY",
+  /*  149 */ "SYNCDB",
+  /*  150 */ "ADD",
+  /*  151 */ "COLUMN",
+  /*  152 */ "MODIFY",
+  /*  153 */ "TAG",
+  /*  154 */ "CHANGE",
+  /*  155 */ "SET",
+  /*  156 */ "KILL",
+  /*  157 */ "CONNECTION",
+  /*  158 */ "STREAM",
+  /*  159 */ "COLON",
+  /*  160 */ "ABORT",
+  /*  161 */ "AFTER",
+  /*  162 */ "ATTACH",
+  /*  163 */ "BEFORE",
+  /*  164 */ "BEGIN",
+  /*  165 */ "CASCADE",
+  /*  166 */ "CLUSTER",
+  /*  167 */ "CONFLICT",
+  /*  168 */ "COPY",
+  /*  169 */ "DEFERRED",
+  /*  170 */ "DELIMITERS",
+  /*  171 */ "DETACH",
+  /*  172 */ "EACH",
+  /*  173 */ "END",
+  /*  174 */ "EXPLAIN",
+  /*  175 */ "FAIL",
+  /*  176 */ "FOR",
+  /*  177 */ "IGNORE",
+  /*  178 */ "IMMEDIATE",
+  /*  179 */ "INITIALLY",
+  /*  180 */ "INSTEAD",
+  /*  181 */ "KEY",
+  /*  182 */ "OF",
+  /*  183 */ "RAISE",
+  /*  184 */ "REPLACE",
+  /*  185 */ "RESTRICT",
+  /*  186 */ "ROW",
+  /*  187 */ "STATEMENT",
+  /*  188 */ "TRIGGER",
+  /*  189 */ "VIEW",
+  /*  190 */ "IPTOKEN",
+  /*  191 */ "SEMI",
+  /*  192 */ "NONE",
+  /*  193 */ "PREV",
+  /*  194 */ "LINEAR",
+  /*  195 */ "IMPORT",
+  /*  196 */ "TBNAME",
+  /*  197 */ "JOIN",
+  /*  198 */ "INSERT",
+  /*  199 */ "INTO",
+  /*  200 */ "VALUES",
+  /*  201 */ "FILE",
+  /*  202 */ "error",
+  /*  203 */ "program",
+  /*  204 */ "cmd",
+  /*  205 */ "ids",
+  /*  206 */ "dbPrefix",
+  /*  207 */ "cpxName",
+  /*  208 */ "ifexists",
+  /*  209 */ "alter_db_optr",
+  /*  210 */ "alter_topic_optr",
+  /*  211 */ "acct_optr",
+  /*  212 */ "exprlist",
+  /*  213 */ "ifnotexists",
+  /*  214 */ "db_optr",
+  /*  215 */ "topic_optr",
+  /*  216 */ "typename",
+  /*  217 */ "bufsize",
+  /*  218 */ "pps",
+  /*  219 */ "tseries",
+  /*  220 */ "dbs",
+  /*  221 */ "streams",
+  /*  222 */ "storage",
+  /*  223 */ "qtime",
+  /*  224 */ "users",
+  /*  225 */ "conns",
+  /*  226 */ "state",
+  /*  227 */ "intitemlist",
+  /*  228 */ "intitem",
+  /*  229 */ "keep",
+  /*  230 */ "cache",
+  /*  231 */ "replica",
+  /*  232 */ "quorum",
+  /*  233 */ "days",
+  /*  234 */ "minrows",
+  /*  235 */ "maxrows",
+  /*  236 */ "blocks",
+  /*  237 */ "ctime",
+  /*  238 */ "wal",
+  /*  239 */ "fsync",
+  /*  240 */ "comp",
+  /*  241 */ "prec",
+  /*  242 */ "update",
+  /*  243 */ "cachelast",
+  /*  244 */ "partitions",
+  /*  245 */ "signed",
+  /*  246 */ "create_table_args",
+  /*  247 */ "create_stable_args",
+  /*  248 */ "create_table_list",
+  /*  249 */ "create_from_stable",
+  /*  250 */ "columnlist",
+  /*  251 */ "tagitemlist",
+  /*  252 */ "tagNamelist",
+  /*  253 */ "select",
+  /*  254 */ "column",
+  /*  255 */ "tagitem",
+  /*  256 */ "selcollist",
+  /*  257 */ "from",
+  /*  258 */ "where_opt",
+  /*  259 */ "range_option",
+  /*  260 */ "interval_option",
+  /*  261 */ "sliding_opt",
+  /*  262 */ "session_option",
+  /*  263 */ "windowstate_option",
+  /*  264 */ "fill_opt",
+  /*  265 */ "groupby_opt",
+  /*  266 */ "having_opt",
+  /*  267 */ "orderby_opt",
+  /*  268 */ "slimit_opt",
+  /*  269 */ "limit_opt",
+  /*  270 */ "union",
+  /*  271 */ "sclp",
+  /*  272 */ "distinct",
+  /*  273 */ "expr",
+  /*  274 */ "as",
+  /*  275 */ "tablelist",
+  /*  276 */ "sub",
+  /*  277 */ "tmvar",
+  /*  278 */ "timestamp",
+  /*  279 */ "intervalKey",
+  /*  280 */ "sortlist",
+  /*  281 */ "item",
+  /*  282 */ "sortorder",
+  /*  283 */ "arrow",
+  /*  284 */ "grouplist",
+  /*  285 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1400,40 +1414,45 @@ static const char *const yyRuleName[] = {
  /* 279 */ "expr ::= expr SLASH expr",
  /* 280 */ "expr ::= expr REM expr",
  /* 281 */ "expr ::= expr BITAND expr",
- /* 282 */ "expr ::= expr LIKE expr",
- /* 283 */ "expr ::= expr MATCH expr",
- /* 284 */ "expr ::= expr NMATCH expr",
- /* 285 */ "expr ::= ID CONTAINS STRING",
- /* 286 */ "expr ::= ID DOT ID CONTAINS STRING",
- /* 287 */ "arrow ::= ID ARROW STRING",
- /* 288 */ "arrow ::= ID DOT ID ARROW STRING",
- /* 289 */ "expr ::= arrow",
- /* 290 */ "expr ::= expr IN LP exprlist RP",
- /* 291 */ "exprlist ::= exprlist COMMA expritem",
- /* 292 */ "exprlist ::= expritem",
- /* 293 */ "expritem ::= expr",
- /* 294 */ "expritem ::=",
- /* 295 */ "cmd ::= RESET QUERY CACHE",
- /* 296 */ "cmd ::= SYNCDB ids REPLICA",
- /* 297 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 298 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 299 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
- /* 300 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 301 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 302 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 303 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 304 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
- /* 305 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 306 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 307 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
- /* 308 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 309 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 310 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 311 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
- /* 312 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
- /* 313 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 314 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 315 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 282 */ "expr ::= expr BITOR expr",
+ /* 283 */ "expr ::= expr BITXOR expr",
+ /* 284 */ "expr ::= BITNOT expr",
+ /* 285 */ "expr ::= expr LSHIFT expr",
+ /* 286 */ "expr ::= expr RSHIFT expr",
+ /* 287 */ "expr ::= expr LIKE expr",
+ /* 288 */ "expr ::= expr MATCH expr",
+ /* 289 */ "expr ::= expr NMATCH expr",
+ /* 290 */ "expr ::= ID CONTAINS STRING",
+ /* 291 */ "expr ::= ID DOT ID CONTAINS STRING",
+ /* 292 */ "arrow ::= ID ARROW STRING",
+ /* 293 */ "arrow ::= ID DOT ID ARROW STRING",
+ /* 294 */ "expr ::= arrow",
+ /* 295 */ "expr ::= expr IN LP exprlist RP",
+ /* 296 */ "exprlist ::= exprlist COMMA expritem",
+ /* 297 */ "exprlist ::= expritem",
+ /* 298 */ "expritem ::= expr",
+ /* 299 */ "expritem ::=",
+ /* 300 */ "cmd ::= RESET QUERY CACHE",
+ /* 301 */ "cmd ::= SYNCDB ids REPLICA",
+ /* 302 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 303 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 304 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 305 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 306 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 307 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 308 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 309 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
+ /* 310 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 311 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 312 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 313 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 314 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 315 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 316 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 317 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
+ /* 318 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 319 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 320 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1554,57 +1573,57 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 211: /* exprlist */
-    case 255: /* selcollist */
-    case 270: /* sclp */
+    case 212: /* exprlist */
+    case 256: /* selcollist */
+    case 271: /* sclp */
 {
-tSqlExprListDestroy((yypminor->yy231));
+tSqlExprListDestroy((yypminor->yy373));
 }
       break;
-    case 226: /* intitemlist */
-    case 228: /* keep */
-    case 249: /* columnlist */
-    case 250: /* tagitemlist */
-    case 251: /* tagNamelist */
-    case 263: /* fill_opt */
-    case 264: /* groupby_opt */
-    case 266: /* orderby_opt */
-    case 279: /* sortlist */
-    case 283: /* grouplist */
-{
-taosArrayDestroy(&(yypminor->yy231));
+    case 227: /* intitemlist */
+    case 229: /* keep */
+    case 250: /* columnlist */
+    case 251: /* tagitemlist */
+    case 252: /* tagNamelist */
+    case 264: /* fill_opt */
+    case 265: /* groupby_opt */
+    case 267: /* orderby_opt */
+    case 280: /* sortlist */
+    case 284: /* grouplist */
+{
+taosArrayDestroy(&(yypminor->yy373));
 }
       break;
-    case 247: /* create_table_list */
+    case 248: /* create_table_list */
 {
-destroyCreateTableSql((yypminor->yy422));
+destroyCreateTableSql((yypminor->yy118));
 }
       break;
-    case 252: /* select */
+    case 253: /* select */
 {
-destroySqlNode((yypminor->yy86));
+destroySqlNode((yypminor->yy564));
 }
       break;
-    case 256: /* from */
-    case 274: /* tablelist */
-    case 275: /* sub */
+    case 257: /* from */
+    case 275: /* tablelist */
+    case 276: /* sub */
 {
-destroyRelationInfo((yypminor->yy484));
+destroyRelationInfo((yypminor->yy192));
 }
       break;
-    case 257: /* where_opt */
-    case 265: /* having_opt */
-    case 272: /* expr */
-    case 277: /* timestamp */
-    case 282: /* arrow */
-    case 284: /* expritem */
+    case 258: /* where_opt */
+    case 266: /* having_opt */
+    case 273: /* expr */
+    case 278: /* timestamp */
+    case 283: /* arrow */
+    case 285: /* expritem */
 {
-tSqlExprDestroy((yypminor->yy226));
+tSqlExprDestroy((yypminor->yy46));
 }
       break;
-    case 269: /* union */
+    case 270: /* union */
 {
-destroyAllSqlNode((yypminor->yy231));
+destroyAllSqlNode((yypminor->yy373));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1898,322 +1917,327 @@ static const struct {
   YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
   signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
 } yyRuleInfo[] = {
-  {  202,   -1 }, /* (0) program ::= cmd */
-  {  203,   -2 }, /* (1) cmd ::= SHOW DATABASES */
-  {  203,   -2 }, /* (2) cmd ::= SHOW TOPICS */
-  {  203,   -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
-  {  203,   -2 }, /* (4) cmd ::= SHOW MNODES */
-  {  203,   -2 }, /* (5) cmd ::= SHOW DNODES */
-  {  203,   -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
-  {  203,   -2 }, /* (7) cmd ::= SHOW USERS */
-  {  203,   -2 }, /* (8) cmd ::= SHOW MODULES */
-  {  203,   -2 }, /* (9) cmd ::= SHOW QUERIES */
-  {  203,   -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
-  {  203,   -2 }, /* (11) cmd ::= SHOW STREAMS */
-  {  203,   -2 }, /* (12) cmd ::= SHOW VARIABLES */
-  {  203,   -2 }, /* (13) cmd ::= SHOW SCORES */
-  {  203,   -2 }, /* (14) cmd ::= SHOW GRANTS */
-  {  203,   -2 }, /* (15) cmd ::= SHOW VNODES */
-  {  203,   -3 }, /* (16) cmd ::= SHOW VNODES ids */
-  {  205,    0 }, /* (17) dbPrefix ::= */
-  {  205,   -2 }, /* (18) dbPrefix ::= ids DOT */
-  {  206,    0 }, /* (19) cpxName ::= */
-  {  206,   -2 }, /* (20) cpxName ::= DOT ids */
-  {  203,   -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
-  {  203,   -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
-  {  203,   -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
-  {  203,   -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
-  {  203,   -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-  {  203,   -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
-  {  203,   -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-  {  203,   -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
-  {  203,   -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  203,   -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
-  {  203,   -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
-  {  203,   -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
-  {  203,   -3 }, /* (33) cmd ::= DROP FUNCTION ids */
-  {  203,   -3 }, /* (34) cmd ::= DROP DNODE ids */
-  {  203,   -3 }, /* (35) cmd ::= DROP USER ids */
-  {  203,   -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
-  {  203,   -2 }, /* (37) cmd ::= USE ids */
-  {  203,   -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
-  {  203,   -3 }, /* (39) cmd ::= DESC ids cpxName */
-  {  203,   -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
-  {  203,   -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  203,   -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
-  {  203,   -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
-  {  203,   -3 }, /* (44) cmd ::= ALTER LOCAL ids */
-  {  203,   -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
-  {  203,   -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  203,   -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
-  {  203,   -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  203,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  203,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
-  {  204,   -1 }, /* (51) ids ::= ID */
-  {  204,   -1 }, /* (52) ids ::= STRING */
-  {  207,   -2 }, /* (53) ifexists ::= IF EXISTS */
-  {  207,    0 }, /* (54) ifexists ::= */
-  {  212,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
-  {  212,    0 }, /* (56) ifnotexists ::= */
-  {  203,   -3 }, /* (57) cmd ::= CREATE DNODE ids */
-  {  203,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  203,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  203,   -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
-  {  203,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-  {  203,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-  {  203,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
-  {  216,    0 }, /* (64) bufsize ::= */
-  {  216,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
-  {  217,    0 }, /* (66) pps ::= */
-  {  217,   -2 }, /* (67) pps ::= PPS INTEGER */
-  {  218,    0 }, /* (68) tseries ::= */
-  {  218,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
-  {  219,    0 }, /* (70) dbs ::= */
-  {  219,   -2 }, /* (71) dbs ::= DBS INTEGER */
-  {  220,    0 }, /* (72) streams ::= */
-  {  220,   -2 }, /* (73) streams ::= STREAMS INTEGER */
-  {  221,    0 }, /* (74) storage ::= */
-  {  221,   -2 }, /* (75) storage ::= STORAGE INTEGER */
-  {  222,    0 }, /* (76) qtime ::= */
-  {  222,   -2 }, /* (77) qtime ::= QTIME INTEGER */
-  {  223,    0 }, /* (78) users ::= */
-  {  223,   -2 }, /* (79) users ::= USERS INTEGER */
-  {  224,    0 }, /* (80) conns ::= */
-  {  224,   -2 }, /* (81) conns ::= CONNS INTEGER */
-  {  225,    0 }, /* (82) state ::= */
-  {  225,   -2 }, /* (83) state ::= STATE ids */
-  {  210,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  226,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
-  {  226,   -1 }, /* (86) intitemlist ::= intitem */
-  {  227,   -1 }, /* (87) intitem ::= INTEGER */
-  {  228,   -2 }, /* (88) keep ::= KEEP intitemlist */
-  {  229,   -2 }, /* (89) cache ::= CACHE INTEGER */
-  {  230,   -2 }, /* (90) replica ::= REPLICA INTEGER */
-  {  231,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
-  {  232,   -2 }, /* (92) days ::= DAYS INTEGER */
-  {  233,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
-  {  234,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
-  {  235,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
-  {  236,   -2 }, /* (96) ctime ::= CTIME INTEGER */
-  {  237,   -2 }, /* (97) wal ::= WAL INTEGER */
-  {  238,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
-  {  239,   -2 }, /* (99) comp ::= COMP INTEGER */
-  {  240,   -2 }, /* (100) prec ::= PRECISION STRING */
-  {  241,   -2 }, /* (101) update ::= UPDATE INTEGER */
-  {  242,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
-  {  243,   -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
-  {  213,    0 }, /* (104) db_optr ::= */
-  {  213,   -2 }, /* (105) db_optr ::= db_optr cache */
-  {  213,   -2 }, /* (106) db_optr ::= db_optr replica */
-  {  213,   -2 }, /* (107) db_optr ::= db_optr quorum */
-  {  213,   -2 }, /* (108) db_optr ::= db_optr days */
-  {  213,   -2 }, /* (109) db_optr ::= db_optr minrows */
-  {  213,   -2 }, /* (110) db_optr ::= db_optr maxrows */
-  {  213,   -2 }, /* (111) db_optr ::= db_optr blocks */
-  {  213,   -2 }, /* (112) db_optr ::= db_optr ctime */
-  {  213,   -2 }, /* (113) db_optr ::= db_optr wal */
-  {  213,   -2 }, /* (114) db_optr ::= db_optr fsync */
-  {  213,   -2 }, /* (115) db_optr ::= db_optr comp */
-  {  213,   -2 }, /* (116) db_optr ::= db_optr prec */
-  {  213,   -2 }, /* (117) db_optr ::= db_optr keep */
-  {  213,   -2 }, /* (118) db_optr ::= db_optr update */
-  {  213,   -2 }, /* (119) db_optr ::= db_optr cachelast */
-  {  214,   -1 }, /* (120) topic_optr ::= db_optr */
-  {  214,   -2 }, /* (121) topic_optr ::= topic_optr partitions */
-  {  208,    0 }, /* (122) alter_db_optr ::= */
-  {  208,   -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
-  {  208,   -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
-  {  208,   -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
-  {  208,   -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
-  {  208,   -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
-  {  208,   -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
-  {  208,   -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
-  {  209,   -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
-  {  209,   -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
-  {  215,   -1 }, /* (132) typename ::= ids */
-  {  215,   -4 }, /* (133) typename ::= ids LP signed RP */
-  {  215,   -2 }, /* (134) typename ::= ids UNSIGNED */
-  {  244,   -1 }, /* (135) signed ::= INTEGER */
-  {  244,   -2 }, /* (136) signed ::= PLUS INTEGER */
-  {  244,   -2 }, /* (137) signed ::= MINUS INTEGER */
-  {  203,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
-  {  203,   -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
-  {  203,   -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
-  {  203,   -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
-  {  247,   -1 }, /* (142) create_table_list ::= create_from_stable */
-  {  247,   -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
-  {  245,   -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  246,  -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  248,  -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  {  248,  -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
-  {  251,   -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
-  {  251,   -1 }, /* (149) tagNamelist ::= ids */
-  {  245,   -5 }, /* (150) create_table_args ::= ifnotexists ids cpxName AS select */
-  {  249,   -3 }, /* (151) columnlist ::= columnlist COMMA column */
-  {  249,   -1 }, /* (152) columnlist ::= column */
-  {  253,   -2 }, /* (153) column ::= ids typename */
-  {  250,   -3 }, /* (154) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  250,   -1 }, /* (155) tagitemlist ::= tagitem */
-  {  254,   -1 }, /* (156) tagitem ::= INTEGER */
-  {  254,   -1 }, /* (157) tagitem ::= FLOAT */
-  {  254,   -1 }, /* (158) tagitem ::= STRING */
-  {  254,   -1 }, /* (159) tagitem ::= BOOL */
-  {  254,   -1 }, /* (160) tagitem ::= NULL */
-  {  254,   -1 }, /* (161) tagitem ::= NOW */
-  {  254,   -3 }, /* (162) tagitem ::= NOW PLUS VARIABLE */
-  {  254,   -3 }, /* (163) tagitem ::= NOW MINUS VARIABLE */
-  {  254,   -2 }, /* (164) tagitem ::= MINUS INTEGER */
-  {  254,   -2 }, /* (165) tagitem ::= MINUS FLOAT */
-  {  254,   -2 }, /* (166) tagitem ::= PLUS INTEGER */
-  {  254,   -2 }, /* (167) tagitem ::= PLUS FLOAT */
-  {  252,  -15 }, /* (168) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
-  {  252,   -3 }, /* (169) select ::= LP select RP */
-  {  269,   -1 }, /* (170) union ::= select */
-  {  269,   -4 }, /* (171) union ::= union UNION ALL select */
-  {  203,   -1 }, /* (172) cmd ::= union */
-  {  252,   -2 }, /* (173) select ::= SELECT selcollist */
-  {  270,   -2 }, /* (174) sclp ::= selcollist COMMA */
-  {  270,    0 }, /* (175) sclp ::= */
-  {  255,   -4 }, /* (176) selcollist ::= sclp distinct expr as */
-  {  255,   -2 }, /* (177) selcollist ::= sclp STAR */
-  {  273,   -2 }, /* (178) as ::= AS ids */
-  {  273,   -1 }, /* (179) as ::= ids */
-  {  273,    0 }, /* (180) as ::= */
-  {  271,   -1 }, /* (181) distinct ::= DISTINCT */
-  {  271,    0 }, /* (182) distinct ::= */
-  {  256,   -2 }, /* (183) from ::= FROM tablelist */
-  {  256,   -2 }, /* (184) from ::= FROM sub */
-  {  275,   -3 }, /* (185) sub ::= LP union RP */
-  {  275,   -4 }, /* (186) sub ::= LP union RP ids */
-  {  275,   -6 }, /* (187) sub ::= sub COMMA LP union RP ids */
-  {  274,   -2 }, /* (188) tablelist ::= ids cpxName */
-  {  274,   -3 }, /* (189) tablelist ::= ids cpxName ids */
-  {  274,   -4 }, /* (190) tablelist ::= tablelist COMMA ids cpxName */
-  {  274,   -5 }, /* (191) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  276,   -1 }, /* (192) tmvar ::= VARIABLE */
-  {  277,   -1 }, /* (193) timestamp ::= INTEGER */
-  {  277,   -2 }, /* (194) timestamp ::= MINUS INTEGER */
-  {  277,   -2 }, /* (195) timestamp ::= PLUS INTEGER */
-  {  277,   -1 }, /* (196) timestamp ::= STRING */
-  {  277,   -1 }, /* (197) timestamp ::= NOW */
-  {  277,   -3 }, /* (198) timestamp ::= NOW PLUS VARIABLE */
-  {  277,   -3 }, /* (199) timestamp ::= NOW MINUS VARIABLE */
-  {  258,    0 }, /* (200) range_option ::= */
-  {  258,   -6 }, /* (201) range_option ::= RANGE LP timestamp COMMA timestamp RP */
-  {  259,   -4 }, /* (202) interval_option ::= intervalKey LP tmvar RP */
-  {  259,   -6 }, /* (203) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-  {  259,    0 }, /* (204) interval_option ::= */
-  {  278,   -1 }, /* (205) intervalKey ::= INTERVAL */
-  {  278,   -1 }, /* (206) intervalKey ::= EVERY */
-  {  261,    0 }, /* (207) session_option ::= */
-  {  261,   -7 }, /* (208) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-  {  262,    0 }, /* (209) windowstate_option ::= */
-  {  262,   -4 }, /* (210) windowstate_option ::= STATE_WINDOW LP ids RP */
-  {  263,    0 }, /* (211) fill_opt ::= */
-  {  263,   -6 }, /* (212) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  263,   -4 }, /* (213) fill_opt ::= FILL LP ID RP */
-  {  260,   -4 }, /* (214) sliding_opt ::= SLIDING LP tmvar RP */
-  {  260,    0 }, /* (215) sliding_opt ::= */
-  {  266,    0 }, /* (216) orderby_opt ::= */
-  {  266,   -3 }, /* (217) orderby_opt ::= ORDER BY sortlist */
-  {  279,   -4 }, /* (218) sortlist ::= sortlist COMMA item sortorder */
-  {  279,   -4 }, /* (219) sortlist ::= sortlist COMMA arrow sortorder */
-  {  279,   -2 }, /* (220) sortlist ::= item sortorder */
-  {  279,   -2 }, /* (221) sortlist ::= arrow sortorder */
-  {  280,   -1 }, /* (222) item ::= ID */
-  {  280,   -3 }, /* (223) item ::= ID DOT ID */
-  {  281,   -1 }, /* (224) sortorder ::= ASC */
-  {  281,   -1 }, /* (225) sortorder ::= DESC */
-  {  281,    0 }, /* (226) sortorder ::= */
-  {  264,    0 }, /* (227) groupby_opt ::= */
-  {  264,   -3 }, /* (228) groupby_opt ::= GROUP BY grouplist */
-  {  283,   -3 }, /* (229) grouplist ::= grouplist COMMA item */
-  {  283,   -3 }, /* (230) grouplist ::= grouplist COMMA arrow */
-  {  283,   -1 }, /* (231) grouplist ::= item */
-  {  283,   -1 }, /* (232) grouplist ::= arrow */
-  {  265,    0 }, /* (233) having_opt ::= */
-  {  265,   -2 }, /* (234) having_opt ::= HAVING expr */
-  {  268,    0 }, /* (235) limit_opt ::= */
-  {  268,   -2 }, /* (236) limit_opt ::= LIMIT signed */
-  {  268,   -4 }, /* (237) limit_opt ::= LIMIT signed OFFSET signed */
-  {  268,   -4 }, /* (238) limit_opt ::= LIMIT signed COMMA signed */
-  {  267,    0 }, /* (239) slimit_opt ::= */
-  {  267,   -2 }, /* (240) slimit_opt ::= SLIMIT signed */
-  {  267,   -4 }, /* (241) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  267,   -4 }, /* (242) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  257,    0 }, /* (243) where_opt ::= */
-  {  257,   -2 }, /* (244) where_opt ::= WHERE expr */
-  {  272,   -3 }, /* (245) expr ::= LP expr RP */
-  {  272,   -1 }, /* (246) expr ::= ID */
-  {  272,   -3 }, /* (247) expr ::= ID DOT ID */
-  {  272,   -3 }, /* (248) expr ::= ID DOT STAR */
-  {  272,   -1 }, /* (249) expr ::= INTEGER */
-  {  272,   -2 }, /* (250) expr ::= MINUS INTEGER */
-  {  272,   -2 }, /* (251) expr ::= PLUS INTEGER */
-  {  272,   -1 }, /* (252) expr ::= FLOAT */
-  {  272,   -2 }, /* (253) expr ::= MINUS FLOAT */
-  {  272,   -2 }, /* (254) expr ::= PLUS FLOAT */
-  {  272,   -1 }, /* (255) expr ::= STRING */
-  {  272,   -1 }, /* (256) expr ::= NOW */
-  {  272,   -1 }, /* (257) expr ::= VARIABLE */
-  {  272,   -2 }, /* (258) expr ::= PLUS VARIABLE */
-  {  272,   -2 }, /* (259) expr ::= MINUS VARIABLE */
-  {  272,   -1 }, /* (260) expr ::= BOOL */
-  {  272,   -1 }, /* (261) expr ::= NULL */
-  {  272,   -4 }, /* (262) expr ::= ID LP exprlist RP */
-  {  272,   -4 }, /* (263) expr ::= ID LP STAR RP */
-  {  272,   -6 }, /* (264) expr ::= ID LP expr AS typename RP */
-  {  272,   -3 }, /* (265) expr ::= expr IS NULL */
-  {  272,   -4 }, /* (266) expr ::= expr IS NOT NULL */
-  {  272,   -3 }, /* (267) expr ::= expr LT expr */
-  {  272,   -3 }, /* (268) expr ::= expr GT expr */
-  {  272,   -3 }, /* (269) expr ::= expr LE expr */
-  {  272,   -3 }, /* (270) expr ::= expr GE expr */
-  {  272,   -3 }, /* (271) expr ::= expr NE expr */
-  {  272,   -3 }, /* (272) expr ::= expr EQ expr */
-  {  272,   -5 }, /* (273) expr ::= expr BETWEEN expr AND expr */
-  {  272,   -3 }, /* (274) expr ::= expr AND expr */
-  {  272,   -3 }, /* (275) expr ::= expr OR expr */
-  {  272,   -3 }, /* (276) expr ::= expr PLUS expr */
-  {  272,   -3 }, /* (277) expr ::= expr MINUS expr */
-  {  272,   -3 }, /* (278) expr ::= expr STAR expr */
-  {  272,   -3 }, /* (279) expr ::= expr SLASH expr */
-  {  272,   -3 }, /* (280) expr ::= expr REM expr */
-  {  272,   -3 }, /* (281) expr ::= expr BITAND expr */
-  {  272,   -3 }, /* (282) expr ::= expr LIKE expr */
-  {  272,   -3 }, /* (283) expr ::= expr MATCH expr */
-  {  272,   -3 }, /* (284) expr ::= expr NMATCH expr */
-  {  272,   -3 }, /* (285) expr ::= ID CONTAINS STRING */
-  {  272,   -5 }, /* (286) expr ::= ID DOT ID CONTAINS STRING */
-  {  282,   -3 }, /* (287) arrow ::= ID ARROW STRING */
-  {  282,   -5 }, /* (288) arrow ::= ID DOT ID ARROW STRING */
-  {  272,   -1 }, /* (289) expr ::= arrow */
-  {  272,   -5 }, /* (290) expr ::= expr IN LP exprlist RP */
-  {  211,   -3 }, /* (291) exprlist ::= exprlist COMMA expritem */
-  {  211,   -1 }, /* (292) exprlist ::= expritem */
-  {  284,   -1 }, /* (293) expritem ::= expr */
-  {  284,    0 }, /* (294) expritem ::= */
-  {  203,   -3 }, /* (295) cmd ::= RESET QUERY CACHE */
-  {  203,   -3 }, /* (296) cmd ::= SYNCDB ids REPLICA */
-  {  203,   -7 }, /* (297) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  203,   -7 }, /* (298) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  203,   -7 }, /* (299) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
-  {  203,   -7 }, /* (300) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  203,   -7 }, /* (301) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  203,   -8 }, /* (302) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  203,   -9 }, /* (303) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  203,   -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
-  {  203,   -7 }, /* (305) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-  {  203,   -7 }, /* (306) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-  {  203,   -7 }, /* (307) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
-  {  203,   -7 }, /* (308) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-  {  203,   -7 }, /* (309) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-  {  203,   -8 }, /* (310) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-  {  203,   -9 }, /* (311) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
-  {  203,   -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
-  {  203,   -3 }, /* (313) cmd ::= KILL CONNECTION INTEGER */
-  {  203,   -5 }, /* (314) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  203,   -5 }, /* (315) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  203,   -1 }, /* (0) program ::= cmd */
+  {  204,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  204,   -2 }, /* (2) cmd ::= SHOW TOPICS */
+  {  204,   -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
+  {  204,   -2 }, /* (4) cmd ::= SHOW MNODES */
+  {  204,   -2 }, /* (5) cmd ::= SHOW DNODES */
+  {  204,   -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
+  {  204,   -2 }, /* (7) cmd ::= SHOW USERS */
+  {  204,   -2 }, /* (8) cmd ::= SHOW MODULES */
+  {  204,   -2 }, /* (9) cmd ::= SHOW QUERIES */
+  {  204,   -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
+  {  204,   -2 }, /* (11) cmd ::= SHOW STREAMS */
+  {  204,   -2 }, /* (12) cmd ::= SHOW VARIABLES */
+  {  204,   -2 }, /* (13) cmd ::= SHOW SCORES */
+  {  204,   -2 }, /* (14) cmd ::= SHOW GRANTS */
+  {  204,   -2 }, /* (15) cmd ::= SHOW VNODES */
+  {  204,   -3 }, /* (16) cmd ::= SHOW VNODES ids */
+  {  206,    0 }, /* (17) dbPrefix ::= */
+  {  206,   -2 }, /* (18) dbPrefix ::= ids DOT */
+  {  207,    0 }, /* (19) cpxName ::= */
+  {  207,   -2 }, /* (20) cpxName ::= DOT ids */
+  {  204,   -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
+  {  204,   -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
+  {  204,   -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
+  {  204,   -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
+  {  204,   -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+  {  204,   -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
+  {  204,   -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+  {  204,   -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
+  {  204,   -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  204,   -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
+  {  204,   -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
+  {  204,   -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
+  {  204,   -3 }, /* (33) cmd ::= DROP FUNCTION ids */
+  {  204,   -3 }, /* (34) cmd ::= DROP DNODE ids */
+  {  204,   -3 }, /* (35) cmd ::= DROP USER ids */
+  {  204,   -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
+  {  204,   -2 }, /* (37) cmd ::= USE ids */
+  {  204,   -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
+  {  204,   -3 }, /* (39) cmd ::= DESC ids cpxName */
+  {  204,   -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
+  {  204,   -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  204,   -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
+  {  204,   -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
+  {  204,   -3 }, /* (44) cmd ::= ALTER LOCAL ids */
+  {  204,   -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
+  {  204,   -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  204,   -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
+  {  204,   -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  204,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  204,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
+  {  205,   -1 }, /* (51) ids ::= ID */
+  {  205,   -1 }, /* (52) ids ::= STRING */
+  {  208,   -2 }, /* (53) ifexists ::= IF EXISTS */
+  {  208,    0 }, /* (54) ifexists ::= */
+  {  213,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
+  {  213,    0 }, /* (56) ifnotexists ::= */
+  {  204,   -3 }, /* (57) cmd ::= CREATE DNODE ids */
+  {  204,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  204,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  204,   -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
+  {  204,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  204,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  204,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
+  {  217,    0 }, /* (64) bufsize ::= */
+  {  217,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
+  {  218,    0 }, /* (66) pps ::= */
+  {  218,   -2 }, /* (67) pps ::= PPS INTEGER */
+  {  219,    0 }, /* (68) tseries ::= */
+  {  219,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
+  {  220,    0 }, /* (70) dbs ::= */
+  {  220,   -2 }, /* (71) dbs ::= DBS INTEGER */
+  {  221,    0 }, /* (72) streams ::= */
+  {  221,   -2 }, /* (73) streams ::= STREAMS INTEGER */
+  {  222,    0 }, /* (74) storage ::= */
+  {  222,   -2 }, /* (75) storage ::= STORAGE INTEGER */
+  {  223,    0 }, /* (76) qtime ::= */
+  {  223,   -2 }, /* (77) qtime ::= QTIME INTEGER */
+  {  224,    0 }, /* (78) users ::= */
+  {  224,   -2 }, /* (79) users ::= USERS INTEGER */
+  {  225,    0 }, /* (80) conns ::= */
+  {  225,   -2 }, /* (81) conns ::= CONNS INTEGER */
+  {  226,    0 }, /* (82) state ::= */
+  {  226,   -2 }, /* (83) state ::= STATE ids */
+  {  211,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  227,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
+  {  227,   -1 }, /* (86) intitemlist ::= intitem */
+  {  228,   -1 }, /* (87) intitem ::= INTEGER */
+  {  229,   -2 }, /* (88) keep ::= KEEP intitemlist */
+  {  230,   -2 }, /* (89) cache ::= CACHE INTEGER */
+  {  231,   -2 }, /* (90) replica ::= REPLICA INTEGER */
+  {  232,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
+  {  233,   -2 }, /* (92) days ::= DAYS INTEGER */
+  {  234,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
+  {  235,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
+  {  236,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
+  {  237,   -2 }, /* (96) ctime ::= CTIME INTEGER */
+  {  238,   -2 }, /* (97) wal ::= WAL INTEGER */
+  {  239,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
+  {  240,   -2 }, /* (99) comp ::= COMP INTEGER */
+  {  241,   -2 }, /* (100) prec ::= PRECISION STRING */
+  {  242,   -2 }, /* (101) update ::= UPDATE INTEGER */
+  {  243,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
+  {  244,   -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
+  {  214,    0 }, /* (104) db_optr ::= */
+  {  214,   -2 }, /* (105) db_optr ::= db_optr cache */
+  {  214,   -2 }, /* (106) db_optr ::= db_optr replica */
+  {  214,   -2 }, /* (107) db_optr ::= db_optr quorum */
+  {  214,   -2 }, /* (108) db_optr ::= db_optr days */
+  {  214,   -2 }, /* (109) db_optr ::= db_optr minrows */
+  {  214,   -2 }, /* (110) db_optr ::= db_optr maxrows */
+  {  214,   -2 }, /* (111) db_optr ::= db_optr blocks */
+  {  214,   -2 }, /* (112) db_optr ::= db_optr ctime */
+  {  214,   -2 }, /* (113) db_optr ::= db_optr wal */
+  {  214,   -2 }, /* (114) db_optr ::= db_optr fsync */
+  {  214,   -2 }, /* (115) db_optr ::= db_optr comp */
+  {  214,   -2 }, /* (116) db_optr ::= db_optr prec */
+  {  214,   -2 }, /* (117) db_optr ::= db_optr keep */
+  {  214,   -2 }, /* (118) db_optr ::= db_optr update */
+  {  214,   -2 }, /* (119) db_optr ::= db_optr cachelast */
+  {  215,   -1 }, /* (120) topic_optr ::= db_optr */
+  {  215,   -2 }, /* (121) topic_optr ::= topic_optr partitions */
+  {  209,    0 }, /* (122) alter_db_optr ::= */
+  {  209,   -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
+  {  209,   -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
+  {  209,   -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
+  {  209,   -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
+  {  209,   -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
+  {  209,   -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
+  {  209,   -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
+  {  210,   -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
+  {  210,   -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
+  {  216,   -1 }, /* (132) typename ::= ids */
+  {  216,   -4 }, /* (133) typename ::= ids LP signed RP */
+  {  216,   -2 }, /* (134) typename ::= ids UNSIGNED */
+  {  245,   -1 }, /* (135) signed ::= INTEGER */
+  {  245,   -2 }, /* (136) signed ::= PLUS INTEGER */
+  {  245,   -2 }, /* (137) signed ::= MINUS INTEGER */
+  {  204,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
+  {  204,   -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
+  {  204,   -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
+  {  204,   -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
+  {  248,   -1 }, /* (142) create_table_list ::= create_from_stable */
+  {  248,   -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
+  {  246,   -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  247,  -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  249,  -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  249,  -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+  {  252,   -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
+  {  252,   -1 }, /* (149) tagNamelist ::= ids */
+  {  246,   -5 }, /* (150) create_table_args ::= ifnotexists ids cpxName AS select */
+  {  250,   -3 }, /* (151) columnlist ::= columnlist COMMA column */
+  {  250,   -1 }, /* (152) columnlist ::= column */
+  {  254,   -2 }, /* (153) column ::= ids typename */
+  {  251,   -3 }, /* (154) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  251,   -1 }, /* (155) tagitemlist ::= tagitem */
+  {  255,   -1 }, /* (156) tagitem ::= INTEGER */
+  {  255,   -1 }, /* (157) tagitem ::= FLOAT */
+  {  255,   -1 }, /* (158) tagitem ::= STRING */
+  {  255,   -1 }, /* (159) tagitem ::= BOOL */
+  {  255,   -1 }, /* (160) tagitem ::= NULL */
+  {  255,   -1 }, /* (161) tagitem ::= NOW */
+  {  255,   -3 }, /* (162) tagitem ::= NOW PLUS VARIABLE */
+  {  255,   -3 }, /* (163) tagitem ::= NOW MINUS VARIABLE */
+  {  255,   -2 }, /* (164) tagitem ::= MINUS INTEGER */
+  {  255,   -2 }, /* (165) tagitem ::= MINUS FLOAT */
+  {  255,   -2 }, /* (166) tagitem ::= PLUS INTEGER */
+  {  255,   -2 }, /* (167) tagitem ::= PLUS FLOAT */
+  {  253,  -15 }, /* (168) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+  {  253,   -3 }, /* (169) select ::= LP select RP */
+  {  270,   -1 }, /* (170) union ::= select */
+  {  270,   -4 }, /* (171) union ::= union UNION ALL select */
+  {  204,   -1 }, /* (172) cmd ::= union */
+  {  253,   -2 }, /* (173) select ::= SELECT selcollist */
+  {  271,   -2 }, /* (174) sclp ::= selcollist COMMA */
+  {  271,    0 }, /* (175) sclp ::= */
+  {  256,   -4 }, /* (176) selcollist ::= sclp distinct expr as */
+  {  256,   -2 }, /* (177) selcollist ::= sclp STAR */
+  {  274,   -2 }, /* (178) as ::= AS ids */
+  {  274,   -1 }, /* (179) as ::= ids */
+  {  274,    0 }, /* (180) as ::= */
+  {  272,   -1 }, /* (181) distinct ::= DISTINCT */
+  {  272,    0 }, /* (182) distinct ::= */
+  {  257,   -2 }, /* (183) from ::= FROM tablelist */
+  {  257,   -2 }, /* (184) from ::= FROM sub */
+  {  276,   -3 }, /* (185) sub ::= LP union RP */
+  {  276,   -4 }, /* (186) sub ::= LP union RP ids */
+  {  276,   -6 }, /* (187) sub ::= sub COMMA LP union RP ids */
+  {  275,   -2 }, /* (188) tablelist ::= ids cpxName */
+  {  275,   -3 }, /* (189) tablelist ::= ids cpxName ids */
+  {  275,   -4 }, /* (190) tablelist ::= tablelist COMMA ids cpxName */
+  {  275,   -5 }, /* (191) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  277,   -1 }, /* (192) tmvar ::= VARIABLE */
+  {  278,   -1 }, /* (193) timestamp ::= INTEGER */
+  {  278,   -2 }, /* (194) timestamp ::= MINUS INTEGER */
+  {  278,   -2 }, /* (195) timestamp ::= PLUS INTEGER */
+  {  278,   -1 }, /* (196) timestamp ::= STRING */
+  {  278,   -1 }, /* (197) timestamp ::= NOW */
+  {  278,   -3 }, /* (198) timestamp ::= NOW PLUS VARIABLE */
+  {  278,   -3 }, /* (199) timestamp ::= NOW MINUS VARIABLE */
+  {  259,    0 }, /* (200) range_option ::= */
+  {  259,   -6 }, /* (201) range_option ::= RANGE LP timestamp COMMA timestamp RP */
+  {  260,   -4 }, /* (202) interval_option ::= intervalKey LP tmvar RP */
+  {  260,   -6 }, /* (203) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+  {  260,    0 }, /* (204) interval_option ::= */
+  {  279,   -1 }, /* (205) intervalKey ::= INTERVAL */
+  {  279,   -1 }, /* (206) intervalKey ::= EVERY */
+  {  262,    0 }, /* (207) session_option ::= */
+  {  262,   -7 }, /* (208) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+  {  263,    0 }, /* (209) windowstate_option ::= */
+  {  263,   -4 }, /* (210) windowstate_option ::= STATE_WINDOW LP ids RP */
+  {  264,    0 }, /* (211) fill_opt ::= */
+  {  264,   -6 }, /* (212) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  264,   -4 }, /* (213) fill_opt ::= FILL LP ID RP */
+  {  261,   -4 }, /* (214) sliding_opt ::= SLIDING LP tmvar RP */
+  {  261,    0 }, /* (215) sliding_opt ::= */
+  {  267,    0 }, /* (216) orderby_opt ::= */
+  {  267,   -3 }, /* (217) orderby_opt ::= ORDER BY sortlist */
+  {  280,   -4 }, /* (218) sortlist ::= sortlist COMMA item sortorder */
+  {  280,   -4 }, /* (219) sortlist ::= sortlist COMMA arrow sortorder */
+  {  280,   -2 }, /* (220) sortlist ::= item sortorder */
+  {  280,   -2 }, /* (221) sortlist ::= arrow sortorder */
+  {  281,   -1 }, /* (222) item ::= ID */
+  {  281,   -3 }, /* (223) item ::= ID DOT ID */
+  {  282,   -1 }, /* (224) sortorder ::= ASC */
+  {  282,   -1 }, /* (225) sortorder ::= DESC */
+  {  282,    0 }, /* (226) sortorder ::= */
+  {  265,    0 }, /* (227) groupby_opt ::= */
+  {  265,   -3 }, /* (228) groupby_opt ::= GROUP BY grouplist */
+  {  284,   -3 }, /* (229) grouplist ::= grouplist COMMA item */
+  {  284,   -3 }, /* (230) grouplist ::= grouplist COMMA arrow */
+  {  284,   -1 }, /* (231) grouplist ::= item */
+  {  284,   -1 }, /* (232) grouplist ::= arrow */
+  {  266,    0 }, /* (233) having_opt ::= */
+  {  266,   -2 }, /* (234) having_opt ::= HAVING expr */
+  {  269,    0 }, /* (235) limit_opt ::= */
+  {  269,   -2 }, /* (236) limit_opt ::= LIMIT signed */
+  {  269,   -4 }, /* (237) limit_opt ::= LIMIT signed OFFSET signed */
+  {  269,   -4 }, /* (238) limit_opt ::= LIMIT signed COMMA signed */
+  {  268,    0 }, /* (239) slimit_opt ::= */
+  {  268,   -2 }, /* (240) slimit_opt ::= SLIMIT signed */
+  {  268,   -4 }, /* (241) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  268,   -4 }, /* (242) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  258,    0 }, /* (243) where_opt ::= */
+  {  258,   -2 }, /* (244) where_opt ::= WHERE expr */
+  {  273,   -3 }, /* (245) expr ::= LP expr RP */
+  {  273,   -1 }, /* (246) expr ::= ID */
+  {  273,   -3 }, /* (247) expr ::= ID DOT ID */
+  {  273,   -3 }, /* (248) expr ::= ID DOT STAR */
+  {  273,   -1 }, /* (249) expr ::= INTEGER */
+  {  273,   -2 }, /* (250) expr ::= MINUS INTEGER */
+  {  273,   -2 }, /* (251) expr ::= PLUS INTEGER */
+  {  273,   -1 }, /* (252) expr ::= FLOAT */
+  {  273,   -2 }, /* (253) expr ::= MINUS FLOAT */
+  {  273,   -2 }, /* (254) expr ::= PLUS FLOAT */
+  {  273,   -1 }, /* (255) expr ::= STRING */
+  {  273,   -1 }, /* (256) expr ::= NOW */
+  {  273,   -1 }, /* (257) expr ::= VARIABLE */
+  {  273,   -2 }, /* (258) expr ::= PLUS VARIABLE */
+  {  273,   -2 }, /* (259) expr ::= MINUS VARIABLE */
+  {  273,   -1 }, /* (260) expr ::= BOOL */
+  {  273,   -1 }, /* (261) expr ::= NULL */
+  {  273,   -4 }, /* (262) expr ::= ID LP exprlist RP */
+  {  273,   -4 }, /* (263) expr ::= ID LP STAR RP */
+  {  273,   -6 }, /* (264) expr ::= ID LP expr AS typename RP */
+  {  273,   -3 }, /* (265) expr ::= expr IS NULL */
+  {  273,   -4 }, /* (266) expr ::= expr IS NOT NULL */
+  {  273,   -3 }, /* (267) expr ::= expr LT expr */
+  {  273,   -3 }, /* (268) expr ::= expr GT expr */
+  {  273,   -3 }, /* (269) expr ::= expr LE expr */
+  {  273,   -3 }, /* (270) expr ::= expr GE expr */
+  {  273,   -3 }, /* (271) expr ::= expr NE expr */
+  {  273,   -3 }, /* (272) expr ::= expr EQ expr */
+  {  273,   -5 }, /* (273) expr ::= expr BETWEEN expr AND expr */
+  {  273,   -3 }, /* (274) expr ::= expr AND expr */
+  {  273,   -3 }, /* (275) expr ::= expr OR expr */
+  {  273,   -3 }, /* (276) expr ::= expr PLUS expr */
+  {  273,   -3 }, /* (277) expr ::= expr MINUS expr */
+  {  273,   -3 }, /* (278) expr ::= expr STAR expr */
+  {  273,   -3 }, /* (279) expr ::= expr SLASH expr */
+  {  273,   -3 }, /* (280) expr ::= expr REM expr */
+  {  273,   -3 }, /* (281) expr ::= expr BITAND expr */
+  {  273,   -3 }, /* (282) expr ::= expr BITOR expr */
+  {  273,   -3 }, /* (283) expr ::= expr BITXOR expr */
+  {  273,   -2 }, /* (284) expr ::= BITNOT expr */
+  {  273,   -3 }, /* (285) expr ::= expr LSHIFT expr */
+  {  273,   -3 }, /* (286) expr ::= expr RSHIFT expr */
+  {  273,   -3 }, /* (287) expr ::= expr LIKE expr */
+  {  273,   -3 }, /* (288) expr ::= expr MATCH expr */
+  {  273,   -3 }, /* (289) expr ::= expr NMATCH expr */
+  {  273,   -3 }, /* (290) expr ::= ID CONTAINS STRING */
+  {  273,   -5 }, /* (291) expr ::= ID DOT ID CONTAINS STRING */
+  {  283,   -3 }, /* (292) arrow ::= ID ARROW STRING */
+  {  283,   -5 }, /* (293) arrow ::= ID DOT ID ARROW STRING */
+  {  273,   -1 }, /* (294) expr ::= arrow */
+  {  273,   -5 }, /* (295) expr ::= expr IN LP exprlist RP */
+  {  212,   -3 }, /* (296) exprlist ::= exprlist COMMA expritem */
+  {  212,   -1 }, /* (297) exprlist ::= expritem */
+  {  285,   -1 }, /* (298) expritem ::= expr */
+  {  285,    0 }, /* (299) expritem ::= */
+  {  204,   -3 }, /* (300) cmd ::= RESET QUERY CACHE */
+  {  204,   -3 }, /* (301) cmd ::= SYNCDB ids REPLICA */
+  {  204,   -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  204,   -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  204,   -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+  {  204,   -7 }, /* (305) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  204,   -7 }, /* (306) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  204,   -8 }, /* (307) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  204,   -9 }, /* (308) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  204,   -7 }, /* (309) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+  {  204,   -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  204,   -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  204,   -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+  {  204,   -7 }, /* (313) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  204,   -7 }, /* (314) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  204,   -8 }, /* (315) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  204,   -9 }, /* (316) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+  {  204,   -7 }, /* (317) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+  {  204,   -3 }, /* (318) cmd ::= KILL CONNECTION INTEGER */
+  {  204,   -5 }, /* (319) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  204,   -5 }, /* (320) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2466,16 +2490,16 @@ static void yy_reduce(
         break;
       case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */
       case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47);
-{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy532, &t);}
+{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy42, &t);}
         break;
       case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy31);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy55);}
         break;
       case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy31);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy55);}
         break;
       case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
-{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy231);}
+{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy373);}
         break;
       case 51: /* ids ::= ID */
       case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
@@ -2497,17 +2521,17 @@ static void yy_reduce(
 { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy31);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy55);}
         break;
       case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
       case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60);
-{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy532, &yymsp[-2].minor.yy0);}
+{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy42, &yymsp[-2].minor.yy0);}
         break;
       case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy103, &yymsp[0].minor.yy0, 1);}
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy119, &yymsp[0].minor.yy0, 1);}
         break;
       case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy103, &yymsp[0].minor.yy0, 2);}
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy119, &yymsp[0].minor.yy0, 2);}
         break;
       case 63: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
@@ -2538,38 +2562,38 @@ static void yy_reduce(
         break;
       case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy31.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy31.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy31.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy31.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy31.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy31.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy31.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy31.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy31.stat    = yymsp[0].minor.yy0;
+    yylhsminor.yy55.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy55.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy55.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy55.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy55.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy55.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy55.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy55.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy55.stat    = yymsp[0].minor.yy0;
 }
-  yymsp[-8].minor.yy31 = yylhsminor.yy31;
+  yymsp[-8].minor.yy55 = yylhsminor.yy55;
         break;
       case 85: /* intitemlist ::= intitemlist COMMA intitem */
       case 154: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==154);
-{ yylhsminor.yy231 = tVariantListAppend(yymsp[-2].minor.yy231, &yymsp[0].minor.yy176, -1);    }
-  yymsp[-2].minor.yy231 = yylhsminor.yy231;
+{ yylhsminor.yy373 = tVariantListAppend(yymsp[-2].minor.yy373, &yymsp[0].minor.yy186, -1);    }
+  yymsp[-2].minor.yy373 = yylhsminor.yy373;
         break;
       case 86: /* intitemlist ::= intitem */
       case 155: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==155);
-{ yylhsminor.yy231 = tVariantListAppend(NULL, &yymsp[0].minor.yy176, -1); }
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+{ yylhsminor.yy373 = tVariantListAppend(NULL, &yymsp[0].minor.yy186, -1); }
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
         break;
       case 87: /* intitem ::= INTEGER */
       case 156: /* tagitem ::= INTEGER */ yytestcase(yyruleno==156);
       case 157: /* tagitem ::= FLOAT */ yytestcase(yyruleno==157);
       case 158: /* tagitem ::= STRING */ yytestcase(yyruleno==158);
       case 159: /* tagitem ::= BOOL */ yytestcase(yyruleno==159);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy176, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy176 = yylhsminor.yy176;
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy186, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy186 = yylhsminor.yy186;
         break;
       case 88: /* keep ::= KEEP intitemlist */
-{ yymsp[-1].minor.yy231 = yymsp[0].minor.yy231; }
+{ yymsp[-1].minor.yy373 = yymsp[0].minor.yy373; }
         break;
       case 89: /* cache ::= CACHE INTEGER */
       case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
@@ -2589,232 +2613,232 @@ static void yy_reduce(
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
       case 104: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy532); yymsp[1].minor.yy532.dbType = TSDB_DB_TYPE_DEFAULT;}
+{setDefaultCreateDbOption(&yymsp[1].minor.yy42); yymsp[1].minor.yy42.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 105: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 106: /* db_optr ::= db_optr replica */
       case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 107: /* db_optr ::= db_optr quorum */
       case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 108: /* db_optr ::= db_optr days */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 109: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 110: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 111: /* db_optr ::= db_optr blocks */
       case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 112: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 113: /* db_optr ::= db_optr wal */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 114: /* db_optr ::= db_optr fsync */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 115: /* db_optr ::= db_optr comp */
       case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 116: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 117: /* db_optr ::= db_optr keep */
       case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.keep = yymsp[0].minor.yy231; }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.keep = yymsp[0].minor.yy373; }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 118: /* db_optr ::= db_optr update */
       case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 119: /* db_optr ::= db_optr cachelast */
       case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 120: /* topic_optr ::= db_optr */
       case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130);
-{ yylhsminor.yy532 = yymsp[0].minor.yy532; yylhsminor.yy532.dbType = TSDB_DB_TYPE_TOPIC; }
-  yymsp[0].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[0].minor.yy42; yylhsminor.yy42.dbType = TSDB_DB_TYPE_TOPIC; }
+  yymsp[0].minor.yy42 = yylhsminor.yy42;
         break;
       case 121: /* topic_optr ::= topic_optr partitions */
       case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131);
-{ yylhsminor.yy532 = yymsp[-1].minor.yy532; yylhsminor.yy532.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy532 = yylhsminor.yy532;
+{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy42 = yylhsminor.yy42;
         break;
       case 122: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy532); yymsp[1].minor.yy532.dbType = TSDB_DB_TYPE_DEFAULT;}
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy42); yymsp[1].minor.yy42.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 132: /* typename ::= ids */
 {
   yymsp[0].minor.yy0.type = 0;
-  tSetColumnType (&yylhsminor.yy103, &yymsp[0].minor.yy0);
+  tSetColumnType (&yylhsminor.yy119, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy103 = yylhsminor.yy103;
+  yymsp[0].minor.yy119 = yylhsminor.yy119;
         break;
       case 133: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy549 <= 0) {
+  if (yymsp[-1].minor.yy129 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSetColumnType(&yylhsminor.yy103, &yymsp[-3].minor.yy0);
+    tSetColumnType(&yylhsminor.yy119, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy549;  // negative value of name length
-    tSetColumnType(&yylhsminor.yy103, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy129;  // negative value of name length
+    tSetColumnType(&yylhsminor.yy119, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy103 = yylhsminor.yy103;
+  yymsp[-3].minor.yy119 = yylhsminor.yy119;
         break;
       case 134: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
-  tSetColumnType (&yylhsminor.yy103, &yymsp[-1].minor.yy0);
+  tSetColumnType (&yylhsminor.yy119, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy103 = yylhsminor.yy103;
+  yymsp[-1].minor.yy119 = yylhsminor.yy119;
         break;
       case 135: /* signed ::= INTEGER */
-{ yylhsminor.yy549 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy549 = yylhsminor.yy549;
+{ yylhsminor.yy129 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy129 = yylhsminor.yy129;
         break;
       case 136: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy549 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy129 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
       case 137: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy549 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+{ yymsp[-1].minor.yy129 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
       case 141: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy422;}
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy118;}
         break;
       case 142: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy306);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy228);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
-  yylhsminor.yy422 = pCreateTable;
+  yylhsminor.yy118 = pCreateTable;
 }
-  yymsp[0].minor.yy422 = yylhsminor.yy422;
+  yymsp[0].minor.yy118 = yylhsminor.yy118;
         break;
       case 143: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy422->childTableInfo, &yymsp[0].minor.yy306);
-  yylhsminor.yy422 = yymsp[-1].minor.yy422;
+  taosArrayPush(yymsp[-1].minor.yy118->childTableInfo, &yymsp[0].minor.yy228);
+  yylhsminor.yy118 = yymsp[-1].minor.yy118;
 }
-  yymsp[-1].minor.yy422 = yylhsminor.yy422;
+  yymsp[-1].minor.yy118 = yylhsminor.yy118;
         break;
       case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy422 = tSetCreateTableInfo(yymsp[-1].minor.yy231, NULL, NULL, TSQL_CREATE_TABLE);
-  setSqlInfo(pInfo, yylhsminor.yy422, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy118 = tSetCreateTableInfo(yymsp[-1].minor.yy373, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy118, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy422 = yylhsminor.yy422;
+  yymsp[-5].minor.yy118 = yylhsminor.yy118;
         break;
       case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy422 = tSetCreateTableInfo(yymsp[-5].minor.yy231, yymsp[-1].minor.yy231, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy422, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy118 = tSetCreateTableInfo(yymsp[-5].minor.yy373, yymsp[-1].minor.yy373, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, yylhsminor.yy118, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy422 = yylhsminor.yy422;
+  yymsp[-9].minor.yy118 = yylhsminor.yy118;
         break;
       case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy306 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy231, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy228 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy373, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy306 = yylhsminor.yy306;
+  yymsp[-9].minor.yy228 = yylhsminor.yy228;
         break;
       case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
 {
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
-  yylhsminor.yy306 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy231, yymsp[-1].minor.yy231, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+  yylhsminor.yy228 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy373, yymsp[-1].minor.yy373, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
 }
-  yymsp[-12].minor.yy306 = yylhsminor.yy306;
+  yymsp[-12].minor.yy228 = yylhsminor.yy228;
         break;
       case 148: /* tagNamelist ::= tagNamelist COMMA ids */
-{taosArrayPush(yymsp[-2].minor.yy231, &yymsp[0].minor.yy0); yylhsminor.yy231 = yymsp[-2].minor.yy231;  }
-  yymsp[-2].minor.yy231 = yylhsminor.yy231;
+{taosArrayPush(yymsp[-2].minor.yy373, &yymsp[0].minor.yy0); yylhsminor.yy373 = yymsp[-2].minor.yy373;  }
+  yymsp[-2].minor.yy373 = yylhsminor.yy373;
         break;
       case 149: /* tagNamelist ::= ids */
-{yylhsminor.yy231 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy231, &yymsp[0].minor.yy0);}
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+{yylhsminor.yy373 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy373, &yymsp[0].minor.yy0);}
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
         break;
       case 150: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-  yylhsminor.yy422 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy86, TSQL_CREATE_STREAM);
-  setSqlInfo(pInfo, yylhsminor.yy422, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy118 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy564, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, yylhsminor.yy118, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0);
 }
-  yymsp[-4].minor.yy422 = yylhsminor.yy422;
+  yymsp[-4].minor.yy118 = yylhsminor.yy118;
         break;
       case 151: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy231, &yymsp[0].minor.yy103); yylhsminor.yy231 = yymsp[-2].minor.yy231;  }
-  yymsp[-2].minor.yy231 = yylhsminor.yy231;
+{taosArrayPush(yymsp[-2].minor.yy373, &yymsp[0].minor.yy119); yylhsminor.yy373 = yymsp[-2].minor.yy373;  }
+  yymsp[-2].minor.yy373 = yylhsminor.yy373;
         break;
       case 152: /* columnlist ::= column */
-{yylhsminor.yy231 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy231, &yymsp[0].minor.yy103);}
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+{yylhsminor.yy373 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy373, &yymsp[0].minor.yy119);}
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
         break;
       case 153: /* column ::= ids typename */
 {
-  tSetColumnInfo(&yylhsminor.yy103, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy103);
+  tSetColumnInfo(&yylhsminor.yy119, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy119);
 }
-  yymsp[-1].minor.yy103 = yylhsminor.yy103;
+  yymsp[-1].minor.yy119 = yylhsminor.yy119;
         break;
       case 160: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy176, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy176 = yylhsminor.yy176;
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy186, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy186 = yylhsminor.yy186;
         break;
       case 161: /* tagitem ::= NOW */
-{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy176, &yymsp[0].minor.yy0, TK_NOW, true);}
-  yymsp[0].minor.yy176 = yylhsminor.yy176;
+{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy186, &yymsp[0].minor.yy0, TK_NOW, true);}
+  yymsp[0].minor.yy186 = yylhsminor.yy186;
         break;
       case 162: /* tagitem ::= NOW PLUS VARIABLE */
 {
     yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
-    tVariantCreateExt(&yymsp[-2].minor.yy176, &yymsp[0].minor.yy0, TK_PLUS, true);
+    tVariantCreateExt(&yymsp[-2].minor.yy186, &yymsp[0].minor.yy0, TK_PLUS, true);
 }
         break;
       case 163: /* tagitem ::= NOW MINUS VARIABLE */
 {
     yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
-    tVariantCreateExt(&yymsp[-2].minor.yy176, &yymsp[0].minor.yy0, TK_MINUS, true);
+    tVariantCreateExt(&yymsp[-2].minor.yy186, &yymsp[0].minor.yy0, TK_MINUS, true);
 }
         break;
       case 164: /* tagitem ::= MINUS INTEGER */
@@ -2825,56 +2849,56 @@ static void yy_reduce(
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy176, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy186, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy176 = yylhsminor.yy176;
+  yymsp[-1].minor.yy186 = yylhsminor.yy186;
         break;
       case 168: /* select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy86 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy231, yymsp[-12].minor.yy484, yymsp[-11].minor.yy226, yymsp[-4].minor.yy231, yymsp[-2].minor.yy231, &yymsp[-9].minor.yy430, &yymsp[-7].minor.yy409, &yymsp[-6].minor.yy228, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy231, &yymsp[0].minor.yy444, &yymsp[-1].minor.yy444, yymsp[-3].minor.yy226, &yymsp[-10].minor.yy480);
+  yylhsminor.yy564 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy373, yymsp[-12].minor.yy192, yymsp[-11].minor.yy46, yymsp[-4].minor.yy373, yymsp[-2].minor.yy373, &yymsp[-9].minor.yy376, &yymsp[-7].minor.yy435, &yymsp[-6].minor.yy32, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy373, &yymsp[0].minor.yy86, &yymsp[-1].minor.yy86, yymsp[-3].minor.yy46, &yymsp[-10].minor.yy229);
 }
-  yymsp[-14].minor.yy86 = yylhsminor.yy86;
+  yymsp[-14].minor.yy564 = yylhsminor.yy564;
         break;
       case 169: /* select ::= LP select RP */
-{yymsp[-2].minor.yy86 = yymsp[-1].minor.yy86;}
+{yymsp[-2].minor.yy564 = yymsp[-1].minor.yy564;}
         break;
       case 170: /* union ::= select */
-{ yylhsminor.yy231 = setSubclause(NULL, yymsp[0].minor.yy86); }
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+{ yylhsminor.yy373 = setSubclause(NULL, yymsp[0].minor.yy564); }
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
         break;
       case 171: /* union ::= union UNION ALL select */
-{ yylhsminor.yy231 = appendSelectClause(yymsp[-3].minor.yy231, yymsp[0].minor.yy86); }
-  yymsp[-3].minor.yy231 = yylhsminor.yy231;
+{ yylhsminor.yy373 = appendSelectClause(yymsp[-3].minor.yy373, yymsp[0].minor.yy564); }
+  yymsp[-3].minor.yy373 = yylhsminor.yy373;
         break;
       case 172: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy231, NULL, TSDB_SQL_SELECT); }
+{ setSqlInfo(pInfo, yymsp[0].minor.yy373, NULL, TSDB_SQL_SELECT); }
         break;
       case 173: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy86 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy231, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy564 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy373, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy86 = yylhsminor.yy86;
+  yymsp[-1].minor.yy564 = yylhsminor.yy564;
         break;
       case 174: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy231 = yymsp[-1].minor.yy231;}
-  yymsp[-1].minor.yy231 = yylhsminor.yy231;
+{yylhsminor.yy373 = yymsp[-1].minor.yy373;}
+  yymsp[-1].minor.yy373 = yylhsminor.yy373;
         break;
       case 175: /* sclp ::= */
       case 216: /* orderby_opt ::= */ yytestcase(yyruleno==216);
-{yymsp[1].minor.yy231 = 0;}
+{yymsp[1].minor.yy373 = 0;}
         break;
       case 176: /* selcollist ::= sclp distinct expr as */
 {
-   yylhsminor.yy231 = tSqlExprListAppend(yymsp[-3].minor.yy231, yymsp[-1].minor.yy226,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy373 = tSqlExprListAppend(yymsp[-3].minor.yy373, yymsp[-1].minor.yy46,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-3].minor.yy231 = yylhsminor.yy231;
+  yymsp[-3].minor.yy373 = yylhsminor.yy373;
         break;
       case 177: /* selcollist ::= sclp STAR */
 {
    tSqlExpr *pNode = tSqlExprCreateIdValue(pInfo, NULL, TK_ALL);
-   yylhsminor.yy231 = tSqlExprListAppend(yymsp[-1].minor.yy231, pNode, 0, 0);
+   yylhsminor.yy373 = tSqlExprListAppend(yymsp[-1].minor.yy373, pNode, 0, 0);
 }
-  yymsp[-1].minor.yy231 = yylhsminor.yy231;
+  yymsp[-1].minor.yy373 = yylhsminor.yy373;
         break;
       case 178: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
@@ -2892,114 +2916,114 @@ static void yy_reduce(
         break;
       case 183: /* from ::= FROM tablelist */
       case 184: /* from ::= FROM sub */ yytestcase(yyruleno==184);
-{yymsp[-1].minor.yy484 = yymsp[0].minor.yy484;}
+{yymsp[-1].minor.yy192 = yymsp[0].minor.yy192;}
         break;
       case 185: /* sub ::= LP union RP */
-{yymsp[-2].minor.yy484 = addSubqueryElem(NULL, yymsp[-1].minor.yy231, NULL);}
+{yymsp[-2].minor.yy192 = addSubqueryElem(NULL, yymsp[-1].minor.yy373, NULL);}
         break;
       case 186: /* sub ::= LP union RP ids */
-{yymsp[-3].minor.yy484 = addSubqueryElem(NULL, yymsp[-2].minor.yy231, &yymsp[0].minor.yy0);}
+{yymsp[-3].minor.yy192 = addSubqueryElem(NULL, yymsp[-2].minor.yy373, &yymsp[0].minor.yy0);}
         break;
       case 187: /* sub ::= sub COMMA LP union RP ids */
-{yylhsminor.yy484 = addSubqueryElem(yymsp[-5].minor.yy484, yymsp[-2].minor.yy231, &yymsp[0].minor.yy0);}
-  yymsp[-5].minor.yy484 = yylhsminor.yy484;
+{yylhsminor.yy192 = addSubqueryElem(yymsp[-5].minor.yy192, yymsp[-2].minor.yy373, &yymsp[0].minor.yy0);}
+  yymsp[-5].minor.yy192 = yylhsminor.yy192;
         break;
       case 188: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy484 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy192 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-1].minor.yy484 = yylhsminor.yy484;
+  yymsp[-1].minor.yy192 = yylhsminor.yy192;
         break;
       case 189: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy484 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy192 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy484 = yylhsminor.yy484;
+  yymsp[-2].minor.yy192 = yylhsminor.yy192;
         break;
       case 190: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy484 = setTableNameList(yymsp[-3].minor.yy484, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy192 = setTableNameList(yymsp[-3].minor.yy192, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-3].minor.yy484 = yylhsminor.yy484;
+  yymsp[-3].minor.yy192 = yylhsminor.yy192;
         break;
       case 191: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy484 = setTableNameList(yymsp[-4].minor.yy484, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy192 = setTableNameList(yymsp[-4].minor.yy192, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-4].minor.yy484 = yylhsminor.yy484;
+  yymsp[-4].minor.yy192 = yylhsminor.yy192;
         break;
       case 192: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
       case 193: /* timestamp ::= INTEGER */
-{ yylhsminor.yy226 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 194: /* timestamp ::= MINUS INTEGER */
       case 195: /* timestamp ::= PLUS INTEGER */ yytestcase(yyruleno==195);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy226 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy226 = yylhsminor.yy226;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy46 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy46 = yylhsminor.yy46;
         break;
       case 196: /* timestamp ::= STRING */
-{ yylhsminor.yy226 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 197: /* timestamp ::= NOW */
-{ yylhsminor.yy226 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 198: /* timestamp ::= NOW PLUS VARIABLE */
-{yymsp[-2].minor.yy226 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS);  }
+{yymsp[-2].minor.yy46 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS);  }
         break;
       case 199: /* timestamp ::= NOW MINUS VARIABLE */
-{yymsp[-2].minor.yy226 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
+{yymsp[-2].minor.yy46 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
         break;
       case 200: /* range_option ::= */
-{yymsp[1].minor.yy480.start = 0; yymsp[1].minor.yy480.end = 0;}
+{yymsp[1].minor.yy229.start = 0; yymsp[1].minor.yy229.end = 0;}
         break;
       case 201: /* range_option ::= RANGE LP timestamp COMMA timestamp RP */
-{yymsp[-5].minor.yy480.start = yymsp[-3].minor.yy226; yymsp[-5].minor.yy480.end = yymsp[-1].minor.yy226;}
+{yymsp[-5].minor.yy229.start = yymsp[-3].minor.yy46; yymsp[-5].minor.yy229.end = yymsp[-1].minor.yy46;}
         break;
       case 202: /* interval_option ::= intervalKey LP tmvar RP */
-{yylhsminor.yy430.interval = yymsp[-1].minor.yy0; yylhsminor.yy430.offset.n = 0; yylhsminor.yy430.token = yymsp[-3].minor.yy310;}
-  yymsp[-3].minor.yy430 = yylhsminor.yy430;
+{yylhsminor.yy376.interval = yymsp[-1].minor.yy0; yylhsminor.yy376.offset.n = 0; yylhsminor.yy376.token = yymsp[-3].minor.yy332;}
+  yymsp[-3].minor.yy376 = yylhsminor.yy376;
         break;
       case 203: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-{yylhsminor.yy430.interval = yymsp[-3].minor.yy0; yylhsminor.yy430.offset = yymsp[-1].minor.yy0;   yylhsminor.yy430.token = yymsp[-5].minor.yy310;}
-  yymsp[-5].minor.yy430 = yylhsminor.yy430;
+{yylhsminor.yy376.interval = yymsp[-3].minor.yy0; yylhsminor.yy376.offset = yymsp[-1].minor.yy0;   yylhsminor.yy376.token = yymsp[-5].minor.yy332;}
+  yymsp[-5].minor.yy376 = yylhsminor.yy376;
         break;
       case 204: /* interval_option ::= */
-{memset(&yymsp[1].minor.yy430, 0, sizeof(yymsp[1].minor.yy430));}
+{memset(&yymsp[1].minor.yy376, 0, sizeof(yymsp[1].minor.yy376));}
         break;
       case 205: /* intervalKey ::= INTERVAL */
-{yymsp[0].minor.yy310 = TK_INTERVAL;}
+{yymsp[0].minor.yy332 = TK_INTERVAL;}
         break;
       case 206: /* intervalKey ::= EVERY */
-{yymsp[0].minor.yy310 = TK_EVERY;   }
+{yymsp[0].minor.yy332 = TK_EVERY;   }
         break;
       case 207: /* session_option ::= */
-{yymsp[1].minor.yy409.col.n = 0; yymsp[1].minor.yy409.gap.n = 0;}
+{yymsp[1].minor.yy435.col.n = 0; yymsp[1].minor.yy435.gap.n = 0;}
         break;
       case 208: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
 {
    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-   yymsp[-6].minor.yy409.col = yymsp[-4].minor.yy0;
-   yymsp[-6].minor.yy409.gap = yymsp[-1].minor.yy0;
+   yymsp[-6].minor.yy435.col = yymsp[-4].minor.yy0;
+   yymsp[-6].minor.yy435.gap = yymsp[-1].minor.yy0;
 }
         break;
       case 209: /* windowstate_option ::= */
-{ yymsp[1].minor.yy228.col.n = 0; yymsp[1].minor.yy228.col.z = NULL;}
+{ yymsp[1].minor.yy32.col.n = 0; yymsp[1].minor.yy32.col.z = NULL;}
         break;
       case 210: /* windowstate_option ::= STATE_WINDOW LP ids RP */
-{ yymsp[-3].minor.yy228.col = yymsp[-1].minor.yy0; }
+{ yymsp[-3].minor.yy32.col = yymsp[-1].minor.yy0; }
         break;
       case 211: /* fill_opt ::= */
-{ yymsp[1].minor.yy231 = 0;     }
+{ yymsp[1].minor.yy373 = 0;     }
         break;
       case 212: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
@@ -3007,14 +3031,14 @@ static void yy_reduce(
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy231, &A, -1, 0);
-    yymsp[-5].minor.yy231 = yymsp[-1].minor.yy231;
+    tVariantListInsert(yymsp[-1].minor.yy373, &A, -1, 0);
+    yymsp[-5].minor.yy373 = yymsp[-1].minor.yy373;
 }
         break;
       case 213: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy231 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
+    yymsp[-3].minor.yy373 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
 }
         break;
       case 214: /* sliding_opt ::= SLIDING LP tmvar RP */
@@ -3024,313 +3048,332 @@ static void yy_reduce(
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
       case 217: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy231 = yymsp[0].minor.yy231;}
+{yymsp[-2].minor.yy373 = yymsp[0].minor.yy373;}
         break;
       case 218: /* sortlist ::= sortlist COMMA item sortorder */
 {
-  yylhsminor.yy231 = commonItemAppend(yymsp[-3].minor.yy231, &yymsp[-1].minor.yy176, NULL, false, yymsp[0].minor.yy502);
+  yylhsminor.yy373 = commonItemAppend(yymsp[-3].minor.yy373, &yymsp[-1].minor.yy186, NULL, false, yymsp[0].minor.yy20);
 }
-  yymsp[-3].minor.yy231 = yylhsminor.yy231;
+  yymsp[-3].minor.yy373 = yylhsminor.yy373;
         break;
       case 219: /* sortlist ::= sortlist COMMA arrow sortorder */
 {
-  yylhsminor.yy231 = commonItemAppend(yymsp[-3].minor.yy231, NULL, yymsp[-1].minor.yy226, true, yymsp[0].minor.yy502);
+  yylhsminor.yy373 = commonItemAppend(yymsp[-3].minor.yy373, NULL, yymsp[-1].minor.yy46, true, yymsp[0].minor.yy20);
 }
-  yymsp[-3].minor.yy231 = yylhsminor.yy231;
+  yymsp[-3].minor.yy373 = yylhsminor.yy373;
         break;
       case 220: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy231 = commonItemAppend(NULL, &yymsp[-1].minor.yy176, NULL, false, yymsp[0].minor.yy502);
+  yylhsminor.yy373 = commonItemAppend(NULL, &yymsp[-1].minor.yy186, NULL, false, yymsp[0].minor.yy20);
 }
-  yymsp[-1].minor.yy231 = yylhsminor.yy231;
+  yymsp[-1].minor.yy373 = yylhsminor.yy373;
         break;
       case 221: /* sortlist ::= arrow sortorder */
 {
-  yylhsminor.yy231 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy226, true, yymsp[0].minor.yy502);
+  yylhsminor.yy373 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy46, true, yymsp[0].minor.yy20);
 }
-  yymsp[-1].minor.yy231 = yylhsminor.yy231;
+  yymsp[-1].minor.yy373 = yylhsminor.yy373;
         break;
       case 222: /* item ::= ID */
 {
   toTSDBType(yymsp[0].minor.yy0.type);
-  tVariantCreate(&yylhsminor.yy176, &yymsp[0].minor.yy0);
+  tVariantCreate(&yylhsminor.yy186, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy176 = yylhsminor.yy176;
+  yymsp[0].minor.yy186 = yylhsminor.yy186;
         break;
       case 223: /* item ::= ID DOT ID */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n);
-  tVariantCreate(&yylhsminor.yy176, &yymsp[-2].minor.yy0);
+  tVariantCreate(&yylhsminor.yy186, &yymsp[-2].minor.yy0);
 }
-  yymsp[-2].minor.yy176 = yylhsminor.yy176;
+  yymsp[-2].minor.yy186 = yylhsminor.yy186;
         break;
       case 224: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy502 = TSDB_ORDER_ASC; }
+{ yymsp[0].minor.yy20 = TSDB_ORDER_ASC; }
         break;
       case 225: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy502 = TSDB_ORDER_DESC;}
+{ yymsp[0].minor.yy20 = TSDB_ORDER_DESC;}
         break;
       case 226: /* sortorder ::= */
-{ yymsp[1].minor.yy502 = TSDB_ORDER_ASC; }
+{ yymsp[1].minor.yy20 = TSDB_ORDER_ASC; }
         break;
       case 227: /* groupby_opt ::= */
-{ yymsp[1].minor.yy231 = 0;}
+{ yymsp[1].minor.yy373 = 0;}
         break;
       case 228: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy231 = yymsp[0].minor.yy231;}
+{ yymsp[-2].minor.yy373 = yymsp[0].minor.yy373;}
         break;
       case 229: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy231 = commonItemAppend(yymsp[-2].minor.yy231, &yymsp[0].minor.yy176, NULL, false, -1);
+  yylhsminor.yy373 = commonItemAppend(yymsp[-2].minor.yy373, &yymsp[0].minor.yy186, NULL, false, -1);
 }
-  yymsp[-2].minor.yy231 = yylhsminor.yy231;
+  yymsp[-2].minor.yy373 = yylhsminor.yy373;
         break;
       case 230: /* grouplist ::= grouplist COMMA arrow */
 {
-  yylhsminor.yy231 = commonItemAppend(yymsp[-2].minor.yy231, NULL, yymsp[0].minor.yy226, true, -1);
+  yylhsminor.yy373 = commonItemAppend(yymsp[-2].minor.yy373, NULL, yymsp[0].minor.yy46, true, -1);
 }
-  yymsp[-2].minor.yy231 = yylhsminor.yy231;
+  yymsp[-2].minor.yy373 = yylhsminor.yy373;
         break;
       case 231: /* grouplist ::= item */
 {
-  yylhsminor.yy231 = commonItemAppend(NULL, &yymsp[0].minor.yy176, NULL, false, -1);
+  yylhsminor.yy373 = commonItemAppend(NULL, &yymsp[0].minor.yy186, NULL, false, -1);
 }
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
         break;
       case 232: /* grouplist ::= arrow */
 {
-  yylhsminor.yy231 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy226, true, -1);
+  yylhsminor.yy373 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy46, true, -1);
 }
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
         break;
       case 233: /* having_opt ::= */
       case 243: /* where_opt ::= */ yytestcase(yyruleno==243);
-      case 294: /* expritem ::= */ yytestcase(yyruleno==294);
-{yymsp[1].minor.yy226 = 0;}
+      case 299: /* expritem ::= */ yytestcase(yyruleno==299);
+{yymsp[1].minor.yy46 = 0;}
         break;
       case 234: /* having_opt ::= HAVING expr */
       case 244: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==244);
-{yymsp[-1].minor.yy226 = yymsp[0].minor.yy226;}
+{yymsp[-1].minor.yy46 = yymsp[0].minor.yy46;}
         break;
       case 235: /* limit_opt ::= */
       case 239: /* slimit_opt ::= */ yytestcase(yyruleno==239);
-{yymsp[1].minor.yy444.limit = -1; yymsp[1].minor.yy444.offset = 0;}
+{yymsp[1].minor.yy86.limit = -1; yymsp[1].minor.yy86.offset = 0;}
         break;
       case 236: /* limit_opt ::= LIMIT signed */
       case 240: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==240);
-{yymsp[-1].minor.yy444.limit = yymsp[0].minor.yy549;  yymsp[-1].minor.yy444.offset = 0;}
+{yymsp[-1].minor.yy86.limit = yymsp[0].minor.yy129;  yymsp[-1].minor.yy86.offset = 0;}
         break;
       case 237: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy444.limit = yymsp[-2].minor.yy549;  yymsp[-3].minor.yy444.offset = yymsp[0].minor.yy549;}
+{ yymsp[-3].minor.yy86.limit = yymsp[-2].minor.yy129;  yymsp[-3].minor.yy86.offset = yymsp[0].minor.yy129;}
         break;
       case 238: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy444.limit = yymsp[0].minor.yy549;  yymsp[-3].minor.yy444.offset = yymsp[-2].minor.yy549;}
+{ yymsp[-3].minor.yy86.limit = yymsp[0].minor.yy129;  yymsp[-3].minor.yy86.offset = yymsp[-2].minor.yy129;}
         break;
       case 241: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy444.limit = yymsp[-2].minor.yy549;  yymsp[-3].minor.yy444.offset = yymsp[0].minor.yy549;}
+{yymsp[-3].minor.yy86.limit = yymsp[-2].minor.yy129;  yymsp[-3].minor.yy86.offset = yymsp[0].minor.yy129;}
         break;
       case 242: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy444.limit = yymsp[0].minor.yy549;  yymsp[-3].minor.yy444.offset = yymsp[-2].minor.yy549;}
+{yymsp[-3].minor.yy86.limit = yymsp[0].minor.yy129;  yymsp[-3].minor.yy86.offset = yymsp[-2].minor.yy129;}
         break;
       case 245: /* expr ::= LP expr RP */
-{yylhsminor.yy226 = yymsp[-1].minor.yy226; yylhsminor.yy226->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy226->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = yymsp[-1].minor.yy46; yylhsminor.yy46->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy46->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 246: /* expr ::= ID */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 247: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 248: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 249: /* expr ::= INTEGER */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 250: /* expr ::= MINUS INTEGER */
       case 251: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==251);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy226 = yylhsminor.yy226;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy46 = yylhsminor.yy46;
         break;
       case 252: /* expr ::= FLOAT */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 253: /* expr ::= MINUS FLOAT */
       case 254: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==254);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy226 = yylhsminor.yy226;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy46 = yylhsminor.yy46;
         break;
       case 255: /* expr ::= STRING */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 256: /* expr ::= NOW */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 257: /* expr ::= VARIABLE */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 258: /* expr ::= PLUS VARIABLE */
       case 259: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==259);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
-  yymsp[-1].minor.yy226 = yylhsminor.yy226;
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
+  yymsp[-1].minor.yy46 = yylhsminor.yy46;
         break;
       case 260: /* expr ::= BOOL */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 261: /* expr ::= NULL */
-{ yylhsminor.yy226 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+{ yylhsminor.yy46 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
         break;
       case 262: /* expr ::= ID LP exprlist RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy226 = tSqlExprCreateFunction(yymsp[-1].minor.yy231, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy226 = yylhsminor.yy226;
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy46 = tSqlExprCreateFunction(yymsp[-1].minor.yy373, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy46 = yylhsminor.yy46;
         break;
       case 263: /* expr ::= ID LP STAR RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy226 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy226 = yylhsminor.yy226;
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy46 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy46 = yylhsminor.yy46;
         break;
       case 264: /* expr ::= ID LP expr AS typename RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy226 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy226, &yymsp[-1].minor.yy103, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
-  yymsp[-5].minor.yy226 = yylhsminor.yy226;
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy46 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy46, &yymsp[-1].minor.yy119, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
+  yymsp[-5].minor.yy46 = yylhsminor.yy46;
         break;
       case 265: /* expr ::= expr IS NULL */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 266: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-3].minor.yy226, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-3].minor.yy46, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy46 = yylhsminor.yy46;
         break;
       case 267: /* expr ::= expr LT expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_LT);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LT);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 268: /* expr ::= expr GT expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_GT);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_GT);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 269: /* expr ::= expr LE expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_LE);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LE);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 270: /* expr ::= expr GE expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_GE);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_GE);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 271: /* expr ::= expr NE expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_NE);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_NE);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 272: /* expr ::= expr EQ expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_EQ);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_EQ);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 273: /* expr ::= expr BETWEEN expr AND expr */
-{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy226); yylhsminor.yy226 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy226, yymsp[-2].minor.yy226, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy226, TK_LE), TK_AND);}
-  yymsp[-4].minor.yy226 = yylhsminor.yy226;
+{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy46); yylhsminor.yy46 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy46, yymsp[-2].minor.yy46, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy46, TK_LE), TK_AND);}
+  yymsp[-4].minor.yy46 = yylhsminor.yy46;
         break;
       case 274: /* expr ::= expr AND expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_AND);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_AND);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 275: /* expr ::= expr OR expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_OR); }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_OR); }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 276: /* expr ::= expr PLUS expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_PLUS);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_PLUS);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 277: /* expr ::= expr MINUS expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_MINUS); }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_MINUS); }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 278: /* expr ::= expr STAR expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_STAR);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_STAR);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 279: /* expr ::= expr SLASH expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_DIVIDE);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_DIVIDE);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 280: /* expr ::= expr REM expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_REM);   }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_REM);   }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
       case 281: /* expr ::= expr BITAND expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_BITAND);}
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_BITAND);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 282: /* expr ::= expr LIKE expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_LIKE);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+      case 282: /* expr ::= expr BITOR expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_BITOR); }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 283: /* expr ::= expr MATCH expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_MATCH);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+      case 283: /* expr ::= expr BITXOR expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_BITXOR);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 284: /* expr ::= expr NMATCH expr */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-2].minor.yy226, yymsp[0].minor.yy226, TK_NMATCH);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+      case 284: /* expr ::= BITNOT expr */
+{yymsp[-1].minor.yy46 = tSqlExprCreate(yymsp[0].minor.yy46, NULL, TK_BITNOT);}
         break;
-      case 285: /* expr ::= ID CONTAINS STRING */
-{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy226 = tSqlExprCreate(S, M, TK_CONTAINS);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+      case 285: /* expr ::= expr LSHIFT expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LSHIFT);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 286: /* expr ::= ID DOT ID CONTAINS STRING */
-{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy226 = tSqlExprCreate(S, M, TK_CONTAINS);  }
-  yymsp[-4].minor.yy226 = yylhsminor.yy226;
+      case 286: /* expr ::= expr RSHIFT expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_RSHIFT);}
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 287: /* arrow ::= ID ARROW STRING */
-{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy226 = tSqlExprCreate(S, M, TK_ARROW);  }
-  yymsp[-2].minor.yy226 = yylhsminor.yy226;
+      case 287: /* expr ::= expr LIKE expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LIKE);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 288: /* arrow ::= ID DOT ID ARROW STRING */
-{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy226 = tSqlExprCreate(S, M, TK_ARROW);  }
-  yymsp[-4].minor.yy226 = yylhsminor.yy226;
+      case 288: /* expr ::= expr MATCH expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_MATCH);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 289: /* expr ::= arrow */
-      case 293: /* expritem ::= expr */ yytestcase(yyruleno==293);
-{yylhsminor.yy226 = yymsp[0].minor.yy226;}
-  yymsp[0].minor.yy226 = yylhsminor.yy226;
+      case 289: /* expr ::= expr NMATCH expr */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_NMATCH);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 290: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy226 = tSqlExprCreate(yymsp[-4].minor.yy226, (tSqlExpr*)yymsp[-1].minor.yy231, TK_IN); }
-  yymsp[-4].minor.yy226 = yylhsminor.yy226;
+      case 290: /* expr ::= ID CONTAINS STRING */
+{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy46 = tSqlExprCreate(S, M, TK_CONTAINS);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 291: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy231 = tSqlExprListAppend(yymsp[-2].minor.yy231,yymsp[0].minor.yy226,0, 0);}
-  yymsp[-2].minor.yy231 = yylhsminor.yy231;
+      case 291: /* expr ::= ID DOT ID CONTAINS STRING */
+{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy46 = tSqlExprCreate(S, M, TK_CONTAINS);  }
+  yymsp[-4].minor.yy46 = yylhsminor.yy46;
         break;
-      case 292: /* exprlist ::= expritem */
-{yylhsminor.yy231 = tSqlExprListAppend(0,yymsp[0].minor.yy226,0, 0);}
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+      case 292: /* arrow ::= ID ARROW STRING */
+{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy46 = tSqlExprCreate(S, M, TK_ARROW);  }
+  yymsp[-2].minor.yy46 = yylhsminor.yy46;
         break;
-      case 295: /* cmd ::= RESET QUERY CACHE */
+      case 293: /* arrow ::= ID DOT ID ARROW STRING */
+{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy46 = tSqlExprCreate(S, M, TK_ARROW);  }
+  yymsp[-4].minor.yy46 = yylhsminor.yy46;
+        break;
+      case 294: /* expr ::= arrow */
+      case 298: /* expritem ::= expr */ yytestcase(yyruleno==298);
+{yylhsminor.yy46 = yymsp[0].minor.yy46;}
+  yymsp[0].minor.yy46 = yylhsminor.yy46;
+        break;
+      case 295: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy46 = tSqlExprCreate(yymsp[-4].minor.yy46, (tSqlExpr*)yymsp[-1].minor.yy373, TK_IN); }
+  yymsp[-4].minor.yy46 = yylhsminor.yy46;
+        break;
+      case 296: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy373 = tSqlExprListAppend(yymsp[-2].minor.yy373,yymsp[0].minor.yy46,0, 0);}
+  yymsp[-2].minor.yy373 = yylhsminor.yy373;
+        break;
+      case 297: /* exprlist ::= expritem */
+{yylhsminor.yy373 = tSqlExprListAppend(0,yymsp[0].minor.yy46,0, 0);}
+  yymsp[0].minor.yy373 = yylhsminor.yy373;
+        break;
+      case 300: /* cmd ::= RESET QUERY CACHE */
 { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 296: /* cmd ::= SYNCDB ids REPLICA */
+      case 301: /* cmd ::= SYNCDB ids REPLICA */
 { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
         break;
-      case 297: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 302: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 298: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 303: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3341,21 +3384,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 299: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+      case 304: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 300: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 305: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 301: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 306: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3366,7 +3409,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 302: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 307: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3380,33 +3423,33 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 303: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 308: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy176, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy186, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 304: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+      case 309: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 305: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+      case 310: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 306: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+      case 311: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3417,21 +3460,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 307: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+      case 312: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 308: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+      case 313: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 309: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+      case 314: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3442,7 +3485,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 310: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+      case 315: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3456,32 +3499,32 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 311: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+      case 316: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy176, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy186, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 312: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+      case 317: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy231, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy373, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 313: /* cmd ::= KILL CONNECTION INTEGER */
+      case 318: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 314: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 319: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 315: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 320: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index e559839e3e48f953bbb2890f56d92b820411bdf5..2abeed87a6acc22bf2006d02050ce5924f2c47e6 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -173,6 +173,11 @@ typedef struct SRange {
   int32_t to;
 } SRange;
 
+typedef struct STagBlockInfo {
+  SSkipListNode *pSkipListNode;
+  SArray *pBlock;
+} STagBlockInfo;
+
 static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
 static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
 static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle);
@@ -4334,7 +4339,15 @@ static FORCE_INLINE int32_t tsdbGetTagDataFromId(void *param, int32_t id, void *
   return TSDB_CODE_SUCCESS;
 }
 
-
+static FORCE_INLINE int32_t tsdbGetTagData(void *param, int32_t id, void **data) {
+  STagBlockInfo* pInfo = (STagBlockInfo*) param;
+  if (id == INT32_MAX) {
+   *data = pInfo->pBlock;
+  } else {
+    return tsdbGetTagDataFromId(pInfo->pSkipListNode, id, data);
+  }
+  return TSDB_CODE_SUCCESS;
+}
 
 static void queryIndexedColumn(SSkipList* pSkipList, void* filterInfo, SArray* res) {
   SSkipListIterator* iter = NULL;
@@ -4389,26 +4402,77 @@ static void queryIndexedColumn(SSkipList* pSkipList, void* filterInfo, SArray* r
   tsdbDebug("filter index column end");
 }
 
+static void getAllExprColId(tExprNode* pExpr, SArray* array) {
+  if (!pExpr) {
+    return;
+  }
+  if (pExpr->nodeType == TSQL_NODE_FUNC) {
+    for (int32_t i = 0; i < pExpr->_func.numChildren; ++i) {
+      getAllExprColId(pExpr->_func.pChildren[i], array);
+    }
+  } else if (pExpr->nodeType == TSQL_NODE_EXPR) {
+    getAllExprColId(pExpr->_node.pLeft, array);
+    getAllExprColId(pExpr->_node.pRight, array);
+  } else if (pExpr->nodeType == TSQL_NODE_COL) {
+    taosArrayPush(array, &pExpr->pSchema->colId);
+  }
+}
+
+static void getAllFilterExprColId(SFilterFields* pSf, SArray* array) {
+  for (uint32_t i = 0; i < pSf->num; ++i) {
+    SFilterField* fi = &(pSf->fields[i]);
+    if (FILTER_GET_TYPE(fi->flag) == FLD_TYPE_EXPR) {
+      getAllExprColId(fi->desc, array);
+    }
+  }
+  taosArraySort(array, getComparFunc(TSDB_DATA_TYPE_SMALLINT, 0));
+  taosArrayRemoveDuplicate(array, getComparFunc(TSDB_DATA_TYPE_SMALLINT, 0), NULL);
+}
+
 static void queryIndexlessColumn(SSkipList* pSkipList, void* filterInfo, SArray* res) {
   SSkipListIterator* iter = tSkipListCreateIter(pSkipList);
   int8_t *addToResult = NULL;
+  SFilterInfo *sfInfo = (SFilterInfo *)filterInfo;
+  SArray *array = NULL;
+  SArray *pDataBlock = NULL;
 
+  if (sfInfo->fields[FLD_TYPE_EXPR].num > 0) {
+    array = taosArrayInit(10, sizeof(int16_t));
+    getAllFilterExprColId(&(sfInfo->fields[FLD_TYPE_EXPR]), array);
+  }
   while (tSkipListIterNext(iter)) {
 
     SSkipListNode *pNode = tSkipListIterGet(iter);
 
-    filterSetColFieldData(filterInfo, pNode, tsdbGetTagDataFromId);
 
-    char *pData = SL_GET_NODE_DATA(pNode);
+    if (sfInfo->fields[FLD_TYPE_EXPR].num > 0) {
+      pDataBlock = taosArrayInit(10, sizeof(SColumnInfoData));
+      size_t num = taosArrayGetSize(array);
+      for(int32_t i = 0; i < num; ++i) {
+        int16_t *pColId = taosArrayGet(array, i);
+        void *data = NULL;
+        tsdbGetTagDataFromId(pNode, *pColId, &data);
+        SColumnInfoData colData = {{0}};
+        colData.pData = data;
+        colData.info.colId = *pColId;
+        taosArrayPush(pDataBlock, &colData);
+      }
+    }
+    STagBlockInfo stInfo = {.pSkipListNode = pNode, .pBlock = pDataBlock};
+    filterSetColFieldData(filterInfo, &stInfo, tsdbGetTagData);
 
-    bool all = filterExecute(filterInfo, 1, &addToResult, NULL, 0);
+    char *pData = SL_GET_NODE_DATA(pNode);
+    int16_t numOfCols = array ? (int16_t)taosArrayGetSize(array) : 0;
+    bool all = filterExecute(filterInfo, 1, &addToResult, NULL, numOfCols);
 
     if (all || (addToResult && *addToResult)) {
       STableKeyInfo info = {.pTable = (void*)pData, .lastKey = TSKEY_INITIAL_VAL};
       taosArrayPush(res, &info);
     }
+    taosArrayDestroy(&pDataBlock);
   }
 
+  taosArrayDestroy(&array);
   tfree(addToResult);
 
   tSkipListDestroyIter(iter);
diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c
index 2b6307aae82d0cce2c8d5fd4d8973b85ed7821cb..21ad7b8c4e3226eb5be8db837dff67d8f27c9d2e 100644
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
@@ -413,6 +413,10 @@ uint32_t tGetToken(char* z, uint32_t* tokenId) {
       *tokenId = TK_BITNOT;
       return 1;
     }
+    case '^': {
+      *tokenId = TK_BITXOR;
+      return 1;
+    }
     case '?': {
       *tokenId = TK_QUESTION;
       return 1;