From 13735d725715922aba2a8881ace4c52a992f635c Mon Sep 17 00:00:00 2001
From: Xiaoyu Wang <xiaoyuwang@taosdata.com>
Date: Wed, 13 Apr 2022 19:04:25 +0800
Subject: [PATCH 01/11] feat(query): distributed splitting of child/normal
 table JOIN

---
 include/libs/nodes/nodes.h                    |   1 +
 source/libs/executor/src/scanoperator.c       |   2 +-
 source/libs/nodes/src/nodesTraverseFuncs.c    |  50 ++--
 source/libs/parser/src/parAstCreater.c        |  22 +-
 .../libs/parser/test/mockCatalogService.cpp   |  11 +-
 source/libs/planner/src/planLogicCreater.c    |   1 -
 source/libs/planner/src/planOptimizer.c       | 244 ++++++++++++++++--
 source/libs/planner/src/planSpliter.c         | 147 ++++++++---
 source/libs/planner/test/plannerTest.cpp      |  16 +-
 9 files changed, 396 insertions(+), 98 deletions(-)

diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index 3a1d7954a7..4ffacf3787 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -231,6 +231,7 @@ typedef enum EDealRes {
   DEAL_RES_CONTINUE = 1,
   DEAL_RES_IGNORE_CHILD,
   DEAL_RES_ERROR,
+  DEAL_RES_END
 } EDealRes;
 
 typedef EDealRes (*FNodeWalker)(SNode* pNode, void* pContext);
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index 4179999c4b..5079a49a62 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -548,7 +548,7 @@ EDealRes getDBNameFromConditionWalker(SNode* pNode, void* pContext) {
       char*       dbName = nodesGetValueFromNode(node);
       strncpy(pContext, varDataVal(dbName), varDataLen(dbName));
       *((char*)pContext + varDataLen(dbName)) = 0;
-      return DEAL_RES_ERROR;  // stop walk
+      return DEAL_RES_END;  // stop walk
     }
     default:
       break;
diff --git a/source/libs/nodes/src/nodesTraverseFuncs.c b/source/libs/nodes/src/nodesTraverseFuncs.c
index 4a782cce08..99a08923bb 100644
--- a/source/libs/nodes/src/nodesTraverseFuncs.c
+++ b/source/libs/nodes/src/nodesTraverseFuncs.c
@@ -46,7 +46,7 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
     case QUERY_NODE_OPERATOR: {
       SOperatorNode* pOpNode = (SOperatorNode*)pNode;
       res = walkNode(pOpNode->pLeft, order, walker, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pOpNode->pRight, order, walker, pContext);
       }
       break;
@@ -63,10 +63,10 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
     case QUERY_NODE_JOIN_TABLE: {
       SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
       res = walkNode(pJoinTableNode->pLeft, order, walker, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pJoinTableNode->pRight, order, walker, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pJoinTableNode->pOnCond, order, walker, pContext);
       }
       break;
@@ -80,7 +80,7 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
     case QUERY_NODE_STATE_WINDOW: {
       SStateWindowNode* pState = (SStateWindowNode*)pNode;
       res = walkNode(pState->pExpr, order, walker, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pState->pCol, order, walker, pContext);
       }
       break;
@@ -88,7 +88,7 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
     case QUERY_NODE_SESSION_WINDOW: {
       SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
       res = walkNode(pSession->pCol, order, walker, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pSession->pGap, order, walker, pContext);
       }
       break;
@@ -96,16 +96,16 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
     case QUERY_NODE_INTERVAL_WINDOW: {
       SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
       res = walkNode(pInterval->pInterval, order, walker, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pInterval->pOffset, order, walker, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pInterval->pSliding, order, walker, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pInterval->pFill, order, walker, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = walkNode(pInterval->pCol, order, walker, pContext);
       }
       break;
@@ -126,7 +126,7 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
       break;
   }
 
-  if (DEAL_RES_ERROR != res && TRAVERSAL_POSTORDER == order) {
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {
     res = walker(pNode, pContext);
   }
 
@@ -136,8 +136,9 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
 static EDealRes walkList(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {
   SNode* node;
   FOREACH(node, pNodeList) {
-    if (DEAL_RES_ERROR == walkNode(node, order, walker, pContext)) {
-      return DEAL_RES_ERROR;
+    EDealRes res = walkNode(node, order, walker, pContext);
+    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
+      return res;
     }
   }
   return DEAL_RES_CONTINUE;
@@ -185,7 +186,7 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
     case QUERY_NODE_OPERATOR: {
       SOperatorNode* pOpNode = (SOperatorNode*)pNode;
       res = rewriteNode(&(pOpNode->pLeft), order, rewriter, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pOpNode->pRight), order, rewriter, pContext);
       }
       break;
@@ -202,10 +203,10 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
     case QUERY_NODE_JOIN_TABLE: {
       SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
       res = rewriteNode(&(pJoinTableNode->pLeft), order, rewriter, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pJoinTableNode->pRight), order, rewriter, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pJoinTableNode->pOnCond), order, rewriter, pContext);
       }
       break;
@@ -219,7 +220,7 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
     case QUERY_NODE_STATE_WINDOW: {
       SStateWindowNode* pState = (SStateWindowNode*)pNode;
       res = rewriteNode(&pState->pExpr, order, rewriter, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&pState->pCol, order, rewriter, pContext);
       }
       break;
@@ -227,7 +228,7 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
     case QUERY_NODE_SESSION_WINDOW: {
       SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
       res = rewriteNode(&pSession->pCol, order, rewriter, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&pSession->pGap, order, rewriter, pContext);
       }
       break;
@@ -235,16 +236,16 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
     case QUERY_NODE_INTERVAL_WINDOW: {
       SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
       res = rewriteNode(&(pInterval->pInterval), order, rewriter, pContext);
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pInterval->pOffset), order, rewriter, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pInterval->pSliding), order, rewriter, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pInterval->pFill), order, rewriter, pContext);
       }
-      if (DEAL_RES_ERROR != res) {
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
         res = rewriteNode(&(pInterval->pCol), order, rewriter, pContext);
       }
       break;
@@ -265,7 +266,7 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
       break;
   }
 
-  if (DEAL_RES_ERROR != res && TRAVERSAL_POSTORDER == order) {
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {
     res = rewriter(pRawNode, pContext);
   }
 
@@ -275,8 +276,9 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
 static EDealRes rewriteList(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
   SNode** pNode;
   FOREACH_FOR_REWRITE(pNode, pNodeList) {
-    if (DEAL_RES_ERROR == rewriteNode(pNode, order, rewriter, pContext)) {
-      return DEAL_RES_ERROR;
+    EDealRes res = rewriteNode(pNode, order, rewriter, pContext);
+    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
+      return res;
     }
   }
   return DEAL_RES_CONTINUE;
diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c
index 318f7ca5f7..9a26e38c98 100644
--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@@ -328,8 +328,26 @@ SNode* createLogicConditionNode(SAstCreateContext* pCxt, ELogicConditionType typ
   CHECK_OUT_OF_MEM(cond);
   cond->condType = type;
   cond->pParameterList = nodesMakeList();
-  nodesListAppend(cond->pParameterList, pParam1);
-  nodesListAppend(cond->pParameterList, pParam2);
+  if ((QUERY_NODE_LOGIC_CONDITION == nodeType(pParam1) && type != ((SLogicConditionNode*)pParam1)->condType) ||
+      (QUERY_NODE_LOGIC_CONDITION == nodeType(pParam2) && type != ((SLogicConditionNode*)pParam2)->condType)) {
+    nodesListAppend(cond->pParameterList, pParam1);
+    nodesListAppend(cond->pParameterList, pParam2);
+  } else {
+    if (QUERY_NODE_LOGIC_CONDITION == nodeType(pParam1)) {
+      nodesListAppendList(cond->pParameterList, ((SLogicConditionNode*)pParam1)->pParameterList);
+      ((SLogicConditionNode*)pParam1)->pParameterList = NULL;
+      nodesDestroyNode(pParam1);
+    } else {
+      nodesListAppend(cond->pParameterList, pParam1);
+    }
+    if (QUERY_NODE_LOGIC_CONDITION == nodeType(pParam2)) {
+      nodesListAppendList(cond->pParameterList, ((SLogicConditionNode*)pParam2)->pParameterList);
+      ((SLogicConditionNode*)pParam2)->pParameterList = NULL;
+      nodesDestroyNode(pParam2);
+    } else {
+      nodesListAppend(cond->pParameterList, pParam2);
+    }
+  }
   return (SNode*)cond;
 }
 
diff --git a/source/libs/parser/test/mockCatalogService.cpp b/source/libs/parser/test/mockCatalogService.cpp
index 402caeb252..3da3678563 100644
--- a/source/libs/parser/test/mockCatalogService.cpp
+++ b/source/libs/parser/test/mockCatalogService.cpp
@@ -146,6 +146,7 @@ public:
     meta_[db][tbname].reset(new MockTableMeta());
     meta_[db][tbname]->schema = table.release();
     meta_[db][tbname]->schema->uid = id_++;
+    meta_[db][tbname]->schema->tableType = TSDB_CHILD_TABLE;
 
     SVgroupInfo vgroup = {.vgId = vgid, .hashBegin = 0, .hashEnd = 0,};
     addEpIntoEpSet(&vgroup.epSet, "dnode_1", 6030);
@@ -197,11 +198,11 @@ public:
         std::cout << "Table:" << table.first << std::endl;
         std::cout << SH("Field") << SH("Type") << SH("DataType") << IH("Bytes") << std::endl;
         std::cout << SL(3, 1) << std::endl;
-        int16_t numOfTags = schema->tableInfo.numOfTags;
-        int16_t numOfFields = numOfTags + schema->tableInfo.numOfColumns;
+        int16_t numOfColumns = schema->tableInfo.numOfColumns;
+        int16_t numOfFields = numOfColumns + schema->tableInfo.numOfTags;
         for (int16_t i = 0; i < numOfFields; ++i) {
           const SSchema* col = schema->schema + i;
-          std::cout << SF(std::string(col->name)) << SH(ftToString(i, numOfTags)) << SH(dtToString(col->type)) << IF(col->bytes) << std::endl;
+          std::cout << SF(std::string(col->name)) << SH(ftToString(i, numOfColumns)) << SH(dtToString(col->type)) << IF(col->bytes) << std::endl;
         }
         std::cout << std::endl;
       }
@@ -262,8 +263,8 @@ private:
     return tDataTypes[type].name;
   }
 
-  std::string ftToString(int16_t colid, int16_t numOfTags) const {
-    return (0 == colid ? "column" : (colid <= numOfTags ? "tag" : "column"));
+  std::string ftToString(int16_t colid, int16_t numOfColumns) const {
+    return (0 == colid ? "column" : (colid <= numOfColumns ? "tag" : "column"));
   }
 
   STableMeta* getTableSchemaMeta(const std::string& db, const std::string& tbname) const {
diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c
index 1d8400e1eb..3c60b62434 100644
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@@ -694,7 +694,6 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
   }
 
   return code;
-  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t createDistinctLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) {
diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c
index c56e113d40..19e6718fe8 100644
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@@ -41,6 +41,21 @@ typedef struct SOsdInfo {
   SNodeList* pDsoFuncs;
 } SOsdInfo;
 
+typedef struct SCpdIsMultiTableCondCxt {
+  SNodeList* pLeftCols;
+  SNodeList* pRightCols;
+  bool havaLeftCol;
+  bool haveRightCol;
+} SCpdIsMultiTableCondCxt;
+
+typedef enum ECondAction {
+  COND_ACTION_STAY = 1,
+  COND_ACTION_PUSH_JOIN,
+  COND_ACTION_PUSH_LEFT_CHILD,
+  COND_ACTION_PUSH_RIGHT_CHILD
+  // after supporting outer join, there are other possibilities
+} ECondAction;
+
 static bool osdMayBeOptimized(SLogicNode* pNode) {
   if (OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_OSD)) {
     return false;
@@ -152,34 +167,227 @@ static int32_t cpdOptimizeScanCondition(SOptimizeContext* pCxt, SScanLogicNode*
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t cpdPartitionCondition(SJoinLogicNode* pJoin, SNodeList** pMultiTableCond, SNodeList** pSingleTableCond) {
-  // todo
+static bool belongThisTable(SNode* pCondCol, SNodeList* pTableCols) {
+  SNode* pTableCol = NULL;
+  FOREACH(pTableCol, pTableCols) {
+    if (nodesEqualNode(pCondCol, pTableCol)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static EDealRes cpdIsMultiTableCondImpl(SNode* pNode, void* pContext) {
+  SCpdIsMultiTableCondCxt* pCxt = pContext;
+  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
+    if (belongThisTable(pNode, pCxt->pLeftCols)) {
+      pCxt->havaLeftCol = true;
+    } else if (belongThisTable(pNode, pCxt->pRightCols)) {
+      pCxt->haveRightCol = true;
+    }
+    return pCxt->havaLeftCol && pCxt->haveRightCol ? DEAL_RES_END : DEAL_RES_CONTINUE;
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+static ECondAction cpdCondAction(EJoinType joinType, SNodeList* pLeftCols, SNodeList* pRightCols, SNode* pNode) {
+  SCpdIsMultiTableCondCxt cxt = { .pLeftCols = pLeftCols, .pRightCols = pRightCols, .havaLeftCol = false, .haveRightCol = false };
+  nodesWalkExpr(pNode, cpdIsMultiTableCondImpl, &cxt);
+  return (JOIN_TYPE_INNER != joinType ? COND_ACTION_STAY :
+      (cxt.havaLeftCol && cxt.haveRightCol ? COND_ACTION_PUSH_JOIN : (cxt.havaLeftCol ? COND_ACTION_PUSH_LEFT_CHILD : COND_ACTION_PUSH_RIGHT_CHILD)));
+}
+
+static int32_t cpdMakeCond(SNodeList** pConds, SNode** pCond) {
+  if (NULL == *pConds) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (1 == LIST_LENGTH(*pConds)) {
+    *pCond = nodesListGetNode(*pConds, 0);
+    nodesClearList(*pConds);
+  } else {
+    SLogicConditionNode* pLogicCond = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
+    if (NULL == pLogicCond) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    pLogicCond->condType = LOGIC_COND_TYPE_AND;
+    pLogicCond->pParameterList = *pConds;
+    *pCond = (SNode*)pLogicCond;
+  }
+  *pConds = NULL;
+
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t cpdPushJoinCondToOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin, SNodeList* pMultiTableCond) {
-  // todo
+static int32_t cpdPartitionLogicCond(SJoinLogicNode* pJoin, SNode** pOnCond, SNode** pLeftChildCond, SNode** pRightChildCond) {
+  SLogicConditionNode* pLogicCond = (SLogicConditionNode*)pJoin->node.pConditions;
+  if (LOGIC_COND_TYPE_AND != pLogicCond->condType) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets;
+  SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets;
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SNodeList* pOnConds = NULL;
+  SNodeList* pLeftChildConds = NULL;
+  SNodeList* pRightChildConds = NULL;
+  SNodeList* pRemainConds = NULL;
+  SNode* pCond = NULL;
+  FOREACH(pCond, pLogicCond->pParameterList) {
+    ECondAction condAction = cpdCondAction(pJoin->joinType, pLeftCols, pRightCols, pCond);
+    if (COND_ACTION_PUSH_JOIN == condAction) {
+      code = nodesListMakeAppend(&pOnConds, nodesCloneNode(pCond));
+    } else if (COND_ACTION_PUSH_LEFT_CHILD == condAction) {
+      code = nodesListMakeAppend(&pLeftChildConds, nodesCloneNode(pCond));
+    } else if (COND_ACTION_PUSH_RIGHT_CHILD == condAction) {
+      code = nodesListMakeAppend(&pRightChildConds, nodesCloneNode(pCond));
+    } else {
+      code = nodesListMakeAppend(&pRemainConds, nodesCloneNode(pCond));
+    }
+    if (TSDB_CODE_SUCCESS != code) {
+      break;
+    }
+  }
+
+  SNode* pTempOnCond = NULL;
+  SNode* pTempLeftChildCond = NULL;
+  SNode* pTempRightChildCond = NULL;
+  SNode* pTempRemainCond = NULL;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = cpdMakeCond(&pOnConds, &pTempOnCond);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = cpdMakeCond(&pLeftChildConds, &pTempLeftChildCond);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = cpdMakeCond(&pRightChildConds, &pTempRightChildCond);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = cpdMakeCond(&pRemainConds, &pTempRemainCond);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pOnCond = pTempOnCond;
+    *pLeftChildCond = pTempLeftChildCond;
+    *pRightChildCond = pTempRightChildCond;
+    nodesDestroyNode(pJoin->node.pConditions);
+    pJoin->node.pConditions = pTempRemainCond;
+  } else {
+    nodesDestroyList(pOnConds);
+    nodesDestroyList(pLeftChildConds);
+    nodesDestroyList(pRightChildConds);
+    nodesDestroyList(pRemainConds);
+    nodesDestroyNode(pTempOnCond);
+    nodesDestroyNode(pTempLeftChildCond);
+    nodesDestroyNode(pTempRightChildCond);
+    nodesDestroyNode(pTempRemainCond);
+  }
+
+  return code;
+}
+
+static int32_t cpdPartitionOpCond(SJoinLogicNode* pJoin, SNode** pOnCond, SNode** pLeftChildCond, SNode** pRightChildCond) {
+  SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets;
+  SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets;
+  ECondAction condAction = cpdCondAction(pJoin->joinType, pLeftCols, pRightCols, pJoin->node.pConditions);
+  if (COND_ACTION_STAY == condAction) {
+    return TSDB_CODE_SUCCESS;
+  } else if (COND_ACTION_PUSH_JOIN == condAction) {
+    *pOnCond = pJoin->node.pConditions;
+  } else if (COND_ACTION_PUSH_LEFT_CHILD == condAction) {
+    *pLeftChildCond = pJoin->node.pConditions;
+  } else if (COND_ACTION_PUSH_RIGHT_CHILD == condAction) {
+    *pRightChildCond = pJoin->node.pConditions;
+  }
+  pJoin->node.pConditions = NULL;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t cpdPushJoinCondToChildren(SOptimizeContext* pCxt, SJoinLogicNode* pJoin, SNodeList* pSingleTableCond) {
-  // todo
-  return TSDB_CODE_SUCCESS;
+static int32_t cpdPartitionCond(SJoinLogicNode* pJoin, SNode** pOnCond, SNode** pLeftChildCond, SNode** pRightChildCond) {
+  if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->node.pConditions)) {
+    return cpdPartitionLogicCond(pJoin, pOnCond, pLeftChildCond, pRightChildCond);
+  } else {
+    return cpdPartitionOpCond(pJoin, pOnCond, pLeftChildCond, pRightChildCond);
+  }
+}
+
+static int32_t cpdCondAppend(SOptimizeContext* pCxt, SNode** pCond, SNode** pAdditionalCond) {
+  if (NULL == *pCond) {
+    TSWAP(*pCond, *pAdditionalCond, SNode*);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCond)) {
+    code = nodesListAppend(((SLogicConditionNode*)*pCond)->pParameterList, *pAdditionalCond);
+    if (TSDB_CODE_SUCCESS == code) {
+      *pAdditionalCond = NULL;
+    }
+  } else {
+    SLogicConditionNode* pLogicCond = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
+    if (NULL == pLogicCond) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    pLogicCond->condType = LOGIC_COND_TYPE_AND;
+    code = nodesListMakeAppend(&pLogicCond->pParameterList, *pAdditionalCond);
+    if (TSDB_CODE_SUCCESS == code) {
+      *pAdditionalCond = NULL;
+      code = nodesListMakeAppend(&pLogicCond->pParameterList, *pCond);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      *pCond = (SNode*)pLogicCond;
+    } else {
+      nodesDestroyNode(pLogicCond);
+    }
+  }
+  return code;
+}
+
+static int32_t cpdPushCondToOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin, SNode** pCond) {
+  return cpdCondAppend(pCxt, &pJoin->pOnConditions, pCond);
+}
+
+static int32_t cpdPushCondToScan(SOptimizeContext* pCxt, SScanLogicNode* pScan, SNode** pCond) {
+  return cpdCondAppend(pCxt, &pScan->node.pConditions, pCond);
+}
+
+static int32_t cpdPushCondToChild(SOptimizeContext* pCxt, SLogicNode* pChild, SNode** pCond) {
+  switch (nodeType(pChild)) {
+    case QUERY_NODE_LOGIC_PLAN_SCAN:
+      return cpdPushCondToScan(pCxt, (SScanLogicNode*)pChild, pCond);    
+    default:
+      break;
+  }
+  return TSDB_CODE_PLAN_INTERNAL_ERROR;
 }
 
 static int32_t cpdPushJoinCondition(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
-  if (NULL != pJoin->node.pConditions) {
-    SNodeList* pMultiTableCond = NULL;
-    SNodeList* pSingleTableCond = NULL;
-    int32_t code = cpdPartitionCondition(pJoin, &pMultiTableCond, &pSingleTableCond);
-    if (TSDB_CODE_SUCCESS == code && NULL != pMultiTableCond) {
-      code = cpdPushJoinCondToOnCond(pCxt, pJoin, pMultiTableCond);
-    }
-    if (TSDB_CODE_SUCCESS == code && NULL != pSingleTableCond) {
-      code = cpdPushJoinCondToChildren(pCxt, pJoin, pSingleTableCond);
-    }
+  if (NULL == pJoin->node.pConditions) {
+    return TSDB_CODE_SUCCESS;
   }
-  return TSDB_CODE_SUCCESS;
+
+  SNode* pOnCond = NULL;
+  SNode* pLeftChildCond = NULL;
+  SNode* pRightChildCond = NULL;
+  int32_t code = cpdPartitionCond(pJoin, &pOnCond, &pLeftChildCond, &pRightChildCond);
+  if (TSDB_CODE_SUCCESS == code && NULL != pOnCond) {
+    code = cpdPushCondToOnCond(pCxt, pJoin, &pOnCond);
+  }
+  if (TSDB_CODE_SUCCESS == code && NULL != pLeftChildCond) {
+    code = cpdPushCondToChild(pCxt, (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0), &pLeftChildCond);
+  }
+  if (TSDB_CODE_SUCCESS == code && NULL != pRightChildCond) {
+    code = cpdPushCondToChild(pCxt, (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1), &pRightChildCond);
+  }
+
+  if (TSDB_CODE_SUCCESS != code) {
+    nodesDestroyNode(pOnCond);
+    nodesDestroyNode(pLeftChildCond);
+    nodesDestroyNode(pRightChildCond);
+  }
+
+  return code;
 }
 
 static int32_t cpdPushAggCondition(SOptimizeContext* pCxt, SAggLogicNode* pAgg) {
diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c
index 0b21052955..e54cf33934 100644
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
@@ -18,6 +18,7 @@
 #define SPLIT_FLAG_MASK(n)    (1 << n)
 
 #define SPLIT_FLAG_STS SPLIT_FLAG_MASK(0)
+#define SPLIT_FLAG_CTJ SPLIT_FLAG_MASK(1)
 
 #define SPLIT_FLAG_SET_MASK(val, mask) (val) |= (mask)
 #define SPLIT_FLAG_TEST_MASK(val, mask) (((val) & (mask)) != 0)
@@ -39,43 +40,14 @@ typedef struct SStsInfo {
   SLogicSubplan* pSubplan;
 } SStsInfo;
 
-static SLogicNode* stsMatchByNode(SLogicNode* pNode) {
-  if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode) &&
-      NULL != ((SScanLogicNode*)pNode)->pVgroupList && ((SScanLogicNode*)pNode)->pVgroupList->numOfVgroups > 1) {
-    return pNode;
-  }
-  SNode* pChild;
-  FOREACH(pChild, pNode->pChildren) {
-    SLogicNode* pSplitNode = stsMatchByNode((SLogicNode*)pChild);
-    if (NULL != pSplitNode) {
-      return pSplitNode;
-    }
-  }
-  return NULL;
-}
+typedef struct SCtjInfo {
+  SScanLogicNode* pScan;
+  SLogicSubplan* pSubplan;
+} SCtjInfo;
 
-static void stsFindSplitNode(SLogicSubplan* pSubplan, SStsInfo* pInfo) {
-  SLogicNode* pSplitNode = stsMatchByNode(pSubplan->pNode);
-  if (NULL != pSplitNode) {
-    pInfo->pScan = (SScanLogicNode*)pSplitNode;
-    pInfo->pSubplan = pSubplan;
-  }
-}
-static void stsMatch(SSplitContext* pCxt, SLogicSubplan* pSubplan, SStsInfo* pInfo) {
-  if (!SPLIT_FLAG_TEST_MASK(pSubplan->splitFlag, SPLIT_FLAG_STS)) {
-    stsFindSplitNode(pSubplan, pInfo);
-  }
-  SNode* pChild;
-  FOREACH(pChild, pSubplan->pChildren) {
-    stsMatch(pCxt, (SLogicSubplan*)pChild, pInfo);
-    if (NULL != pInfo->pScan) {
-      break;
-    }
-  }
-  return;
-}
+typedef bool (*FSplFindSplitNode)(SLogicSubplan* pSubplan, SStsInfo* pInfo);
 
-static SLogicSubplan* stsCreateScanSubplan(SSplitContext* pCxt, SScanLogicNode* pScan) {
+static SLogicSubplan* splCreateScanSubplan(SSplitContext* pCxt, SScanLogicNode* pScan, int32_t flag) {
   SLogicSubplan* pSubplan = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
   if (NULL == pSubplan) {
     return NULL;
@@ -84,11 +56,11 @@ static SLogicSubplan* stsCreateScanSubplan(SSplitContext* pCxt, SScanLogicNode*
   pSubplan->subplanType = SUBPLAN_TYPE_SCAN;
   pSubplan->pNode = (SLogicNode*)nodesCloneNode(pScan);
   TSWAP(pSubplan->pVgroupList, ((SScanLogicNode*)pSubplan->pNode)->pVgroupList, SVgroupsInfo*);
-  SPLIT_FLAG_SET_MASK(pSubplan->splitFlag, SPLIT_FLAG_STS);
+  SPLIT_FLAG_SET_MASK(pSubplan->splitFlag, flag);
   return pSubplan;
 }
 
-static int32_t stsCreateExchangeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SScanLogicNode* pScan) {
+static int32_t splCreateExchangeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SScanLogicNode* pScan, ESubplanType subplanType) {
   SExchangeLogicNode* pExchange = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE);
   if (NULL == pExchange) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -119,10 +91,48 @@ static int32_t stsCreateExchangeNode(SSplitContext* pCxt, SLogicSubplan* pSubpla
   return TSDB_CODE_FAILED;
 }
 
+static bool splMatch(SSplitContext* pCxt, SLogicSubplan* pSubplan, int32_t flag, FSplFindSplitNode func, void* pInfo) {
+  if (!SPLIT_FLAG_TEST_MASK(pSubplan->splitFlag, flag)) {
+    if (func(pSubplan, pInfo)) {
+      return true;
+    }
+  }
+  SNode* pChild;
+  FOREACH(pChild, pSubplan->pChildren) {
+    if (splMatch(pCxt, (SLogicSubplan*)pChild, flag, func, pInfo)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static SLogicNode* stsMatchByNode(SLogicNode* pNode) {
+  if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode) &&
+      NULL != ((SScanLogicNode*)pNode)->pVgroupList && ((SScanLogicNode*)pNode)->pVgroupList->numOfVgroups > 1) {
+    return pNode;
+  }
+  SNode* pChild;
+  FOREACH(pChild, pNode->pChildren) {
+    SLogicNode* pSplitNode = stsMatchByNode((SLogicNode*)pChild);
+    if (NULL != pSplitNode) {
+      return pSplitNode;
+    }
+  }
+  return NULL;
+}
+
+static bool stsFindSplitNode(SLogicSubplan* pSubplan, SStsInfo* pInfo) {
+  SLogicNode* pSplitNode = stsMatchByNode(pSubplan->pNode);
+  if (NULL != pSplitNode) {
+    pInfo->pScan = (SScanLogicNode*)pSplitNode;
+    pInfo->pSubplan = pSubplan;
+  }
+  return NULL != pSplitNode;
+}
+
 static int32_t stsSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
   SStsInfo info = {0};
-  stsMatch(pCxt, pSubplan, &info);
-  if (NULL == info.pScan) {
+  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_STS, stsFindSplitNode, &info)) {
     return TSDB_CODE_SUCCESS;
   }
   if (NULL == info.pSubplan->pChildren) {
@@ -131,9 +141,61 @@ static int32_t stsSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
   }
-  int32_t code = nodesListStrictAppend(info.pSubplan->pChildren, stsCreateScanSubplan(pCxt, info.pScan));
+  int32_t code = nodesListStrictAppend(info.pSubplan->pChildren, splCreateScanSubplan(pCxt, info.pScan, SPLIT_FLAG_STS));
   if (TSDB_CODE_SUCCESS == code) {
-    code = stsCreateExchangeNode(pCxt, info.pSubplan, info.pScan);
+    code = splCreateExchangeNode(pCxt, info.pSubplan, info.pScan, SUBPLAN_TYPE_MERGE);
+  }
+  ++(pCxt->groupId);
+  pCxt->split = true;
+  return code;
+}
+
+static bool ctjIsSingleTable(int8_t tableType) {
+  return (TSDB_CHILD_TABLE == tableType || TSDB_NORMAL_TABLE == tableType);
+}
+
+static SLogicNode* ctjMatchByNode(SLogicNode* pNode) {
+  if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pNode)) {
+    SLogicNode* pLeft = (SLogicNode*)nodesListGetNode(pNode->pChildren, 0);
+    SLogicNode* pRight = (SLogicNode*)nodesListGetNode(pNode->pChildren, 1);
+    if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pLeft) && ctjIsSingleTable(((SScanLogicNode*)pLeft)->pMeta->tableType) &&
+        QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pRight) && ctjIsSingleTable(((SScanLogicNode*)pRight)->pMeta->tableType)) {
+      return pRight;
+    }
+  }
+  SNode* pChild;
+  FOREACH(pChild, pNode->pChildren) {
+    SLogicNode* pSplitNode = ctjMatchByNode((SLogicNode*)pChild);
+    if (NULL != pSplitNode) {
+      return pSplitNode;
+    }
+  }
+  return NULL;
+}
+
+static bool ctjFindSplitNode(SLogicSubplan* pSubplan, SStsInfo* pInfo) {
+  SLogicNode* pSplitNode = ctjMatchByNode(pSubplan->pNode);
+  if (NULL != pSplitNode) {
+    pInfo->pScan = (SScanLogicNode*)pSplitNode;
+    pInfo->pSubplan = pSubplan;
+  }
+  return NULL != pSplitNode;
+}
+
+static int32_t ctjSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
+  SCtjInfo info = {0};
+  if (!splMatch(pCxt, pSubplan, SPLIT_FLAG_CTJ, ctjFindSplitNode, &info)) {
+    return TSDB_CODE_SUCCESS;
+  }
+  if (NULL == info.pSubplan->pChildren) {
+    info.pSubplan->pChildren = nodesMakeList();
+    if (NULL == info.pSubplan->pChildren) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+  int32_t code = nodesListStrictAppend(info.pSubplan->pChildren, splCreateScanSubplan(pCxt, info.pScan, SPLIT_FLAG_CTJ));
+  if (TSDB_CODE_SUCCESS == code) {
+    code = splCreateExchangeNode(pCxt, info.pSubplan, info.pScan, info.pSubplan->subplanType);
   }
   ++(pCxt->groupId);
   pCxt->split = true;
@@ -141,7 +203,8 @@ static int32_t stsSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
 }
 
 static const SSplitRule splitRuleSet[] = {
-  { .pName = "SuperTableScan", .splitFunc = stsSplit }
+  { .pName = "SuperTableScan", .splitFunc = stsSplit },
+  { .pName = "ChildTableJoin", .splitFunc = ctjSplit },
 };
 
 static const int32_t splitRuleNum = (sizeof(splitRuleSet) / sizeof(SSplitRule));
diff --git a/source/libs/planner/test/plannerTest.cpp b/source/libs/planner/test/plannerTest.cpp
index fd0084c01e..69c76fc3ae 100644
--- a/source/libs/planner/test/plannerTest.cpp
+++ b/source/libs/planner/test/plannerTest.cpp
@@ -70,6 +70,12 @@ protected:
     cout << "unformatted logic plan : " << endl;
     cout << toString((const SNode*)pLogicNode, false) << endl;
 
+    code = optimizeLogicPlan(&cxt, pLogicNode);
+    if (code != TSDB_CODE_SUCCESS) {
+      cout << "sql:[" << cxt_.pSql << "] optimizeLogicPlan code:" << code << ", strerror:" << tstrerror(code) << endl;
+      return false;
+    }
+
     SLogicSubplan* pLogicSubplan = nullptr;
     code = splitLogicPlan(&cxt, pLogicNode, &pLogicSubplan);
     if (code != TSDB_CODE_SUCCESS) {
@@ -174,13 +180,13 @@ TEST_F(PlannerTest, selectStableBasic) {
 TEST_F(PlannerTest, selectJoin) {
   setDatabase("root", "test");
 
-  bind("SELECT * FROM st1s1 t1, st1s2 t2 where t1.ts = t2.ts");
-  ASSERT_TRUE(run());
+  // bind("SELECT t1.c1, t2.c2 FROM st1s1 t1, st1s2 t2 where t1.ts = t2.ts");
+  // ASSERT_TRUE(run());
 
-  bind("SELECT * FROM st1s1 t1 join st1s2 t2 on t1.ts = t2.ts where t1.c1 > t2.c1");
-  ASSERT_TRUE(run());
+  // bind("SELECT t1.*, t2.* FROM st1s1 t1, st1s2 t2 where t1.ts = t2.ts");
+  // ASSERT_TRUE(run());
 
-  bind("SELECT t1.* FROM st1s1 t1 join st1s2 t2 on t1.ts = t2.ts where t1.c1 > t2.c1");
+  bind("SELECT t1.c1, t2.c1 FROM st1s1 t1 join st1s2 t2 on t1.ts = t2.ts where t1.c1 > t2.c1 and t1.c2 = 'abc' and t2.c2 = 'qwe'");
   ASSERT_TRUE(run());
 }
 

From 744a198906ca1156791456e15f27774c2877795c Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Wed, 13 Apr 2022 20:02:11 +0800
Subject: [PATCH 02/11] add version for tsma expired window updating

---
 source/dnode/vnode/inc/vnode.h          |  5 +--
 source/dnode/vnode/src/tq/tq.c          |  2 +-
 source/dnode/vnode/src/tsdb/tsdbSma.c   | 47 +++++++++----------------
 source/dnode/vnode/test/tsdbSmaTest.cpp |  2 +-
 4 files changed, 22 insertions(+), 34 deletions(-)

diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index aab835b958..a93e1741bb 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -393,10 +393,11 @@ int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg);
  * @brief When submit msg received, update the relative expired window synchronously.
  *
  * @param pTsdb
- * @param msg
+ * @param pMsg
+ * @param version
  * @return int32_t
  */
-int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg);
+int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
 
 /**
  * @brief Insert tSma(Time-range-wise SMA) data from stream computing engine
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index bee61f4d40..d7cde44a6f 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -82,7 +82,7 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t versi
   memcpy(data, msg, msgLen);
 
   if (msgType == TDMT_VND_SUBMIT) {
-    if (tsdbUpdateSmaWindow(pTq->pVnode->pTsdb, msg) != 0) {
+    if (tsdbUpdateSmaWindow(pTq->pVnode->pTsdb, msg, version) != 0) {
       return -1;
     }
   }
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index bfdad836f1..7de5a0d5a9 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -105,8 +105,8 @@ struct SSmaStat {
 // declaration of static functions
 
 // expired window
-static int32_t  tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg);
-static int32_t  tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey);
+static int32_t  tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
+static int32_t  tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey, int64_t version);
 static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat);
 static void    *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem);
 static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat);
@@ -544,7 +544,7 @@ static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
   return TSDB_CODE_SUCCESS;
 };
 
-static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey) {
+static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey, int64_t version) {
   SSmaStatItem *pItem = taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
   if (pItem == NULL) {
     // TODO: use TSDB_SMA_STAT_EXPIRED and update by stream computing later
@@ -578,8 +578,7 @@ static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t
     return TSDB_CODE_FAILED;
   }
 
-  int8_t state = TSDB_SMA_STAT_EXPIRED;
-  if (taosHashPut(pItem->expiredWindows, &winSKey, sizeof(TSKEY), &state, sizeof(state)) != 0) {
+  if (taosHashPut(pItem->expiredWindows, &winSKey, sizeof(TSKEY), &version, sizeof(version)) != 0) {
     // If error occurs during taosHashPut expired windows, remove the smaIndex from pTsdb->pSmaStat, thus TSDB would
     // tell query module to query raw TS data.
     // N.B.
@@ -606,7 +605,8 @@ static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t
  * @param msg SSubmitReq
  * @return int32_t
  */
-int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg) {
+int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version) {
+  // no time-range-sma, just return success
   if (atomic_load_16(&REPO_TSMA_NUM(pTsdb)) <= 0) {
     tsdbTrace("vgId:%d not update expire window since no tSma", REPO_ID(pTsdb));
     return TSDB_CODE_SUCCESS;
@@ -621,20 +621,6 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg) {
     return TSDB_CODE_FAILED;
   }
 
-// TODO: decode the msg from Stream Computing module => start
-#ifdef TSDB_SMA_TESTx
-  int64_t       indexUid = SMA_TEST_INDEX_UID;
-  const int32_t SMA_TEST_EXPIRED_WINDOW_SIZE = 10;
-  TSKEY         expiredWindows[SMA_TEST_EXPIRED_WINDOW_SIZE];
-  TSKEY         skey1 = 1646987196 * 1e3;
-  for (int32_t i = 0; i < SMA_TEST_EXPIRED_WINDOW_SIZE; ++i) {
-    expiredWindows[i] = skey1 + i;
-  }
-#else
-
-#endif
-  // TODO: decode the msg <= end
-
   if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
     terrno = TSDB_CODE_TDB_INIT_FAILED;
     return TSDB_CODE_FAILED;
@@ -700,7 +686,7 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg) {
 
       TSKEY winSKey = taosTimeTruncate(TD_ROW_KEY(row), &interval, interval.precision);
 
-      tsdbSetExpiredWindow(pTsdb, pItemsHash, pTSma->indexUid, winSKey);
+      tsdbSetExpiredWindow(pTsdb, pItemsHash, pTSma->indexUid, winSKey, version);
 
       // TODO: release only when suid changes.
       tdDestroyTSmaWrapper(pSW);
@@ -975,7 +961,7 @@ static int tsdbSmaBeginCommit(SSmaEnv *pEnv) {
   // start a new txn
   tdbTxnOpen(pTxn, 0, poolMalloc, poolFree, pEnv->pPool, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED);
   if (tdbBegin(pEnv->dbEnv, pTxn) != 0) {
-    tsdbWarn("tsdbSma tdb restart txn fail");
+    tsdbWarn("tsdbSma tdb begin commit fail");
     return -1;
   }
   return 0;
@@ -986,7 +972,7 @@ static int tsdbSmaEndCommit(SSmaEnv *pEnv) {
 
   // Commit current txn
   if (tdbCommit(pEnv->dbEnv, pTxn) != 0) {
-    tsdbWarn("tsdbSma tdb commit fail");
+    tsdbWarn("tsdbSma tdb end commit fail");
     return -1;
   }
   tdbTxnClose(pTxn);
@@ -1009,12 +995,12 @@ static int tsdbSmaEndCommit(SSmaEnv *pEnv) {
 static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char *msg) {
   STsdbCfg     *pCfg = REPO_CFG(pTsdb);
   const SArray *pDataBlocks = (const SArray *)msg;
-  SSmaEnv      *pEnv = atomic_load_ptr(&REPO_TSMA_ENV(pTsdb));
 
-  if (pEnv == NULL) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert tSma data failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
-    return terrno;
+  // For super table aggregation, the sma data is stored in vgroup calculated from the hash value of stable name. Thus
+  // the sma data would arrive ahead of the update-expired-window msg.
+  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
+    terrno = TSDB_CODE_TDB_INIT_FAILED;
+    return TSDB_CODE_FAILED;
   }
 
   if (pDataBlocks == NULL) {
@@ -1029,6 +1015,7 @@ static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char
     return TSDB_CODE_FAILED;
   }
 
+  SSmaEnv      *pEnv = REPO_TSMA_ENV(pTsdb);
   SSmaStat     *pStat = SMA_ENV_STAT(pEnv);
   SSmaStatItem *pItem = NULL;
 
@@ -1683,9 +1670,9 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg) {
   return code;
 }
 
-int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg) {
+int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version) {
   int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbUpdateExpiredWindowImpl(pTsdb, pMsg)) < 0) {
+  if ((code = tsdbUpdateExpiredWindowImpl(pTsdb, pMsg, version)) < 0) {
     tsdbWarn("vgId:%d update expired sma window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
   }
   return code;
diff --git a/source/dnode/vnode/test/tsdbSmaTest.cpp b/source/dnode/vnode/test/tsdbSmaTest.cpp
index da874716f2..b0217a0462 100644
--- a/source/dnode/vnode/test/tsdbSmaTest.cpp
+++ b/source/dnode/vnode/test/tsdbSmaTest.cpp
@@ -409,7 +409,7 @@ TEST(testCase, tSma_Data_Insert_Query_Test) {
 
   EXPECT_EQ(tdScanAndConvertSubmitMsg(pMsg), TSDB_CODE_SUCCESS);
 
-  EXPECT_EQ(tsdbUpdateSmaWindow(pTsdb, pMsg), 0);
+  EXPECT_EQ(tsdbUpdateSmaWindow(pTsdb, pMsg, 0), 0);
 
   // init
   const int32_t  tSmaGroupSize = 4;

From 0fe0d6fc77b2bd2ef0b9012c11e3a197820bb644 Mon Sep 17 00:00:00 2001
From: Liu Jicong <liujicong@qq.com>
Date: Wed, 13 Apr 2022 20:37:51 +0800
Subject: [PATCH 03/11] fix: fix tmq result parse

---
 example/src/tmq.c                          | 23 ++++++++---
 include/common/tmsg.h                      | 15 +++-----
 source/client/src/clientMain.c             | 24 +++++++-----
 source/client/src/tmq.c                    | 24 +++++++-----
 source/dnode/mnode/impl/src/mndSubscribe.c | 44 +++++++++++++++-------
 source/dnode/vnode/src/tq/tq.c             | 32 ++++++++++------
 6 files changed, 102 insertions(+), 60 deletions(-)

diff --git a/example/src/tmq.c b/example/src/tmq.c
index 85dea5b382..832e389a13 100644
--- a/example/src/tmq.c
+++ b/example/src/tmq.c
@@ -19,8 +19,20 @@
 #include <time.h>
 #include "taos.h"
 
-static int running = 1;
-/*static void msg_process(tmq_message_t* message) { tmqShowMsg(message); }*/
+static int  running = 1;
+static void msg_process(TAOS_RES* msg) {
+  char buf[1024];
+  printf("topic: %s\n", tmq_get_topic_name(msg));
+  printf("vg:%d\n", tmq_get_vgroup_id(msg));
+  while (1) {
+    TAOS_ROW row = taos_fetch_row(msg);
+    if (row == NULL) break;
+    TAOS_FIELD* fields = taos_fetch_fields(msg);
+    int32_t     numOfFields = taos_field_count(msg);
+    taos_print_row(buf, row, fields, numOfFields);
+    printf("%s\n", buf);
+  }
+}
 
 int32_t init_env() {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -42,8 +54,7 @@ int32_t init_env() {
   }
   taos_free_result(pRes);
 
-  pRes =
-      taos_query(pConn, "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(10)) tags(t1 int)");
+  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c4 int) tags(t1 int)");
   if (taos_errno(pRes) != 0) {
     printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -90,7 +101,7 @@ int32_t create_topic() {
 
   /*const char* sql = "select * from tu1";*/
   /*pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));*/
-  pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1 from ct1");
+  pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c4 from ct1");
   if (taos_errno(pRes) != 0) {
     printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -200,7 +211,7 @@ void sync_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
   while (running) {
     TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, 1000);
     if (tmqmessage) {
-      /*msg_process(tmqmessage);*/
+      msg_process(tmqmessage);
       tmq_message_destroy(tmqmessage);
 
       if ((++msg_count % MIN_COMMIT_COUNT) == 0) tmq_commit(tmq, NULL, 0);
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 5d5889e308..1ded61eb3f 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -2365,11 +2365,10 @@ typedef struct {
 } SMqSubVgEp;
 
 typedef struct {
-  char        topic[TSDB_TOPIC_FNAME_LEN];
-  int8_t      isSchemaAdaptive;
-  SArray*     vgs;  // SArray<SMqSubVgEp>
-  int32_t     numOfFields;
-  TAOS_FIELD* fields;
+  char           topic[TSDB_TOPIC_FNAME_LEN];
+  int8_t         isSchemaAdaptive;
+  SArray*        vgs;  // SArray<SMqSubVgEp>
+  SSchemaWrapper schema;
 } SMqSubTopicEp;
 
 typedef struct {
@@ -2468,8 +2467,7 @@ static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp
     SMqSubVgEp* pVgEp = (SMqSubVgEp*)taosArrayGet(pTopicEp->vgs, i);
     tlen += tEncodeSMqSubVgEp(buf, pVgEp);
   }
-  tlen += taosEncodeFixedI32(buf, pTopicEp->numOfFields);
-  // tlen += taosEncodeBinary(buf, pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD));
+  tlen += taosEncodeSSchemaWrapper(buf, &pTopicEp->schema);
   return tlen;
 }
 
@@ -2487,8 +2485,7 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE
     buf = tDecodeSMqSubVgEp(buf, &vgEp);
     taosArrayPush(pTopicEp->vgs, &vgEp);
   }
-  buf = taosDecodeFixedI32(buf, &pTopicEp->numOfFields);
-  // buf = taosDecodeBinary(buf, (void**)&pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD));
+  buf = taosDecodeSSchemaWrapper(buf, &pTopicEp->schema);
   return buf;
 }
 
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index c93260be37..fa55e9c295 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -171,21 +171,25 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
     return doFetchRow(pRequest, true, true);
 
   } else if (TD_RES_TMQ(res)) {
-    SMqRspObj      *msg = ((SMqRspObj *)res);
+    SMqRspObj *msg = ((SMqRspObj *)res);
+    if (msg->resIter == -1) msg->resIter++;
     SReqResultInfo *pResultInfo = taosArrayGet(msg->res, msg->resIter);
-
-    doSetOneRowPtr(pResultInfo);
-    pResultInfo->current += 1;
-
-    if (pResultInfo->row == NULL) {
-      msg->resIter++;
-      pResultInfo = taosArrayGet(msg->res, msg->resIter);
+    if (pResultInfo->current < pResultInfo->numOfRows) {
       doSetOneRowPtr(pResultInfo);
       pResultInfo->current += 1;
+      return pResultInfo->row;
+    } else {
+      msg->resIter++;
+      if (msg->resIter < taosArrayGetSize(msg->res)) {
+        pResultInfo = taosArrayGet(msg->res, msg->resIter);
+        doSetOneRowPtr(pResultInfo);
+        pResultInfo->current += 1;
+        return pResultInfo->row;
+      } else {
+        return NULL;
+      }
     }
 
-    return pResultInfo->row;
-
   } else {
     // assert to avoid uninitialization error
     ASSERT(0);
diff --git a/source/client/src/tmq.c b/source/client/src/tmq.c
index ea31170b1f..2b69b47865 100644
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@@ -119,14 +119,14 @@ typedef struct {
 
 typedef struct {
   // subscribe info
-  int32_t     sqlLen;
-  char*       sql;
-  char*       topicName;
-  int64_t     topicId;
-  SArray*     vgs;  // SArray<SMqClientVg>
-  int8_t      isSchemaAdaptive;
-  int32_t     numOfFields;
-  TAOS_FIELD* fields;
+  int32_t        sqlLen;
+  char*          sql;
+  char*          topicName;
+  int64_t        topicId;
+  SArray*        vgs;  // SArray<SMqClientVg>
+  int8_t         isSchemaAdaptive;
+  int32_t        numOfFields;
+  SSchemaWrapper schema;
 } SMqClientTopic;
 
 typedef struct {
@@ -956,6 +956,7 @@ bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqCMGetSubEpRsp* pRsp) {
   for (int32_t i = 0; i < topicNumGet; i++) {
     SMqClientTopic topic = {0};
     SMqSubTopicEp* pTopicEp = taosArrayGet(pRsp->topics, i);
+    topic.schema = pTopicEp->schema;
     taosHashClear(pHash);
     topic.topicName = strdup(pTopicEp->topic);
 
@@ -1191,7 +1192,10 @@ SMqRspObj* tmqBuildRspFromWrapper(SMqPollRspWrapper* pWrapper) {
   for (int32_t i = 0; i < blockNum; i++) {
     int32_t            pos = *(int32_t*)taosArrayGet(pRsp->blockPos, i);
     SRetrieveTableRsp* pRetrieve = POINTER_SHIFT(pRsp->blockData, pos);
-    SReqResultInfo     resInfo;
+    SReqResultInfo     resInfo = {0};
+    resInfo.totalRows = 0;
+    resInfo.precision = TSDB_TIME_PRECISION_MILLI;
+    setResSchemaInfo(&resInfo, pWrapper->topicHandle->schema.pSchema, pWrapper->topicHandle->schema.nCols);
     setQueryResultFromRsp(&resInfo, pRetrieve, true);
     taosArrayPush(pRspObj->res, &resInfo);
   }
@@ -1386,7 +1390,7 @@ SMqRspObj* tmqHandleAllRsp(tmq_t* tmq, int64_t blockingTime, bool pollIfReset) {
           rspWrapper = NULL;
           continue;
         }
-        // build msg
+        // build rsp
         SMqRspObj* pRsp = tmqBuildRspFromWrapper(pollRspWrapper);
         return pRsp;
       } else {
diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c
index dbd5e43b6d..e1461c0eba 100644
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@@ -60,8 +60,10 @@ static int32_t mndProcessResetOffsetReq(SNodeMsg *pMsg);
 static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqTopicObj *pTopic, const char *cgroup,
                                       const SMqConsumerEp *pConsumerEp);
 
-static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp, const char* topicName);
-static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp, const char* oldTopicName);
+static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,
+                                      const char *topicName);
+static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,
+                                       const char *oldTopicName);
 
 int32_t mndInitSubscribe(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_SUBSCRIBE,
@@ -102,7 +104,8 @@ static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj
   return pSub;
 }
 
-static int32_t mndBuildRebalanceMsg(void **pBuf, int32_t *pLen, const SMqConsumerEp *pConsumerEp, const char* topicName) {
+static int32_t mndBuildRebalanceMsg(void **pBuf, int32_t *pLen, const SMqConsumerEp *pConsumerEp,
+                                    const char *topicName) {
   SMqMVRebReq req = {
       .vgId = pConsumerEp->vgId,
       .oldConsumerId = pConsumerEp->oldConsumerId,
@@ -131,7 +134,8 @@ static int32_t mndBuildRebalanceMsg(void **pBuf, int32_t *pLen, const SMqConsume
   return 0;
 }
 
-static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp, const char* topicName) {
+static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,
+                                      const char *topicName) {
   ASSERT(pConsumerEp->oldConsumerId != -1);
 
   void   *buf;
@@ -158,7 +162,8 @@ static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqC
   return 0;
 }
 
-static int32_t mndBuildCancelConnReq(void **pBuf, int32_t *pLen, const SMqConsumerEp *pConsumerEp, const char* oldTopicName) {
+static int32_t mndBuildCancelConnReq(void **pBuf, int32_t *pLen, const SMqConsumerEp *pConsumerEp,
+                                     const char *oldTopicName) {
   SMqCancelConnReq req = {0};
   req.consumerId = pConsumerEp->consumerId;
   req.vgId = pConsumerEp->vgId;
@@ -182,7 +187,8 @@ static int32_t mndBuildCancelConnReq(void **pBuf, int32_t *pLen, const SMqConsum
   return 0;
 }
 
-static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp, const char* oldTopicName) {
+static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp,
+                                       const char *oldTopicName) {
   void   *buf;
   int32_t tlen;
   if (mndBuildCancelConnReq(&buf, &tlen, pConsumerEp, oldTopicName) < 0) {
@@ -219,13 +225,14 @@ static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg) {
     terrno = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
     return -1;
   }
-  //TODO add lock
+  // TODO add lock
   ASSERT(strcmp(pReq->cgroup, pConsumer->cgroup) == 0);
-  int32_t           serverEpoch = pConsumer->epoch;
+  int32_t serverEpoch = pConsumer->epoch;
 
   // TODO
   int32_t hbStatus = atomic_load_32(&pConsumer->hbStatus);
-  mDebug("consumer %ld epoch(%d) try to get sub ep, server epoch %d, old val: %d", consumerId, epoch, serverEpoch, hbStatus);
+  mDebug("consumer %ld epoch(%d) try to get sub ep, server epoch %d, old val: %d", consumerId, epoch, serverEpoch,
+         hbStatus);
   atomic_store_32(&pConsumer->hbStatus, 0);
   /*SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pConsumer);*/
   /*sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY);*/
@@ -233,7 +240,8 @@ static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg) {
 
   strcpy(rsp.cgroup, pReq->cgroup);
   if (epoch != serverEpoch) {
-    mInfo("send new assignment to consumer %ld, consumer epoch %d, server epoch %d", pConsumer->consumerId, epoch, serverEpoch);
+    mInfo("send new assignment to consumer %ld, consumer epoch %d, server epoch %d", pConsumer->consumerId, epoch,
+          serverEpoch);
     mDebug("consumer %ld try r lock", consumerId);
     taosRLockLatch(&pConsumer->lock);
     mDebug("consumer %ld r locked", consumerId);
@@ -251,8 +259,15 @@ static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg) {
         if (consumerId == pSubConsumer->consumerId) {
           int32_t vgsz = taosArrayGetSize(pSubConsumer->vgInfo);
           mInfo("topic %s has %d vg", topicName, serverEpoch);
+
           SMqSubTopicEp topicEp;
           strcpy(topicEp.topic, topicName);
+
+          SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topicName);
+          ASSERT(pTopic != NULL);
+          topicEp.schema = pTopic->schema;
+          mndReleaseTopic(pMnode, pTopic);
+
           topicEp.vgs = taosArrayInit(vgsz, sizeof(SMqSubVgEp));
           for (int32_t k = 0; k < vgsz; k++) {
             char           offsetKey[TSDB_PARTITION_KEY_LEN];
@@ -409,7 +424,8 @@ static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg) {
     SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, pRebSub->key);
     taosMemoryFreeClear(pRebSub->key);
 
-    mInfo("mq rebalance subscription: %s, vgNum: %d, unassignedVg: %d", pSub->key, pSub->vgNum, (int32_t)taosArrayGetSize(pSub->unassignedVg));
+    mInfo("mq rebalance subscription: %s, vgNum: %d, unassignedVg: %d", pSub->key, pSub->vgNum,
+          (int32_t)taosArrayGetSize(pSub->unassignedVg));
 
     // remove lost consumer
     for (int32_t i = 0; i < taosArrayGetSize(pRebSub->lostConsumers); i++) {
@@ -459,12 +475,12 @@ static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg) {
         mDebug("consumer %ld try w lock", pRebConsumer->consumerId);
         taosWLockLatch(&pRebConsumer->lock);
         mDebug("consumer %ld w locked", pRebConsumer->consumerId);
-        int32_t         status = atomic_load_32(&pRebConsumer->status);
+        int32_t status = atomic_load_32(&pRebConsumer->status);
         if (vgThisConsumerAfterRb != vgThisConsumerBeforeRb ||
             (vgThisConsumerAfterRb != 0 && status != MQ_CONSUMER_STATUS__ACTIVE) ||
             (vgThisConsumerAfterRb == 0 && status != MQ_CONSUMER_STATUS__LOST)) {
           /*if (vgThisConsumerAfterRb != vgThisConsumerBeforeRb) {*/
-            /*pRebConsumer->epoch++;*/
+          /*pRebConsumer->epoch++;*/
           /*}*/
           if (vgThisConsumerAfterRb != 0) {
             atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__ACTIVE);
@@ -500,7 +516,7 @@ static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg) {
 
             pConsumerEp->oldConsumerId = pConsumerEp->consumerId;
             pConsumerEp->consumerId = pSubConsumer->consumerId;
-            //TODO
+            // TODO
             pConsumerEp->epoch = 0;
             taosArrayPush(pSubConsumer->vgInfo, pConsumerEp);
 
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 654d7c3a65..f08b39b907 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -551,30 +551,40 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       rspV2.rspOffset = fetchOffset;
 
       int32_t blockSz = taosArrayGetSize(pRes);
-      int32_t tlen = 0;
+      int32_t dataBlockStrLen = 0;
       for (int32_t i = 0; i < blockSz; i++) {
         SSDataBlock* pBlock = taosArrayGet(pRes, i);
-        tlen += sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock);
+        dataBlockStrLen += sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock);
       }
 
-      void* data = taosMemoryMalloc(tlen);
-      if (data == NULL) {
+      void* dataBlockBuf = taosMemoryMalloc(dataBlockStrLen);
+      if (dataBlockBuf == NULL) {
         pMsg->code = -1;
         taosMemoryFree(pHead);
       }
 
-      rspV2.blockData = data;
+      rspV2.blockData = dataBlockBuf;
 
-      void*   dataBlockBuf = data;
       int32_t pos;
+      rspV2.blockPos = taosArrayInit(blockSz, sizeof(int32_t));
       for (int32_t i = 0; i < blockSz; i++) {
         pos = 0;
-        SSDataBlock* pBlock = taosArrayGet(pRes, i);
-        blockCompressEncode(pBlock, dataBlockBuf, &pos, pBlock->info.numOfCols, false);
+        SSDataBlock*       pBlock = taosArrayGet(pRes, i);
+        SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)dataBlockBuf;
+        pRetrieve->useconds = 0;
+        pRetrieve->precision = 0;
+        pRetrieve->compressed = 0;
+        pRetrieve->completed = 1;
+        pRetrieve->numOfRows = htonl(pBlock->info.rows);
+        blockCompressEncode(pBlock, pRetrieve->data, &pos, pBlock->info.numOfCols, false);
         taosArrayPush(rspV2.blockPos, &rspV2.dataLen);
-        rspV2.dataLen += pos;
-        dataBlockBuf = POINTER_SHIFT(dataBlockBuf, pos);
+
+        int32_t totLen = sizeof(SRetrieveTableRsp) + pos;
+        pRetrieve->compLen = htonl(totLen);
+        rspV2.dataLen += totLen;
+        dataBlockBuf = POINTER_SHIFT(dataBlockBuf, totLen);
       }
+      ASSERT(POINTER_DISTANCE(dataBlockBuf, rspV2.blockData) <= dataBlockStrLen);
 
       int32_t msgLen = sizeof(SMqRspHead) + tEncodeSMqPollRspV2(NULL, &rspV2);
       void*   buf = rpcMallocCont(msgLen);
@@ -590,7 +600,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
       /*taosArrayDestroyEx(rsp.pBlockData, (void (*)(void*))tDeleteSSDataBlock);*/
       pMsg->pCont = buf;
-      pMsg->contLen = tlen;
+      pMsg->contLen = msgLen;
       pMsg->code = 0;
       vDebug("vg %d offset %ld msgType %d from consumer %ld (epoch %d) actual rsp", pTq->pVnode->vgId, fetchOffset,
              pHead->msgType, consumerId, pReq->epoch);

From 729218f3e8d725702856e09c2dfcf593860a6f0b Mon Sep 17 00:00:00 2001
From: Ganlin Zhao <36554565+glzhao89@users.noreply.github.com>
Date: Wed, 13 Apr 2022 12:38:57 +0800
Subject: [PATCH 04/11] feat(query): support now()/now() + duration syntax in
 insert clause

TD-14243
---
 source/libs/parser/src/parInsert.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c
index 435ab317e6..81831ab164 100644
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
@@ -325,6 +325,11 @@ static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time
 
   for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
     if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
+    if (pToken->z[k] == '(' && pToken->z[k + 1] == ')') { //for insert NOW()/TODAY()
+      *end = pTokenEnd = &pToken->z[k + 2];
+      k++;
+      continue;
+    }
     if (pToken->z[k] == ',') {
       *end = pTokenEnd;
       *time = ts;

From 742611164d139178832c4abef68da519ef4c7140 Mon Sep 17 00:00:00 2001
From: plum-lihui <huili@taosdata.com>
Date: Wed, 13 Apr 2022 20:49:19 +0800
Subject: [PATCH 05/11] test: add tmq case

---
 .../script/tsim/tmq/overlapTopic2Con1Cgrp.sim | 240 ++++++++++++++++++
 tests/test/c/tmqSim.c                         |  27 ++
 2 files changed, 267 insertions(+)
 create mode 100644 tests/script/tsim/tmq/overlapTopic2Con1Cgrp.sim

diff --git a/tests/script/tsim/tmq/overlapTopic2Con1Cgrp.sim b/tests/script/tsim/tmq/overlapTopic2Con1Cgrp.sim
new file mode 100644
index 0000000000..62ec3149be
--- /dev/null
+++ b/tests/script/tsim/tmq/overlapTopic2Con1Cgrp.sim
@@ -0,0 +1,240 @@
+#### test scenario, please refer to https://jira.taosdata.com:18090/pages/viewpage.action?pageId=135120406
+# scene1: vgroups=1, one topic for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb
+# scene2: vgroups=1, multi topics for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb
+# scene3: vgroups=4, one topic for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb
+# scene4: vgroups=4, multi topics for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb
+# notes1: Scalar function: ABS/ACOS/ASIN/ATAN/CEIL/COS/FLOOR/LOG/POW/ROUND/SIN/SQRT/TAN
+# The above use cases are combined with where filter conditions, such as: where ts > "2017-08-12 18:25:58.128Z" and sin(a) > 0.5;
+#
+# notes2: not support aggregate functions(such as sum/count/min/max) and time-windows(interval).
+#
+######## ######## ######## ######## ######## ######## ######## ######## ######## ######## 
+######## This test case include scene2 and scene4
+######## ######## ######## ######## ######## ######## ######## ######## ######## ######## 
+
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1
+system sh/exec.sh -n dnode1 -s start
+
+$loop_cnt = 0
+check_dnode_ready:
+	$loop_cnt = $loop_cnt + 1
+	sleep 200
+	if $loop_cnt == 10 then
+	  print ====> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ===> $rows $data00 $data01 $data02 $data03 $data04 $data05
+if $data00 != 1 then
+  return -1
+endi
+if $data04 != ready then
+  goto check_dnode_ready
+endi
+
+sql connect
+
+$loop_cnt = 0
+$vgroups  = 1
+$dbNamme  = d0
+loop_vgroups:
+print =============== create database $dbNamme vgroups $vgroups
+sql create database $dbNamme vgroups $vgroups
+sql show databases
+print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
+print $data10 $data11 $data12 $data13 $data14 $data15 $data16 $data17 $data18 $data19
+print $data20 $data21 $data22 $data23 $data24 $data25 $data26 $data27 $data28 $data29
+
+if $loop_cnt == 0 then 
+  if $rows != 2 then 
+    return -1
+  endi
+  if $data02 != 1 then  # vgroups
+    print vgroups: $data02
+    return -1
+  endi
+else
+  if $rows != 3 then 
+    return -1
+  endi
+  if $data00 == d1 then 
+    if $data02 != 4 then  # vgroups
+      print vgroups: $data02
+      return -1
+    endi
+  else  
+    if $data12 != 4 then  # vgroups
+      print vgroups: $data12
+      return -1
+    endi
+  endi
+endi
+
+sql use $dbNamme
+
+print =============== create super table
+sql create table if not exists stb (ts timestamp, c1 int, c2 float, c3 binary(10)) tags (t1 int)
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+print =============== create child table
+$tbPrefix = ct
+$tbNum = 10
+
+$i = 0
+while $i < $tbNum
+  $tb = $tbPrefix . $i
+  sql create table $tb using stb tags( $i )
+  $i = $i + 1
+endw
+
+print =============== create normal table
+sql create table ntb (ts timestamp, c1 int, c2 float, c3 binary(10))
+
+print =============== create multi topics. notes: now only support:
+print =============== 1. columns from stb/ctb/ntb; 2. * from ctb/ntb; 3. function from stb/ctb/ntb
+print =============== will support: * from stb
+
+sql create topic topic_stb_column as select ts, c1, c3 from stb
+sql create topic topic_stb_all as select sqrt(c1) from stb
+sql create topic topic_stb_function as select ts, abs(c1), sin(c2) from stb
+
+sql create topic topic_ctb_column as select ts, c1, c3 from ct0
+sql create topic topic_ctb_all as select * from ct0
+sql create topic topic_ctb_function as select ts, abs(c1), sin(c2) from ct0
+
+sql create topic topic_ntb_column as select ts, c1, c3 from ntb
+sql create topic topic_ntb_all as select * from ntb
+sql create topic topic_ntb_function as select ts, abs(c1), sin(c2) from ntb
+
+sql show tables
+if $rows != 11 then 
+  return -1
+endi
+
+print =============== insert data
+$rowNum = 100
+$tstart = 1640966400000  # 2022-01-01 00:00:00.000
+
+$i = 0
+while $i < $tbNum
+  $tb = $tbPrefix . $i
+
+  $x = 0
+  while $x < $rowNum
+    $c = $x / 10
+    $c = $c * 10
+    $c = $x - $c
+
+    $binary = ' . binary
+    $binary = $binary . $c
+    $binary = $binary . '
+
+    sql insert into $tb values ($tstart , $c , $x , $binary )
+    sql insert into ntb values ($tstart , $c , $x , $binary )
+    $tstart = $tstart + 1
+    $x = $x + 1
+  endw
+
+  $i = $i + 1
+#  $tstart = 1640966400000
+endw
+
+#root@trd02 /home $ tmq_sim --help                                                                          
+# -c      Configuration directory, default is 
+# -d      The name of the database for cosumer, no default 
+# -t      The topic string for cosumer, no default 
+# -k      The key-value string for cosumer, no default 
+# -g      showMsgFlag, default is 0
+#        
+
+$consumeDelay = 2
+
+$expectMsgCntFromCtb = $rowNum
+$expectMsgCntFromStb = $rowNum * $tbNum
+$expectMsgCntFromNtb = $rowNum * $tbNum
+print expectMsgCntFromCtb: $expectMsgCntFromCtb
+print expectMsgCntFromStb: $expectMsgCntFromStb
+print expectMsgCntFromNtb: $expectMsgCntFromNtb
+
+# supported key:
+# group.id:<xxx>
+# enable.auto.commit:<true | false>
+# auto.offset.reset:<earliest | latest | none>
+# td.connect.ip:<fqdn | ipaddress>
+# td.connect.user:root
+# td.connect.pass:taosdata
+# td.connect.port:6030
+# td.connect.db:db
+ 
+$numOfTopics = 3
+$totalMsgCntOfmultiTopics = $expectMsgCntFromStb * $numOfTopics
+$expect_result = @{consume success: @
+$expect_result = $expect_result . $totalMsgCntOfmultiTopics
+$expect_result = $expect_result . @, @ 
+$expect_result = $expect_result . 0}
+print expect_result----> $expect_result
+print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t1 "topic_stb_column, topic_stb_function" -k1 "group.id:tg2" -t "topic_stb_function, topic_stb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromStb -j 2
+system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t1 "topic_stb_column, topic_stb_function" -k1 "group.id:tg2" -t "topic_stb_function, topic_stb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromStb -j 2
+print cmd result----> $system_content
+if $system_content != success then
+  return -1
+endi
+
+print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t1 "topic_stb_column, topic_stb_function" -k1 "group.id:tg1" -t "topic_stb_function, topic_stb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromStb -j 3
+system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t1 "topic_stb_column, topic_stb_function" -k1 "group.id:tg1" -t "topic_stb_function, topic_stb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromStb -j 3
+print cmd result----> $system_content
+if $system_content != success then
+  return -1
+endi
+
+#$numOfTopics = 3
+#$totalMsgCntOfmultiTopics = $rowNum * $numOfTopics
+#$expect_result = @{consume success: @
+#$expect_result = $expect_result . $totalMsgCntOfmultiTopics
+#$expect_result = $expect_result . @, @ 
+#$expect_result = $expect_result . 0}
+#print expect_result----> $expect_result
+print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_column, topic_ctb_function, topic_ctb_all" -k "group.id:tg2" -t "topic_ctb_column, topic_ctb_function, topic_ctb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromCtb -j 4
+system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_column, topic_ctb_function, topic_ctb_all" -k "group.id:tg2" -t "topic_ctb_column, topic_ctb_function, topic_ctb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromCtb -j 4
+print cmd result----> $system_content
+if $system_content != success then
+  return -1
+endi
+
+print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_column, topic_ctb_function" -k "group.id:tg1" -t "topic_ctb_function, topic_ctb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromCtb -j 3
+system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_column, topic_ctb_function" -k "group.id:tg1" -t "topic_ctb_function, topic_ctb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromCtb -j 3
+print cmd result----> $system_content
+if $system_content != success then
+  return -1
+endi
+
+print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_column, topic_ntb_function, topic_ntb_all" -k "group.id:tg2" -t "topic_ntb_column, topic_ntb_function, topic_ntb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromNtb -j 4
+system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_column, topic_ntb_function, topic_ntb_all" -k "group.id:tg2" -t "topic_ntb_column, topic_ntb_function, topic_ntb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromNtb -j 4
+print cmd result----> $system_content
+if $system_content != success then
+  return -1
+endi
+
+print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_column, topic_ntb_function" -k "group.id:tg1" -t "topic_ntb_function, topic_ntb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromNtb -j 3
+system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_column, topic_ntb_function" -k "group.id:tg1" -t "topic_ntb_function, topic_ntb_all" -k "group.id:tg2" -y $consumeDelay -m $expectMsgCntFromNtb -j 3
+print cmd result----> $system_content
+if $system_content != success then
+  return -1
+endi
+
+
+if $loop_cnt == 0 then
+  $loop_cnt = 1
+  $vgroups  = 4
+  $dbNamme  = d1
+  goto loop_vgroups
+endi
+
+
+#system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/test/c/tmqSim.c b/tests/test/c/tmqSim.c
index 86d0bef1a9..7862788a71 100644
--- a/tests/test/c/tmqSim.c
+++ b/tests/test/c/tmqSim.c
@@ -136,6 +136,10 @@ void parseArgument(int32_t argc, char* argv[]) {
     }
   }
 
+  if (0 == g_stConfInfo.consumeMsgCnt) {
+    g_stConfInfo.consumeMsgCnt = 0x7fffffff;
+  }
+
 #if 0
   pPrint("%s configDir:%s %s", GREEN, configDir, NC);
   pPrint("%s dbName:%s %s", GREEN, g_stConfInfo.dbName, NC);
@@ -493,6 +497,29 @@ int main(int32_t argc, char* argv[]) {
       } else {
     	 printf("fail, consumer msg cnt: %d, %d", totalMsgs, pInfo->consumeMsgCnt);
       }	
+	} else if (2 == g_stConfInfo.checkMode) {
+      if ((totalMsgs +  pInfo->consumeMsgCnt) == 3 * g_stConfInfo.consumeMsgCnt) {
+    	 printf("success");
+      } else {
+    	 printf("fail, consumer msg cnt: %d, %d", totalMsgs, pInfo->consumeMsgCnt);
+      }	
+	} else if (3 == g_stConfInfo.checkMode) {
+      if ((totalMsgs == 2 * g_stConfInfo.consumeMsgCnt) && (pInfo->consumeMsgCnt == 2 * g_stConfInfo.consumeMsgCnt)) {
+    	 printf("success");
+      } else {
+    	 printf("fail, consumer msg cnt: %d, %d", totalMsgs, pInfo->consumeMsgCnt);
+      }	
+	} else if (4 == g_stConfInfo.checkMode) {
+      if (((totalMsgs == 0) && (pInfo->consumeMsgCnt == 3 * g_stConfInfo.consumeMsgCnt)) 
+	  	|| ((pInfo->consumeMsgCnt == 0) && (totalMsgs == 3 * g_stConfInfo.consumeMsgCnt)) 
+	  	|| ((pInfo->consumeMsgCnt == g_stConfInfo.consumeMsgCnt) && (totalMsgs == 2 * g_stConfInfo.consumeMsgCnt))
+	  	|| ((pInfo->consumeMsgCnt == 2 * g_stConfInfo.consumeMsgCnt) && (totalMsgs == g_stConfInfo.consumeMsgCnt))) {
+    	 printf("success");
+      } else {
+    	 printf("fail, consumer msg cnt: %d, %d", totalMsgs, pInfo->consumeMsgCnt);
+      }	
+	} else {
+    	 printf("fail, check mode unknow. consumer msg cnt: %d, %d", totalMsgs, pInfo->consumeMsgCnt);
 	}
   }
 

From 8572bd2afa74839b5c498cc7aee06962206f1269 Mon Sep 17 00:00:00 2001
From: Ganlin Zhao <36554565+glzhao89@users.noreply.github.com>
Date: Wed, 13 Apr 2022 12:38:57 +0800
Subject: [PATCH 06/11] feat(query): add TK_TODAY in keyword hashtable

TD-14243
---
 include/common/ttokendef.h            |   83 +-
 source/libs/parser/inc/sql.y          |    1 +
 source/libs/parser/src/parTokenizer.c |    1 +
 source/libs/parser/src/sql.c          | 4067 ++++++++++++++-----------
 4 files changed, 2285 insertions(+), 1867 deletions(-)

diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h
index f5b9c23ee6..7840d18256 100644
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@@ -182,47 +182,48 @@
 #define TK_FIRST                          164
 #define TK_LAST                           165
 #define TK_NOW                            166
-#define TK_ROWTS                          167
-#define TK_TBNAME                         168
-#define TK_QSTARTTS                       169
-#define TK_QENDTS                         170
-#define TK_WSTARTTS                       171
-#define TK_WENDTS                         172
-#define TK_WDURATION                      173
-#define TK_BETWEEN                        174
-#define TK_IS                             175
-#define TK_NK_LT                          176
-#define TK_NK_GT                          177
-#define TK_NK_LE                          178
-#define TK_NK_GE                          179
-#define TK_NK_NE                          180
-#define TK_MATCH                          181
-#define TK_NMATCH                         182
-#define TK_JOIN                           183
-#define TK_INNER                          184
-#define TK_SELECT                         185
-#define TK_DISTINCT                       186
-#define TK_WHERE                          187
-#define TK_PARTITION                      188
-#define TK_BY                             189
-#define TK_SESSION                        190
-#define TK_STATE_WINDOW                   191
-#define TK_SLIDING                        192
-#define TK_FILL                           193
-#define TK_VALUE                          194
-#define TK_NONE                           195
-#define TK_PREV                           196
-#define TK_LINEAR                         197
-#define TK_NEXT                           198
-#define TK_GROUP                          199
-#define TK_HAVING                         200
-#define TK_ORDER                          201
-#define TK_SLIMIT                         202
-#define TK_SOFFSET                        203
-#define TK_LIMIT                          204
-#define TK_OFFSET                         205
-#define TK_ASC                            206
-#define TK_NULLS                          207
+#define TK_TODAY                          167
+#define TK_ROWTS                          168
+#define TK_TBNAME                         169
+#define TK_QSTARTTS                       170
+#define TK_QENDTS                         171
+#define TK_WSTARTTS                       172
+#define TK_WENDTS                         173
+#define TK_WDURATION                      174
+#define TK_BETWEEN                        175
+#define TK_IS                             176
+#define TK_NK_LT                          177
+#define TK_NK_GT                          178
+#define TK_NK_LE                          179
+#define TK_NK_GE                          180
+#define TK_NK_NE                          181
+#define TK_MATCH                          182
+#define TK_NMATCH                         183
+#define TK_JOIN                           184
+#define TK_INNER                          185
+#define TK_SELECT                         186
+#define TK_DISTINCT                       187
+#define TK_WHERE                          188
+#define TK_PARTITION                      189
+#define TK_BY                             190
+#define TK_SESSION                        191
+#define TK_STATE_WINDOW                   192
+#define TK_SLIDING                        193
+#define TK_FILL                           194
+#define TK_VALUE                          195
+#define TK_NONE                           196
+#define TK_PREV                           197
+#define TK_LINEAR                         198
+#define TK_NEXT                           199
+#define TK_GROUP                          200
+#define TK_HAVING                         201
+#define TK_ORDER                          202
+#define TK_SLIMIT                         203
+#define TK_SOFFSET                        204
+#define TK_LIMIT                          205
+#define TK_OFFSET                         206
+#define TK_ASC                            207
+#define TK_NULLS                          208
 
 #define TK_NK_SPACE                       300
 #define TK_NK_COMMENT                     301
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 94aec0e744..12ae5819b4 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -588,6 +588,7 @@ column_reference(A) ::= column_name(B).
 column_reference(A) ::= table_name(B) NK_DOT column_name(C).                      { A = createRawExprNodeExt(pCxt, &B, &C, createColumnNode(pCxt, &B, &C)); }
 
 pseudo_column(A) ::=  NOW(B).                                                     { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
+pseudo_column(A) ::=  TODAY(B).                                                   { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
 pseudo_column(A) ::=  ROWTS(B).                                                   { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
 pseudo_column(A) ::=  TBNAME(B).                                                  { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
 pseudo_column(A) ::=  QSTARTTS(B).                                                { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c
index 5c2f10f810..0493771b61 100644
--- a/source/libs/parser/src/parTokenizer.c
+++ b/source/libs/parser/src/parTokenizer.c
@@ -175,6 +175,7 @@ static SKeyword keywordTable[] = {
     {"TBNAME",        TK_TBNAME},
     {"TIMESTAMP",     TK_TIMESTAMP},
     {"TINYINT",       TK_TINYINT},
+    {"TODAY",         TK_TODAY},
     {"TOPIC",         TK_TOPIC},
     {"TOPICS",        TK_TOPICS},
     {"TSERIES",       TK_TSERIES},
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index 610f6b9263..b1f8a24a83 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -100,24 +100,24 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 314
+#define YYNOCODE 315
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE  SToken 
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  ENullOrder yy69;
-  SNode* yy140;
-  EFillMode yy174;
-  SAlterOption yy181;
-  SNodeList* yy220;
-  EJoinType yy224;
-  EOrder yy238;
-  SToken yy253;
-  bool yy273;
-  SDataType yy368;
-  EOperatorType yy480;
-  int32_t yy528;
+  SToken yy29;
+  bool yy47;
+  EFillMode yy144;
+  EJoinType yy162;
+  SNode* yy182;
+  EOrder yy218;
+  SNodeList* yy334;
+  EOperatorType yy380;
+  ENullOrder yy487;
+  SAlterOption yy515;
+  int32_t yy550;
+  SDataType yy574;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -133,16 +133,17 @@ typedef union {
 #define ParseCTX_FETCH
 #define ParseCTX_STORE
 #define YYNSTATE             548
-#define YYNRULE              410
-#define YYNTOKEN             208
+#define YYNRULE              411
+#define YYNRULE_WITH_ACTION  411
+#define YYNTOKEN             209
 #define YY_MAX_SHIFT         547
-#define YY_MIN_SHIFTREDUCE   807
-#define YY_MAX_SHIFTREDUCE   1216
-#define YY_ERROR_ACTION      1217
-#define YY_ACCEPT_ACTION     1218
-#define YY_NO_ACTION         1219
-#define YY_MIN_REDUCE        1220
-#define YY_MAX_REDUCE        1629
+#define YY_MIN_SHIFTREDUCE   808
+#define YY_MAX_SHIFTREDUCE   1218
+#define YY_ERROR_ACTION      1219
+#define YY_ACCEPT_ACTION     1220
+#define YY_NO_ACTION         1221
+#define YY_MIN_REDUCE        1222
+#define YY_MAX_REDUCE        1632
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -209,483 +210,483 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (1533)
+#define YY_ACTTAB_COUNT (1539)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   463,   25,  194,   52,  257,  306, 1497,    9,    8,   72,
- /*    10 */   277,  388,   30,   28,  463,  274,  369, 1421, 1423,  270,
- /*    20 */   266, 1481, 1052,  310, 1336, 1340,  396,  115, 1072, 1481,
- /*    30 */  1514, 1497, 1481, 1477, 1483, 1342, 1608,  446, 1050, 1340,
- /*    40 */   166, 1477, 1484,  391, 1477, 1483,  462,  449,  385,  131,
- /*    50 */    11, 1468,  406, 1606,  165, 1514,  312, 1057,   29,   27,
- /*    60 */    26,  348,  446,   30,   28, 1159,  463,  119, 1498, 1499,
- /*    70 */  1503,  266,  449, 1052,    1,   72, 1468,   30,   28,  265,
- /*    80 */    42, 1135,  375,   41,  462,  266,  238, 1052, 1497, 1050,
- /*    90 */  1331, 1340,  229, 1498, 1499, 1503,  407,  544,  540,  539,
- /*   100 */  1075,   11,  462, 1050,  450,  435, 1621,  269, 1057, 1051,
- /*   110 */  1430,  463, 1514,  381,  380,   11,   30,   28,  430,  446,
- /*   120 */   311,  117, 1057, 1232,  266,    1, 1052, 1608, 1608,  449,
- /*   130 */   513,  511, 1243, 1468,  430, 1468, 1340, 1124,   12,    1,
- /*   140 */   131, 1607, 1050,  100, 1606, 1606, 1053, 1318,  544,   70,
- /*   150 */  1498, 1499, 1503, 1547,  420, 1128,   12, 1546, 1543,  100,
- /*   160 */  1051, 1057,  544, 1056, 1076, 1077, 1103, 1104, 1105, 1106,
- /*   170 */  1107, 1108, 1109, 1110, 1051,  463,   98, 1468,    7,   22,
- /*   180 */  1242,   30,   28,  448,  319,  132,  128, 1554, 1555,  266,
- /*   190 */  1559, 1052,   98,  132,  118,  132,  348, 1053, 1298, 1387,
- /*   200 */  1340,  544,  129, 1554, 1555,  256, 1559, 1050,  425,  421,
- /*   210 */  1385, 1053, 1074, 1051, 1056, 1076, 1077, 1103, 1104, 1105,
- /*   220 */  1106, 1107, 1108, 1109, 1110, 1468, 1057, 1221, 1056, 1076,
- /*   230 */  1077, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110,  305,
- /*   240 */   844,  304,  843,    7, 1076, 1077,    9,    8,   84,  132,
- /*   250 */  1053,   83,   82,   81,   80,   79,   78,   77,   76,   75,
- /*   260 */   845,   32,   31,   29,   27,   26,  544, 1056, 1076, 1077,
- /*   270 */  1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1051,  132,
- /*   280 */   424, 1418,   52,   30,   28,  237,   65, 1072,  139,  132,
- /*   290 */   383,  266,  377, 1052,  327,   96,  382,  339, 1241,   97,
- /*   300 */   101,  378,  376, 1335,  379,  216,  340, 1332, 1370, 1050,
- /*   310 */    32,   31,   29,   27,   26, 1053,   84, 1566, 1154,   83,
- /*   320 */    82,   81,   80,   79,   78,   77,   76,   75, 1057, 1220,
- /*   330 */   334, 1183, 1056, 1076, 1077, 1103, 1104, 1105, 1106, 1107,
- /*   340 */  1108, 1109, 1110, 1468, 1078,    7,  164,  445,  241,  137,
- /*   350 */   372,  895,  498,   93,   92,   91,   90,   89,   88,   87,
- /*   360 */    86,   85,  417, 1181, 1182, 1184, 1185,  501,  544, 1312,
- /*   370 */   897, 1079,  374, 1091,  250,   50,  141,  140,   49,  338,
- /*   380 */  1051, 1122,  333,  332,  331,  330,  329,  430,  326,  325,
- /*   390 */   324,  323,  322,  318,  317,  316,  315,  314,  313,  463,
- /*   400 */   164,   30,   28,  489,  372, 1561,  463,  450,  320,  266,
- /*   410 */  1561, 1052,  100, 1431, 1387,  347,  251, 1053,  249,  248,
- /*   420 */   271,  371, 1514, 1558, 1340, 1385,  374, 1050, 1557,  446,
- /*   430 */  1123, 1340, 1215, 1216, 1056, 1076, 1077, 1103, 1104, 1105,
- /*   440 */  1106, 1107, 1108, 1109, 1110,   98, 1057, 1269, 1127,   32,
- /*   450 */    31,   29,   27,   26,  432,  127, 1554, 1555, 1317, 1559,
- /*   460 */  1114,  423,  189,    1, 1073,   32,   31,   29,   27,   26,
- /*   470 */  1561,   59,   24,  264, 1117, 1118, 1119, 1120, 1121, 1125,
- /*   480 */  1126,   32,   31,   29,   27,   26,  544,  241, 1556,  175,
- /*   490 */  1166,  157, 1333,  122,  155, 1158, 1074, 1240, 1051,  520,
- /*   500 */   519,  518,  517,  281, 1380,  516,  515,  514,  102,  509,
- /*   510 */   508,  507,  506,  505,  504,  503,  502,  108,  159,  209,
- /*   520 */  1122,  158,  500,  494,  933,  486,  485,  484,  937,  483,
- /*   530 */   939,  940,  482,  942,  479, 1053,  948,  476,  950,  951,
- /*   540 */   473,  470, 1468, 1239, 1173,  496,  116, 1329, 1218, 1316,
- /*   550 */     6,  222, 1056, 1076, 1077, 1103, 1104, 1105, 1106, 1107,
- /*   560 */  1108, 1109, 1110,  220,  493,  492,  491,   21,  490, 1123,
- /*   570 */   161,  437,   23,  160,  843, 1238,  142,   32,   31,   29,
- /*   580 */    27,   26,   32,   31,   29,   27,   26, 1127, 1468,  115,
- /*   590 */   367, 1325, 1213,  152, 1272, 1327,  125, 1343,  498,  463,
- /*   600 */   463,  282,  365,  397,  361,  357,  353,  151, 1337,  460,
- /*   610 */  1387,   24,  264, 1117, 1118, 1119, 1120, 1121, 1125, 1126,
- /*   620 */  1468, 1422, 1323,  169, 1340, 1340,  297,  276,  447,  463,
- /*   630 */   273,  272, 1608,   53, 1608,  115,  149, 1237,  461,   67,
- /*   640 */  1065,  299, 1497, 1342, 1457,  131,  383,  131,  377, 1606,
- /*   650 */   163, 1606,  382,  162, 1340,   97, 1058,  378,  376, 1212,
- /*   660 */   379,   32,   31,   29,   27,   26, 1514,   48,   47,  309,
- /*   670 */  1387,  136,  405,  446,  512, 1057,  303, 1157,  300, 1259,
- /*   680 */   289, 1386, 1468,  449,  246, 1497,  295, 1468,  291,  287,
- /*   690 */   133, 1154,  434,  148,  279,  121,  106,  145, 1497, 1236,
- /*   700 */   409,  384,  115,   68, 1498, 1499, 1503, 1547,  488, 1514,
- /*   710 */  1342,  240, 1543,  132,  143,  464,  433,   32,   31,   29,
- /*   720 */    27,   26, 1514, 1608, 1091,  395,  449, 1061,  463,  446,
- /*   730 */  1468, 1235, 1234, 1299,  441,  438,  131,  208,  393,  449,
- /*   740 */  1606, 1497,  463, 1468, 1468, 1231,   69, 1498, 1499, 1503,
- /*   750 */  1547,  280, 1387, 1340,  259, 1543,  126, 1254,  278,  119,
- /*   760 */  1498, 1499, 1503, 1385, 1066, 1514,  547, 1340,  190,  436,
- /*   770 */   430, 1233,  433, 1230,  413, 1574, 1468, 1468, 1060,  386,
- /*   780 */   213, 1069,  449,   95, 1052, 1252, 1468, 1229, 1228,  536,
- /*   790 */  1468,  532,  528,  524,  212,  100, 1227,   44, 1622, 1226,
- /*   800 */  1050, 1180,   69, 1498, 1499, 1503, 1547,  389,  191,  178,
- /*   810 */   259, 1543,  126,  180,  434, 1225, 1224,  418, 1468, 1057,
- /*   820 */    66, 1223,   33,  206, 1497,   33, 1129, 1059,   98, 1087,
- /*   830 */   343, 1575, 1468, 1468, 1488, 1381,  404,   64,  187, 1554,
- /*   840 */   429, 1468,  428,  114, 1468, 1608, 1486,   61, 1514, 1063,
- /*   850 */    44, 1497,   33,  459,  921,  446, 1019,  366,  131,  544,
- /*   860 */  1468, 1468, 1606,  184, 1577,  449, 1468,  439,  442, 1468,
- /*   870 */   197, 1051,   94,  104,  199, 1514,  455,  205, 1497,  106,
- /*   880 */  1515,  412,  446,  926,  171,   69, 1498, 1499, 1503, 1547,
- /*   890 */   431,    2,  449,  259, 1543, 1620, 1468,  193, 1062, 1036,
- /*   900 */  1072,  168, 1514,  468, 1581,  869,  104,  954, 1053,  446,
- /*   910 */   958,  284,   69, 1498, 1499, 1503, 1547,  288,  245,  449,
- /*   920 */   259, 1543, 1620, 1468,  870, 1056,  105,  895, 1497,  247,
- /*   930 */   964, 1604,  106,  104, 1028,  214,  963,  107,  321,   69,
- /*   940 */  1498, 1499, 1503, 1547, 1420,  138,  328,  259, 1543, 1620,
- /*   950 */   336,  335, 1514, 1497,  337, 1083,  341,  342, 1565,  446,
- /*   960 */  1082,  344,  144, 1081,  345,  346, 1080,  147,   51,  449,
- /*   970 */   349,  150,  368, 1468,  398,  399,  370, 1514,  434, 1330,
- /*   980 */  1497,  154,  411,  400,  446, 1326,  255,   74,  401,  228,
- /*   990 */  1498, 1499, 1503,  156,  449,  373,  109,  408, 1468,  110,
- /*  1000 */  1328, 1324,  111,  112, 1514, 1079, 1497,  170,  173, 1608,
- /*  1010 */   419,  446, 1588,  410,   70, 1498, 1499, 1503, 1547,  453,
- /*  1020 */  1057,  449,  131, 1544,    5, 1468, 1606, 1578,  183,  176,
- /*  1030 */  1514,  416, 1497, 1587,  179, 1568,  258,  446,  422,  427,
- /*  1040 */  1497,   70, 1498, 1499, 1503, 1547,  415,  449, 1154,  444,
- /*  1050 */  1543, 1468,    4,   99,  414, 1078, 1514, 1562,   34,  260,
- /*  1060 */   443,  186,  440,  446, 1514,   17, 1429,  233, 1498, 1499,
- /*  1070 */  1503,  446,  124,  449, 1497, 1529,  451, 1468,  185,  452,
- /*  1080 */   456,  449,  203, 1428,  268, 1468,  201, 1497,  263,   58,
- /*  1090 */   457,  458, 1341,  232, 1498, 1499, 1503, 1623, 1514, 1497,
- /*  1100 */   192,  233, 1498, 1499, 1503,  446, 1605,  466,  215, 1313,
- /*  1110 */    60, 1514,  495,  217,  211,  449,  543,   40,  446, 1468,
- /*  1120 */   219,  223,  267, 1514,  224,  426,  221, 1462,  449, 1461,
- /*  1130 */   446,  283, 1468, 1497, 1458,  233, 1498, 1499, 1503,  285,
- /*  1140 */   449,  286, 1046, 1047, 1468,  134,  290, 1456,  225, 1498,
- /*  1150 */  1499, 1503,  292,  293,  294, 1455,  296, 1514, 1454, 1497,
- /*  1160 */   231, 1498, 1499, 1503,  446, 1445,  298,  135,  301,  302,
- /*  1170 */  1031, 1030, 1439, 1438,  449,  307,  308, 1437, 1468,  103,
- /*  1180 */  1002, 1413, 1412, 1514, 1436, 1497, 1411, 1410, 1409, 1408,
- /*  1190 */   446, 1407, 1406, 1405,  234, 1498, 1499, 1503, 1404, 1403,
- /*  1200 */   449, 1402, 1401, 1400, 1468, 1004, 1391, 1390, 1389, 1514,
- /*  1210 */  1497, 1399, 1398, 1397, 1396, 1395,  446, 1394, 1393, 1392,
- /*  1220 */   226, 1498, 1499, 1503, 1388, 1271,  449, 1453, 1447, 1435,
- /*  1230 */  1468, 1426, 1319,  146, 1514, 1497,  862, 1270, 1268,  352,
- /*  1240 */  1266,  446,  350,  356, 1497,  351,  235, 1498, 1499, 1503,
- /*  1250 */  1264,  449, 1262,  360,  354, 1468,  355,  359, 1251, 1514,
- /*  1260 */   358,  362,  363, 1250, 1247, 1321,  446,  969, 1514, 1320,
- /*  1270 */  1260,  227, 1498, 1499, 1503,  446,  449,  364,   73, 1497,
- /*  1280 */  1468,  971,  894,  252,  893,  449,  892,  891, 1255, 1468,
- /*  1290 */   253,  888,  887, 1253,  387,  254,  236, 1498, 1499, 1503,
- /*  1300 */   390, 1246,  392, 1514,  512, 1511, 1498, 1499, 1503, 1245,
- /*  1310 */   446,  153,  510, 1497,  394,   71, 1452,  167,   43, 1038,
- /*  1320 */   449, 1446,  113, 1434, 1468,  402, 1433, 1425,  172,   14,
- /*  1330 */    54,    3,  403, 1486,  177,   37,   35, 1514,   33,   15,
- /*  1340 */  1510, 1498, 1499, 1503,  446,   38, 1179, 1497,   10,  120,
- /*  1350 */   181,   19,  188, 1172,  449,  182, 1497,   55, 1468,   56,
- /*  1360 */    20, 1151, 1497, 1201,    8, 1150, 1206,   36,  130,  174,
- /*  1370 */   123, 1514, 1200,   16,  243, 1498, 1499, 1503,  446,  261,
- /*  1380 */  1514, 1315, 1205, 1204,  262,  195, 1514,  446,  449, 1089,
- /*  1390 */  1497,   13, 1468,  446, 1088,  196,   18,  449, 1424, 1177,
- /*  1400 */   202, 1468, 1115,  449,  198,  200,   45, 1468, 1509, 1498,
- /*  1410 */  1499, 1503,   57,   61, 1514,  454, 1497,  244, 1498, 1499,
- /*  1420 */  1503,  446, 1485,  242, 1498, 1499, 1503,  204,  207, 1067,
- /*  1430 */    39,  449,  465,  955,  467, 1468,  952,  275,  469,  471,
- /*  1440 */  1514,  472,  209,  949,  474,  475,  494,  446,  943,  477,
- /*  1450 */   478,  239, 1498, 1499, 1503,  941,  480,  449,  481,  947,
- /*  1460 */   932, 1468,  946,   62,  945,  944,  487,  966,  496,   46,
- /*  1470 */   962,   63,  960,  860,  497,  499,  901,  230, 1498, 1499,
- /*  1480 */  1503,  965,  883,  210,  882,  881,  880,  493,  492,  491,
- /*  1490 */   879,  490,  878,  877,  876,  896,  898,  873,  872,  871,
- /*  1500 */   868,  867,  866,  865, 1267,  521,  522, 1265, 1263,  523,
- /*  1510 */   526,  525,  527,  529,  530, 1261,  534,  533, 1249,  531,
- /*  1520 */   535,  537,  538, 1248, 1244,  541,  542, 1219, 1054, 1219,
- /*  1530 */   546,  218,  545,
+ /*     0 */   450,  257, 1483,  269,   25,  194, 1432,  117,  122, 1234,
+ /*    10 */   312, 1331,   30,   28, 1479, 1486,  306, 1499, 1483, 1382,
+ /*    20 */   266,  462, 1053,   21, 1075,   32,   31,   29,   27,   26,
+ /*    30 */  1479, 1485,   23,   32,   31,   29,   27,   26, 1051,  274,
+ /*    40 */   238, 1516,   32,   31,   29,   27,   26, 1611,  446, 1073,
+ /*    50 */    11,   30,   28, 1161,  348,  406, 1483, 1058,  449,  266,
+ /*    60 */   131, 1053, 1470, 1320, 1609,   30,   28,  434, 1479, 1485,
+ /*    70 */   430,    9,    8,  266,    1, 1053,  463, 1051,   68, 1500,
+ /*    80 */  1501, 1505, 1550,  540,  539,   72,  240, 1546, 1175,   11,
+ /*    90 */  1499, 1051,  369,  424,  450,  100, 1058,  544, 1611,  407,
+ /*   100 */  1433, 1342, 1261,   11,   32,   31,   29,   27,   26, 1052,
+ /*   110 */  1058,  131,  348,    1, 1516, 1609,   32,   31,   29,   27,
+ /*   120 */    26,  433,  118, 1389,  384,  277, 1300,    1,   98,  256,
+ /*   130 */  1611,  449, 1423, 1425, 1387, 1470,  544,  432,  127, 1557,
+ /*   140 */  1558,  270, 1562,  131,  498, 1137, 1054, 1609, 1052,  115,
+ /*   150 */   544,   69, 1500, 1501, 1505, 1550,  845, 1344,  844,  259,
+ /*   160 */  1546,  126, 1052, 1057, 1077, 1078, 1104, 1105, 1106, 1107,
+ /*   170 */  1108, 1109, 1110, 1111, 1112,  164,  846,  381,  380,  372,
+ /*   180 */  1578,  462, 1564, 1220,   84, 1054,  132,   83,   82,   81,
+ /*   190 */    80,   79,   78,   77,   76,   75,   29,   27,   26, 1054,
+ /*   200 */  1561,  374, 1057, 1077, 1078, 1104, 1105, 1106, 1107, 1108,
+ /*   210 */  1109, 1110, 1111, 1112, 1319,  132, 1057, 1077, 1078, 1104,
+ /*   220 */  1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1318,   30,
+ /*   230 */    28,  547,  305, 1564,  304,   12,  282,  266,  383, 1053,
+ /*   240 */   377,  896,  132, 1215,  382,  213,  462,   97,   95,  378,
+ /*   250 */   376, 1560,  379,  115,  536, 1051,  532,  528,  524,  212,
+ /*   260 */   898, 1345,   32,   31,   29,   27,   26, 1611,   30,   28,
+ /*   270 */   448, 1499,  463,  132, 1058,  209,  266,  498, 1053,  494,
+ /*   280 */   131,  310,   30,   28, 1609,   66,   52, 1076,  206, 1074,
+ /*   290 */   266,    7, 1053, 1333, 1051, 1516,   65, 1342, 1516,   96,
+ /*   300 */    12,  496,  433, 1245,  334,  446,  463, 1337, 1051,  489,
+ /*   310 */   101, 1214,  449, 1058,  544,  311, 1470, 1334,  459,  438,
+ /*   320 */   493,  492,  491, 1185,  490, 1092, 1052, 1058,  513,  511,
+ /*   330 */     7, 1342,   69, 1500, 1501, 1505, 1550,  423, 1470,  395,
+ /*   340 */   259, 1546,  126, 1274,    7, 1222,  412,  132, 1470,  171,
+ /*   350 */   141,  140,  393,  544,  190,  417, 1183, 1184, 1186, 1187,
+ /*   360 */   413, 1577,  500, 1054, 1037, 1052,  168,  544, 1244,   93,
+ /*   370 */    92,   91,   90,   89,   88,   87,   86,   85, 1327, 1052,
+ /*   380 */  1057, 1077, 1078, 1104, 1105, 1106, 1107, 1108, 1109, 1110,
+ /*   390 */  1111, 1112, 1079,  430, 1389,  383,   52,  377, 1611, 1329,
+ /*   400 */   271,  382, 1054,  132,   97, 1387,  378,  376, 1243,  379,
+ /*   410 */  1242, 1610,  405, 1470, 1241, 1609, 1054, 1338,  100, 1057,
+ /*   420 */  1077, 1078, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111,
+ /*   430 */  1112, 1077, 1078, 1057, 1077, 1078, 1104, 1105, 1106, 1107,
+ /*   440 */  1108, 1109, 1110, 1111, 1112,  430,   30,   28,  237,  420,
+ /*   450 */  1073,   98,  439, 1470,  266, 1470, 1053,  327,   59, 1470,
+ /*   460 */   339,  128, 1557, 1558, 1420, 1562, 1080, 1160,  397,  340,
+ /*   470 */   100,  139, 1051,   32,   31,   29,   27,   26,  437, 1335,
+ /*   480 */   934,  486,  485,  484,  938,  483,  940,  941,  482,  943,
+ /*   490 */   479, 1058,  949,  476,  951,  952,  473,  470, 1223, 1611,
+ /*   500 */  1569, 1156, 1564,   98,  425,  421,    9,    8,    1,  463,
+ /*   510 */   189,  241,  131,  129, 1557, 1558, 1609, 1562,  319,   84,
+ /*   520 */  1559, 1240,   83,   82,   81,   80,   79,   78,   77,   76,
+ /*   530 */    75,  544,  216, 1325, 1342, 1372, 1092,   32,   31,   29,
+ /*   540 */    27,   26,  338, 1052, 1124,  333,  332,  331,  330,  329,
+ /*   550 */  1239,  326,  325,  324,  323,  322,  318,  317,  316,  315,
+ /*   560 */   314,  313, 1271,  137,  116,  463, 1470, 1238,  501,  222,
+ /*   570 */  1314, 1389, 1389,    6,  320,   32,   31,   29,   27,   26,
+ /*   580 */  1054,  220, 1424, 1388,  175, 1168,  169,  447, 1237,   50,
+ /*   590 */  1342, 1075,   49, 1125,  142, 1470,  488, 1057, 1077, 1078,
+ /*   600 */  1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1235,
+ /*   610 */  1236, 1129, 1470,  241,  520,  519,  518,  517,  281, 1233,
+ /*   620 */   516,  515,  514,  102,  509,  508,  507,  506,  505,  504,
+ /*   630 */   503,  502,  108, 1470, 1232, 1499,   24,  264, 1119, 1120,
+ /*   640 */  1121, 1122, 1123, 1127, 1128,  463, 1124,  463, 1231,  463,
+ /*   650 */  1159,  844,  276,  463,   72, 1470,  347,   67, 1339, 1516,
+ /*   660 */   115,  375,  460,  114, 1470,  279,  446,  367, 1344, 1256,
+ /*   670 */  1342,  870, 1342,  115, 1342,  463,  449,  436, 1342, 1470,
+ /*   680 */  1470, 1344, 1230, 1229,  461,   48,   47,  309, 1499,  136,
+ /*   690 */   871,  386,  463, 1470,  303, 1125,  119, 1500, 1501, 1505,
+ /*   700 */  1342,  208,  246,  297,  295, 1389,  291,  287,  133, 1301,
+ /*   710 */   512,  278, 1516, 1129,  300, 1156, 1387, 1342,  299,  446,
+ /*   720 */   157, 1053,  463,  155, 1499, 1228, 1227, 1470, 1470,  449,
+ /*   730 */   445,  280,  132, 1470,  435, 1624, 1126, 1051,   24,  264,
+ /*   740 */  1119, 1120, 1121, 1122, 1123, 1127, 1128, 1342, 1516,   69,
+ /*   750 */  1500, 1501, 1505, 1550, 1130,  446, 1058,  259, 1546, 1623,
+ /*   760 */  1499, 1459, 1226,  152, 1225,  449,  125,  191, 1584, 1470,
+ /*   770 */  1470, 1470,  365,  343,  361,  357,  353,  151,  159,   22,
+ /*   780 */   161,  158,  418,  160, 1516,   69, 1500, 1501, 1505, 1550,
+ /*   790 */  1254,  446,  441,  259, 1546, 1623,  544,  289, 1217, 1218,
+ /*   800 */  1383,  449,  250,   53, 1607, 1470,  149, 1470, 1052, 1470,
+ /*   810 */  1499,  163,  389,  106,  162,   44,  178,  409,  404, 1182,
+ /*   820 */   180,   69, 1500, 1501, 1505, 1550, 1490,  184,  164,  259,
+ /*   830 */  1546, 1623,  372,  366, 1516,   33, 1580, 1499, 1488, 1131,
+ /*   840 */  1568,  446,  431, 1116,  251, 1054,  249,  248, 1061,  371,
+ /*   850 */  1517,  449, 1499,   33,  374, 1470,  193, 1088, 1073, 1060,
+ /*   860 */   434, 1516, 1057,  148,    2,  121,   33,  145,  446,  284,
+ /*   870 */  1020,  228, 1500, 1501, 1505,  288, 1516,  197,  449, 1499,
+ /*   880 */   245,  199, 1470,  446,  143,   94,  273,  272,  104,  455,
+ /*   890 */   896, 1611,  205,  449,  247, 1029, 1066, 1470,   70, 1500,
+ /*   900 */  1501, 1505, 1550, 1516,  131,  321, 1549, 1546, 1609,  214,
+ /*   910 */   446, 1422, 1059,   70, 1500, 1501, 1505, 1550,   64, 1064,
+ /*   920 */   449,  444, 1546,  430, 1470,  106,  328,  442,   61,  927,
+ /*   930 */  1063, 1058,   44,  468,  104,  138,  922,  955,  959,  336,
+ /*   940 */    70, 1500, 1501, 1505, 1550,  335,  105,  337,  100, 1547,
+ /*   950 */   965, 1084,  341,  106,  104, 1499,  342,  964,  107, 1083,
+ /*   960 */   144,  345,  344, 1082,  346,  349,  147,  434,   51,  150,
+ /*   970 */  1081,  464,  368,  370, 1332,  154,  373, 1328,   74, 1516,
+ /*   980 */   399,   98, 1499, 1062,  400,  401,  446,  255,  408,  156,
+ /*   990 */  1499,  187, 1557,  429,  170,  428,  449,  173, 1611,  109,
+ /*  1000 */  1470,  110, 1330,  265, 1326,  111, 1516,  112, 1080,  411,
+ /*  1010 */   419,  131, 1591,  446, 1516, 1609,  229, 1500, 1501, 1505,
+ /*  1020 */  1067,  446,  398,  449,  410,  453, 1058, 1470, 1581,  416,
+ /*  1030 */   414,  449,  176,  179, 1499, 1470,    5, 1070, 1590,  415,
+ /*  1040 */   258,  422,  427,  233, 1500, 1501, 1505,    4,   99, 1079,
+ /*  1050 */  1571,  232, 1500, 1501, 1505,  185,  183, 1156, 1516,  124,
+ /*  1060 */  1565,   34,  443,  260,   17,  446, 1431, 1532, 1499,  186,
+ /*  1070 */   440, 1430,  456,  457,   60,  449, 1499,  451,  458, 1470,
+ /*  1080 */   452, 1499,  268,  426,  201,  203, 1343,  466,   58,  221,
+ /*  1090 */  1626, 1315, 1516,  211,  192,  119, 1500, 1501, 1505,  446,
+ /*  1100 */  1516, 1608,  215,  495,  217, 1516,  543,  446,  223,  449,
+ /*  1110 */    40, 1464,  446, 1470,  224,  219,  263,  449, 1463,  283,
+ /*  1120 */  1460, 1470,  449, 1499,  267,  285, 1470, 1047, 1499,  233,
+ /*  1130 */  1500, 1501, 1505,  388, 1625,  286, 1499,  233, 1500, 1501,
+ /*  1140 */  1505, 1048,  225, 1500, 1501, 1505,  290, 1516,  396, 1458,
+ /*  1150 */   134,  294, 1516,  292,  446,  293, 1457,  296, 1456,  446,
+ /*  1160 */  1516,  298,  166, 1447,  449,  391,  135,  446, 1470,  449,
+ /*  1170 */   385,  301,  302, 1470, 1317, 1441,  165,  449, 1032, 1031,
+ /*  1180 */  1499, 1470, 1440,  307,  231, 1500, 1501, 1505,  308,  234,
+ /*  1190 */  1500, 1501, 1505, 1439, 1438, 1499, 1003,  226, 1500, 1501,
+ /*  1200 */  1505, 1415,   42, 1414, 1516,   41, 1499, 1413, 1412, 1411,
+ /*  1210 */  1410,  446, 1409, 1408, 1407, 1406, 1405, 1404, 1403, 1516,
+ /*  1220 */  1402,  449, 1401, 1400,  103, 1470,  446, 1399, 1398, 1397,
+ /*  1230 */  1516, 1499, 1396, 1395, 1394,  209,  449,  446, 1393,  494,
+ /*  1240 */  1470,  235, 1500, 1501, 1505, 1392, 1005,  449, 1391, 1390,
+ /*  1250 */  1273, 1470, 1455, 1449, 1437, 1516,  227, 1500, 1501, 1505,
+ /*  1260 */  1428,  496,  446, 1321,  146, 1499, 1272,  236, 1500, 1501,
+ /*  1270 */  1505, 1270,  449,  350,  352,  351, 1470,  863, 1499, 1268,
+ /*  1280 */   493,  492,  491,  356,  490,  354, 1266,  355, 1264, 1516,
+ /*  1290 */  1253,  359, 1513, 1500, 1501, 1505,  446,  358, 1252,  360,
+ /*  1300 */   362,  363, 1516, 1249,  364, 1323,  449,  972,   73,  446,
+ /*  1310 */  1470,  153, 1499,  512,  970, 1322,  895,  510,  894,  449,
+ /*  1320 */  1499,  893,  892, 1470, 1262, 1499, 1512, 1500, 1501, 1505,
+ /*  1330 */   252,  889,  888, 1257,  253,  387, 1516, 1255,  254,  243,
+ /*  1340 */  1500, 1501, 1505,  446, 1516,  390, 1248,  392, 1247, 1516,
+ /*  1350 */   394,  446,   71,  449, 1454,  167,  446, 1470, 1039, 1448,
+ /*  1360 */   402,  449,  113, 1436, 1435, 1470,  449, 1499, 1427,   54,
+ /*  1370 */  1470,  123, 1499, 1511, 1500, 1501, 1505,  172,   14,   43,
+ /*  1380 */     3,  244, 1500, 1501, 1505,   33,  242, 1500, 1501, 1505,
+ /*  1390 */    38, 1516,  177, 1181,   15,  403, 1516,  120,  446, 1488,
+ /*  1400 */   174,  181,   37,  446,   19,   56, 1174,  182,  449,   55,
+ /*  1410 */    20, 1203, 1470,  449,   36, 1153, 1152, 1470,   16, 1208,
+ /*  1420 */  1202,   35,  261, 1207, 1206,  262,    8,   13,  239, 1500,
+ /*  1430 */  1501, 1505, 1090,  230, 1500, 1501, 1505,  188,  130, 1117,
+ /*  1440 */  1089,  195,  196,   18, 1426, 1179,  198,  454,   10,  200,
+ /*  1450 */    45,  202,   57, 1068,  204,   61,  956,   39,  467,  275,
+ /*  1460 */  1487,  471,  469,  207,  465,  953,  472,  474,  950,  475,
+ /*  1470 */   477,  944,  478,  480,  942,  933,  481,   62,  967,  948,
+ /*  1480 */    46,   63,  961,  963,  487,  861,  497,  902,  947,  499,
+ /*  1490 */   946,  877,  884,  945,  883,  882,  210,  881,  899,  880,
+ /*  1500 */   879,  878,  897,  874,  873,  872,  869, 1269,  868,  966,
+ /*  1510 */   867,  866,  521,  522,  523, 1267,  525,  526,  527, 1265,
+ /*  1520 */   529,  530,  531, 1263,  533,  534,  535, 1251,  537,  538,
+ /*  1530 */  1250, 1246,  541,  542, 1221, 1055,  218,  545,  546,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   217,  277,  278,  219,  239,  261,  211,    1,    2,  226,
- /*    10 */   244,    4,   12,   13,  217,  239,  233,  251,  252,  227,
- /*    20 */    20,  256,   22,  226,  240,  242,   19,  235,   20,  256,
- /*    30 */   235,  211,  256,  268,  269,  243,  292,  242,   38,  242,
- /*    40 */    33,  268,  269,   36,  268,  269,   20,  252,   41,  305,
- /*    50 */    50,  256,  217,  309,   47,  235,  217,   57,   14,   15,
- /*    60 */    16,   49,  242,   12,   13,   14,  217,  272,  273,  274,
- /*    70 */   275,   20,  252,   22,   74,  226,  256,   12,   13,  259,
- /*    80 */    73,   75,  233,   76,   20,   20,  247,   22,  211,   38,
- /*    90 */   211,  242,  272,  273,  274,  275,  261,   97,  214,  215,
- /*   100 */    20,   50,   20,   38,  252,  310,  311,  255,   57,  109,
- /*   110 */   258,  217,  235,  221,  222,   50,   12,   13,  217,  242,
- /*   120 */   226,  210,   57,  212,   20,   74,   22,  292,  292,  252,
- /*   130 */   221,  222,  211,  256,  217,  256,  242,  132,   74,   74,
- /*   140 */   305,  305,   38,  242,  309,  309,  146,    0,   97,  272,
- /*   150 */   273,  274,  275,  276,  136,  150,   74,  280,  281,  242,
- /*   160 */   109,   57,   97,  163,  164,  165,  166,  167,  168,  169,
- /*   170 */   170,  171,  172,  173,  109,  217,  275,  256,   74,  174,
- /*   180 */   211,   12,   13,   14,  226,  185,  285,  286,  287,   20,
- /*   190 */   289,   22,  275,  185,  220,  185,   49,  146,  224,  235,
- /*   200 */   242,   97,  285,  286,  287,  241,  289,   38,  190,  191,
- /*   210 */   246,  146,   20,  109,  163,  164,  165,  166,  167,  168,
- /*   220 */   169,  170,  171,  172,  173,  256,   57,    0,  163,  164,
- /*   230 */   165,  166,  167,  168,  169,  170,  171,  172,  173,  145,
- /*   240 */    20,  147,   22,   74,  164,  165,    1,    2,   21,  185,
- /*   250 */   146,   24,   25,   26,   27,   28,   29,   30,   31,   32,
- /*   260 */    40,   12,   13,   14,   15,   16,   97,  163,  164,  165,
- /*   270 */   166,  167,  168,  169,  170,  171,  172,  173,  109,  185,
- /*   280 */    20,  242,  219,   12,   13,   18,  216,   20,  249,  185,
- /*   290 */    52,   20,   54,   22,   27,  232,   58,   30,  211,   61,
- /*   300 */   230,   63,   64,  240,   66,  228,   39,  237,  231,   38,
- /*   310 */    12,   13,   14,   15,   16,  146,   21,  183,  184,   24,
- /*   320 */    25,   26,   27,   28,   29,   30,   31,   32,   57,    0,
- /*   330 */    67,  163,  163,  164,  165,  166,  167,  168,  169,  170,
- /*   340 */   171,  172,  173,  256,   20,   74,   61,   50,   50,   47,
- /*   350 */    65,   38,   49,   24,   25,   26,   27,   28,   29,   30,
- /*   360 */    31,   32,  194,  195,  196,  197,  198,  223,   97,  225,
- /*   370 */    57,   20,   87,   75,   35,   73,  113,  114,   76,  112,
- /*   380 */   109,   83,  115,  116,  117,  118,  119,  217,  121,  122,
- /*   390 */   123,  124,  125,  126,  127,  128,  129,  130,  131,  217,
- /*   400 */    61,   12,   13,   85,   65,  270,  217,  252,  226,   20,
- /*   410 */   270,   22,  242,  258,  235,  226,   77,  146,   79,   80,
- /*   420 */   241,   82,  235,  288,  242,  246,   87,   38,  288,  242,
- /*   430 */   132,  242,  164,  165,  163,  164,  165,  166,  167,  168,
- /*   440 */   169,  170,  171,  172,  173,  275,   57,    0,  150,   12,
- /*   450 */    13,   14,   15,   16,  284,  285,  286,  287,    0,  289,
- /*   460 */   163,  274,  138,   74,   20,   12,   13,   14,   15,   16,
- /*   470 */   270,  216,  174,  175,  176,  177,  178,  179,  180,  181,
- /*   480 */   182,   12,   13,   14,   15,   16,   97,   50,  288,  138,
- /*   490 */    14,   78,  237,  234,   81,    4,   20,  211,  109,   52,
- /*   500 */    53,   54,   55,   56,  245,   58,   59,   60,   61,   62,
- /*   510 */    63,   64,   65,   66,   67,   68,   69,   70,   78,   61,
- /*   520 */    83,   81,   57,   65,   88,   89,   90,   91,   92,   93,
- /*   530 */    94,   95,   96,   97,   98,  146,  100,  101,  102,  103,
- /*   540 */   104,  105,  256,  211,   75,   87,   18,  236,  208,    0,
- /*   550 */    43,   23,  163,  164,  165,  166,  167,  168,  169,  170,
- /*   560 */   171,  172,  173,   35,  106,  107,  108,    2,  110,  132,
- /*   570 */    78,    3,    2,   81,   22,  211,   48,   12,   13,   14,
- /*   580 */    15,   16,   12,   13,   14,   15,   16,  150,  256,  235,
- /*   590 */    38,  236,  139,   33,    0,  236,   36,  243,   49,  217,
- /*   600 */   217,  261,   42,  261,   44,   45,   46,   47,  226,  226,
- /*   610 */   235,  174,  175,  176,  177,  178,  179,  180,  181,  182,
- /*   620 */   256,  246,  236,  236,  242,  242,  142,  227,  236,  217,
- /*   630 */    12,   13,  292,   73,  292,  235,   76,  211,  226,  111,
- /*   640 */    22,  157,  211,  243,    0,  305,   52,  305,   54,  309,
- /*   650 */    78,  309,   58,   81,  242,   61,   38,   63,   64,  206,
- /*   660 */    66,   12,   13,   14,   15,   16,  235,  139,  140,  141,
- /*   670 */   235,  143,  264,  242,   71,   57,  148,  186,   75,    0,
- /*   680 */    36,  246,  256,  252,  156,  211,  158,  256,  160,  161,
- /*   690 */   162,  184,  261,  133,  227,  135,   71,  137,  211,  211,
- /*   700 */    75,   22,  235,  272,  273,  274,  275,  276,  236,  235,
- /*   710 */   243,  280,  281,  185,  154,   97,  242,   12,   13,   14,
- /*   720 */    15,   16,  235,  292,   75,   21,  252,  109,  217,  242,
- /*   730 */   256,  211,  211,  224,   71,   71,  305,  226,   34,  252,
- /*   740 */   309,  211,  217,  256,  256,  211,  272,  273,  274,  275,
- /*   750 */   276,  226,  235,  242,  280,  281,  282,    0,  241,  272,
- /*   760 */   273,  274,  275,  246,  146,  235,   19,  242,  294,  201,
- /*   770 */   217,  212,  242,  211,  300,  301,  256,  256,   38,   22,
- /*   780 */    33,  163,  252,   36,   22,    0,  256,  211,  211,   42,
- /*   790 */   256,   44,   45,   46,   47,  242,  211,   71,  311,  211,
- /*   800 */    38,   75,  272,  273,  274,  275,  276,   22,  312,   71,
- /*   810 */   280,  281,  282,   75,  261,  211,  211,  303,  256,   57,
- /*   820 */    73,  211,   71,   76,  211,   71,   75,   38,  275,   75,
- /*   830 */   252,  301,  256,  256,   74,  245,  252,   74,  285,  286,
- /*   840 */   287,  256,  289,  138,  256,  292,   86,   84,  235,  109,
- /*   850 */    71,  211,   71,  106,   75,  242,   75,  214,  305,   97,
- /*   860 */   256,  256,  309,  297,  271,  252,  256,  203,  205,  256,
- /*   870 */    71,  109,   71,   71,   75,  235,   75,   75,  211,   71,
- /*   880 */   235,  134,  242,   75,  137,  272,  273,  274,  275,  276,
- /*   890 */   290,  293,  252,  280,  281,  282,  256,  306,  109,  152,
- /*   900 */    20,  154,  235,   71,  291,   38,   71,   75,  146,  242,
- /*   910 */    75,  217,  272,  273,  274,  275,  276,   36,  267,  252,
- /*   920 */   280,  281,  282,  256,   57,  163,   71,   38,  211,  221,
- /*   930 */    75,  291,   71,   71,  144,  262,   75,   75,  217,  272,
- /*   940 */   273,  274,  275,  276,  217,  120,  250,  280,  281,  282,
- /*   950 */   132,  248,  235,  211,  248,   20,  217,  266,  291,  242,
- /*   960 */    20,  260,  219,   20,  242,  253,   20,  219,  219,  252,
- /*   970 */   217,  219,  213,  256,  242,  266,  235,  235,  261,  235,
- /*   980 */   211,  235,  253,  153,  242,  235,  213,  217,  265,  272,
- /*   990 */   273,  274,  275,  235,  252,  221,  235,  260,  256,  235,
- /*  1000 */   235,  235,  235,  235,  235,   20,  211,  216,  216,  292,
- /*  1010 */   193,  242,  302,  242,  272,  273,  274,  275,  276,  192,
- /*  1020 */    57,  252,  305,  281,  200,  256,  309,  271,  298,  257,
- /*  1030 */   235,  256,  211,  302,  257,  299,  256,  242,  256,  199,
- /*  1040 */   211,  272,  273,  274,  275,  276,  188,  252,  184,  280,
- /*  1050 */   281,  256,  187,  242,  259,   20,  235,  270,  120,  207,
- /*  1060 */   204,  283,  202,  242,  235,   74,  257,  272,  273,  274,
- /*  1070 */   275,  242,  296,  252,  211,  279,  256,  256,  295,  256,
- /*  1080 */   135,  252,  216,  257,  256,  256,  242,  211,  259,  216,
- /*  1090 */   254,  253,  242,  272,  273,  274,  275,  313,  235,  211,
- /*  1100 */   307,  272,  273,  274,  275,  242,  308,  238,  231,  225,
- /*  1110 */    74,  235,  221,  217,  216,  252,  213,  263,  242,  256,
- /*  1120 */   218,  229,  259,  235,  229,  304,  209,    0,  252,    0,
- /*  1130 */   242,   64,  256,  211,    0,  272,  273,  274,  275,   38,
- /*  1140 */   252,  159,   38,   38,  256,   38,  159,    0,  272,  273,
- /*  1150 */   274,  275,   38,   38,  159,    0,   38,  235,    0,  211,
- /*  1160 */   272,  273,  274,  275,  242,    0,   38,   74,  150,  149,
- /*  1170 */   109,  146,    0,    0,  252,   53,  142,    0,  256,  120,
- /*  1180 */    86,    0,    0,  235,    0,  211,    0,    0,    0,    0,
- /*  1190 */   242,    0,    0,    0,  272,  273,  274,  275,    0,    0,
- /*  1200 */   252,    0,    0,    0,  256,   22,    0,    0,    0,  235,
- /*  1210 */   211,    0,    0,    0,    0,    0,  242,    0,    0,    0,
- /*  1220 */   272,  273,  274,  275,    0,    0,  252,    0,    0,    0,
- /*  1230 */   256,    0,    0,   43,  235,  211,   51,    0,    0,   43,
- /*  1240 */     0,  242,   38,   43,  211,   36,  272,  273,  274,  275,
- /*  1250 */     0,  252,    0,   43,   38,  256,   36,   36,    0,  235,
- /*  1260 */    38,   38,   36,    0,    0,    0,  242,   22,  235,    0,
- /*  1270 */     0,  272,  273,  274,  275,  242,  252,   43,   83,  211,
- /*  1280 */   256,   38,   38,   22,   38,  252,   38,   38,    0,  256,
- /*  1290 */    22,   38,   38,    0,   39,   22,  272,  273,  274,  275,
- /*  1300 */    38,    0,   22,  235,   71,  272,  273,  274,  275,    0,
- /*  1310 */   242,   81,   71,  211,   22,   20,    0,  155,  138,   38,
- /*  1320 */   252,    0,  151,    0,  256,   22,    0,    0,   43,  189,
- /*  1330 */    74,   71,  138,   86,   75,  138,  183,  235,   71,  189,
- /*  1340 */   272,  273,  274,  275,  242,   71,   75,  211,  189,   74,
- /*  1350 */    74,   74,   86,   75,  252,   71,  211,   74,  256,    4,
- /*  1360 */    71,   75,  211,   38,    2,   75,   75,   71,   86,  133,
- /*  1370 */   135,  235,   38,   71,  272,  273,  274,  275,  242,   38,
- /*  1380 */   235,    0,   38,   38,   38,   86,  235,  242,  252,   75,
- /*  1390 */   211,   74,  256,  242,   75,   75,   74,  252,    0,   75,
- /*  1400 */    43,  256,  163,  252,   74,   74,   74,  256,  272,  273,
- /*  1410 */   274,  275,   74,   84,  235,  136,  211,  272,  273,  274,
- /*  1420 */   275,  242,   86,  272,  273,  274,  275,  133,   86,   22,
- /*  1430 */    74,  252,   85,   75,   38,  256,   75,   38,   74,   38,
- /*  1440 */   235,   74,   61,   75,   38,   74,   65,  242,   75,   38,
- /*  1450 */    74,  272,  273,  274,  275,   75,   38,  252,   74,   99,
- /*  1460 */    22,  256,   99,   74,   99,   99,   87,   38,   87,   74,
- /*  1470 */    38,   74,   22,   51,   50,   72,   57,  272,  273,  274,
- /*  1480 */   275,  109,   38,   71,   38,   38,   38,  106,  107,  108,
- /*  1490 */    38,  110,   38,   38,   22,   38,   57,   38,   38,   38,
- /*  1500 */    38,   38,   38,   38,    0,   38,   36,    0,    0,   43,
- /*  1510 */    36,   38,   43,   38,   36,    0,   36,   38,    0,   43,
- /*  1520 */    43,   38,   37,    0,    0,   22,   21,  314,   22,  314,
- /*  1530 */    20,   22,   21,  314,  314,  314,  314,  314,  314,  314,
- /*  1540 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1550 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1560 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1570 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1580 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1590 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1600 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1610 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1620 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1630 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1640 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1650 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1660 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1670 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1680 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1690 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1700 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1710 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1720 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1730 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
- /*  1740 */   314,
+ /*     0 */   253,  240,  257,  256,  278,  279,  259,  211,  235,  213,
+ /*    10 */   218,  237,   12,   13,  269,  270,  262,  212,  257,  246,
+ /*    20 */    20,   20,   22,    2,   20,   12,   13,   14,   15,   16,
+ /*    30 */   269,  270,    2,   12,   13,   14,   15,   16,   38,  240,
+ /*    40 */   248,  236,   12,   13,   14,   15,   16,  293,  243,   20,
+ /*    50 */    50,   12,   13,   14,   49,  218,  257,   57,  253,   20,
+ /*    60 */   306,   22,  257,    0,  310,   12,   13,  262,  269,  270,
+ /*    70 */   218,    1,    2,   20,   74,   22,  218,   38,  273,  274,
+ /*    80 */   275,  276,  277,  215,  216,  227,  281,  282,   75,   50,
+ /*    90 */   212,   38,  234,   20,  253,  243,   57,   97,  293,  262,
+ /*   100 */   259,  243,    0,   50,   12,   13,   14,   15,   16,  109,
+ /*   110 */    57,  306,   49,   74,  236,  310,   12,   13,   14,   15,
+ /*   120 */    16,  243,  221,  236,   22,  245,  225,   74,  276,  242,
+ /*   130 */   293,  253,  252,  253,  247,  257,   97,  285,  286,  287,
+ /*   140 */   288,  228,  290,  306,   49,   75,  146,  310,  109,  236,
+ /*   150 */    97,  273,  274,  275,  276,  277,   20,  244,   22,  281,
+ /*   160 */   282,  283,  109,  163,  164,  165,  166,  167,  168,  169,
+ /*   170 */   170,  171,  172,  173,  174,   61,   40,  222,  223,   65,
+ /*   180 */   302,   20,  271,  209,   21,  146,  186,   24,   25,   26,
+ /*   190 */    27,   28,   29,   30,   31,   32,   14,   15,   16,  146,
+ /*   200 */   289,   87,  163,  164,  165,  166,  167,  168,  169,  170,
+ /*   210 */   171,  172,  173,  174,    0,  186,  163,  164,  165,  166,
+ /*   220 */   167,  168,  169,  170,  171,  172,  173,  174,    0,   12,
+ /*   230 */    13,   19,  145,  271,  147,   74,  262,   20,   52,   22,
+ /*   240 */    54,   38,  186,  139,   58,   33,   20,   61,   36,   63,
+ /*   250 */    64,  289,   66,  236,   42,   38,   44,   45,   46,   47,
+ /*   260 */    57,  244,   12,   13,   14,   15,   16,  293,   12,   13,
+ /*   270 */    14,  212,  218,  186,   57,   61,   20,   49,   22,   65,
+ /*   280 */   306,  227,   12,   13,  310,   73,  220,   20,   76,   20,
+ /*   290 */    20,   74,   22,  212,   38,  236,  217,  243,  236,  233,
+ /*   300 */    74,   87,  243,  212,   67,  243,  218,  241,   38,   85,
+ /*   310 */   231,  207,  253,   57,   97,  227,  257,  238,  106,   71,
+ /*   320 */   106,  107,  108,  163,  110,   75,  109,   57,  222,  223,
+ /*   330 */    74,  243,  273,  274,  275,  276,  277,  275,  257,   21,
+ /*   340 */   281,  282,  283,    0,   74,    0,  134,  186,  257,  137,
+ /*   350 */   113,  114,   34,   97,  295,  195,  196,  197,  198,  199,
+ /*   360 */   301,  302,   57,  146,  152,  109,  154,   97,  212,   24,
+ /*   370 */    25,   26,   27,   28,   29,   30,   31,   32,  237,  109,
+ /*   380 */   163,  164,  165,  166,  167,  168,  169,  170,  171,  172,
+ /*   390 */   173,  174,   20,  218,  236,   52,  220,   54,  293,  237,
+ /*   400 */   242,   58,  146,  186,   61,  247,   63,   64,  212,   66,
+ /*   410 */   212,  306,  265,  257,  212,  310,  146,  241,  243,  163,
+ /*   420 */   164,  165,  166,  167,  168,  169,  170,  171,  172,  173,
+ /*   430 */   174,  164,  165,  163,  164,  165,  166,  167,  168,  169,
+ /*   440 */   170,  171,  172,  173,  174,  218,   12,   13,   18,  136,
+ /*   450 */    20,  276,  204,  257,   20,  257,   22,   27,  217,  257,
+ /*   460 */    30,  286,  287,  288,  243,  290,   20,    4,  262,   39,
+ /*   470 */   243,  250,   38,   12,   13,   14,   15,   16,    3,  238,
+ /*   480 */    88,   89,   90,   91,   92,   93,   94,   95,   96,   97,
+ /*   490 */    98,   57,  100,  101,  102,  103,  104,  105,    0,  293,
+ /*   500 */   184,  185,  271,  276,  191,  192,    1,    2,   74,  218,
+ /*   510 */   138,   50,  306,  286,  287,  288,  310,  290,  227,   21,
+ /*   520 */   289,  212,   24,   25,   26,   27,   28,   29,   30,   31,
+ /*   530 */    32,   97,  229,  237,  243,  232,   75,   12,   13,   14,
+ /*   540 */    15,   16,  112,  109,   83,  115,  116,  117,  118,  119,
+ /*   550 */   212,  121,  122,  123,  124,  125,  126,  127,  128,  129,
+ /*   560 */   130,  131,    0,   47,   18,  218,  257,  212,  224,   23,
+ /*   570 */   226,  236,  236,   43,  227,   12,   13,   14,   15,   16,
+ /*   580 */   146,   35,  247,  247,  138,   14,  237,  237,  212,   73,
+ /*   590 */   243,   20,   76,  132,   48,  257,  237,  163,  164,  165,
+ /*   600 */   166,  167,  168,  169,  170,  171,  172,  173,  174,  213,
+ /*   610 */   212,  150,  257,   50,   52,   53,   54,   55,   56,  212,
+ /*   620 */    58,   59,   60,   61,   62,   63,   64,   65,   66,   67,
+ /*   630 */    68,   69,   70,  257,  212,  212,  175,  176,  177,  178,
+ /*   640 */   179,  180,  181,  182,  183,  218,   83,  218,  212,  218,
+ /*   650 */   187,   22,  228,  218,  227,  257,  227,  111,  227,  236,
+ /*   660 */   236,  234,  227,  138,  257,  228,  243,   38,  244,    0,
+ /*   670 */   243,   38,  243,  236,  243,  218,  253,  202,  243,  257,
+ /*   680 */   257,  244,  212,  212,  227,  139,  140,  141,  212,  143,
+ /*   690 */    57,   22,  218,  257,  148,  132,  273,  274,  275,  276,
+ /*   700 */   243,  227,  156,  142,  158,  236,  160,  161,  162,  225,
+ /*   710 */    71,  242,  236,  150,   75,  185,  247,  243,  157,  243,
+ /*   720 */    78,   22,  218,   81,  212,  212,  212,  257,  257,  253,
+ /*   730 */    50,  227,  186,  257,  311,  312,  132,   38,  175,  176,
+ /*   740 */   177,  178,  179,  180,  181,  182,  183,  243,  236,  273,
+ /*   750 */   274,  275,  276,  277,  150,  243,   57,  281,  282,  283,
+ /*   760 */   212,    0,  212,   33,  212,  253,   36,  313,  292,  257,
+ /*   770 */   257,  257,   42,  253,   44,   45,   46,   47,   78,  175,
+ /*   780 */    78,   81,  304,   81,  236,  273,  274,  275,  276,  277,
+ /*   790 */     0,  243,   71,  281,  282,  283,   97,   36,  164,  165,
+ /*   800 */   246,  253,   35,   73,  292,  257,   76,  257,  109,  257,
+ /*   810 */   212,   78,   22,   71,   81,   71,   71,   75,  253,   75,
+ /*   820 */    75,  273,  274,  275,  276,  277,   74,  298,   61,  281,
+ /*   830 */   282,  283,   65,  215,  236,   71,  272,  212,   86,   75,
+ /*   840 */   292,  243,  291,  163,   77,  146,   79,   80,   38,   82,
+ /*   850 */   236,  253,  212,   71,   87,  257,  307,   75,   20,   38,
+ /*   860 */   262,  236,  163,  133,  294,  135,   71,  137,  243,  218,
+ /*   870 */    75,  273,  274,  275,  276,   36,  236,   71,  253,  212,
+ /*   880 */   268,   75,  257,  243,  154,   71,   12,   13,   71,   75,
+ /*   890 */    38,  293,   75,  253,  222,  144,   22,  257,  273,  274,
+ /*   900 */   275,  276,  277,  236,  306,  218,  281,  282,  310,  263,
+ /*   910 */   243,  218,   38,  273,  274,  275,  276,  277,   74,  109,
+ /*   920 */   253,  281,  282,  218,  257,   71,  251,  206,   84,   75,
+ /*   930 */   109,   57,   71,   71,   71,  120,   75,   75,   75,  132,
+ /*   940 */   273,  274,  275,  276,  277,  249,   71,  249,  243,  282,
+ /*   950 */    75,   20,  218,   71,   71,  212,  267,   75,   75,   20,
+ /*   960 */   220,  243,  261,   20,  254,  218,  220,  262,  220,  220,
+ /*   970 */    20,   97,  214,  236,  236,  236,  222,  236,  218,  236,
+ /*   980 */   267,  276,  212,  109,  153,  266,  243,  214,  261,  236,
+ /*   990 */   212,  286,  287,  288,  217,  290,  253,  217,  293,  236,
+ /*  1000 */   257,  236,  236,  260,  236,  236,  236,  236,   20,  254,
+ /*  1010 */   194,  306,  303,  243,  236,  310,  273,  274,  275,  276,
+ /*  1020 */   146,  243,  243,  253,  243,  193,   57,  257,  272,  257,
+ /*  1030 */   260,  253,  258,  258,  212,  257,  201,  163,  303,  189,
+ /*  1040 */   257,  257,  200,  273,  274,  275,  276,  188,  243,   20,
+ /*  1050 */   300,  273,  274,  275,  276,  296,  299,  185,  236,  297,
+ /*  1060 */   271,  120,  205,  208,   74,  243,  258,  280,  212,  284,
+ /*  1070 */   203,  258,  135,  255,   74,  253,  212,  257,  254,  257,
+ /*  1080 */   257,  212,  257,  305,  243,  217,  243,  239,  217,  210,
+ /*  1090 */   314,  226,  236,  217,  308,  273,  274,  275,  276,  243,
+ /*  1100 */   236,  309,  232,  222,  218,  236,  214,  243,  230,  253,
+ /*  1110 */   264,    0,  243,  257,  230,  219,  260,  253,    0,   64,
+ /*  1120 */     0,  257,  253,  212,  260,   38,  257,   38,  212,  273,
+ /*  1130 */   274,  275,  276,    4,  312,  159,  212,  273,  274,  275,
+ /*  1140 */   276,   38,  273,  274,  275,  276,  159,  236,   19,    0,
+ /*  1150 */    38,  159,  236,   38,  243,   38,    0,   38,    0,  243,
+ /*  1160 */   236,   38,   33,    0,  253,   36,   74,  243,  257,  253,
+ /*  1170 */    41,  150,  149,  257,    0,    0,   47,  253,  109,  146,
+ /*  1180 */   212,  257,    0,   53,  273,  274,  275,  276,  142,  273,
+ /*  1190 */   274,  275,  276,    0,    0,  212,   86,  273,  274,  275,
+ /*  1200 */   276,    0,   73,    0,  236,   76,  212,    0,    0,    0,
+ /*  1210 */     0,  243,    0,    0,    0,    0,    0,    0,    0,  236,
+ /*  1220 */     0,  253,    0,    0,  120,  257,  243,    0,    0,    0,
+ /*  1230 */   236,  212,    0,    0,    0,   61,  253,  243,    0,   65,
+ /*  1240 */   257,  273,  274,  275,  276,    0,   22,  253,    0,    0,
+ /*  1250 */     0,  257,    0,    0,    0,  236,  273,  274,  275,  276,
+ /*  1260 */     0,   87,  243,    0,   43,  212,    0,  273,  274,  275,
+ /*  1270 */   276,    0,  253,   38,   43,   36,  257,   51,  212,    0,
+ /*  1280 */   106,  107,  108,   43,  110,   38,    0,   36,    0,  236,
+ /*  1290 */     0,   36,  273,  274,  275,  276,  243,   38,    0,   43,
+ /*  1300 */    38,   36,  236,    0,   43,    0,  253,   38,   83,  243,
+ /*  1310 */   257,   81,  212,   71,   22,    0,   38,   71,   38,  253,
+ /*  1320 */   212,   38,   38,  257,    0,  212,  273,  274,  275,  276,
+ /*  1330 */    22,   38,   38,    0,   22,   39,  236,    0,   22,  273,
+ /*  1340 */   274,  275,  276,  243,  236,   38,    0,   22,    0,  236,
+ /*  1350 */    22,  243,   20,  253,    0,  155,  243,  257,   38,    0,
+ /*  1360 */    22,  253,  151,    0,    0,  257,  253,  212,    0,   74,
+ /*  1370 */   257,  135,  212,  273,  274,  275,  276,   43,  190,  138,
+ /*  1380 */    71,  273,  274,  275,  276,   71,  273,  274,  275,  276,
+ /*  1390 */    71,  236,   75,   75,  190,  138,  236,   74,  243,   86,
+ /*  1400 */   133,   74,  138,  243,   74,    4,   75,   71,  253,   74,
+ /*  1410 */    71,   38,  257,  253,   71,   75,   75,  257,   71,   75,
+ /*  1420 */    38,  184,   38,   38,   38,   38,    2,   74,  273,  274,
+ /*  1430 */   275,  276,   75,  273,  274,  275,  276,   86,   86,  163,
+ /*  1440 */    75,   86,   75,   74,    0,   75,   74,  136,  190,   74,
+ /*  1450 */    74,   43,   74,   22,  133,   84,   75,   74,   38,   38,
+ /*  1460 */    86,   38,   74,   86,   85,   75,   74,   38,   75,   74,
+ /*  1470 */    38,   75,   74,   38,   75,   22,   74,   74,   38,   99,
+ /*  1480 */    74,   74,   22,   38,   87,   51,   50,   57,   99,   72,
+ /*  1490 */    99,   22,   38,   99,   38,   38,   71,   38,   57,   38,
+ /*  1500 */    38,   38,   38,   38,   38,   38,   38,    0,   38,  109,
+ /*  1510 */    38,   38,   38,   36,   43,    0,   38,   36,   43,    0,
+ /*  1520 */    38,   36,   43,    0,   38,   36,   43,    0,   38,   37,
+ /*  1530 */     0,    0,   22,   21,  315,   22,   22,   21,   20,  315,
+ /*  1540 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1550 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1560 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1570 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1580 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1590 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1600 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1610 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1620 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1630 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1640 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1650 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1660 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1670 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1680 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1690 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1700 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1710 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1720 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1730 */   315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+ /*  1740 */   315,  315,  315,  315,  315,  315,  315,  315,
 };
 #define YY_SHIFT_COUNT    (547)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (1524)
+#define YY_SHIFT_MAX      (1531)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   528,    0,   51,   65,   65,   65,   65,  104,   65,   65,
- /*    10 */   271,  389,   64,  169,  271,  271,  271,  271,  271,  271,
- /*    20 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
- /*    30 */   271,  271,  271,  271,   82,   82,   82,    8,  618,  618,
- /*    40 */    94,   26,   26,   10,  618,   80,   80,   26,   26,   26,
- /*    50 */    26,   26,   26,   12,  192,  260,   10,  192,   26,   26,
- /*    60 */   192,   26,  192,  192,  192,   26,  303,  267,  298,  437,
- /*    70 */   437,  295,  339,  762,  238,  762,  762,  762,  762,  762,
- /*    80 */   762,  762,  762,  762,  762,  762,  762,  762,  762,  762,
- /*    90 */   762,  762,  762,  762,   80,  220,  147,  313,  324,  324,
- /*   100 */   324,  549,  313,  444,  192,  192,  192,  318,  465,  436,
- /*   110 */   436,  436,  436,  436,  436,  436,  747,  227,  594,  453,
- /*   120 */   168,   80,  285,   80,   18,  552,  351,  134,  507,  134,
- /*   130 */   476,  568,  491,  880,  881,  889,  790,  880,  880,  825,
- /*   140 */   818,  818,  880,  935,  940,   12,  444,  943,   12,   12,
- /*   150 */   880,   12,  946,  192,  192,  192,  192,  192,  192,  192,
- /*   160 */   192,  192,  192,  192,  889,  880,  946,  444,  935,  830,
- /*   170 */   940,  303,  444,  943,  303,  985,  817,  827,  963,  817,
- /*   180 */   827,  963,  963,  824,  840,  858,  865,  864,  444, 1035,
- /*   190 */   938,  852,  856,  860,  991,  192,  827,  963,  963,  827,
- /*   200 */   963,  945,  444,  943,  303,  318,  303,  444, 1036,  889,
- /*   210 */   465,  880,  303,  946, 1533, 1533, 1533, 1533, 1533,  447,
- /*   220 */   560,  329,    7,  458, 1381,  469,  565,  570,  649,  705,
- /*   230 */   249,  249,  249,  249,  249,  249,  249,  302,  263,   44,
- /*   240 */     6,    5,   44,   44,   44,  644,  484,  603,  413,  440,
- /*   250 */   492,  572,  679,  757,  785,  704,  625,  726,  738,  245,
- /*   260 */   268,  664,  663,  751,  297,  754,  760,  781,  799,  801,
- /*   270 */   802,  808,  740,  789,  779,  832,  835,  855,  861,  862,
- /*   280 */   763,  867, 1127, 1129, 1067, 1134, 1101,  982, 1104, 1105,
- /*   290 */  1107,  987, 1147, 1114, 1115,  995, 1155, 1118, 1158, 1128,
- /*   300 */  1165, 1093, 1018, 1020, 1061, 1025, 1172, 1173, 1122, 1034,
- /*   310 */  1177, 1184, 1094, 1181, 1182, 1186, 1187, 1188, 1189, 1191,
- /*   320 */  1192, 1193, 1198, 1199, 1201, 1202, 1203, 1211, 1212, 1059,
- /*   330 */  1213, 1214, 1215, 1217, 1218, 1219, 1183, 1206, 1207, 1208,
- /*   340 */  1224, 1225, 1227, 1228, 1229, 1231, 1190, 1232, 1185, 1237,
- /*   350 */  1238, 1204, 1209, 1196, 1240, 1216, 1220, 1200, 1250, 1222,
- /*   360 */  1221, 1210, 1252, 1223, 1226, 1234, 1258, 1263, 1264, 1265,
- /*   370 */  1195, 1230, 1243, 1233, 1245, 1269, 1244, 1246, 1248, 1249,
- /*   380 */  1241, 1233, 1253, 1254, 1270, 1261, 1288, 1268, 1255, 1293,
- /*   390 */  1273, 1262, 1301, 1280, 1309, 1292, 1295, 1316, 1180, 1162,
- /*   400 */  1281, 1321, 1171, 1303, 1194, 1235, 1323, 1326, 1197, 1327,
- /*   410 */  1256, 1285, 1236, 1260, 1267, 1140, 1259, 1274, 1271, 1275,
- /*   420 */  1276, 1277, 1278, 1284, 1247, 1283, 1289, 1150, 1286, 1290,
- /*   430 */  1266, 1153, 1296, 1282, 1291, 1302, 1159, 1355, 1325, 1334,
- /*   440 */  1341, 1344, 1345, 1346, 1362, 1239, 1299, 1314, 1319, 1317,
- /*   450 */  1322, 1320, 1324, 1330, 1331, 1279, 1332, 1398, 1357, 1294,
- /*   460 */  1338, 1329, 1336, 1342, 1407, 1356, 1347, 1358, 1396, 1399,
- /*   470 */  1364, 1361, 1401, 1367, 1368, 1406, 1371, 1373, 1411, 1376,
- /*   480 */  1380, 1418, 1384, 1360, 1363, 1365, 1366, 1438, 1379, 1389,
- /*   490 */  1429, 1372, 1395, 1397, 1432, 1233, 1450, 1422, 1424, 1419,
- /*   500 */  1403, 1412, 1444, 1446, 1447, 1448, 1452, 1454, 1455, 1472,
- /*   510 */  1439, 1241, 1457, 1233, 1459, 1460, 1461, 1462, 1463, 1464,
- /*   520 */  1465, 1504, 1467, 1470, 1466, 1507, 1473, 1474, 1469, 1508,
- /*   530 */  1475, 1478, 1476, 1515, 1479, 1480, 1477, 1518, 1483, 1485,
- /*   540 */  1523, 1524, 1503, 1505, 1506, 1509, 1511, 1510,
+ /*     0 */   546,    0,   39,   53,   53,   53,   53,  217,   53,   53,
+ /*    10 */   270,  434,  161,  256,  270,  270,  270,  270,  270,  270,
+ /*    20 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+ /*    30 */   270,  270,  270,  270,  226,  226,  226,   29,  874,  874,
+ /*    40 */    87,    1,    1,   56,  874,  267,  267,    1,    1,    1,
+ /*    50 */     1,    1,    1,    5,    4,   73,   56,    4,    1,    1,
+ /*    60 */     4,    1,    4,    4,    4,    1,   95,  430,  461,  563,
+ /*    70 */   563,  163,  767,  699,  186,  699,  699,  699,  699,  699,
+ /*    80 */   699,  699,  699,  699,  699,  699,  699,  699,  699,  699,
+ /*    90 */   699,  699,  699,  699,  267,  136,   63,  203,  372,  372,
+ /*   100 */   372,  228,  203,  269,    4,    4,    4,  224,  305,  392,
+ /*   110 */   392,  392,  392,  392,  392,  392,  212,  498,  343,  104,
+ /*   120 */   160,  267,  114,  267,  313,  629,  446,  316,  530,  316,
+ /*   130 */   571,  475,  463,  838,  839,  852,  751,  838,  838,  815,
+ /*   140 */   807,  807,  838,  931,  939,    5,  269,  943,    5,    5,
+ /*   150 */   838,    5,  950,    4,    4,    4,    4,    4,    4,    4,
+ /*   160 */     4,    4,    4,    4,  852,  838,  950,  269,  931,  831,
+ /*   170 */   939,   95,  269,  943,   95,  988,  816,  832,  969,  816,
+ /*   180 */   832,  969,  969,  835,  842,  850,  859,  872,  269, 1029,
+ /*   190 */   941,  855,  857,  867,  990,    4,  832,  969,  969,  832,
+ /*   200 */   969,  937,  269,  943,   95,  224,   95,  269, 1000,  852,
+ /*   210 */   305,  838,   95,  950, 1539, 1539, 1539, 1539, 1539,  562,
+ /*   220 */   730,  345, 1129,  214, 1174,   13,   21,   30,  250,  525,
+ /*   230 */    92,   92,   92,   92,   92,   92,   92,  516,  237,  182,
+ /*   240 */    70,  604,  182,  182,  182,  761,  561,  639,  642,  700,
+ /*   250 */   702,  733,  102,  669,  790,  318,  742,  744,  745,  505,
+ /*   260 */   634,  248,  721,  764,  680,  782,  752,  795,  806,  814,
+ /*   270 */   817,  854,  810,  821,  861,  862,  863,  875,  882,  883,
+ /*   280 */   844,  633, 1111, 1118, 1055, 1120, 1087,  976, 1089, 1103,
+ /*   290 */  1112,  987, 1149, 1115, 1117,  992, 1156, 1119, 1158, 1123,
+ /*   300 */  1163, 1092, 1021, 1023, 1069, 1033, 1175, 1182, 1130, 1046,
+ /*   310 */  1193, 1194, 1110, 1201, 1203, 1207, 1208, 1209, 1210, 1212,
+ /*   320 */  1213, 1214, 1215, 1216, 1217, 1218, 1220, 1222, 1223, 1104,
+ /*   330 */  1227, 1228, 1229, 1232, 1233, 1234, 1224, 1238, 1245, 1248,
+ /*   340 */  1249, 1250, 1252, 1253, 1254, 1260, 1221, 1263, 1226, 1266,
+ /*   350 */  1271, 1235, 1239, 1231, 1279, 1247, 1251, 1240, 1286, 1259,
+ /*   360 */  1255, 1256, 1288, 1262, 1265, 1261, 1290, 1298, 1303, 1305,
+ /*   370 */  1225, 1230, 1269, 1242, 1292, 1315, 1278, 1280, 1283, 1284,
+ /*   380 */  1246, 1242, 1293, 1294, 1324, 1308, 1333, 1312, 1296, 1337,
+ /*   390 */  1316, 1307, 1346, 1325, 1348, 1328, 1332, 1354, 1241, 1200,
+ /*   400 */  1320, 1359, 1211, 1338, 1257, 1236, 1363, 1364, 1264, 1368,
+ /*   410 */  1295, 1334, 1267, 1309, 1314, 1188, 1317, 1319, 1318, 1323,
+ /*   420 */  1327, 1330, 1331, 1336, 1313, 1335, 1339, 1204, 1340, 1341,
+ /*   430 */  1351, 1237, 1343, 1352, 1344, 1347, 1258, 1401, 1373, 1382,
+ /*   440 */  1384, 1385, 1386, 1387, 1424, 1276, 1355, 1357, 1365, 1353,
+ /*   450 */  1369, 1367, 1370, 1372, 1375, 1311, 1376, 1444, 1408, 1321,
+ /*   460 */  1378, 1371, 1374, 1377, 1431, 1383, 1379, 1381, 1420, 1421,
+ /*   470 */  1388, 1390, 1423, 1392, 1393, 1429, 1395, 1396, 1432, 1398,
+ /*   480 */  1399, 1435, 1402, 1380, 1389, 1391, 1394, 1453, 1397, 1403,
+ /*   490 */  1440, 1400, 1406, 1407, 1445, 1242, 1460, 1434, 1436, 1430,
+ /*   500 */  1417, 1425, 1454, 1456, 1457, 1459, 1461, 1462, 1463, 1469,
+ /*   510 */  1441, 1246, 1464, 1242, 1465, 1466, 1467, 1468, 1470, 1472,
+ /*   520 */  1473, 1507, 1474, 1477, 1471, 1515, 1478, 1481, 1475, 1519,
+ /*   530 */  1482, 1485, 1479, 1523, 1486, 1489, 1483, 1527, 1490, 1492,
+ /*   540 */  1530, 1531, 1510, 1512, 1513, 1514, 1516, 1518,
 };
 #define YY_REDUCE_COUNT (218)
-#define YY_REDUCE_MIN   (-276)
-#define YY_REDUCE_MAX   (1205)
+#define YY_REDUCE_MIN   (-274)
+#define YY_REDUCE_MAX   (1160)
 static const short yy_reduce_ofst[] = {
- /*     0 */   340,  431,  474,  530,  613,  640,  667,  717, -123,  769,
- /*    10 */  -205,  742,  553, -180,  795,  821,  487,  829,  863,  876,
- /*    20 */   888,  922,  948,  974,  999, 1024, 1033, 1068, 1102, 1136,
- /*    30 */  1145, 1151, 1179, 1205,  170,  -99,  -83, -165, -235, -224,
- /*    40 */  -256, -217, -151,  342, -227, -148, -234, -203, -106,  -42,
- /*    50 */   182,  189,  382,   63,  -36,  187, -164, -208,  383,  412,
- /*    60 */   179,  511,  400,  517,  467,  525,   70, -161, -276, -276,
- /*    70 */  -276,  -89,  259, -121,  -26,  -79,  -31,   87,  286,  332,
- /*    80 */   364,  426,  488,  520,  521,  534,  562,  576,  577,  585,
- /*    90 */   588,  604,  605,  610,  155, -116, -216, -108,  135,  140,
- /*   100 */   200,  255,  -91,   39,  354,  375,  435,   77,  144,  311,
- /*   110 */   355,  359,  386,  387,  392,  472,  408,  559,  509,  496,
- /*   120 */   514,  578,  590,  584,  566,  643,  593,  600,  600,  600,
- /*   130 */   645,  591,  598,  694,  651,  708,  673,  721,  727,  696,
- /*   140 */   703,  706,  739,  691,  701,  743,  722,  712,  748,  749,
- /*   150 */   753,  752,  759,  741,  744,  746,  750,  758,  761,  764,
- /*   160 */   765,  766,  767,  768,  774,  770,  773,  732,  709,  723,
- /*   170 */   737,  791,  771,  729,  792,  756,  710,  772,  775,  731,
- /*   180 */   777,  780,  782,  736,  730,  776,  783,  600,  811,  787,
- /*   190 */   778,  784,  798,  793,  796,  645,  809,  820,  823,  826,
- /*   200 */   828,  836,  844,  838,  866,  877,  873,  850,  869,  891,
- /*   210 */   884,  896,  898,  903,  854,  892,  895,  902,  917,
+ /*     0 */   -26, -195,   59, -122,  476,  512,  548,  598,  625,  640,
+ /*    10 */   423,  667,  705,  743,  770,  778,  822,  856,  864,  869,
+ /*    20 */   911,  916,  924,  968,  983,  994, 1019, 1053, 1066, 1100,
+ /*    30 */  1108, 1113, 1155, 1160, -148,  175,  227, -163, -239, -201,
+ /*    40 */  -246, -142,  427,  206, -255, -253, -120,   54,   88,  291,
+ /*    50 */   347,  429,  431,   66, -113,   62,  105,  -87,  435,  457,
+ /*    60 */   158,  474,  424,  469,  437,  504,   79, -208, -274, -274,
+ /*    70 */  -274, -204, -227,   81,  -99,   91,  156,  196,  198,  202,
+ /*    80 */   309,  338,  355,  376,  398,  407,  422,  436,  470,  471,
+ /*    90 */   513,  514,  550,  552, -159, -132,  176,  -45,  -89,  -38,
+ /*   100 */   231,  241,  106,  221,   17,  335,  336,  303,  344, -226,
+ /*   110 */   141,  162,  296,  349,  350,  359,  147,  396,  484,  454,
+ /*   120 */   478,  520,  554,  565,  529,  618,  564,  551,  551,  551,
+ /*   130 */   614,  549,  570,  651,  612,  672,  646,  687,  693,  675,
+ /*   140 */   696,  698,  734,  689,  701,  740,  718,  710,  746,  748,
+ /*   150 */   747,  749,  758,  737,  738,  739,  741,  753,  763,  765,
+ /*   160 */   766,  768,  769,  771,  754,  760,  773,  779,  713,  719,
+ /*   170 */   727,  777,  781,  755,  780,  756,  709,  774,  772,  735,
+ /*   180 */   775,  783,  784,  750,  757,  762,  759,  551,  805,  789,
+ /*   190 */   785,  776,  792,  786,  787,  614,  808,  820,  823,  813,
+ /*   200 */   825,  818,  841,  824,  868,  870,  871,  843,  848,  881,
+ /*   210 */   865,  886,  876,  892,  846,  878,  884,  896,  879,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    10 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    20 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    30 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    40 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    50 */  1217, 1217, 1217, 1276, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    60 */  1217, 1217, 1217, 1217, 1217, 1217, 1274, 1414, 1217, 1549,
- /*    70 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    80 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*    90 */  1217, 1217, 1217, 1217, 1217, 1217, 1276, 1217, 1560, 1560,
- /*   100 */  1560, 1274, 1217, 1217, 1217, 1217, 1217, 1369, 1217, 1217,
- /*   110 */  1217, 1217, 1217, 1217, 1217, 1217, 1448, 1217, 1217, 1624,
- /*   120 */  1217, 1217, 1322, 1217, 1584, 1217, 1576, 1552, 1566, 1553,
- /*   130 */  1217, 1609, 1569, 1217, 1217, 1217, 1440, 1217, 1217, 1419,
- /*   140 */  1416, 1416, 1217, 1217, 1217, 1276, 1217, 1217, 1276, 1276,
- /*   150 */  1217, 1276, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   160 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1450,
- /*   170 */  1217, 1274, 1217, 1217, 1274, 1217, 1591, 1589, 1217, 1591,
- /*   180 */  1589, 1217, 1217, 1603, 1599, 1582, 1580, 1566, 1217, 1217,
- /*   190 */  1217, 1627, 1615, 1611, 1217, 1217, 1589, 1217, 1217, 1589,
- /*   200 */  1217, 1427, 1217, 1217, 1274, 1217, 1274, 1217, 1338, 1217,
- /*   210 */  1217, 1217, 1274, 1217, 1442, 1372, 1372, 1277, 1222, 1217,
- /*   220 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1512,
- /*   230 */  1513, 1602, 1601, 1512, 1526, 1525, 1524, 1217, 1217, 1507,
- /*   240 */  1217, 1217, 1508, 1506, 1505, 1217, 1217, 1217, 1217, 1217,
- /*   250 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1550,
- /*   260 */  1217, 1612, 1616, 1217, 1217, 1217, 1487, 1217, 1217, 1217,
- /*   270 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   280 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   290 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   300 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   310 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   320 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   330 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   340 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   350 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   360 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   370 */  1217, 1217, 1217, 1383, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   380 */  1303, 1302, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   390 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   400 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   410 */  1217, 1217, 1217, 1573, 1583, 1217, 1217, 1217, 1217, 1217,
- /*   420 */  1217, 1217, 1217, 1217, 1487, 1217, 1600, 1217, 1559, 1555,
- /*   430 */  1217, 1217, 1551, 1217, 1217, 1610, 1217, 1217, 1217, 1217,
- /*   440 */  1217, 1217, 1217, 1217, 1545, 1217, 1217, 1217, 1217, 1217,
- /*   450 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   460 */  1217, 1217, 1486, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   470 */  1366, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   480 */  1217, 1217, 1217, 1351, 1349, 1348, 1347, 1217, 1344, 1217,
- /*   490 */  1217, 1217, 1217, 1217, 1217, 1374, 1217, 1217, 1217, 1217,
- /*   500 */  1217, 1297, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   510 */  1217, 1288, 1217, 1287, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   520 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   530 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
- /*   540 */  1217, 1217, 1217, 1217, 1217, 1217, 1217, 1217,
+ /*     0 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    10 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    20 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    30 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    40 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    50 */  1219, 1219, 1219, 1278, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    60 */  1219, 1219, 1219, 1219, 1219, 1219, 1276, 1416, 1219, 1552,
+ /*    70 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    80 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*    90 */  1219, 1219, 1219, 1219, 1219, 1219, 1278, 1219, 1563, 1563,
+ /*   100 */  1563, 1276, 1219, 1219, 1219, 1219, 1219, 1371, 1219, 1219,
+ /*   110 */  1219, 1219, 1219, 1219, 1219, 1219, 1450, 1219, 1219, 1627,
+ /*   120 */  1219, 1219, 1324, 1219, 1587, 1219, 1579, 1555, 1569, 1556,
+ /*   130 */  1219, 1612, 1572, 1219, 1219, 1219, 1442, 1219, 1219, 1421,
+ /*   140 */  1418, 1418, 1219, 1219, 1219, 1278, 1219, 1219, 1278, 1278,
+ /*   150 */  1219, 1278, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   160 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1452,
+ /*   170 */  1219, 1276, 1219, 1219, 1276, 1219, 1594, 1592, 1219, 1594,
+ /*   180 */  1592, 1219, 1219, 1606, 1602, 1585, 1583, 1569, 1219, 1219,
+ /*   190 */  1219, 1630, 1618, 1614, 1219, 1219, 1592, 1219, 1219, 1592,
+ /*   200 */  1219, 1429, 1219, 1219, 1276, 1219, 1276, 1219, 1340, 1219,
+ /*   210 */  1219, 1219, 1276, 1219, 1444, 1374, 1374, 1279, 1224, 1219,
+ /*   220 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1514,
+ /*   230 */  1515, 1605, 1604, 1514, 1529, 1528, 1527, 1219, 1219, 1509,
+ /*   240 */  1219, 1219, 1510, 1508, 1507, 1219, 1219, 1219, 1219, 1219,
+ /*   250 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1553,
+ /*   260 */  1219, 1615, 1619, 1219, 1219, 1219, 1489, 1219, 1219, 1219,
+ /*   270 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   280 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   290 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   300 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   310 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   320 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   330 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   340 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   350 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   360 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   370 */  1219, 1219, 1219, 1385, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   380 */  1305, 1304, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   390 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   400 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   410 */  1219, 1219, 1219, 1576, 1586, 1219, 1219, 1219, 1219, 1219,
+ /*   420 */  1219, 1219, 1219, 1219, 1489, 1219, 1603, 1219, 1562, 1558,
+ /*   430 */  1219, 1219, 1554, 1219, 1219, 1613, 1219, 1219, 1219, 1219,
+ /*   440 */  1219, 1219, 1219, 1219, 1548, 1219, 1219, 1219, 1219, 1219,
+ /*   450 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   460 */  1219, 1219, 1488, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   470 */  1368, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   480 */  1219, 1219, 1219, 1353, 1351, 1350, 1349, 1219, 1346, 1219,
+ /*   490 */  1219, 1219, 1219, 1219, 1219, 1376, 1219, 1219, 1219, 1219,
+ /*   500 */  1219, 1299, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   510 */  1219, 1290, 1219, 1289, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   520 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   530 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
+ /*   540 */  1219, 1219, 1219, 1219, 1219, 1219, 1219, 1219,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -959,153 +960,154 @@ static const char *const yyTokenName[] = {
   /*  164 */ "FIRST",
   /*  165 */ "LAST",
   /*  166 */ "NOW",
-  /*  167 */ "ROWTS",
-  /*  168 */ "TBNAME",
-  /*  169 */ "QSTARTTS",
-  /*  170 */ "QENDTS",
-  /*  171 */ "WSTARTTS",
-  /*  172 */ "WENDTS",
-  /*  173 */ "WDURATION",
-  /*  174 */ "BETWEEN",
-  /*  175 */ "IS",
-  /*  176 */ "NK_LT",
-  /*  177 */ "NK_GT",
-  /*  178 */ "NK_LE",
-  /*  179 */ "NK_GE",
-  /*  180 */ "NK_NE",
-  /*  181 */ "MATCH",
-  /*  182 */ "NMATCH",
-  /*  183 */ "JOIN",
-  /*  184 */ "INNER",
-  /*  185 */ "SELECT",
-  /*  186 */ "DISTINCT",
-  /*  187 */ "WHERE",
-  /*  188 */ "PARTITION",
-  /*  189 */ "BY",
-  /*  190 */ "SESSION",
-  /*  191 */ "STATE_WINDOW",
-  /*  192 */ "SLIDING",
-  /*  193 */ "FILL",
-  /*  194 */ "VALUE",
-  /*  195 */ "NONE",
-  /*  196 */ "PREV",
-  /*  197 */ "LINEAR",
-  /*  198 */ "NEXT",
-  /*  199 */ "GROUP",
-  /*  200 */ "HAVING",
-  /*  201 */ "ORDER",
-  /*  202 */ "SLIMIT",
-  /*  203 */ "SOFFSET",
-  /*  204 */ "LIMIT",
-  /*  205 */ "OFFSET",
-  /*  206 */ "ASC",
-  /*  207 */ "NULLS",
-  /*  208 */ "cmd",
-  /*  209 */ "account_options",
-  /*  210 */ "alter_account_options",
-  /*  211 */ "literal",
-  /*  212 */ "alter_account_option",
-  /*  213 */ "user_name",
-  /*  214 */ "dnode_endpoint",
-  /*  215 */ "dnode_host_name",
-  /*  216 */ "not_exists_opt",
-  /*  217 */ "db_name",
-  /*  218 */ "db_options",
-  /*  219 */ "exists_opt",
-  /*  220 */ "alter_db_options",
-  /*  221 */ "integer_list",
-  /*  222 */ "variable_list",
-  /*  223 */ "retention_list",
-  /*  224 */ "alter_db_option",
-  /*  225 */ "retention",
-  /*  226 */ "full_table_name",
-  /*  227 */ "column_def_list",
-  /*  228 */ "tags_def_opt",
-  /*  229 */ "table_options",
-  /*  230 */ "multi_create_clause",
-  /*  231 */ "tags_def",
-  /*  232 */ "multi_drop_clause",
-  /*  233 */ "alter_table_clause",
-  /*  234 */ "alter_table_options",
-  /*  235 */ "column_name",
-  /*  236 */ "type_name",
-  /*  237 */ "create_subtable_clause",
-  /*  238 */ "specific_tags_opt",
-  /*  239 */ "literal_list",
-  /*  240 */ "drop_table_clause",
-  /*  241 */ "col_name_list",
-  /*  242 */ "table_name",
-  /*  243 */ "column_def",
-  /*  244 */ "func_name_list",
-  /*  245 */ "alter_table_option",
-  /*  246 */ "col_name",
-  /*  247 */ "db_name_cond_opt",
-  /*  248 */ "like_pattern_opt",
-  /*  249 */ "table_name_cond",
-  /*  250 */ "from_db_opt",
-  /*  251 */ "func_name",
-  /*  252 */ "function_name",
-  /*  253 */ "index_name",
-  /*  254 */ "index_options",
-  /*  255 */ "func_list",
-  /*  256 */ "duration_literal",
-  /*  257 */ "sliding_opt",
-  /*  258 */ "func",
-  /*  259 */ "expression_list",
-  /*  260 */ "topic_name",
-  /*  261 */ "query_expression",
-  /*  262 */ "analyze_opt",
-  /*  263 */ "explain_options",
-  /*  264 */ "agg_func_opt",
-  /*  265 */ "bufsize_opt",
-  /*  266 */ "stream_name",
-  /*  267 */ "dnode_list",
-  /*  268 */ "signed",
-  /*  269 */ "signed_literal",
-  /*  270 */ "table_alias",
-  /*  271 */ "column_alias",
-  /*  272 */ "expression",
-  /*  273 */ "pseudo_column",
-  /*  274 */ "column_reference",
-  /*  275 */ "subquery",
-  /*  276 */ "predicate",
-  /*  277 */ "compare_op",
-  /*  278 */ "in_op",
-  /*  279 */ "in_predicate_value",
-  /*  280 */ "boolean_value_expression",
-  /*  281 */ "boolean_primary",
-  /*  282 */ "common_expression",
-  /*  283 */ "from_clause",
-  /*  284 */ "table_reference_list",
-  /*  285 */ "table_reference",
-  /*  286 */ "table_primary",
-  /*  287 */ "joined_table",
-  /*  288 */ "alias_opt",
-  /*  289 */ "parenthesized_joined_table",
-  /*  290 */ "join_type",
-  /*  291 */ "search_condition",
-  /*  292 */ "query_specification",
-  /*  293 */ "set_quantifier_opt",
-  /*  294 */ "select_list",
-  /*  295 */ "where_clause_opt",
-  /*  296 */ "partition_by_clause_opt",
-  /*  297 */ "twindow_clause_opt",
-  /*  298 */ "group_by_clause_opt",
-  /*  299 */ "having_clause_opt",
-  /*  300 */ "select_sublist",
-  /*  301 */ "select_item",
-  /*  302 */ "fill_opt",
-  /*  303 */ "fill_mode",
-  /*  304 */ "group_by_list",
-  /*  305 */ "query_expression_body",
-  /*  306 */ "order_by_clause_opt",
-  /*  307 */ "slimit_clause_opt",
-  /*  308 */ "limit_clause_opt",
-  /*  309 */ "query_primary",
-  /*  310 */ "sort_specification_list",
-  /*  311 */ "sort_specification",
-  /*  312 */ "ordering_specification_opt",
-  /*  313 */ "null_ordering_opt",
+  /*  167 */ "TODAY",
+  /*  168 */ "ROWTS",
+  /*  169 */ "TBNAME",
+  /*  170 */ "QSTARTTS",
+  /*  171 */ "QENDTS",
+  /*  172 */ "WSTARTTS",
+  /*  173 */ "WENDTS",
+  /*  174 */ "WDURATION",
+  /*  175 */ "BETWEEN",
+  /*  176 */ "IS",
+  /*  177 */ "NK_LT",
+  /*  178 */ "NK_GT",
+  /*  179 */ "NK_LE",
+  /*  180 */ "NK_GE",
+  /*  181 */ "NK_NE",
+  /*  182 */ "MATCH",
+  /*  183 */ "NMATCH",
+  /*  184 */ "JOIN",
+  /*  185 */ "INNER",
+  /*  186 */ "SELECT",
+  /*  187 */ "DISTINCT",
+  /*  188 */ "WHERE",
+  /*  189 */ "PARTITION",
+  /*  190 */ "BY",
+  /*  191 */ "SESSION",
+  /*  192 */ "STATE_WINDOW",
+  /*  193 */ "SLIDING",
+  /*  194 */ "FILL",
+  /*  195 */ "VALUE",
+  /*  196 */ "NONE",
+  /*  197 */ "PREV",
+  /*  198 */ "LINEAR",
+  /*  199 */ "NEXT",
+  /*  200 */ "GROUP",
+  /*  201 */ "HAVING",
+  /*  202 */ "ORDER",
+  /*  203 */ "SLIMIT",
+  /*  204 */ "SOFFSET",
+  /*  205 */ "LIMIT",
+  /*  206 */ "OFFSET",
+  /*  207 */ "ASC",
+  /*  208 */ "NULLS",
+  /*  209 */ "cmd",
+  /*  210 */ "account_options",
+  /*  211 */ "alter_account_options",
+  /*  212 */ "literal",
+  /*  213 */ "alter_account_option",
+  /*  214 */ "user_name",
+  /*  215 */ "dnode_endpoint",
+  /*  216 */ "dnode_host_name",
+  /*  217 */ "not_exists_opt",
+  /*  218 */ "db_name",
+  /*  219 */ "db_options",
+  /*  220 */ "exists_opt",
+  /*  221 */ "alter_db_options",
+  /*  222 */ "integer_list",
+  /*  223 */ "variable_list",
+  /*  224 */ "retention_list",
+  /*  225 */ "alter_db_option",
+  /*  226 */ "retention",
+  /*  227 */ "full_table_name",
+  /*  228 */ "column_def_list",
+  /*  229 */ "tags_def_opt",
+  /*  230 */ "table_options",
+  /*  231 */ "multi_create_clause",
+  /*  232 */ "tags_def",
+  /*  233 */ "multi_drop_clause",
+  /*  234 */ "alter_table_clause",
+  /*  235 */ "alter_table_options",
+  /*  236 */ "column_name",
+  /*  237 */ "type_name",
+  /*  238 */ "create_subtable_clause",
+  /*  239 */ "specific_tags_opt",
+  /*  240 */ "literal_list",
+  /*  241 */ "drop_table_clause",
+  /*  242 */ "col_name_list",
+  /*  243 */ "table_name",
+  /*  244 */ "column_def",
+  /*  245 */ "func_name_list",
+  /*  246 */ "alter_table_option",
+  /*  247 */ "col_name",
+  /*  248 */ "db_name_cond_opt",
+  /*  249 */ "like_pattern_opt",
+  /*  250 */ "table_name_cond",
+  /*  251 */ "from_db_opt",
+  /*  252 */ "func_name",
+  /*  253 */ "function_name",
+  /*  254 */ "index_name",
+  /*  255 */ "index_options",
+  /*  256 */ "func_list",
+  /*  257 */ "duration_literal",
+  /*  258 */ "sliding_opt",
+  /*  259 */ "func",
+  /*  260 */ "expression_list",
+  /*  261 */ "topic_name",
+  /*  262 */ "query_expression",
+  /*  263 */ "analyze_opt",
+  /*  264 */ "explain_options",
+  /*  265 */ "agg_func_opt",
+  /*  266 */ "bufsize_opt",
+  /*  267 */ "stream_name",
+  /*  268 */ "dnode_list",
+  /*  269 */ "signed",
+  /*  270 */ "signed_literal",
+  /*  271 */ "table_alias",
+  /*  272 */ "column_alias",
+  /*  273 */ "expression",
+  /*  274 */ "pseudo_column",
+  /*  275 */ "column_reference",
+  /*  276 */ "subquery",
+  /*  277 */ "predicate",
+  /*  278 */ "compare_op",
+  /*  279 */ "in_op",
+  /*  280 */ "in_predicate_value",
+  /*  281 */ "boolean_value_expression",
+  /*  282 */ "boolean_primary",
+  /*  283 */ "common_expression",
+  /*  284 */ "from_clause",
+  /*  285 */ "table_reference_list",
+  /*  286 */ "table_reference",
+  /*  287 */ "table_primary",
+  /*  288 */ "joined_table",
+  /*  289 */ "alias_opt",
+  /*  290 */ "parenthesized_joined_table",
+  /*  291 */ "join_type",
+  /*  292 */ "search_condition",
+  /*  293 */ "query_specification",
+  /*  294 */ "set_quantifier_opt",
+  /*  295 */ "select_list",
+  /*  296 */ "where_clause_opt",
+  /*  297 */ "partition_by_clause_opt",
+  /*  298 */ "twindow_clause_opt",
+  /*  299 */ "group_by_clause_opt",
+  /*  300 */ "having_clause_opt",
+  /*  301 */ "select_sublist",
+  /*  302 */ "select_item",
+  /*  303 */ "fill_opt",
+  /*  304 */ "fill_mode",
+  /*  305 */ "group_by_list",
+  /*  306 */ "query_expression_body",
+  /*  307 */ "order_by_clause_opt",
+  /*  308 */ "slimit_clause_opt",
+  /*  309 */ "limit_clause_opt",
+  /*  310 */ "query_primary",
+  /*  311 */ "sort_specification_list",
+  /*  312 */ "sort_specification",
+  /*  313 */ "ordering_specification_opt",
+  /*  314 */ "null_ordering_opt",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1410,119 +1412,120 @@ static const char *const yyRuleName[] = {
  /* 294 */ "column_reference ::= column_name",
  /* 295 */ "column_reference ::= table_name NK_DOT column_name",
  /* 296 */ "pseudo_column ::= NOW",
- /* 297 */ "pseudo_column ::= ROWTS",
- /* 298 */ "pseudo_column ::= TBNAME",
- /* 299 */ "pseudo_column ::= QSTARTTS",
- /* 300 */ "pseudo_column ::= QENDTS",
- /* 301 */ "pseudo_column ::= WSTARTTS",
- /* 302 */ "pseudo_column ::= WENDTS",
- /* 303 */ "pseudo_column ::= WDURATION",
- /* 304 */ "predicate ::= expression compare_op expression",
- /* 305 */ "predicate ::= expression BETWEEN expression AND expression",
- /* 306 */ "predicate ::= expression NOT BETWEEN expression AND expression",
- /* 307 */ "predicate ::= expression IS NULL",
- /* 308 */ "predicate ::= expression IS NOT NULL",
- /* 309 */ "predicate ::= expression in_op in_predicate_value",
- /* 310 */ "compare_op ::= NK_LT",
- /* 311 */ "compare_op ::= NK_GT",
- /* 312 */ "compare_op ::= NK_LE",
- /* 313 */ "compare_op ::= NK_GE",
- /* 314 */ "compare_op ::= NK_NE",
- /* 315 */ "compare_op ::= NK_EQ",
- /* 316 */ "compare_op ::= LIKE",
- /* 317 */ "compare_op ::= NOT LIKE",
- /* 318 */ "compare_op ::= MATCH",
- /* 319 */ "compare_op ::= NMATCH",
- /* 320 */ "in_op ::= IN",
- /* 321 */ "in_op ::= NOT IN",
- /* 322 */ "in_predicate_value ::= NK_LP expression_list NK_RP",
- /* 323 */ "boolean_value_expression ::= boolean_primary",
- /* 324 */ "boolean_value_expression ::= NOT boolean_primary",
- /* 325 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
- /* 326 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
- /* 327 */ "boolean_primary ::= predicate",
- /* 328 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
- /* 329 */ "common_expression ::= expression",
- /* 330 */ "common_expression ::= boolean_value_expression",
- /* 331 */ "from_clause ::= FROM table_reference_list",
- /* 332 */ "table_reference_list ::= table_reference",
- /* 333 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
- /* 334 */ "table_reference ::= table_primary",
- /* 335 */ "table_reference ::= joined_table",
- /* 336 */ "table_primary ::= table_name alias_opt",
- /* 337 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
- /* 338 */ "table_primary ::= subquery alias_opt",
- /* 339 */ "table_primary ::= parenthesized_joined_table",
- /* 340 */ "alias_opt ::=",
- /* 341 */ "alias_opt ::= table_alias",
- /* 342 */ "alias_opt ::= AS table_alias",
- /* 343 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
- /* 344 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
- /* 345 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
- /* 346 */ "join_type ::=",
- /* 347 */ "join_type ::= INNER",
- /* 348 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
- /* 349 */ "set_quantifier_opt ::=",
- /* 350 */ "set_quantifier_opt ::= DISTINCT",
- /* 351 */ "set_quantifier_opt ::= ALL",
- /* 352 */ "select_list ::= NK_STAR",
- /* 353 */ "select_list ::= select_sublist",
- /* 354 */ "select_sublist ::= select_item",
- /* 355 */ "select_sublist ::= select_sublist NK_COMMA select_item",
- /* 356 */ "select_item ::= common_expression",
- /* 357 */ "select_item ::= common_expression column_alias",
- /* 358 */ "select_item ::= common_expression AS column_alias",
- /* 359 */ "select_item ::= table_name NK_DOT NK_STAR",
- /* 360 */ "where_clause_opt ::=",
- /* 361 */ "where_clause_opt ::= WHERE search_condition",
- /* 362 */ "partition_by_clause_opt ::=",
- /* 363 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
- /* 364 */ "twindow_clause_opt ::=",
- /* 365 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
- /* 366 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
- /* 367 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
- /* 368 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
- /* 369 */ "sliding_opt ::=",
- /* 370 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
- /* 371 */ "fill_opt ::=",
- /* 372 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
- /* 373 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
- /* 374 */ "fill_mode ::= NONE",
- /* 375 */ "fill_mode ::= PREV",
- /* 376 */ "fill_mode ::= NULL",
- /* 377 */ "fill_mode ::= LINEAR",
- /* 378 */ "fill_mode ::= NEXT",
- /* 379 */ "group_by_clause_opt ::=",
- /* 380 */ "group_by_clause_opt ::= GROUP BY group_by_list",
- /* 381 */ "group_by_list ::= expression",
- /* 382 */ "group_by_list ::= group_by_list NK_COMMA expression",
- /* 383 */ "having_clause_opt ::=",
- /* 384 */ "having_clause_opt ::= HAVING search_condition",
- /* 385 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
- /* 386 */ "query_expression_body ::= query_primary",
- /* 387 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
- /* 388 */ "query_primary ::= query_specification",
- /* 389 */ "order_by_clause_opt ::=",
- /* 390 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
- /* 391 */ "slimit_clause_opt ::=",
- /* 392 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
- /* 393 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
- /* 394 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 395 */ "limit_clause_opt ::=",
- /* 396 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
- /* 397 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
- /* 398 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 399 */ "subquery ::= NK_LP query_expression NK_RP",
- /* 400 */ "search_condition ::= common_expression",
- /* 401 */ "sort_specification_list ::= sort_specification",
- /* 402 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
- /* 403 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
- /* 404 */ "ordering_specification_opt ::=",
- /* 405 */ "ordering_specification_opt ::= ASC",
- /* 406 */ "ordering_specification_opt ::= DESC",
- /* 407 */ "null_ordering_opt ::=",
- /* 408 */ "null_ordering_opt ::= NULLS FIRST",
- /* 409 */ "null_ordering_opt ::= NULLS LAST",
+ /* 297 */ "pseudo_column ::= TODAY",
+ /* 298 */ "pseudo_column ::= ROWTS",
+ /* 299 */ "pseudo_column ::= TBNAME",
+ /* 300 */ "pseudo_column ::= QSTARTTS",
+ /* 301 */ "pseudo_column ::= QENDTS",
+ /* 302 */ "pseudo_column ::= WSTARTTS",
+ /* 303 */ "pseudo_column ::= WENDTS",
+ /* 304 */ "pseudo_column ::= WDURATION",
+ /* 305 */ "predicate ::= expression compare_op expression",
+ /* 306 */ "predicate ::= expression BETWEEN expression AND expression",
+ /* 307 */ "predicate ::= expression NOT BETWEEN expression AND expression",
+ /* 308 */ "predicate ::= expression IS NULL",
+ /* 309 */ "predicate ::= expression IS NOT NULL",
+ /* 310 */ "predicate ::= expression in_op in_predicate_value",
+ /* 311 */ "compare_op ::= NK_LT",
+ /* 312 */ "compare_op ::= NK_GT",
+ /* 313 */ "compare_op ::= NK_LE",
+ /* 314 */ "compare_op ::= NK_GE",
+ /* 315 */ "compare_op ::= NK_NE",
+ /* 316 */ "compare_op ::= NK_EQ",
+ /* 317 */ "compare_op ::= LIKE",
+ /* 318 */ "compare_op ::= NOT LIKE",
+ /* 319 */ "compare_op ::= MATCH",
+ /* 320 */ "compare_op ::= NMATCH",
+ /* 321 */ "in_op ::= IN",
+ /* 322 */ "in_op ::= NOT IN",
+ /* 323 */ "in_predicate_value ::= NK_LP expression_list NK_RP",
+ /* 324 */ "boolean_value_expression ::= boolean_primary",
+ /* 325 */ "boolean_value_expression ::= NOT boolean_primary",
+ /* 326 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
+ /* 327 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
+ /* 328 */ "boolean_primary ::= predicate",
+ /* 329 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
+ /* 330 */ "common_expression ::= expression",
+ /* 331 */ "common_expression ::= boolean_value_expression",
+ /* 332 */ "from_clause ::= FROM table_reference_list",
+ /* 333 */ "table_reference_list ::= table_reference",
+ /* 334 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
+ /* 335 */ "table_reference ::= table_primary",
+ /* 336 */ "table_reference ::= joined_table",
+ /* 337 */ "table_primary ::= table_name alias_opt",
+ /* 338 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
+ /* 339 */ "table_primary ::= subquery alias_opt",
+ /* 340 */ "table_primary ::= parenthesized_joined_table",
+ /* 341 */ "alias_opt ::=",
+ /* 342 */ "alias_opt ::= table_alias",
+ /* 343 */ "alias_opt ::= AS table_alias",
+ /* 344 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
+ /* 345 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
+ /* 346 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
+ /* 347 */ "join_type ::=",
+ /* 348 */ "join_type ::= INNER",
+ /* 349 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
+ /* 350 */ "set_quantifier_opt ::=",
+ /* 351 */ "set_quantifier_opt ::= DISTINCT",
+ /* 352 */ "set_quantifier_opt ::= ALL",
+ /* 353 */ "select_list ::= NK_STAR",
+ /* 354 */ "select_list ::= select_sublist",
+ /* 355 */ "select_sublist ::= select_item",
+ /* 356 */ "select_sublist ::= select_sublist NK_COMMA select_item",
+ /* 357 */ "select_item ::= common_expression",
+ /* 358 */ "select_item ::= common_expression column_alias",
+ /* 359 */ "select_item ::= common_expression AS column_alias",
+ /* 360 */ "select_item ::= table_name NK_DOT NK_STAR",
+ /* 361 */ "where_clause_opt ::=",
+ /* 362 */ "where_clause_opt ::= WHERE search_condition",
+ /* 363 */ "partition_by_clause_opt ::=",
+ /* 364 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
+ /* 365 */ "twindow_clause_opt ::=",
+ /* 366 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
+ /* 367 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
+ /* 368 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
+ /* 369 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
+ /* 370 */ "sliding_opt ::=",
+ /* 371 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
+ /* 372 */ "fill_opt ::=",
+ /* 373 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
+ /* 374 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
+ /* 375 */ "fill_mode ::= NONE",
+ /* 376 */ "fill_mode ::= PREV",
+ /* 377 */ "fill_mode ::= NULL",
+ /* 378 */ "fill_mode ::= LINEAR",
+ /* 379 */ "fill_mode ::= NEXT",
+ /* 380 */ "group_by_clause_opt ::=",
+ /* 381 */ "group_by_clause_opt ::= GROUP BY group_by_list",
+ /* 382 */ "group_by_list ::= expression",
+ /* 383 */ "group_by_list ::= group_by_list NK_COMMA expression",
+ /* 384 */ "having_clause_opt ::=",
+ /* 385 */ "having_clause_opt ::= HAVING search_condition",
+ /* 386 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
+ /* 387 */ "query_expression_body ::= query_primary",
+ /* 388 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
+ /* 389 */ "query_primary ::= query_specification",
+ /* 390 */ "order_by_clause_opt ::=",
+ /* 391 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /* 392 */ "slimit_clause_opt ::=",
+ /* 393 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
+ /* 394 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /* 395 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 396 */ "limit_clause_opt ::=",
+ /* 397 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
+ /* 398 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /* 399 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 400 */ "subquery ::= NK_LP query_expression NK_RP",
+ /* 401 */ "search_condition ::= common_expression",
+ /* 402 */ "sort_specification_list ::= sort_specification",
+ /* 403 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /* 404 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
+ /* 405 */ "ordering_specification_opt ::=",
+ /* 406 */ "ordering_specification_opt ::= ASC",
+ /* 407 */ "ordering_specification_opt ::= DESC",
+ /* 408 */ "null_ordering_opt ::=",
+ /* 409 */ "null_ordering_opt ::= NULLS FIRST",
+ /* 410 */ "null_ordering_opt ::= NULLS LAST",
 };
 #endif /* NDEBUG */
 
@@ -1649,156 +1652,156 @@ static void yy_destructor(
     */
 /********* Begin destructor definitions ***************************************/
       /* Default NON-TERMINAL Destructor */
-    case 208: /* cmd */
-    case 211: /* literal */
-    case 218: /* db_options */
-    case 220: /* alter_db_options */
-    case 225: /* retention */
-    case 226: /* full_table_name */
-    case 229: /* table_options */
-    case 233: /* alter_table_clause */
-    case 234: /* alter_table_options */
-    case 237: /* create_subtable_clause */
-    case 240: /* drop_table_clause */
-    case 243: /* column_def */
-    case 246: /* col_name */
-    case 247: /* db_name_cond_opt */
-    case 248: /* like_pattern_opt */
-    case 249: /* table_name_cond */
-    case 250: /* from_db_opt */
-    case 251: /* func_name */
-    case 254: /* index_options */
-    case 256: /* duration_literal */
-    case 257: /* sliding_opt */
-    case 258: /* func */
-    case 261: /* query_expression */
-    case 263: /* explain_options */
-    case 268: /* signed */
-    case 269: /* signed_literal */
-    case 272: /* expression */
-    case 273: /* pseudo_column */
-    case 274: /* column_reference */
-    case 275: /* subquery */
-    case 276: /* predicate */
-    case 279: /* in_predicate_value */
-    case 280: /* boolean_value_expression */
-    case 281: /* boolean_primary */
-    case 282: /* common_expression */
-    case 283: /* from_clause */
-    case 284: /* table_reference_list */
-    case 285: /* table_reference */
-    case 286: /* table_primary */
-    case 287: /* joined_table */
-    case 289: /* parenthesized_joined_table */
-    case 291: /* search_condition */
-    case 292: /* query_specification */
-    case 295: /* where_clause_opt */
-    case 297: /* twindow_clause_opt */
-    case 299: /* having_clause_opt */
-    case 301: /* select_item */
-    case 302: /* fill_opt */
-    case 305: /* query_expression_body */
-    case 307: /* slimit_clause_opt */
-    case 308: /* limit_clause_opt */
-    case 309: /* query_primary */
-    case 311: /* sort_specification */
+    case 209: /* cmd */
+    case 212: /* literal */
+    case 219: /* db_options */
+    case 221: /* alter_db_options */
+    case 226: /* retention */
+    case 227: /* full_table_name */
+    case 230: /* table_options */
+    case 234: /* alter_table_clause */
+    case 235: /* alter_table_options */
+    case 238: /* create_subtable_clause */
+    case 241: /* drop_table_clause */
+    case 244: /* column_def */
+    case 247: /* col_name */
+    case 248: /* db_name_cond_opt */
+    case 249: /* like_pattern_opt */
+    case 250: /* table_name_cond */
+    case 251: /* from_db_opt */
+    case 252: /* func_name */
+    case 255: /* index_options */
+    case 257: /* duration_literal */
+    case 258: /* sliding_opt */
+    case 259: /* func */
+    case 262: /* query_expression */
+    case 264: /* explain_options */
+    case 269: /* signed */
+    case 270: /* signed_literal */
+    case 273: /* expression */
+    case 274: /* pseudo_column */
+    case 275: /* column_reference */
+    case 276: /* subquery */
+    case 277: /* predicate */
+    case 280: /* in_predicate_value */
+    case 281: /* boolean_value_expression */
+    case 282: /* boolean_primary */
+    case 283: /* common_expression */
+    case 284: /* from_clause */
+    case 285: /* table_reference_list */
+    case 286: /* table_reference */
+    case 287: /* table_primary */
+    case 288: /* joined_table */
+    case 290: /* parenthesized_joined_table */
+    case 292: /* search_condition */
+    case 293: /* query_specification */
+    case 296: /* where_clause_opt */
+    case 298: /* twindow_clause_opt */
+    case 300: /* having_clause_opt */
+    case 302: /* select_item */
+    case 303: /* fill_opt */
+    case 306: /* query_expression_body */
+    case 308: /* slimit_clause_opt */
+    case 309: /* limit_clause_opt */
+    case 310: /* query_primary */
+    case 312: /* sort_specification */
 {
- nodesDestroyNode((yypminor->yy140)); 
+ nodesDestroyNode((yypminor->yy182)); 
 }
       break;
-    case 209: /* account_options */
-    case 210: /* alter_account_options */
-    case 212: /* alter_account_option */
-    case 265: /* bufsize_opt */
+    case 210: /* account_options */
+    case 211: /* alter_account_options */
+    case 213: /* alter_account_option */
+    case 266: /* bufsize_opt */
 {
  
 }
       break;
-    case 213: /* user_name */
-    case 214: /* dnode_endpoint */
-    case 215: /* dnode_host_name */
-    case 217: /* db_name */
-    case 235: /* column_name */
-    case 242: /* table_name */
-    case 252: /* function_name */
-    case 253: /* index_name */
-    case 260: /* topic_name */
-    case 266: /* stream_name */
-    case 270: /* table_alias */
-    case 271: /* column_alias */
-    case 288: /* alias_opt */
+    case 214: /* user_name */
+    case 215: /* dnode_endpoint */
+    case 216: /* dnode_host_name */
+    case 218: /* db_name */
+    case 236: /* column_name */
+    case 243: /* table_name */
+    case 253: /* function_name */
+    case 254: /* index_name */
+    case 261: /* topic_name */
+    case 267: /* stream_name */
+    case 271: /* table_alias */
+    case 272: /* column_alias */
+    case 289: /* alias_opt */
 {
  
 }
       break;
-    case 216: /* not_exists_opt */
-    case 219: /* exists_opt */
-    case 262: /* analyze_opt */
-    case 264: /* agg_func_opt */
-    case 293: /* set_quantifier_opt */
+    case 217: /* not_exists_opt */
+    case 220: /* exists_opt */
+    case 263: /* analyze_opt */
+    case 265: /* agg_func_opt */
+    case 294: /* set_quantifier_opt */
 {
  
 }
       break;
-    case 221: /* integer_list */
-    case 222: /* variable_list */
-    case 223: /* retention_list */
-    case 227: /* column_def_list */
-    case 228: /* tags_def_opt */
-    case 230: /* multi_create_clause */
-    case 231: /* tags_def */
-    case 232: /* multi_drop_clause */
-    case 238: /* specific_tags_opt */
-    case 239: /* literal_list */
-    case 241: /* col_name_list */
-    case 244: /* func_name_list */
-    case 255: /* func_list */
-    case 259: /* expression_list */
-    case 267: /* dnode_list */
-    case 294: /* select_list */
-    case 296: /* partition_by_clause_opt */
-    case 298: /* group_by_clause_opt */
-    case 300: /* select_sublist */
-    case 304: /* group_by_list */
-    case 306: /* order_by_clause_opt */
-    case 310: /* sort_specification_list */
+    case 222: /* integer_list */
+    case 223: /* variable_list */
+    case 224: /* retention_list */
+    case 228: /* column_def_list */
+    case 229: /* tags_def_opt */
+    case 231: /* multi_create_clause */
+    case 232: /* tags_def */
+    case 233: /* multi_drop_clause */
+    case 239: /* specific_tags_opt */
+    case 240: /* literal_list */
+    case 242: /* col_name_list */
+    case 245: /* func_name_list */
+    case 256: /* func_list */
+    case 260: /* expression_list */
+    case 268: /* dnode_list */
+    case 295: /* select_list */
+    case 297: /* partition_by_clause_opt */
+    case 299: /* group_by_clause_opt */
+    case 301: /* select_sublist */
+    case 305: /* group_by_list */
+    case 307: /* order_by_clause_opt */
+    case 311: /* sort_specification_list */
 {
- nodesDestroyList((yypminor->yy220)); 
+ nodesDestroyList((yypminor->yy334)); 
 }
       break;
-    case 224: /* alter_db_option */
-    case 245: /* alter_table_option */
+    case 225: /* alter_db_option */
+    case 246: /* alter_table_option */
 {
  
 }
       break;
-    case 236: /* type_name */
+    case 237: /* type_name */
 {
  
 }
       break;
-    case 277: /* compare_op */
-    case 278: /* in_op */
+    case 278: /* compare_op */
+    case 279: /* in_op */
 {
  
 }
       break;
-    case 290: /* join_type */
+    case 291: /* join_type */
 {
  
 }
       break;
-    case 303: /* fill_mode */
+    case 304: /* fill_mode */
 {
  
 }
       break;
-    case 312: /* ordering_specification_opt */
+    case 313: /* ordering_specification_opt */
 {
  
 }
       break;
-    case 313: /* null_ordering_opt */
+    case 314: /* null_ordering_opt */
 {
  
 }
@@ -1926,15 +1929,18 @@ static YYACTIONTYPE yy_find_shift_action(
   do{
     i = yy_shift_ofst[stateno];
     assert( i>=0 );
-    /* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */
+    assert( i<=YY_ACTTAB_COUNT );
+    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
     assert( iLookAhead!=YYNOCODE );
     assert( iLookAhead < YYNTOKEN );
     i += iLookAhead;
-    if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){
+    assert( i<(int)YY_NLOOKAHEAD );
+    if( yy_lookahead[i]!=iLookAhead ){
 #ifdef YYFALLBACK
       YYCODETYPE iFallback;            /* Fallback token */
-      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
-             && (iFallback = yyFallback[iLookAhead])!=0 ){
+      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
+      iFallback = yyFallback[iLookAhead];
+      if( iFallback!=0 ){
 #ifndef NDEBUG
         if( yyTraceFILE ){
           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
@@ -1949,16 +1955,8 @@ static YYACTIONTYPE yy_find_shift_action(
 #ifdef YYWILDCARD
       {
         int j = i - iLookAhead + YYWILDCARD;
-        if( 
-#if YY_SHIFT_MIN+YYWILDCARD<0
-          j>=0 &&
-#endif
-#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
-          j<YY_ACTTAB_COUNT &&
-#endif
-          j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) &&
-          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
-        ){
+        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
+        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
 #ifndef NDEBUG
           if( yyTraceFILE ){
             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -1972,6 +1970,7 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif /* YYWILDCARD */
       return yy_default[stateno];
     }else{
+      assert( i>=0 && i<sizeof(yy_action)/sizeof(yy_action[0]) );
       return yy_action[i];
     }
   }while(1);
@@ -2090,423 +2089,836 @@ static void yy_shift(
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* The following table contains information about every rule that
-** is used during the reduce.
-*/
-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[] = {
-  {  208,   -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
-  {  208,   -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
-  {  209,    0 }, /* (2) account_options ::= */
-  {  209,   -3 }, /* (3) account_options ::= account_options PPS literal */
-  {  209,   -3 }, /* (4) account_options ::= account_options TSERIES literal */
-  {  209,   -3 }, /* (5) account_options ::= account_options STORAGE literal */
-  {  209,   -3 }, /* (6) account_options ::= account_options STREAMS literal */
-  {  209,   -3 }, /* (7) account_options ::= account_options QTIME literal */
-  {  209,   -3 }, /* (8) account_options ::= account_options DBS literal */
-  {  209,   -3 }, /* (9) account_options ::= account_options USERS literal */
-  {  209,   -3 }, /* (10) account_options ::= account_options CONNS literal */
-  {  209,   -3 }, /* (11) account_options ::= account_options STATE literal */
-  {  210,   -1 }, /* (12) alter_account_options ::= alter_account_option */
-  {  210,   -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */
-  {  212,   -2 }, /* (14) alter_account_option ::= PASS literal */
-  {  212,   -2 }, /* (15) alter_account_option ::= PPS literal */
-  {  212,   -2 }, /* (16) alter_account_option ::= TSERIES literal */
-  {  212,   -2 }, /* (17) alter_account_option ::= STORAGE literal */
-  {  212,   -2 }, /* (18) alter_account_option ::= STREAMS literal */
-  {  212,   -2 }, /* (19) alter_account_option ::= QTIME literal */
-  {  212,   -2 }, /* (20) alter_account_option ::= DBS literal */
-  {  212,   -2 }, /* (21) alter_account_option ::= USERS literal */
-  {  212,   -2 }, /* (22) alter_account_option ::= CONNS literal */
-  {  212,   -2 }, /* (23) alter_account_option ::= STATE literal */
-  {  208,   -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
-  {  208,   -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
-  {  208,   -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
-  {  208,   -3 }, /* (27) cmd ::= DROP USER user_name */
-  {  208,   -3 }, /* (28) cmd ::= CREATE DNODE dnode_endpoint */
-  {  208,   -5 }, /* (29) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
-  {  208,   -3 }, /* (30) cmd ::= DROP DNODE NK_INTEGER */
-  {  208,   -3 }, /* (31) cmd ::= DROP DNODE dnode_endpoint */
-  {  208,   -4 }, /* (32) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
-  {  208,   -5 }, /* (33) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
-  {  208,   -4 }, /* (34) cmd ::= ALTER ALL DNODES NK_STRING */
-  {  208,   -5 }, /* (35) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
-  {  214,   -1 }, /* (36) dnode_endpoint ::= NK_STRING */
-  {  215,   -1 }, /* (37) dnode_host_name ::= NK_ID */
-  {  215,   -1 }, /* (38) dnode_host_name ::= NK_IPTOKEN */
-  {  208,   -3 }, /* (39) cmd ::= ALTER LOCAL NK_STRING */
-  {  208,   -4 }, /* (40) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
-  {  208,   -5 }, /* (41) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (42) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (43) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (44) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (45) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (46) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (47) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (48) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
-  {  208,   -5 }, /* (49) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
-  {  208,   -4 }, /* (50) cmd ::= DROP DATABASE exists_opt db_name */
-  {  208,   -2 }, /* (51) cmd ::= USE db_name */
-  {  208,   -4 }, /* (52) cmd ::= ALTER DATABASE db_name alter_db_options */
-  {  216,   -3 }, /* (53) not_exists_opt ::= IF NOT EXISTS */
-  {  216,    0 }, /* (54) not_exists_opt ::= */
-  {  219,   -2 }, /* (55) exists_opt ::= IF EXISTS */
-  {  219,    0 }, /* (56) exists_opt ::= */
-  {  218,    0 }, /* (57) db_options ::= */
-  {  218,   -3 }, /* (58) db_options ::= db_options BLOCKS NK_INTEGER */
-  {  218,   -3 }, /* (59) db_options ::= db_options CACHE NK_INTEGER */
-  {  218,   -3 }, /* (60) db_options ::= db_options CACHELAST NK_INTEGER */
-  {  218,   -3 }, /* (61) db_options ::= db_options COMP NK_INTEGER */
-  {  218,   -3 }, /* (62) db_options ::= db_options DAYS NK_INTEGER */
-  {  218,   -3 }, /* (63) db_options ::= db_options DAYS NK_VARIABLE */
-  {  218,   -3 }, /* (64) db_options ::= db_options FSYNC NK_INTEGER */
-  {  218,   -3 }, /* (65) db_options ::= db_options MAXROWS NK_INTEGER */
-  {  218,   -3 }, /* (66) db_options ::= db_options MINROWS NK_INTEGER */
-  {  218,   -3 }, /* (67) db_options ::= db_options KEEP integer_list */
-  {  218,   -3 }, /* (68) db_options ::= db_options KEEP variable_list */
-  {  218,   -3 }, /* (69) db_options ::= db_options PRECISION NK_STRING */
-  {  218,   -3 }, /* (70) db_options ::= db_options QUORUM NK_INTEGER */
-  {  218,   -3 }, /* (71) db_options ::= db_options REPLICA NK_INTEGER */
-  {  218,   -3 }, /* (72) db_options ::= db_options TTL NK_INTEGER */
-  {  218,   -3 }, /* (73) db_options ::= db_options WAL NK_INTEGER */
-  {  218,   -3 }, /* (74) db_options ::= db_options VGROUPS NK_INTEGER */
-  {  218,   -3 }, /* (75) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
-  {  218,   -3 }, /* (76) db_options ::= db_options STREAM_MODE NK_INTEGER */
-  {  218,   -3 }, /* (77) db_options ::= db_options RETENTIONS retention_list */
-  {  220,   -1 }, /* (78) alter_db_options ::= alter_db_option */
-  {  220,   -2 }, /* (79) alter_db_options ::= alter_db_options alter_db_option */
-  {  224,   -2 }, /* (80) alter_db_option ::= BLOCKS NK_INTEGER */
-  {  224,   -2 }, /* (81) alter_db_option ::= FSYNC NK_INTEGER */
-  {  224,   -2 }, /* (82) alter_db_option ::= KEEP integer_list */
-  {  224,   -2 }, /* (83) alter_db_option ::= KEEP variable_list */
-  {  224,   -2 }, /* (84) alter_db_option ::= WAL NK_INTEGER */
-  {  224,   -2 }, /* (85) alter_db_option ::= QUORUM NK_INTEGER */
-  {  224,   -2 }, /* (86) alter_db_option ::= CACHELAST NK_INTEGER */
-  {  224,   -2 }, /* (87) alter_db_option ::= REPLICA NK_INTEGER */
-  {  221,   -1 }, /* (88) integer_list ::= NK_INTEGER */
-  {  221,   -3 }, /* (89) integer_list ::= integer_list NK_COMMA NK_INTEGER */
-  {  222,   -1 }, /* (90) variable_list ::= NK_VARIABLE */
-  {  222,   -3 }, /* (91) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
-  {  223,   -1 }, /* (92) retention_list ::= retention */
-  {  223,   -3 }, /* (93) retention_list ::= retention_list NK_COMMA retention */
-  {  225,   -3 }, /* (94) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
-  {  208,   -9 }, /* (95) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
-  {  208,   -3 }, /* (96) cmd ::= CREATE TABLE multi_create_clause */
-  {  208,   -9 }, /* (97) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
-  {  208,   -3 }, /* (98) cmd ::= DROP TABLE multi_drop_clause */
-  {  208,   -4 }, /* (99) cmd ::= DROP STABLE exists_opt full_table_name */
-  {  208,   -3 }, /* (100) cmd ::= ALTER TABLE alter_table_clause */
-  {  208,   -3 }, /* (101) cmd ::= ALTER STABLE alter_table_clause */
-  {  233,   -2 }, /* (102) alter_table_clause ::= full_table_name alter_table_options */
-  {  233,   -5 }, /* (103) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
-  {  233,   -4 }, /* (104) alter_table_clause ::= full_table_name DROP COLUMN column_name */
-  {  233,   -5 }, /* (105) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
-  {  233,   -5 }, /* (106) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-  {  233,   -5 }, /* (107) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
-  {  233,   -4 }, /* (108) alter_table_clause ::= full_table_name DROP TAG column_name */
-  {  233,   -5 }, /* (109) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
-  {  233,   -5 }, /* (110) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
-  {  233,   -6 }, /* (111) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ literal */
-  {  230,   -1 }, /* (112) multi_create_clause ::= create_subtable_clause */
-  {  230,   -2 }, /* (113) multi_create_clause ::= multi_create_clause create_subtable_clause */
-  {  237,   -9 }, /* (114) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP */
-  {  232,   -1 }, /* (115) multi_drop_clause ::= drop_table_clause */
-  {  232,   -2 }, /* (116) multi_drop_clause ::= multi_drop_clause drop_table_clause */
-  {  240,   -2 }, /* (117) drop_table_clause ::= exists_opt full_table_name */
-  {  238,    0 }, /* (118) specific_tags_opt ::= */
-  {  238,   -3 }, /* (119) specific_tags_opt ::= NK_LP col_name_list NK_RP */
-  {  226,   -1 }, /* (120) full_table_name ::= table_name */
-  {  226,   -3 }, /* (121) full_table_name ::= db_name NK_DOT table_name */
-  {  227,   -1 }, /* (122) column_def_list ::= column_def */
-  {  227,   -3 }, /* (123) column_def_list ::= column_def_list NK_COMMA column_def */
-  {  243,   -2 }, /* (124) column_def ::= column_name type_name */
-  {  243,   -4 }, /* (125) column_def ::= column_name type_name COMMENT NK_STRING */
-  {  236,   -1 }, /* (126) type_name ::= BOOL */
-  {  236,   -1 }, /* (127) type_name ::= TINYINT */
-  {  236,   -1 }, /* (128) type_name ::= SMALLINT */
-  {  236,   -1 }, /* (129) type_name ::= INT */
-  {  236,   -1 }, /* (130) type_name ::= INTEGER */
-  {  236,   -1 }, /* (131) type_name ::= BIGINT */
-  {  236,   -1 }, /* (132) type_name ::= FLOAT */
-  {  236,   -1 }, /* (133) type_name ::= DOUBLE */
-  {  236,   -4 }, /* (134) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-  {  236,   -1 }, /* (135) type_name ::= TIMESTAMP */
-  {  236,   -4 }, /* (136) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-  {  236,   -2 }, /* (137) type_name ::= TINYINT UNSIGNED */
-  {  236,   -2 }, /* (138) type_name ::= SMALLINT UNSIGNED */
-  {  236,   -2 }, /* (139) type_name ::= INT UNSIGNED */
-  {  236,   -2 }, /* (140) type_name ::= BIGINT UNSIGNED */
-  {  236,   -1 }, /* (141) type_name ::= JSON */
-  {  236,   -4 }, /* (142) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-  {  236,   -1 }, /* (143) type_name ::= MEDIUMBLOB */
-  {  236,   -1 }, /* (144) type_name ::= BLOB */
-  {  236,   -4 }, /* (145) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-  {  236,   -1 }, /* (146) type_name ::= DECIMAL */
-  {  236,   -4 }, /* (147) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-  {  236,   -6 }, /* (148) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-  {  228,    0 }, /* (149) tags_def_opt ::= */
-  {  228,   -1 }, /* (150) tags_def_opt ::= tags_def */
-  {  231,   -4 }, /* (151) tags_def ::= TAGS NK_LP column_def_list NK_RP */
-  {  229,    0 }, /* (152) table_options ::= */
-  {  229,   -3 }, /* (153) table_options ::= table_options COMMENT NK_STRING */
-  {  229,   -3 }, /* (154) table_options ::= table_options KEEP integer_list */
-  {  229,   -3 }, /* (155) table_options ::= table_options TTL NK_INTEGER */
-  {  229,   -5 }, /* (156) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-  {  229,   -5 }, /* (157) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
-  {  229,   -3 }, /* (158) table_options ::= table_options FILE_FACTOR NK_FLOAT */
-  {  229,   -3 }, /* (159) table_options ::= table_options DELAY NK_INTEGER */
-  {  234,   -1 }, /* (160) alter_table_options ::= alter_table_option */
-  {  234,   -2 }, /* (161) alter_table_options ::= alter_table_options alter_table_option */
-  {  245,   -2 }, /* (162) alter_table_option ::= COMMENT NK_STRING */
-  {  245,   -2 }, /* (163) alter_table_option ::= KEEP integer_list */
-  {  245,   -2 }, /* (164) alter_table_option ::= TTL NK_INTEGER */
-  {  241,   -1 }, /* (165) col_name_list ::= col_name */
-  {  241,   -3 }, /* (166) col_name_list ::= col_name_list NK_COMMA col_name */
-  {  246,   -1 }, /* (167) col_name ::= column_name */
-  {  208,   -2 }, /* (168) cmd ::= SHOW DNODES */
-  {  208,   -2 }, /* (169) cmd ::= SHOW USERS */
-  {  208,   -2 }, /* (170) cmd ::= SHOW DATABASES */
-  {  208,   -4 }, /* (171) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-  {  208,   -4 }, /* (172) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-  {  208,   -3 }, /* (173) cmd ::= SHOW db_name_cond_opt VGROUPS */
-  {  208,   -2 }, /* (174) cmd ::= SHOW MNODES */
-  {  208,   -2 }, /* (175) cmd ::= SHOW MODULES */
-  {  208,   -2 }, /* (176) cmd ::= SHOW QNODES */
-  {  208,   -2 }, /* (177) cmd ::= SHOW FUNCTIONS */
-  {  208,   -5 }, /* (178) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-  {  208,   -2 }, /* (179) cmd ::= SHOW STREAMS */
-  {  208,   -2 }, /* (180) cmd ::= SHOW ACCOUNTS */
-  {  208,   -2 }, /* (181) cmd ::= SHOW APPS */
-  {  208,   -2 }, /* (182) cmd ::= SHOW CONNECTIONS */
-  {  208,   -2 }, /* (183) cmd ::= SHOW LICENCE */
-  {  208,   -2 }, /* (184) cmd ::= SHOW GRANTS */
-  {  208,   -4 }, /* (185) cmd ::= SHOW CREATE DATABASE db_name */
-  {  208,   -4 }, /* (186) cmd ::= SHOW CREATE TABLE full_table_name */
-  {  208,   -4 }, /* (187) cmd ::= SHOW CREATE STABLE full_table_name */
-  {  208,   -2 }, /* (188) cmd ::= SHOW QUERIES */
-  {  208,   -2 }, /* (189) cmd ::= SHOW SCORES */
-  {  208,   -2 }, /* (190) cmd ::= SHOW TOPICS */
-  {  208,   -2 }, /* (191) cmd ::= SHOW VARIABLES */
-  {  208,   -2 }, /* (192) cmd ::= SHOW BNODES */
-  {  208,   -2 }, /* (193) cmd ::= SHOW SNODES */
-  {  247,    0 }, /* (194) db_name_cond_opt ::= */
-  {  247,   -2 }, /* (195) db_name_cond_opt ::= db_name NK_DOT */
-  {  248,    0 }, /* (196) like_pattern_opt ::= */
-  {  248,   -2 }, /* (197) like_pattern_opt ::= LIKE NK_STRING */
-  {  249,   -1 }, /* (198) table_name_cond ::= table_name */
-  {  250,    0 }, /* (199) from_db_opt ::= */
-  {  250,   -2 }, /* (200) from_db_opt ::= FROM db_name */
-  {  244,   -1 }, /* (201) func_name_list ::= func_name */
-  {  244,   -3 }, /* (202) func_name_list ::= func_name_list NK_COMMA col_name */
-  {  251,   -1 }, /* (203) func_name ::= function_name */
-  {  208,   -8 }, /* (204) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
-  {  208,  -10 }, /* (205) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
-  {  208,   -6 }, /* (206) cmd ::= DROP INDEX exists_opt index_name ON table_name */
-  {  254,    0 }, /* (207) index_options ::= */
-  {  254,   -9 }, /* (208) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
-  {  254,  -11 }, /* (209) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
-  {  255,   -1 }, /* (210) func_list ::= func */
-  {  255,   -3 }, /* (211) func_list ::= func_list NK_COMMA func */
-  {  258,   -4 }, /* (212) func ::= function_name NK_LP expression_list NK_RP */
-  {  208,   -6 }, /* (213) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
-  {  208,   -6 }, /* (214) cmd ::= CREATE TOPIC not_exists_opt topic_name AS db_name */
-  {  208,   -4 }, /* (215) cmd ::= DROP TOPIC exists_opt topic_name */
-  {  208,   -2 }, /* (216) cmd ::= DESC full_table_name */
-  {  208,   -2 }, /* (217) cmd ::= DESCRIBE full_table_name */
-  {  208,   -3 }, /* (218) cmd ::= RESET QUERY CACHE */
-  {  208,   -4 }, /* (219) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
-  {  262,    0 }, /* (220) analyze_opt ::= */
-  {  262,   -1 }, /* (221) analyze_opt ::= ANALYZE */
-  {  263,    0 }, /* (222) explain_options ::= */
-  {  263,   -3 }, /* (223) explain_options ::= explain_options VERBOSE NK_BOOL */
-  {  263,   -3 }, /* (224) explain_options ::= explain_options RATIO NK_FLOAT */
-  {  208,   -6 }, /* (225) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
-  {  208,   -9 }, /* (226) cmd ::= CREATE agg_func_opt FUNCTION function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
-  {  208,   -3 }, /* (227) cmd ::= DROP FUNCTION function_name */
-  {  264,    0 }, /* (228) agg_func_opt ::= */
-  {  264,   -1 }, /* (229) agg_func_opt ::= AGGREGATE */
-  {  265,    0 }, /* (230) bufsize_opt ::= */
-  {  265,   -2 }, /* (231) bufsize_opt ::= BUFSIZE NK_INTEGER */
-  {  208,   -7 }, /* (232) cmd ::= CREATE STREAM stream_name INTO table_name AS query_expression */
-  {  208,   -3 }, /* (233) cmd ::= DROP STREAM stream_name */
-  {  208,   -3 }, /* (234) cmd ::= KILL CONNECTION NK_INTEGER */
-  {  208,   -3 }, /* (235) cmd ::= KILL QUERY NK_INTEGER */
-  {  208,   -4 }, /* (236) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
-  {  208,   -4 }, /* (237) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-  {  208,   -3 }, /* (238) cmd ::= SPLIT VGROUP NK_INTEGER */
-  {  267,   -2 }, /* (239) dnode_list ::= DNODE NK_INTEGER */
-  {  267,   -3 }, /* (240) dnode_list ::= dnode_list DNODE NK_INTEGER */
-  {  208,   -3 }, /* (241) cmd ::= SYNCDB db_name REPLICA */
-  {  208,   -1 }, /* (242) cmd ::= query_expression */
-  {  211,   -1 }, /* (243) literal ::= NK_INTEGER */
-  {  211,   -1 }, /* (244) literal ::= NK_FLOAT */
-  {  211,   -1 }, /* (245) literal ::= NK_STRING */
-  {  211,   -1 }, /* (246) literal ::= NK_BOOL */
-  {  211,   -2 }, /* (247) literal ::= TIMESTAMP NK_STRING */
-  {  211,   -1 }, /* (248) literal ::= duration_literal */
-  {  211,   -1 }, /* (249) literal ::= NULL */
-  {  256,   -1 }, /* (250) duration_literal ::= NK_VARIABLE */
-  {  268,   -1 }, /* (251) signed ::= NK_INTEGER */
-  {  268,   -2 }, /* (252) signed ::= NK_PLUS NK_INTEGER */
-  {  268,   -2 }, /* (253) signed ::= NK_MINUS NK_INTEGER */
-  {  268,   -1 }, /* (254) signed ::= NK_FLOAT */
-  {  268,   -2 }, /* (255) signed ::= NK_PLUS NK_FLOAT */
-  {  268,   -2 }, /* (256) signed ::= NK_MINUS NK_FLOAT */
-  {  269,   -1 }, /* (257) signed_literal ::= signed */
-  {  269,   -1 }, /* (258) signed_literal ::= NK_STRING */
-  {  269,   -1 }, /* (259) signed_literal ::= NK_BOOL */
-  {  269,   -2 }, /* (260) signed_literal ::= TIMESTAMP NK_STRING */
-  {  269,   -1 }, /* (261) signed_literal ::= duration_literal */
-  {  269,   -1 }, /* (262) signed_literal ::= NULL */
-  {  239,   -1 }, /* (263) literal_list ::= signed_literal */
-  {  239,   -3 }, /* (264) literal_list ::= literal_list NK_COMMA signed_literal */
-  {  217,   -1 }, /* (265) db_name ::= NK_ID */
-  {  242,   -1 }, /* (266) table_name ::= NK_ID */
-  {  235,   -1 }, /* (267) column_name ::= NK_ID */
-  {  252,   -1 }, /* (268) function_name ::= NK_ID */
-  {  252,   -1 }, /* (269) function_name ::= FIRST */
-  {  252,   -1 }, /* (270) function_name ::= LAST */
-  {  270,   -1 }, /* (271) table_alias ::= NK_ID */
-  {  271,   -1 }, /* (272) column_alias ::= NK_ID */
-  {  213,   -1 }, /* (273) user_name ::= NK_ID */
-  {  253,   -1 }, /* (274) index_name ::= NK_ID */
-  {  260,   -1 }, /* (275) topic_name ::= NK_ID */
-  {  266,   -1 }, /* (276) stream_name ::= NK_ID */
-  {  272,   -1 }, /* (277) expression ::= literal */
-  {  272,   -1 }, /* (278) expression ::= pseudo_column */
-  {  272,   -1 }, /* (279) expression ::= column_reference */
-  {  272,   -4 }, /* (280) expression ::= function_name NK_LP expression_list NK_RP */
-  {  272,   -4 }, /* (281) expression ::= function_name NK_LP NK_STAR NK_RP */
-  {  272,   -6 }, /* (282) expression ::= function_name NK_LP expression AS type_name NK_RP */
-  {  272,   -1 }, /* (283) expression ::= subquery */
-  {  272,   -3 }, /* (284) expression ::= NK_LP expression NK_RP */
-  {  272,   -2 }, /* (285) expression ::= NK_PLUS expression */
-  {  272,   -2 }, /* (286) expression ::= NK_MINUS expression */
-  {  272,   -3 }, /* (287) expression ::= expression NK_PLUS expression */
-  {  272,   -3 }, /* (288) expression ::= expression NK_MINUS expression */
-  {  272,   -3 }, /* (289) expression ::= expression NK_STAR expression */
-  {  272,   -3 }, /* (290) expression ::= expression NK_SLASH expression */
-  {  272,   -3 }, /* (291) expression ::= expression NK_REM expression */
-  {  259,   -1 }, /* (292) expression_list ::= expression */
-  {  259,   -3 }, /* (293) expression_list ::= expression_list NK_COMMA expression */
-  {  274,   -1 }, /* (294) column_reference ::= column_name */
-  {  274,   -3 }, /* (295) column_reference ::= table_name NK_DOT column_name */
-  {  273,   -1 }, /* (296) pseudo_column ::= NOW */
-  {  273,   -1 }, /* (297) pseudo_column ::= ROWTS */
-  {  273,   -1 }, /* (298) pseudo_column ::= TBNAME */
-  {  273,   -1 }, /* (299) pseudo_column ::= QSTARTTS */
-  {  273,   -1 }, /* (300) pseudo_column ::= QENDTS */
-  {  273,   -1 }, /* (301) pseudo_column ::= WSTARTTS */
-  {  273,   -1 }, /* (302) pseudo_column ::= WENDTS */
-  {  273,   -1 }, /* (303) pseudo_column ::= WDURATION */
-  {  276,   -3 }, /* (304) predicate ::= expression compare_op expression */
-  {  276,   -5 }, /* (305) predicate ::= expression BETWEEN expression AND expression */
-  {  276,   -6 }, /* (306) predicate ::= expression NOT BETWEEN expression AND expression */
-  {  276,   -3 }, /* (307) predicate ::= expression IS NULL */
-  {  276,   -4 }, /* (308) predicate ::= expression IS NOT NULL */
-  {  276,   -3 }, /* (309) predicate ::= expression in_op in_predicate_value */
-  {  277,   -1 }, /* (310) compare_op ::= NK_LT */
-  {  277,   -1 }, /* (311) compare_op ::= NK_GT */
-  {  277,   -1 }, /* (312) compare_op ::= NK_LE */
-  {  277,   -1 }, /* (313) compare_op ::= NK_GE */
-  {  277,   -1 }, /* (314) compare_op ::= NK_NE */
-  {  277,   -1 }, /* (315) compare_op ::= NK_EQ */
-  {  277,   -1 }, /* (316) compare_op ::= LIKE */
-  {  277,   -2 }, /* (317) compare_op ::= NOT LIKE */
-  {  277,   -1 }, /* (318) compare_op ::= MATCH */
-  {  277,   -1 }, /* (319) compare_op ::= NMATCH */
-  {  278,   -1 }, /* (320) in_op ::= IN */
-  {  278,   -2 }, /* (321) in_op ::= NOT IN */
-  {  279,   -3 }, /* (322) in_predicate_value ::= NK_LP expression_list NK_RP */
-  {  280,   -1 }, /* (323) boolean_value_expression ::= boolean_primary */
-  {  280,   -2 }, /* (324) boolean_value_expression ::= NOT boolean_primary */
-  {  280,   -3 }, /* (325) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-  {  280,   -3 }, /* (326) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-  {  281,   -1 }, /* (327) boolean_primary ::= predicate */
-  {  281,   -3 }, /* (328) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-  {  282,   -1 }, /* (329) common_expression ::= expression */
-  {  282,   -1 }, /* (330) common_expression ::= boolean_value_expression */
-  {  283,   -2 }, /* (331) from_clause ::= FROM table_reference_list */
-  {  284,   -1 }, /* (332) table_reference_list ::= table_reference */
-  {  284,   -3 }, /* (333) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-  {  285,   -1 }, /* (334) table_reference ::= table_primary */
-  {  285,   -1 }, /* (335) table_reference ::= joined_table */
-  {  286,   -2 }, /* (336) table_primary ::= table_name alias_opt */
-  {  286,   -4 }, /* (337) table_primary ::= db_name NK_DOT table_name alias_opt */
-  {  286,   -2 }, /* (338) table_primary ::= subquery alias_opt */
-  {  286,   -1 }, /* (339) table_primary ::= parenthesized_joined_table */
-  {  288,    0 }, /* (340) alias_opt ::= */
-  {  288,   -1 }, /* (341) alias_opt ::= table_alias */
-  {  288,   -2 }, /* (342) alias_opt ::= AS table_alias */
-  {  289,   -3 }, /* (343) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-  {  289,   -3 }, /* (344) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-  {  287,   -6 }, /* (345) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-  {  290,    0 }, /* (346) join_type ::= */
-  {  290,   -1 }, /* (347) join_type ::= INNER */
-  {  292,   -9 }, /* (348) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-  {  293,    0 }, /* (349) set_quantifier_opt ::= */
-  {  293,   -1 }, /* (350) set_quantifier_opt ::= DISTINCT */
-  {  293,   -1 }, /* (351) set_quantifier_opt ::= ALL */
-  {  294,   -1 }, /* (352) select_list ::= NK_STAR */
-  {  294,   -1 }, /* (353) select_list ::= select_sublist */
-  {  300,   -1 }, /* (354) select_sublist ::= select_item */
-  {  300,   -3 }, /* (355) select_sublist ::= select_sublist NK_COMMA select_item */
-  {  301,   -1 }, /* (356) select_item ::= common_expression */
-  {  301,   -2 }, /* (357) select_item ::= common_expression column_alias */
-  {  301,   -3 }, /* (358) select_item ::= common_expression AS column_alias */
-  {  301,   -3 }, /* (359) select_item ::= table_name NK_DOT NK_STAR */
-  {  295,    0 }, /* (360) where_clause_opt ::= */
-  {  295,   -2 }, /* (361) where_clause_opt ::= WHERE search_condition */
-  {  296,    0 }, /* (362) partition_by_clause_opt ::= */
-  {  296,   -3 }, /* (363) partition_by_clause_opt ::= PARTITION BY expression_list */
-  {  297,    0 }, /* (364) twindow_clause_opt ::= */
-  {  297,   -6 }, /* (365) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-  {  297,   -4 }, /* (366) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-  {  297,   -6 }, /* (367) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-  {  297,   -8 }, /* (368) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-  {  257,    0 }, /* (369) sliding_opt ::= */
-  {  257,   -4 }, /* (370) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-  {  302,    0 }, /* (371) fill_opt ::= */
-  {  302,   -4 }, /* (372) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-  {  302,   -6 }, /* (373) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-  {  303,   -1 }, /* (374) fill_mode ::= NONE */
-  {  303,   -1 }, /* (375) fill_mode ::= PREV */
-  {  303,   -1 }, /* (376) fill_mode ::= NULL */
-  {  303,   -1 }, /* (377) fill_mode ::= LINEAR */
-  {  303,   -1 }, /* (378) fill_mode ::= NEXT */
-  {  298,    0 }, /* (379) group_by_clause_opt ::= */
-  {  298,   -3 }, /* (380) group_by_clause_opt ::= GROUP BY group_by_list */
-  {  304,   -1 }, /* (381) group_by_list ::= expression */
-  {  304,   -3 }, /* (382) group_by_list ::= group_by_list NK_COMMA expression */
-  {  299,    0 }, /* (383) having_clause_opt ::= */
-  {  299,   -2 }, /* (384) having_clause_opt ::= HAVING search_condition */
-  {  261,   -4 }, /* (385) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
-  {  305,   -1 }, /* (386) query_expression_body ::= query_primary */
-  {  305,   -4 }, /* (387) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-  {  309,   -1 }, /* (388) query_primary ::= query_specification */
-  {  306,    0 }, /* (389) order_by_clause_opt ::= */
-  {  306,   -3 }, /* (390) order_by_clause_opt ::= ORDER BY sort_specification_list */
-  {  307,    0 }, /* (391) slimit_clause_opt ::= */
-  {  307,   -2 }, /* (392) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-  {  307,   -4 }, /* (393) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-  {  307,   -4 }, /* (394) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  308,    0 }, /* (395) limit_clause_opt ::= */
-  {  308,   -2 }, /* (396) limit_clause_opt ::= LIMIT NK_INTEGER */
-  {  308,   -4 }, /* (397) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-  {  308,   -4 }, /* (398) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  275,   -3 }, /* (399) subquery ::= NK_LP query_expression NK_RP */
-  {  291,   -1 }, /* (400) search_condition ::= common_expression */
-  {  310,   -1 }, /* (401) sort_specification_list ::= sort_specification */
-  {  310,   -3 }, /* (402) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-  {  311,   -3 }, /* (403) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-  {  312,    0 }, /* (404) ordering_specification_opt ::= */
-  {  312,   -1 }, /* (405) ordering_specification_opt ::= ASC */
-  {  312,   -1 }, /* (406) ordering_specification_opt ::= DESC */
-  {  313,    0 }, /* (407) null_ordering_opt ::= */
-  {  313,   -2 }, /* (408) null_ordering_opt ::= NULLS FIRST */
-  {  313,   -2 }, /* (409) null_ordering_opt ::= NULLS LAST */
+/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
+** of that rule */
+static const YYCODETYPE yyRuleInfoLhs[] = {
+   209,  /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
+   209,  /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
+   210,  /* (2) account_options ::= */
+   210,  /* (3) account_options ::= account_options PPS literal */
+   210,  /* (4) account_options ::= account_options TSERIES literal */
+   210,  /* (5) account_options ::= account_options STORAGE literal */
+   210,  /* (6) account_options ::= account_options STREAMS literal */
+   210,  /* (7) account_options ::= account_options QTIME literal */
+   210,  /* (8) account_options ::= account_options DBS literal */
+   210,  /* (9) account_options ::= account_options USERS literal */
+   210,  /* (10) account_options ::= account_options CONNS literal */
+   210,  /* (11) account_options ::= account_options STATE literal */
+   211,  /* (12) alter_account_options ::= alter_account_option */
+   211,  /* (13) alter_account_options ::= alter_account_options alter_account_option */
+   213,  /* (14) alter_account_option ::= PASS literal */
+   213,  /* (15) alter_account_option ::= PPS literal */
+   213,  /* (16) alter_account_option ::= TSERIES literal */
+   213,  /* (17) alter_account_option ::= STORAGE literal */
+   213,  /* (18) alter_account_option ::= STREAMS literal */
+   213,  /* (19) alter_account_option ::= QTIME literal */
+   213,  /* (20) alter_account_option ::= DBS literal */
+   213,  /* (21) alter_account_option ::= USERS literal */
+   213,  /* (22) alter_account_option ::= CONNS literal */
+   213,  /* (23) alter_account_option ::= STATE literal */
+   209,  /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
+   209,  /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
+   209,  /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
+   209,  /* (27) cmd ::= DROP USER user_name */
+   209,  /* (28) cmd ::= CREATE DNODE dnode_endpoint */
+   209,  /* (29) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
+   209,  /* (30) cmd ::= DROP DNODE NK_INTEGER */
+   209,  /* (31) cmd ::= DROP DNODE dnode_endpoint */
+   209,  /* (32) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
+   209,  /* (33) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
+   209,  /* (34) cmd ::= ALTER ALL DNODES NK_STRING */
+   209,  /* (35) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
+   215,  /* (36) dnode_endpoint ::= NK_STRING */
+   216,  /* (37) dnode_host_name ::= NK_ID */
+   216,  /* (38) dnode_host_name ::= NK_IPTOKEN */
+   209,  /* (39) cmd ::= ALTER LOCAL NK_STRING */
+   209,  /* (40) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
+   209,  /* (41) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
+   209,  /* (42) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
+   209,  /* (43) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
+   209,  /* (44) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
+   209,  /* (45) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
+   209,  /* (46) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
+   209,  /* (47) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
+   209,  /* (48) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
+   209,  /* (49) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
+   209,  /* (50) cmd ::= DROP DATABASE exists_opt db_name */
+   209,  /* (51) cmd ::= USE db_name */
+   209,  /* (52) cmd ::= ALTER DATABASE db_name alter_db_options */
+   217,  /* (53) not_exists_opt ::= IF NOT EXISTS */
+   217,  /* (54) not_exists_opt ::= */
+   220,  /* (55) exists_opt ::= IF EXISTS */
+   220,  /* (56) exists_opt ::= */
+   219,  /* (57) db_options ::= */
+   219,  /* (58) db_options ::= db_options BLOCKS NK_INTEGER */
+   219,  /* (59) db_options ::= db_options CACHE NK_INTEGER */
+   219,  /* (60) db_options ::= db_options CACHELAST NK_INTEGER */
+   219,  /* (61) db_options ::= db_options COMP NK_INTEGER */
+   219,  /* (62) db_options ::= db_options DAYS NK_INTEGER */
+   219,  /* (63) db_options ::= db_options DAYS NK_VARIABLE */
+   219,  /* (64) db_options ::= db_options FSYNC NK_INTEGER */
+   219,  /* (65) db_options ::= db_options MAXROWS NK_INTEGER */
+   219,  /* (66) db_options ::= db_options MINROWS NK_INTEGER */
+   219,  /* (67) db_options ::= db_options KEEP integer_list */
+   219,  /* (68) db_options ::= db_options KEEP variable_list */
+   219,  /* (69) db_options ::= db_options PRECISION NK_STRING */
+   219,  /* (70) db_options ::= db_options QUORUM NK_INTEGER */
+   219,  /* (71) db_options ::= db_options REPLICA NK_INTEGER */
+   219,  /* (72) db_options ::= db_options TTL NK_INTEGER */
+   219,  /* (73) db_options ::= db_options WAL NK_INTEGER */
+   219,  /* (74) db_options ::= db_options VGROUPS NK_INTEGER */
+   219,  /* (75) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
+   219,  /* (76) db_options ::= db_options STREAM_MODE NK_INTEGER */
+   219,  /* (77) db_options ::= db_options RETENTIONS retention_list */
+   221,  /* (78) alter_db_options ::= alter_db_option */
+   221,  /* (79) alter_db_options ::= alter_db_options alter_db_option */
+   225,  /* (80) alter_db_option ::= BLOCKS NK_INTEGER */
+   225,  /* (81) alter_db_option ::= FSYNC NK_INTEGER */
+   225,  /* (82) alter_db_option ::= KEEP integer_list */
+   225,  /* (83) alter_db_option ::= KEEP variable_list */
+   225,  /* (84) alter_db_option ::= WAL NK_INTEGER */
+   225,  /* (85) alter_db_option ::= QUORUM NK_INTEGER */
+   225,  /* (86) alter_db_option ::= CACHELAST NK_INTEGER */
+   225,  /* (87) alter_db_option ::= REPLICA NK_INTEGER */
+   222,  /* (88) integer_list ::= NK_INTEGER */
+   222,  /* (89) integer_list ::= integer_list NK_COMMA NK_INTEGER */
+   223,  /* (90) variable_list ::= NK_VARIABLE */
+   223,  /* (91) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
+   224,  /* (92) retention_list ::= retention */
+   224,  /* (93) retention_list ::= retention_list NK_COMMA retention */
+   226,  /* (94) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
+   209,  /* (95) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
+   209,  /* (96) cmd ::= CREATE TABLE multi_create_clause */
+   209,  /* (97) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
+   209,  /* (98) cmd ::= DROP TABLE multi_drop_clause */
+   209,  /* (99) cmd ::= DROP STABLE exists_opt full_table_name */
+   209,  /* (100) cmd ::= ALTER TABLE alter_table_clause */
+   209,  /* (101) cmd ::= ALTER STABLE alter_table_clause */
+   234,  /* (102) alter_table_clause ::= full_table_name alter_table_options */
+   234,  /* (103) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   234,  /* (104) alter_table_clause ::= full_table_name DROP COLUMN column_name */
+   234,  /* (105) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   234,  /* (106) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
+   234,  /* (107) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   234,  /* (108) alter_table_clause ::= full_table_name DROP TAG column_name */
+   234,  /* (109) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   234,  /* (110) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
+   234,  /* (111) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ literal */
+   231,  /* (112) multi_create_clause ::= create_subtable_clause */
+   231,  /* (113) multi_create_clause ::= multi_create_clause create_subtable_clause */
+   238,  /* (114) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP */
+   233,  /* (115) multi_drop_clause ::= drop_table_clause */
+   233,  /* (116) multi_drop_clause ::= multi_drop_clause drop_table_clause */
+   241,  /* (117) drop_table_clause ::= exists_opt full_table_name */
+   239,  /* (118) specific_tags_opt ::= */
+   239,  /* (119) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+   227,  /* (120) full_table_name ::= table_name */
+   227,  /* (121) full_table_name ::= db_name NK_DOT table_name */
+   228,  /* (122) column_def_list ::= column_def */
+   228,  /* (123) column_def_list ::= column_def_list NK_COMMA column_def */
+   244,  /* (124) column_def ::= column_name type_name */
+   244,  /* (125) column_def ::= column_name type_name COMMENT NK_STRING */
+   237,  /* (126) type_name ::= BOOL */
+   237,  /* (127) type_name ::= TINYINT */
+   237,  /* (128) type_name ::= SMALLINT */
+   237,  /* (129) type_name ::= INT */
+   237,  /* (130) type_name ::= INTEGER */
+   237,  /* (131) type_name ::= BIGINT */
+   237,  /* (132) type_name ::= FLOAT */
+   237,  /* (133) type_name ::= DOUBLE */
+   237,  /* (134) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   237,  /* (135) type_name ::= TIMESTAMP */
+   237,  /* (136) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   237,  /* (137) type_name ::= TINYINT UNSIGNED */
+   237,  /* (138) type_name ::= SMALLINT UNSIGNED */
+   237,  /* (139) type_name ::= INT UNSIGNED */
+   237,  /* (140) type_name ::= BIGINT UNSIGNED */
+   237,  /* (141) type_name ::= JSON */
+   237,  /* (142) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   237,  /* (143) type_name ::= MEDIUMBLOB */
+   237,  /* (144) type_name ::= BLOB */
+   237,  /* (145) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   237,  /* (146) type_name ::= DECIMAL */
+   237,  /* (147) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   237,  /* (148) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+   229,  /* (149) tags_def_opt ::= */
+   229,  /* (150) tags_def_opt ::= tags_def */
+   232,  /* (151) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+   230,  /* (152) table_options ::= */
+   230,  /* (153) table_options ::= table_options COMMENT NK_STRING */
+   230,  /* (154) table_options ::= table_options KEEP integer_list */
+   230,  /* (155) table_options ::= table_options TTL NK_INTEGER */
+   230,  /* (156) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   230,  /* (157) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
+   230,  /* (158) table_options ::= table_options FILE_FACTOR NK_FLOAT */
+   230,  /* (159) table_options ::= table_options DELAY NK_INTEGER */
+   235,  /* (160) alter_table_options ::= alter_table_option */
+   235,  /* (161) alter_table_options ::= alter_table_options alter_table_option */
+   246,  /* (162) alter_table_option ::= COMMENT NK_STRING */
+   246,  /* (163) alter_table_option ::= KEEP integer_list */
+   246,  /* (164) alter_table_option ::= TTL NK_INTEGER */
+   242,  /* (165) col_name_list ::= col_name */
+   242,  /* (166) col_name_list ::= col_name_list NK_COMMA col_name */
+   247,  /* (167) col_name ::= column_name */
+   209,  /* (168) cmd ::= SHOW DNODES */
+   209,  /* (169) cmd ::= SHOW USERS */
+   209,  /* (170) cmd ::= SHOW DATABASES */
+   209,  /* (171) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   209,  /* (172) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   209,  /* (173) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   209,  /* (174) cmd ::= SHOW MNODES */
+   209,  /* (175) cmd ::= SHOW MODULES */
+   209,  /* (176) cmd ::= SHOW QNODES */
+   209,  /* (177) cmd ::= SHOW FUNCTIONS */
+   209,  /* (178) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   209,  /* (179) cmd ::= SHOW STREAMS */
+   209,  /* (180) cmd ::= SHOW ACCOUNTS */
+   209,  /* (181) cmd ::= SHOW APPS */
+   209,  /* (182) cmd ::= SHOW CONNECTIONS */
+   209,  /* (183) cmd ::= SHOW LICENCE */
+   209,  /* (184) cmd ::= SHOW GRANTS */
+   209,  /* (185) cmd ::= SHOW CREATE DATABASE db_name */
+   209,  /* (186) cmd ::= SHOW CREATE TABLE full_table_name */
+   209,  /* (187) cmd ::= SHOW CREATE STABLE full_table_name */
+   209,  /* (188) cmd ::= SHOW QUERIES */
+   209,  /* (189) cmd ::= SHOW SCORES */
+   209,  /* (190) cmd ::= SHOW TOPICS */
+   209,  /* (191) cmd ::= SHOW VARIABLES */
+   209,  /* (192) cmd ::= SHOW BNODES */
+   209,  /* (193) cmd ::= SHOW SNODES */
+   248,  /* (194) db_name_cond_opt ::= */
+   248,  /* (195) db_name_cond_opt ::= db_name NK_DOT */
+   249,  /* (196) like_pattern_opt ::= */
+   249,  /* (197) like_pattern_opt ::= LIKE NK_STRING */
+   250,  /* (198) table_name_cond ::= table_name */
+   251,  /* (199) from_db_opt ::= */
+   251,  /* (200) from_db_opt ::= FROM db_name */
+   245,  /* (201) func_name_list ::= func_name */
+   245,  /* (202) func_name_list ::= func_name_list NK_COMMA col_name */
+   252,  /* (203) func_name ::= function_name */
+   209,  /* (204) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
+   209,  /* (205) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
+   209,  /* (206) cmd ::= DROP INDEX exists_opt index_name ON table_name */
+   255,  /* (207) index_options ::= */
+   255,  /* (208) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
+   255,  /* (209) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
+   256,  /* (210) func_list ::= func */
+   256,  /* (211) func_list ::= func_list NK_COMMA func */
+   259,  /* (212) func ::= function_name NK_LP expression_list NK_RP */
+   209,  /* (213) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
+   209,  /* (214) cmd ::= CREATE TOPIC not_exists_opt topic_name AS db_name */
+   209,  /* (215) cmd ::= DROP TOPIC exists_opt topic_name */
+   209,  /* (216) cmd ::= DESC full_table_name */
+   209,  /* (217) cmd ::= DESCRIBE full_table_name */
+   209,  /* (218) cmd ::= RESET QUERY CACHE */
+   209,  /* (219) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
+   263,  /* (220) analyze_opt ::= */
+   263,  /* (221) analyze_opt ::= ANALYZE */
+   264,  /* (222) explain_options ::= */
+   264,  /* (223) explain_options ::= explain_options VERBOSE NK_BOOL */
+   264,  /* (224) explain_options ::= explain_options RATIO NK_FLOAT */
+   209,  /* (225) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
+   209,  /* (226) cmd ::= CREATE agg_func_opt FUNCTION function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
+   209,  /* (227) cmd ::= DROP FUNCTION function_name */
+   265,  /* (228) agg_func_opt ::= */
+   265,  /* (229) agg_func_opt ::= AGGREGATE */
+   266,  /* (230) bufsize_opt ::= */
+   266,  /* (231) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   209,  /* (232) cmd ::= CREATE STREAM stream_name INTO table_name AS query_expression */
+   209,  /* (233) cmd ::= DROP STREAM stream_name */
+   209,  /* (234) cmd ::= KILL CONNECTION NK_INTEGER */
+   209,  /* (235) cmd ::= KILL QUERY NK_INTEGER */
+   209,  /* (236) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   209,  /* (237) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   209,  /* (238) cmd ::= SPLIT VGROUP NK_INTEGER */
+   268,  /* (239) dnode_list ::= DNODE NK_INTEGER */
+   268,  /* (240) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   209,  /* (241) cmd ::= SYNCDB db_name REPLICA */
+   209,  /* (242) cmd ::= query_expression */
+   212,  /* (243) literal ::= NK_INTEGER */
+   212,  /* (244) literal ::= NK_FLOAT */
+   212,  /* (245) literal ::= NK_STRING */
+   212,  /* (246) literal ::= NK_BOOL */
+   212,  /* (247) literal ::= TIMESTAMP NK_STRING */
+   212,  /* (248) literal ::= duration_literal */
+   212,  /* (249) literal ::= NULL */
+   257,  /* (250) duration_literal ::= NK_VARIABLE */
+   269,  /* (251) signed ::= NK_INTEGER */
+   269,  /* (252) signed ::= NK_PLUS NK_INTEGER */
+   269,  /* (253) signed ::= NK_MINUS NK_INTEGER */
+   269,  /* (254) signed ::= NK_FLOAT */
+   269,  /* (255) signed ::= NK_PLUS NK_FLOAT */
+   269,  /* (256) signed ::= NK_MINUS NK_FLOAT */
+   270,  /* (257) signed_literal ::= signed */
+   270,  /* (258) signed_literal ::= NK_STRING */
+   270,  /* (259) signed_literal ::= NK_BOOL */
+   270,  /* (260) signed_literal ::= TIMESTAMP NK_STRING */
+   270,  /* (261) signed_literal ::= duration_literal */
+   270,  /* (262) signed_literal ::= NULL */
+   240,  /* (263) literal_list ::= signed_literal */
+   240,  /* (264) literal_list ::= literal_list NK_COMMA signed_literal */
+   218,  /* (265) db_name ::= NK_ID */
+   243,  /* (266) table_name ::= NK_ID */
+   236,  /* (267) column_name ::= NK_ID */
+   253,  /* (268) function_name ::= NK_ID */
+   253,  /* (269) function_name ::= FIRST */
+   253,  /* (270) function_name ::= LAST */
+   271,  /* (271) table_alias ::= NK_ID */
+   272,  /* (272) column_alias ::= NK_ID */
+   214,  /* (273) user_name ::= NK_ID */
+   254,  /* (274) index_name ::= NK_ID */
+   261,  /* (275) topic_name ::= NK_ID */
+   267,  /* (276) stream_name ::= NK_ID */
+   273,  /* (277) expression ::= literal */
+   273,  /* (278) expression ::= pseudo_column */
+   273,  /* (279) expression ::= column_reference */
+   273,  /* (280) expression ::= function_name NK_LP expression_list NK_RP */
+   273,  /* (281) expression ::= function_name NK_LP NK_STAR NK_RP */
+   273,  /* (282) expression ::= function_name NK_LP expression AS type_name NK_RP */
+   273,  /* (283) expression ::= subquery */
+   273,  /* (284) expression ::= NK_LP expression NK_RP */
+   273,  /* (285) expression ::= NK_PLUS expression */
+   273,  /* (286) expression ::= NK_MINUS expression */
+   273,  /* (287) expression ::= expression NK_PLUS expression */
+   273,  /* (288) expression ::= expression NK_MINUS expression */
+   273,  /* (289) expression ::= expression NK_STAR expression */
+   273,  /* (290) expression ::= expression NK_SLASH expression */
+   273,  /* (291) expression ::= expression NK_REM expression */
+   260,  /* (292) expression_list ::= expression */
+   260,  /* (293) expression_list ::= expression_list NK_COMMA expression */
+   275,  /* (294) column_reference ::= column_name */
+   275,  /* (295) column_reference ::= table_name NK_DOT column_name */
+   274,  /* (296) pseudo_column ::= NOW */
+   274,  /* (297) pseudo_column ::= TODAY */
+   274,  /* (298) pseudo_column ::= ROWTS */
+   274,  /* (299) pseudo_column ::= TBNAME */
+   274,  /* (300) pseudo_column ::= QSTARTTS */
+   274,  /* (301) pseudo_column ::= QENDTS */
+   274,  /* (302) pseudo_column ::= WSTARTTS */
+   274,  /* (303) pseudo_column ::= WENDTS */
+   274,  /* (304) pseudo_column ::= WDURATION */
+   277,  /* (305) predicate ::= expression compare_op expression */
+   277,  /* (306) predicate ::= expression BETWEEN expression AND expression */
+   277,  /* (307) predicate ::= expression NOT BETWEEN expression AND expression */
+   277,  /* (308) predicate ::= expression IS NULL */
+   277,  /* (309) predicate ::= expression IS NOT NULL */
+   277,  /* (310) predicate ::= expression in_op in_predicate_value */
+   278,  /* (311) compare_op ::= NK_LT */
+   278,  /* (312) compare_op ::= NK_GT */
+   278,  /* (313) compare_op ::= NK_LE */
+   278,  /* (314) compare_op ::= NK_GE */
+   278,  /* (315) compare_op ::= NK_NE */
+   278,  /* (316) compare_op ::= NK_EQ */
+   278,  /* (317) compare_op ::= LIKE */
+   278,  /* (318) compare_op ::= NOT LIKE */
+   278,  /* (319) compare_op ::= MATCH */
+   278,  /* (320) compare_op ::= NMATCH */
+   279,  /* (321) in_op ::= IN */
+   279,  /* (322) in_op ::= NOT IN */
+   280,  /* (323) in_predicate_value ::= NK_LP expression_list NK_RP */
+   281,  /* (324) boolean_value_expression ::= boolean_primary */
+   281,  /* (325) boolean_value_expression ::= NOT boolean_primary */
+   281,  /* (326) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   281,  /* (327) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   282,  /* (328) boolean_primary ::= predicate */
+   282,  /* (329) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   283,  /* (330) common_expression ::= expression */
+   283,  /* (331) common_expression ::= boolean_value_expression */
+   284,  /* (332) from_clause ::= FROM table_reference_list */
+   285,  /* (333) table_reference_list ::= table_reference */
+   285,  /* (334) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   286,  /* (335) table_reference ::= table_primary */
+   286,  /* (336) table_reference ::= joined_table */
+   287,  /* (337) table_primary ::= table_name alias_opt */
+   287,  /* (338) table_primary ::= db_name NK_DOT table_name alias_opt */
+   287,  /* (339) table_primary ::= subquery alias_opt */
+   287,  /* (340) table_primary ::= parenthesized_joined_table */
+   289,  /* (341) alias_opt ::= */
+   289,  /* (342) alias_opt ::= table_alias */
+   289,  /* (343) alias_opt ::= AS table_alias */
+   290,  /* (344) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   290,  /* (345) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   288,  /* (346) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+   291,  /* (347) join_type ::= */
+   291,  /* (348) join_type ::= INNER */
+   293,  /* (349) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+   294,  /* (350) set_quantifier_opt ::= */
+   294,  /* (351) set_quantifier_opt ::= DISTINCT */
+   294,  /* (352) set_quantifier_opt ::= ALL */
+   295,  /* (353) select_list ::= NK_STAR */
+   295,  /* (354) select_list ::= select_sublist */
+   301,  /* (355) select_sublist ::= select_item */
+   301,  /* (356) select_sublist ::= select_sublist NK_COMMA select_item */
+   302,  /* (357) select_item ::= common_expression */
+   302,  /* (358) select_item ::= common_expression column_alias */
+   302,  /* (359) select_item ::= common_expression AS column_alias */
+   302,  /* (360) select_item ::= table_name NK_DOT NK_STAR */
+   296,  /* (361) where_clause_opt ::= */
+   296,  /* (362) where_clause_opt ::= WHERE search_condition */
+   297,  /* (363) partition_by_clause_opt ::= */
+   297,  /* (364) partition_by_clause_opt ::= PARTITION BY expression_list */
+   298,  /* (365) twindow_clause_opt ::= */
+   298,  /* (366) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   298,  /* (367) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+   298,  /* (368) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   298,  /* (369) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+   258,  /* (370) sliding_opt ::= */
+   258,  /* (371) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+   303,  /* (372) fill_opt ::= */
+   303,  /* (373) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   303,  /* (374) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+   304,  /* (375) fill_mode ::= NONE */
+   304,  /* (376) fill_mode ::= PREV */
+   304,  /* (377) fill_mode ::= NULL */
+   304,  /* (378) fill_mode ::= LINEAR */
+   304,  /* (379) fill_mode ::= NEXT */
+   299,  /* (380) group_by_clause_opt ::= */
+   299,  /* (381) group_by_clause_opt ::= GROUP BY group_by_list */
+   305,  /* (382) group_by_list ::= expression */
+   305,  /* (383) group_by_list ::= group_by_list NK_COMMA expression */
+   300,  /* (384) having_clause_opt ::= */
+   300,  /* (385) having_clause_opt ::= HAVING search_condition */
+   262,  /* (386) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   306,  /* (387) query_expression_body ::= query_primary */
+   306,  /* (388) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+   310,  /* (389) query_primary ::= query_specification */
+   307,  /* (390) order_by_clause_opt ::= */
+   307,  /* (391) order_by_clause_opt ::= ORDER BY sort_specification_list */
+   308,  /* (392) slimit_clause_opt ::= */
+   308,  /* (393) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   308,  /* (394) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   308,  /* (395) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   309,  /* (396) limit_clause_opt ::= */
+   309,  /* (397) limit_clause_opt ::= LIMIT NK_INTEGER */
+   309,  /* (398) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   309,  /* (399) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   276,  /* (400) subquery ::= NK_LP query_expression NK_RP */
+   292,  /* (401) search_condition ::= common_expression */
+   311,  /* (402) sort_specification_list ::= sort_specification */
+   311,  /* (403) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   312,  /* (404) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+   313,  /* (405) ordering_specification_opt ::= */
+   313,  /* (406) ordering_specification_opt ::= ASC */
+   313,  /* (407) ordering_specification_opt ::= DESC */
+   314,  /* (408) null_ordering_opt ::= */
+   314,  /* (409) null_ordering_opt ::= NULLS FIRST */
+   314,  /* (410) null_ordering_opt ::= NULLS LAST */
+};
+
+/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
+** of symbols on the right-hand side of that rule. */
+static const signed char yyRuleInfoNRhs[] = {
+   -6,  /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
+   -4,  /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
+    0,  /* (2) account_options ::= */
+   -3,  /* (3) account_options ::= account_options PPS literal */
+   -3,  /* (4) account_options ::= account_options TSERIES literal */
+   -3,  /* (5) account_options ::= account_options STORAGE literal */
+   -3,  /* (6) account_options ::= account_options STREAMS literal */
+   -3,  /* (7) account_options ::= account_options QTIME literal */
+   -3,  /* (8) account_options ::= account_options DBS literal */
+   -3,  /* (9) account_options ::= account_options USERS literal */
+   -3,  /* (10) account_options ::= account_options CONNS literal */
+   -3,  /* (11) account_options ::= account_options STATE literal */
+   -1,  /* (12) alter_account_options ::= alter_account_option */
+   -2,  /* (13) alter_account_options ::= alter_account_options alter_account_option */
+   -2,  /* (14) alter_account_option ::= PASS literal */
+   -2,  /* (15) alter_account_option ::= PPS literal */
+   -2,  /* (16) alter_account_option ::= TSERIES literal */
+   -2,  /* (17) alter_account_option ::= STORAGE literal */
+   -2,  /* (18) alter_account_option ::= STREAMS literal */
+   -2,  /* (19) alter_account_option ::= QTIME literal */
+   -2,  /* (20) alter_account_option ::= DBS literal */
+   -2,  /* (21) alter_account_option ::= USERS literal */
+   -2,  /* (22) alter_account_option ::= CONNS literal */
+   -2,  /* (23) alter_account_option ::= STATE literal */
+   -5,  /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
+   -5,  /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
+   -5,  /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
+   -3,  /* (27) cmd ::= DROP USER user_name */
+   -3,  /* (28) cmd ::= CREATE DNODE dnode_endpoint */
+   -5,  /* (29) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
+   -3,  /* (30) cmd ::= DROP DNODE NK_INTEGER */
+   -3,  /* (31) cmd ::= DROP DNODE dnode_endpoint */
+   -4,  /* (32) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
+   -5,  /* (33) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
+   -4,  /* (34) cmd ::= ALTER ALL DNODES NK_STRING */
+   -5,  /* (35) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
+   -1,  /* (36) dnode_endpoint ::= NK_STRING */
+   -1,  /* (37) dnode_host_name ::= NK_ID */
+   -1,  /* (38) dnode_host_name ::= NK_IPTOKEN */
+   -3,  /* (39) cmd ::= ALTER LOCAL NK_STRING */
+   -4,  /* (40) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
+   -5,  /* (41) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
+   -5,  /* (42) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
+   -5,  /* (43) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
+   -5,  /* (44) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
+   -5,  /* (45) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
+   -5,  /* (46) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
+   -5,  /* (47) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
+   -5,  /* (48) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
+   -5,  /* (49) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
+   -4,  /* (50) cmd ::= DROP DATABASE exists_opt db_name */
+   -2,  /* (51) cmd ::= USE db_name */
+   -4,  /* (52) cmd ::= ALTER DATABASE db_name alter_db_options */
+   -3,  /* (53) not_exists_opt ::= IF NOT EXISTS */
+    0,  /* (54) not_exists_opt ::= */
+   -2,  /* (55) exists_opt ::= IF EXISTS */
+    0,  /* (56) exists_opt ::= */
+    0,  /* (57) db_options ::= */
+   -3,  /* (58) db_options ::= db_options BLOCKS NK_INTEGER */
+   -3,  /* (59) db_options ::= db_options CACHE NK_INTEGER */
+   -3,  /* (60) db_options ::= db_options CACHELAST NK_INTEGER */
+   -3,  /* (61) db_options ::= db_options COMP NK_INTEGER */
+   -3,  /* (62) db_options ::= db_options DAYS NK_INTEGER */
+   -3,  /* (63) db_options ::= db_options DAYS NK_VARIABLE */
+   -3,  /* (64) db_options ::= db_options FSYNC NK_INTEGER */
+   -3,  /* (65) db_options ::= db_options MAXROWS NK_INTEGER */
+   -3,  /* (66) db_options ::= db_options MINROWS NK_INTEGER */
+   -3,  /* (67) db_options ::= db_options KEEP integer_list */
+   -3,  /* (68) db_options ::= db_options KEEP variable_list */
+   -3,  /* (69) db_options ::= db_options PRECISION NK_STRING */
+   -3,  /* (70) db_options ::= db_options QUORUM NK_INTEGER */
+   -3,  /* (71) db_options ::= db_options REPLICA NK_INTEGER */
+   -3,  /* (72) db_options ::= db_options TTL NK_INTEGER */
+   -3,  /* (73) db_options ::= db_options WAL NK_INTEGER */
+   -3,  /* (74) db_options ::= db_options VGROUPS NK_INTEGER */
+   -3,  /* (75) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
+   -3,  /* (76) db_options ::= db_options STREAM_MODE NK_INTEGER */
+   -3,  /* (77) db_options ::= db_options RETENTIONS retention_list */
+   -1,  /* (78) alter_db_options ::= alter_db_option */
+   -2,  /* (79) alter_db_options ::= alter_db_options alter_db_option */
+   -2,  /* (80) alter_db_option ::= BLOCKS NK_INTEGER */
+   -2,  /* (81) alter_db_option ::= FSYNC NK_INTEGER */
+   -2,  /* (82) alter_db_option ::= KEEP integer_list */
+   -2,  /* (83) alter_db_option ::= KEEP variable_list */
+   -2,  /* (84) alter_db_option ::= WAL NK_INTEGER */
+   -2,  /* (85) alter_db_option ::= QUORUM NK_INTEGER */
+   -2,  /* (86) alter_db_option ::= CACHELAST NK_INTEGER */
+   -2,  /* (87) alter_db_option ::= REPLICA NK_INTEGER */
+   -1,  /* (88) integer_list ::= NK_INTEGER */
+   -3,  /* (89) integer_list ::= integer_list NK_COMMA NK_INTEGER */
+   -1,  /* (90) variable_list ::= NK_VARIABLE */
+   -3,  /* (91) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
+   -1,  /* (92) retention_list ::= retention */
+   -3,  /* (93) retention_list ::= retention_list NK_COMMA retention */
+   -3,  /* (94) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
+   -9,  /* (95) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
+   -3,  /* (96) cmd ::= CREATE TABLE multi_create_clause */
+   -9,  /* (97) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
+   -3,  /* (98) cmd ::= DROP TABLE multi_drop_clause */
+   -4,  /* (99) cmd ::= DROP STABLE exists_opt full_table_name */
+   -3,  /* (100) cmd ::= ALTER TABLE alter_table_clause */
+   -3,  /* (101) cmd ::= ALTER STABLE alter_table_clause */
+   -2,  /* (102) alter_table_clause ::= full_table_name alter_table_options */
+   -5,  /* (103) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   -4,  /* (104) alter_table_clause ::= full_table_name DROP COLUMN column_name */
+   -5,  /* (105) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   -5,  /* (106) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
+   -5,  /* (107) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   -4,  /* (108) alter_table_clause ::= full_table_name DROP TAG column_name */
+   -5,  /* (109) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   -5,  /* (110) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
+   -6,  /* (111) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ literal */
+   -1,  /* (112) multi_create_clause ::= create_subtable_clause */
+   -2,  /* (113) multi_create_clause ::= multi_create_clause create_subtable_clause */
+   -9,  /* (114) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP */
+   -1,  /* (115) multi_drop_clause ::= drop_table_clause */
+   -2,  /* (116) multi_drop_clause ::= multi_drop_clause drop_table_clause */
+   -2,  /* (117) drop_table_clause ::= exists_opt full_table_name */
+    0,  /* (118) specific_tags_opt ::= */
+   -3,  /* (119) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+   -1,  /* (120) full_table_name ::= table_name */
+   -3,  /* (121) full_table_name ::= db_name NK_DOT table_name */
+   -1,  /* (122) column_def_list ::= column_def */
+   -3,  /* (123) column_def_list ::= column_def_list NK_COMMA column_def */
+   -2,  /* (124) column_def ::= column_name type_name */
+   -4,  /* (125) column_def ::= column_name type_name COMMENT NK_STRING */
+   -1,  /* (126) type_name ::= BOOL */
+   -1,  /* (127) type_name ::= TINYINT */
+   -1,  /* (128) type_name ::= SMALLINT */
+   -1,  /* (129) type_name ::= INT */
+   -1,  /* (130) type_name ::= INTEGER */
+   -1,  /* (131) type_name ::= BIGINT */
+   -1,  /* (132) type_name ::= FLOAT */
+   -1,  /* (133) type_name ::= DOUBLE */
+   -4,  /* (134) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (135) type_name ::= TIMESTAMP */
+   -4,  /* (136) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   -2,  /* (137) type_name ::= TINYINT UNSIGNED */
+   -2,  /* (138) type_name ::= SMALLINT UNSIGNED */
+   -2,  /* (139) type_name ::= INT UNSIGNED */
+   -2,  /* (140) type_name ::= BIGINT UNSIGNED */
+   -1,  /* (141) type_name ::= JSON */
+   -4,  /* (142) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   -1,  /* (143) type_name ::= MEDIUMBLOB */
+   -1,  /* (144) type_name ::= BLOB */
+   -4,  /* (145) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (146) type_name ::= DECIMAL */
+   -4,  /* (147) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   -6,  /* (148) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+    0,  /* (149) tags_def_opt ::= */
+   -1,  /* (150) tags_def_opt ::= tags_def */
+   -4,  /* (151) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+    0,  /* (152) table_options ::= */
+   -3,  /* (153) table_options ::= table_options COMMENT NK_STRING */
+   -3,  /* (154) table_options ::= table_options KEEP integer_list */
+   -3,  /* (155) table_options ::= table_options TTL NK_INTEGER */
+   -5,  /* (156) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   -5,  /* (157) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
+   -3,  /* (158) table_options ::= table_options FILE_FACTOR NK_FLOAT */
+   -3,  /* (159) table_options ::= table_options DELAY NK_INTEGER */
+   -1,  /* (160) alter_table_options ::= alter_table_option */
+   -2,  /* (161) alter_table_options ::= alter_table_options alter_table_option */
+   -2,  /* (162) alter_table_option ::= COMMENT NK_STRING */
+   -2,  /* (163) alter_table_option ::= KEEP integer_list */
+   -2,  /* (164) alter_table_option ::= TTL NK_INTEGER */
+   -1,  /* (165) col_name_list ::= col_name */
+   -3,  /* (166) col_name_list ::= col_name_list NK_COMMA col_name */
+   -1,  /* (167) col_name ::= column_name */
+   -2,  /* (168) cmd ::= SHOW DNODES */
+   -2,  /* (169) cmd ::= SHOW USERS */
+   -2,  /* (170) cmd ::= SHOW DATABASES */
+   -4,  /* (171) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   -4,  /* (172) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   -3,  /* (173) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   -2,  /* (174) cmd ::= SHOW MNODES */
+   -2,  /* (175) cmd ::= SHOW MODULES */
+   -2,  /* (176) cmd ::= SHOW QNODES */
+   -2,  /* (177) cmd ::= SHOW FUNCTIONS */
+   -5,  /* (178) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   -2,  /* (179) cmd ::= SHOW STREAMS */
+   -2,  /* (180) cmd ::= SHOW ACCOUNTS */
+   -2,  /* (181) cmd ::= SHOW APPS */
+   -2,  /* (182) cmd ::= SHOW CONNECTIONS */
+   -2,  /* (183) cmd ::= SHOW LICENCE */
+   -2,  /* (184) cmd ::= SHOW GRANTS */
+   -4,  /* (185) cmd ::= SHOW CREATE DATABASE db_name */
+   -4,  /* (186) cmd ::= SHOW CREATE TABLE full_table_name */
+   -4,  /* (187) cmd ::= SHOW CREATE STABLE full_table_name */
+   -2,  /* (188) cmd ::= SHOW QUERIES */
+   -2,  /* (189) cmd ::= SHOW SCORES */
+   -2,  /* (190) cmd ::= SHOW TOPICS */
+   -2,  /* (191) cmd ::= SHOW VARIABLES */
+   -2,  /* (192) cmd ::= SHOW BNODES */
+   -2,  /* (193) cmd ::= SHOW SNODES */
+    0,  /* (194) db_name_cond_opt ::= */
+   -2,  /* (195) db_name_cond_opt ::= db_name NK_DOT */
+    0,  /* (196) like_pattern_opt ::= */
+   -2,  /* (197) like_pattern_opt ::= LIKE NK_STRING */
+   -1,  /* (198) table_name_cond ::= table_name */
+    0,  /* (199) from_db_opt ::= */
+   -2,  /* (200) from_db_opt ::= FROM db_name */
+   -1,  /* (201) func_name_list ::= func_name */
+   -3,  /* (202) func_name_list ::= func_name_list NK_COMMA col_name */
+   -1,  /* (203) func_name ::= function_name */
+   -8,  /* (204) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
+  -10,  /* (205) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
+   -6,  /* (206) cmd ::= DROP INDEX exists_opt index_name ON table_name */
+    0,  /* (207) index_options ::= */
+   -9,  /* (208) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
+  -11,  /* (209) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
+   -1,  /* (210) func_list ::= func */
+   -3,  /* (211) func_list ::= func_list NK_COMMA func */
+   -4,  /* (212) func ::= function_name NK_LP expression_list NK_RP */
+   -6,  /* (213) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
+   -6,  /* (214) cmd ::= CREATE TOPIC not_exists_opt topic_name AS db_name */
+   -4,  /* (215) cmd ::= DROP TOPIC exists_opt topic_name */
+   -2,  /* (216) cmd ::= DESC full_table_name */
+   -2,  /* (217) cmd ::= DESCRIBE full_table_name */
+   -3,  /* (218) cmd ::= RESET QUERY CACHE */
+   -4,  /* (219) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
+    0,  /* (220) analyze_opt ::= */
+   -1,  /* (221) analyze_opt ::= ANALYZE */
+    0,  /* (222) explain_options ::= */
+   -3,  /* (223) explain_options ::= explain_options VERBOSE NK_BOOL */
+   -3,  /* (224) explain_options ::= explain_options RATIO NK_FLOAT */
+   -6,  /* (225) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
+   -9,  /* (226) cmd ::= CREATE agg_func_opt FUNCTION function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
+   -3,  /* (227) cmd ::= DROP FUNCTION function_name */
+    0,  /* (228) agg_func_opt ::= */
+   -1,  /* (229) agg_func_opt ::= AGGREGATE */
+    0,  /* (230) bufsize_opt ::= */
+   -2,  /* (231) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   -7,  /* (232) cmd ::= CREATE STREAM stream_name INTO table_name AS query_expression */
+   -3,  /* (233) cmd ::= DROP STREAM stream_name */
+   -3,  /* (234) cmd ::= KILL CONNECTION NK_INTEGER */
+   -3,  /* (235) cmd ::= KILL QUERY NK_INTEGER */
+   -4,  /* (236) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   -4,  /* (237) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   -3,  /* (238) cmd ::= SPLIT VGROUP NK_INTEGER */
+   -2,  /* (239) dnode_list ::= DNODE NK_INTEGER */
+   -3,  /* (240) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   -3,  /* (241) cmd ::= SYNCDB db_name REPLICA */
+   -1,  /* (242) cmd ::= query_expression */
+   -1,  /* (243) literal ::= NK_INTEGER */
+   -1,  /* (244) literal ::= NK_FLOAT */
+   -1,  /* (245) literal ::= NK_STRING */
+   -1,  /* (246) literal ::= NK_BOOL */
+   -2,  /* (247) literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (248) literal ::= duration_literal */
+   -1,  /* (249) literal ::= NULL */
+   -1,  /* (250) duration_literal ::= NK_VARIABLE */
+   -1,  /* (251) signed ::= NK_INTEGER */
+   -2,  /* (252) signed ::= NK_PLUS NK_INTEGER */
+   -2,  /* (253) signed ::= NK_MINUS NK_INTEGER */
+   -1,  /* (254) signed ::= NK_FLOAT */
+   -2,  /* (255) signed ::= NK_PLUS NK_FLOAT */
+   -2,  /* (256) signed ::= NK_MINUS NK_FLOAT */
+   -1,  /* (257) signed_literal ::= signed */
+   -1,  /* (258) signed_literal ::= NK_STRING */
+   -1,  /* (259) signed_literal ::= NK_BOOL */
+   -2,  /* (260) signed_literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (261) signed_literal ::= duration_literal */
+   -1,  /* (262) signed_literal ::= NULL */
+   -1,  /* (263) literal_list ::= signed_literal */
+   -3,  /* (264) literal_list ::= literal_list NK_COMMA signed_literal */
+   -1,  /* (265) db_name ::= NK_ID */
+   -1,  /* (266) table_name ::= NK_ID */
+   -1,  /* (267) column_name ::= NK_ID */
+   -1,  /* (268) function_name ::= NK_ID */
+   -1,  /* (269) function_name ::= FIRST */
+   -1,  /* (270) function_name ::= LAST */
+   -1,  /* (271) table_alias ::= NK_ID */
+   -1,  /* (272) column_alias ::= NK_ID */
+   -1,  /* (273) user_name ::= NK_ID */
+   -1,  /* (274) index_name ::= NK_ID */
+   -1,  /* (275) topic_name ::= NK_ID */
+   -1,  /* (276) stream_name ::= NK_ID */
+   -1,  /* (277) expression ::= literal */
+   -1,  /* (278) expression ::= pseudo_column */
+   -1,  /* (279) expression ::= column_reference */
+   -4,  /* (280) expression ::= function_name NK_LP expression_list NK_RP */
+   -4,  /* (281) expression ::= function_name NK_LP NK_STAR NK_RP */
+   -6,  /* (282) expression ::= function_name NK_LP expression AS type_name NK_RP */
+   -1,  /* (283) expression ::= subquery */
+   -3,  /* (284) expression ::= NK_LP expression NK_RP */
+   -2,  /* (285) expression ::= NK_PLUS expression */
+   -2,  /* (286) expression ::= NK_MINUS expression */
+   -3,  /* (287) expression ::= expression NK_PLUS expression */
+   -3,  /* (288) expression ::= expression NK_MINUS expression */
+   -3,  /* (289) expression ::= expression NK_STAR expression */
+   -3,  /* (290) expression ::= expression NK_SLASH expression */
+   -3,  /* (291) expression ::= expression NK_REM expression */
+   -1,  /* (292) expression_list ::= expression */
+   -3,  /* (293) expression_list ::= expression_list NK_COMMA expression */
+   -1,  /* (294) column_reference ::= column_name */
+   -3,  /* (295) column_reference ::= table_name NK_DOT column_name */
+   -1,  /* (296) pseudo_column ::= NOW */
+   -1,  /* (297) pseudo_column ::= TODAY */
+   -1,  /* (298) pseudo_column ::= ROWTS */
+   -1,  /* (299) pseudo_column ::= TBNAME */
+   -1,  /* (300) pseudo_column ::= QSTARTTS */
+   -1,  /* (301) pseudo_column ::= QENDTS */
+   -1,  /* (302) pseudo_column ::= WSTARTTS */
+   -1,  /* (303) pseudo_column ::= WENDTS */
+   -1,  /* (304) pseudo_column ::= WDURATION */
+   -3,  /* (305) predicate ::= expression compare_op expression */
+   -5,  /* (306) predicate ::= expression BETWEEN expression AND expression */
+   -6,  /* (307) predicate ::= expression NOT BETWEEN expression AND expression */
+   -3,  /* (308) predicate ::= expression IS NULL */
+   -4,  /* (309) predicate ::= expression IS NOT NULL */
+   -3,  /* (310) predicate ::= expression in_op in_predicate_value */
+   -1,  /* (311) compare_op ::= NK_LT */
+   -1,  /* (312) compare_op ::= NK_GT */
+   -1,  /* (313) compare_op ::= NK_LE */
+   -1,  /* (314) compare_op ::= NK_GE */
+   -1,  /* (315) compare_op ::= NK_NE */
+   -1,  /* (316) compare_op ::= NK_EQ */
+   -1,  /* (317) compare_op ::= LIKE */
+   -2,  /* (318) compare_op ::= NOT LIKE */
+   -1,  /* (319) compare_op ::= MATCH */
+   -1,  /* (320) compare_op ::= NMATCH */
+   -1,  /* (321) in_op ::= IN */
+   -2,  /* (322) in_op ::= NOT IN */
+   -3,  /* (323) in_predicate_value ::= NK_LP expression_list NK_RP */
+   -1,  /* (324) boolean_value_expression ::= boolean_primary */
+   -2,  /* (325) boolean_value_expression ::= NOT boolean_primary */
+   -3,  /* (326) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   -3,  /* (327) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   -1,  /* (328) boolean_primary ::= predicate */
+   -3,  /* (329) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   -1,  /* (330) common_expression ::= expression */
+   -1,  /* (331) common_expression ::= boolean_value_expression */
+   -2,  /* (332) from_clause ::= FROM table_reference_list */
+   -1,  /* (333) table_reference_list ::= table_reference */
+   -3,  /* (334) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   -1,  /* (335) table_reference ::= table_primary */
+   -1,  /* (336) table_reference ::= joined_table */
+   -2,  /* (337) table_primary ::= table_name alias_opt */
+   -4,  /* (338) table_primary ::= db_name NK_DOT table_name alias_opt */
+   -2,  /* (339) table_primary ::= subquery alias_opt */
+   -1,  /* (340) table_primary ::= parenthesized_joined_table */
+    0,  /* (341) alias_opt ::= */
+   -1,  /* (342) alias_opt ::= table_alias */
+   -2,  /* (343) alias_opt ::= AS table_alias */
+   -3,  /* (344) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   -3,  /* (345) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   -6,  /* (346) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+    0,  /* (347) join_type ::= */
+   -1,  /* (348) join_type ::= INNER */
+   -9,  /* (349) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+    0,  /* (350) set_quantifier_opt ::= */
+   -1,  /* (351) set_quantifier_opt ::= DISTINCT */
+   -1,  /* (352) set_quantifier_opt ::= ALL */
+   -1,  /* (353) select_list ::= NK_STAR */
+   -1,  /* (354) select_list ::= select_sublist */
+   -1,  /* (355) select_sublist ::= select_item */
+   -3,  /* (356) select_sublist ::= select_sublist NK_COMMA select_item */
+   -1,  /* (357) select_item ::= common_expression */
+   -2,  /* (358) select_item ::= common_expression column_alias */
+   -3,  /* (359) select_item ::= common_expression AS column_alias */
+   -3,  /* (360) select_item ::= table_name NK_DOT NK_STAR */
+    0,  /* (361) where_clause_opt ::= */
+   -2,  /* (362) where_clause_opt ::= WHERE search_condition */
+    0,  /* (363) partition_by_clause_opt ::= */
+   -3,  /* (364) partition_by_clause_opt ::= PARTITION BY expression_list */
+    0,  /* (365) twindow_clause_opt ::= */
+   -6,  /* (366) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   -4,  /* (367) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+   -6,  /* (368) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   -8,  /* (369) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+    0,  /* (370) sliding_opt ::= */
+   -4,  /* (371) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+    0,  /* (372) fill_opt ::= */
+   -4,  /* (373) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   -6,  /* (374) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+   -1,  /* (375) fill_mode ::= NONE */
+   -1,  /* (376) fill_mode ::= PREV */
+   -1,  /* (377) fill_mode ::= NULL */
+   -1,  /* (378) fill_mode ::= LINEAR */
+   -1,  /* (379) fill_mode ::= NEXT */
+    0,  /* (380) group_by_clause_opt ::= */
+   -3,  /* (381) group_by_clause_opt ::= GROUP BY group_by_list */
+   -1,  /* (382) group_by_list ::= expression */
+   -3,  /* (383) group_by_list ::= group_by_list NK_COMMA expression */
+    0,  /* (384) having_clause_opt ::= */
+   -2,  /* (385) having_clause_opt ::= HAVING search_condition */
+   -4,  /* (386) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   -1,  /* (387) query_expression_body ::= query_primary */
+   -4,  /* (388) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+   -1,  /* (389) query_primary ::= query_specification */
+    0,  /* (390) order_by_clause_opt ::= */
+   -3,  /* (391) order_by_clause_opt ::= ORDER BY sort_specification_list */
+    0,  /* (392) slimit_clause_opt ::= */
+   -2,  /* (393) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   -4,  /* (394) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   -4,  /* (395) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+    0,  /* (396) limit_clause_opt ::= */
+   -2,  /* (397) limit_clause_opt ::= LIMIT NK_INTEGER */
+   -4,  /* (398) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   -4,  /* (399) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   -3,  /* (400) subquery ::= NK_LP query_expression NK_RP */
+   -1,  /* (401) search_condition ::= common_expression */
+   -1,  /* (402) sort_specification_list ::= sort_specification */
+   -3,  /* (403) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   -3,  /* (404) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+    0,  /* (405) ordering_specification_opt ::= */
+   -1,  /* (406) ordering_specification_opt ::= ASC */
+   -1,  /* (407) ordering_specification_opt ::= DESC */
+    0,  /* (408) null_ordering_opt ::= */
+   -2,  /* (409) null_ordering_opt ::= NULLS FIRST */
+   -2,  /* (410) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2538,14 +2950,17 @@ static YYACTIONTYPE yy_reduce(
   yymsp = yypParser->yytos;
 #ifndef NDEBUG
   if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
-    yysize = yyRuleInfo[yyruleno].nrhs;
+    yysize = yyRuleInfoNRhs[yyruleno];
     if( yysize ){
-      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
         yyTracePrompt,
-        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
+        yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
+        yymsp[yysize].stateno);
     }else{
-      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
-        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
     }
   }
 #endif /* NDEBUG */
@@ -2553,7 +2968,7 @@ static YYACTIONTYPE yy_reduce(
   /* Check that the stack is large enough to grow by a single entry
   ** if the RHS of the rule is empty.  This ensures that there is room
   ** enough on the stack to push the LHS value */
-  if( yyRuleInfo[yyruleno].nrhs==0 ){
+  if( yyRuleInfoNRhs[yyruleno]==0 ){
 #ifdef YYTRACKMAXSTACKDEPTH
     if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
       yypParser->yyhwm++;
@@ -2595,11 +3010,11 @@ static YYACTIONTYPE yy_reduce(
         YYMINORTYPE yylhsminor;
       case 0: /* cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
 { pCxt->valid = false; generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
-  yy_destructor(yypParser,209,&yymsp[0].minor);
+  yy_destructor(yypParser,210,&yymsp[0].minor);
         break;
       case 1: /* cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
 { pCxt->valid = false; generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
-  yy_destructor(yypParser,210,&yymsp[0].minor);
+  yy_destructor(yypParser,211,&yymsp[0].minor);
         break;
       case 2: /* account_options ::= */
 { }
@@ -2613,20 +3028,20 @@ static YYACTIONTYPE yy_reduce(
       case 9: /* account_options ::= account_options USERS literal */ yytestcase(yyruleno==9);
       case 10: /* account_options ::= account_options CONNS literal */ yytestcase(yyruleno==10);
       case 11: /* account_options ::= account_options STATE literal */ yytestcase(yyruleno==11);
-{  yy_destructor(yypParser,209,&yymsp[-2].minor);
+{  yy_destructor(yypParser,210,&yymsp[-2].minor);
 { }
-  yy_destructor(yypParser,211,&yymsp[0].minor);
+  yy_destructor(yypParser,212,&yymsp[0].minor);
 }
         break;
       case 12: /* alter_account_options ::= alter_account_option */
-{  yy_destructor(yypParser,212,&yymsp[0].minor);
+{  yy_destructor(yypParser,213,&yymsp[0].minor);
 { }
 }
         break;
       case 13: /* alter_account_options ::= alter_account_options alter_account_option */
-{  yy_destructor(yypParser,210,&yymsp[-1].minor);
+{  yy_destructor(yypParser,211,&yymsp[-1].minor);
 { }
-  yy_destructor(yypParser,212,&yymsp[0].minor);
+  yy_destructor(yypParser,213,&yymsp[0].minor);
 }
         break;
       case 14: /* alter_account_option ::= PASS literal */
@@ -2640,31 +3055,31 @@ static YYACTIONTYPE yy_reduce(
       case 22: /* alter_account_option ::= CONNS literal */ yytestcase(yyruleno==22);
       case 23: /* alter_account_option ::= STATE literal */ yytestcase(yyruleno==23);
 { }
-  yy_destructor(yypParser,211,&yymsp[0].minor);
+  yy_destructor(yypParser,212,&yymsp[0].minor);
         break;
       case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING */
-{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0); }
         break;
       case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */
-{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy253, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); }
         break;
       case 26: /* cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
-{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy253, TSDB_ALTER_USER_PRIVILEGES, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_PRIVILEGES, &yymsp[0].minor.yy0); }
         break;
       case 27: /* cmd ::= DROP USER user_name */
-{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy29); }
         break;
       case 28: /* cmd ::= CREATE DNODE dnode_endpoint */
-{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy253, NULL); }
+{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy29, NULL); }
         break;
       case 29: /* cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
-{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy0); }
+{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0); }
         break;
       case 30: /* cmd ::= DROP DNODE NK_INTEGER */
 { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy0); }
         break;
       case 31: /* cmd ::= DROP DNODE dnode_endpoint */
-{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[0].minor.yy29); }
         break;
       case 32: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
 { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); }
@@ -2693,8 +3108,8 @@ static YYACTIONTYPE yy_reduce(
       case 274: /* index_name ::= NK_ID */ yytestcase(yyruleno==274);
       case 275: /* topic_name ::= NK_ID */ yytestcase(yyruleno==275);
       case 276: /* stream_name ::= NK_ID */ yytestcase(yyruleno==276);
-{ yylhsminor.yy253 = yymsp[0].minor.yy0; }
-  yymsp[0].minor.yy253 = yylhsminor.yy253;
+{ yylhsminor.yy29 = yymsp[0].minor.yy0; }
+  yymsp[0].minor.yy29 = yylhsminor.yy29;
         break;
       case 39: /* cmd ::= ALTER LOCAL NK_STRING */
 { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); }
@@ -2727,156 +3142,156 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); }
         break;
       case 49: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
-{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy273, &yymsp[-1].minor.yy253, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy47, &yymsp[-1].minor.yy29, yymsp[0].minor.yy182); }
         break;
       case 50: /* cmd ::= DROP DATABASE exists_opt db_name */
-{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy273, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy47, &yymsp[0].minor.yy29); }
         break;
       case 51: /* cmd ::= USE db_name */
-{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy29); }
         break;
       case 52: /* cmd ::= ALTER DATABASE db_name alter_db_options */
-{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy253, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy29, yymsp[0].minor.yy182); }
         break;
       case 53: /* not_exists_opt ::= IF NOT EXISTS */
-{ yymsp[-2].minor.yy273 = true; }
+{ yymsp[-2].minor.yy47 = true; }
         break;
       case 54: /* not_exists_opt ::= */
       case 56: /* exists_opt ::= */ yytestcase(yyruleno==56);
       case 220: /* analyze_opt ::= */ yytestcase(yyruleno==220);
       case 228: /* agg_func_opt ::= */ yytestcase(yyruleno==228);
-      case 349: /* set_quantifier_opt ::= */ yytestcase(yyruleno==349);
-{ yymsp[1].minor.yy273 = false; }
+      case 350: /* set_quantifier_opt ::= */ yytestcase(yyruleno==350);
+{ yymsp[1].minor.yy47 = false; }
         break;
       case 55: /* exists_opt ::= IF EXISTS */
-{ yymsp[-1].minor.yy273 = true; }
+{ yymsp[-1].minor.yy47 = true; }
         break;
       case 57: /* db_options ::= */
-{ yymsp[1].minor.yy140 = createDatabaseOptions(pCxt); }
+{ yymsp[1].minor.yy182 = createDatabaseOptions(pCxt); }
         break;
       case 58: /* db_options ::= db_options BLOCKS NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pNumOfBlocks = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pNumOfBlocks = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 59: /* db_options ::= db_options CACHE NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pCacheBlockSize = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pCacheBlockSize = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 60: /* db_options ::= db_options CACHELAST NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pCachelast = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pCachelast = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 61: /* db_options ::= db_options COMP NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pCompressionLevel = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pCompressionLevel = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 62: /* db_options ::= db_options DAYS NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pDaysPerFile = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pDaysPerFile = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 63: /* db_options ::= db_options DAYS NK_VARIABLE */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pDaysPerFile = (SValueNode*)createDurationValueNode(pCxt, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pDaysPerFile = (SValueNode*)createDurationValueNode(pCxt, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 64: /* db_options ::= db_options FSYNC NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pFsyncPeriod = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pFsyncPeriod = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 65: /* db_options ::= db_options MAXROWS NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pMaxRowsPerBlock = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pMaxRowsPerBlock = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 66: /* db_options ::= db_options MINROWS NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pMinRowsPerBlock = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pMinRowsPerBlock = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 67: /* db_options ::= db_options KEEP integer_list */
       case 68: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==68);
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pKeep = yymsp[0].minor.yy220; yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pKeep = yymsp[0].minor.yy334; yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 69: /* db_options ::= db_options PRECISION NK_STRING */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pPrecision = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pPrecision = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 70: /* db_options ::= db_options QUORUM NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pQuorum = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pQuorum = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 71: /* db_options ::= db_options REPLICA NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pReplica = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pReplica = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 72: /* db_options ::= db_options TTL NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pTtl = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pTtl = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 73: /* db_options ::= db_options WAL NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pWalLevel = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pWalLevel = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 74: /* db_options ::= db_options VGROUPS NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pNumOfVgroups = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pNumOfVgroups = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 75: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pSingleStable = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pSingleStable = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 76: /* db_options ::= db_options STREAM_MODE NK_INTEGER */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pStreamMode = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pStreamMode = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 77: /* db_options ::= db_options RETENTIONS retention_list */
-{ ((SDatabaseOptions*)yymsp[-2].minor.yy140)->pRetentions = yymsp[0].minor.yy220; yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((SDatabaseOptions*)yymsp[-2].minor.yy182)->pRetentions = yymsp[0].minor.yy334; yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 78: /* alter_db_options ::= alter_db_option */
-{ yylhsminor.yy140 = createDatabaseOptions(pCxt); yylhsminor.yy140 = setDatabaseAlterOption(pCxt, yylhsminor.yy140, &yymsp[0].minor.yy181); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createDatabaseOptions(pCxt); yylhsminor.yy182 = setDatabaseAlterOption(pCxt, yylhsminor.yy182, &yymsp[0].minor.yy515); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 79: /* alter_db_options ::= alter_db_options alter_db_option */
-{ yylhsminor.yy140 = setDatabaseAlterOption(pCxt, yymsp[-1].minor.yy140, &yymsp[0].minor.yy181); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = setDatabaseAlterOption(pCxt, yymsp[-1].minor.yy182, &yymsp[0].minor.yy515); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 80: /* alter_db_option ::= BLOCKS NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = DB_OPTION_BLOCKS; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_BLOCKS; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 81: /* alter_db_option ::= FSYNC NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 82: /* alter_db_option ::= KEEP integer_list */
       case 83: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==83);
-{ yymsp[-1].minor.yy181.type = DB_OPTION_KEEP; yymsp[-1].minor.yy181.pList = yymsp[0].minor.yy220; }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_KEEP; yymsp[-1].minor.yy515.pList = yymsp[0].minor.yy334; }
         break;
       case 84: /* alter_db_option ::= WAL NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = DB_OPTION_WAL; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_WAL; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 85: /* alter_db_option ::= QUORUM NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = DB_OPTION_QUORUM; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_QUORUM; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 86: /* alter_db_option ::= CACHELAST NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = DB_OPTION_CACHELAST; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_CACHELAST; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 87: /* alter_db_option ::= REPLICA NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 88: /* integer_list ::= NK_INTEGER */
-{ yylhsminor.yy220 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy334 = yylhsminor.yy334;
         break;
       case 89: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */
       case 240: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==240);
-{ yylhsminor.yy220 = addNodeToList(pCxt, yymsp[-2].minor.yy220, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
-  yymsp[-2].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = addNodeToList(pCxt, yymsp[-2].minor.yy334, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+  yymsp[-2].minor.yy334 = yylhsminor.yy334;
         break;
       case 90: /* variable_list ::= NK_VARIABLE */
-{ yylhsminor.yy220 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy334 = yylhsminor.yy334;
         break;
       case 91: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */
-{ yylhsminor.yy220 = addNodeToList(pCxt, yymsp[-2].minor.yy220, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-  yymsp[-2].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = addNodeToList(pCxt, yymsp[-2].minor.yy334, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+  yymsp[-2].minor.yy334 = yylhsminor.yy334;
         break;
       case 92: /* retention_list ::= retention */
       case 112: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==112);
@@ -2886,10 +3301,10 @@ static YYACTIONTYPE yy_reduce(
       case 201: /* func_name_list ::= func_name */ yytestcase(yyruleno==201);
       case 210: /* func_list ::= func */ yytestcase(yyruleno==210);
       case 263: /* literal_list ::= signed_literal */ yytestcase(yyruleno==263);
-      case 354: /* select_sublist ::= select_item */ yytestcase(yyruleno==354);
-      case 401: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==401);
-{ yylhsminor.yy220 = createNodeList(pCxt, yymsp[0].minor.yy140); }
-  yymsp[0].minor.yy220 = yylhsminor.yy220;
+      case 355: /* select_sublist ::= select_item */ yytestcase(yyruleno==355);
+      case 402: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==402);
+{ yylhsminor.yy334 = createNodeList(pCxt, yymsp[0].minor.yy182); }
+  yymsp[0].minor.yy334 = yylhsminor.yy334;
         break;
       case 93: /* retention_list ::= retention_list NK_COMMA retention */
       case 123: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==123);
@@ -2897,238 +3312,238 @@ static YYACTIONTYPE yy_reduce(
       case 202: /* func_name_list ::= func_name_list NK_COMMA col_name */ yytestcase(yyruleno==202);
       case 211: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==211);
       case 264: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==264);
-      case 355: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==355);
-      case 402: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==402);
-{ yylhsminor.yy220 = addNodeToList(pCxt, yymsp[-2].minor.yy220, yymsp[0].minor.yy140); }
-  yymsp[-2].minor.yy220 = yylhsminor.yy220;
+      case 356: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==356);
+      case 403: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==403);
+{ yylhsminor.yy334 = addNodeToList(pCxt, yymsp[-2].minor.yy334, yymsp[0].minor.yy182); }
+  yymsp[-2].minor.yy334 = yylhsminor.yy334;
         break;
       case 94: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
-{ yylhsminor.yy140 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 95: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
       case 97: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==97);
-{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy273, yymsp[-5].minor.yy140, yymsp[-3].minor.yy220, yymsp[-1].minor.yy220, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy47, yymsp[-5].minor.yy182, yymsp[-3].minor.yy334, yymsp[-1].minor.yy334, yymsp[0].minor.yy182); }
         break;
       case 96: /* cmd ::= CREATE TABLE multi_create_clause */
-{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy220); }
+{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy334); }
         break;
       case 98: /* cmd ::= DROP TABLE multi_drop_clause */
-{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy220); }
+{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy334); }
         break;
       case 99: /* cmd ::= DROP STABLE exists_opt full_table_name */
-{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy273, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy47, yymsp[0].minor.yy182); }
         break;
       case 100: /* cmd ::= ALTER TABLE alter_table_clause */
       case 101: /* cmd ::= ALTER STABLE alter_table_clause */ yytestcase(yyruleno==101);
       case 242: /* cmd ::= query_expression */ yytestcase(yyruleno==242);
-{ pCxt->pRootNode = yymsp[0].minor.yy140; }
+{ pCxt->pRootNode = yymsp[0].minor.yy182; }
         break;
       case 102: /* alter_table_clause ::= full_table_name alter_table_options */
-{ yylhsminor.yy140 = createAlterTableOption(pCxt, yymsp[-1].minor.yy140, yymsp[0].minor.yy140); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableOption(pCxt, yymsp[-1].minor.yy182, yymsp[0].minor.yy182); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 103: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
-{ yylhsminor.yy140 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy140, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy253, yymsp[0].minor.yy368); }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy182, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy29, yymsp[0].minor.yy574); }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 104: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */
-{ yylhsminor.yy140 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy140, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy253); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy182, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy29); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
       case 105: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
-{ yylhsminor.yy140 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy140, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy253, yymsp[0].minor.yy368); }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy182, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy29, yymsp[0].minor.yy574); }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 106: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-{ yylhsminor.yy140 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy140, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy253, &yymsp[0].minor.yy253); }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy182, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 107: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */
-{ yylhsminor.yy140 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy140, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy253, yymsp[0].minor.yy368); }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy182, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy29, yymsp[0].minor.yy574); }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 108: /* alter_table_clause ::= full_table_name DROP TAG column_name */
-{ yylhsminor.yy140 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy140, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy253); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy182, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy29); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
       case 109: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
-{ yylhsminor.yy140 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy140, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy253, yymsp[0].minor.yy368); }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy182, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy29, yymsp[0].minor.yy574); }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 110: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
-{ yylhsminor.yy140 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy140, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy253, &yymsp[0].minor.yy253); }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy182, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 111: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ literal */
-{ yylhsminor.yy140 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy140, &yymsp[-2].minor.yy253, yymsp[0].minor.yy140); }
-  yymsp[-5].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy182, &yymsp[-2].minor.yy29, yymsp[0].minor.yy182); }
+  yymsp[-5].minor.yy182 = yylhsminor.yy182;
         break;
       case 113: /* multi_create_clause ::= multi_create_clause create_subtable_clause */
       case 116: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==116);
-{ yylhsminor.yy220 = addNodeToList(pCxt, yymsp[-1].minor.yy220, yymsp[0].minor.yy140); }
-  yymsp[-1].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = addNodeToList(pCxt, yymsp[-1].minor.yy334, yymsp[0].minor.yy182); }
+  yymsp[-1].minor.yy334 = yylhsminor.yy334;
         break;
       case 114: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP */
-{ yylhsminor.yy140 = createCreateSubTableClause(pCxt, yymsp[-8].minor.yy273, yymsp[-7].minor.yy140, yymsp[-5].minor.yy140, yymsp[-4].minor.yy220, yymsp[-1].minor.yy220); }
-  yymsp[-8].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createCreateSubTableClause(pCxt, yymsp[-8].minor.yy47, yymsp[-7].minor.yy182, yymsp[-5].minor.yy182, yymsp[-4].minor.yy334, yymsp[-1].minor.yy334); }
+  yymsp[-8].minor.yy182 = yylhsminor.yy182;
         break;
       case 117: /* drop_table_clause ::= exists_opt full_table_name */
-{ yylhsminor.yy140 = createDropTableClause(pCxt, yymsp[-1].minor.yy273, yymsp[0].minor.yy140); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createDropTableClause(pCxt, yymsp[-1].minor.yy47, yymsp[0].minor.yy182); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 118: /* specific_tags_opt ::= */
       case 149: /* tags_def_opt ::= */ yytestcase(yyruleno==149);
-      case 362: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==362);
-      case 379: /* group_by_clause_opt ::= */ yytestcase(yyruleno==379);
-      case 389: /* order_by_clause_opt ::= */ yytestcase(yyruleno==389);
-{ yymsp[1].minor.yy220 = NULL; }
+      case 363: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==363);
+      case 380: /* group_by_clause_opt ::= */ yytestcase(yyruleno==380);
+      case 390: /* order_by_clause_opt ::= */ yytestcase(yyruleno==390);
+{ yymsp[1].minor.yy334 = NULL; }
         break;
       case 119: /* specific_tags_opt ::= NK_LP col_name_list NK_RP */
-{ yymsp[-2].minor.yy220 = yymsp[-1].minor.yy220; }
+{ yymsp[-2].minor.yy334 = yymsp[-1].minor.yy334; }
         break;
       case 120: /* full_table_name ::= table_name */
-{ yylhsminor.yy140 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy253, NULL); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy29, NULL); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 121: /* full_table_name ::= db_name NK_DOT table_name */
-{ yylhsminor.yy140 = createRealTableNode(pCxt, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy253, NULL); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRealTableNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29, NULL); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 124: /* column_def ::= column_name type_name */
-{ yylhsminor.yy140 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy253, yymsp[0].minor.yy368, NULL); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy29, yymsp[0].minor.yy574, NULL); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 125: /* column_def ::= column_name type_name COMMENT NK_STRING */
-{ yylhsminor.yy140 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy253, yymsp[-2].minor.yy368, &yymsp[0].minor.yy0); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy29, yymsp[-2].minor.yy574, &yymsp[0].minor.yy0); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
       case 126: /* type_name ::= BOOL */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_BOOL); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_BOOL); }
         break;
       case 127: /* type_name ::= TINYINT */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_TINYINT); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_TINYINT); }
         break;
       case 128: /* type_name ::= SMALLINT */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_SMALLINT); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_SMALLINT); }
         break;
       case 129: /* type_name ::= INT */
       case 130: /* type_name ::= INTEGER */ yytestcase(yyruleno==130);
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_INT); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_INT); }
         break;
       case 131: /* type_name ::= BIGINT */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_BIGINT); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_BIGINT); }
         break;
       case 132: /* type_name ::= FLOAT */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_FLOAT); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_FLOAT); }
         break;
       case 133: /* type_name ::= DOUBLE */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_DOUBLE); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_DOUBLE); }
         break;
       case 134: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy368 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy574 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); }
         break;
       case 135: /* type_name ::= TIMESTAMP */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); }
         break;
       case 136: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy368 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy574 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); }
         break;
       case 137: /* type_name ::= TINYINT UNSIGNED */
-{ yymsp[-1].minor.yy368 = createDataType(TSDB_DATA_TYPE_UTINYINT); }
+{ yymsp[-1].minor.yy574 = createDataType(TSDB_DATA_TYPE_UTINYINT); }
         break;
       case 138: /* type_name ::= SMALLINT UNSIGNED */
-{ yymsp[-1].minor.yy368 = createDataType(TSDB_DATA_TYPE_USMALLINT); }
+{ yymsp[-1].minor.yy574 = createDataType(TSDB_DATA_TYPE_USMALLINT); }
         break;
       case 139: /* type_name ::= INT UNSIGNED */
-{ yymsp[-1].minor.yy368 = createDataType(TSDB_DATA_TYPE_UINT); }
+{ yymsp[-1].minor.yy574 = createDataType(TSDB_DATA_TYPE_UINT); }
         break;
       case 140: /* type_name ::= BIGINT UNSIGNED */
-{ yymsp[-1].minor.yy368 = createDataType(TSDB_DATA_TYPE_UBIGINT); }
+{ yymsp[-1].minor.yy574 = createDataType(TSDB_DATA_TYPE_UBIGINT); }
         break;
       case 141: /* type_name ::= JSON */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_JSON); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_JSON); }
         break;
       case 142: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy368 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy574 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); }
         break;
       case 143: /* type_name ::= MEDIUMBLOB */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); }
         break;
       case 144: /* type_name ::= BLOB */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_BLOB); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_BLOB); }
         break;
       case 145: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy368 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); }
+{ yymsp[-3].minor.yy574 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); }
         break;
       case 146: /* type_name ::= DECIMAL */
-{ yymsp[0].minor.yy368 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
+{ yymsp[0].minor.yy574 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
         break;
       case 147: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-{ yymsp[-3].minor.yy368 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
+{ yymsp[-3].minor.yy574 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
         break;
       case 148: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-{ yymsp[-5].minor.yy368 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
+{ yymsp[-5].minor.yy574 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
         break;
       case 150: /* tags_def_opt ::= tags_def */
-      case 353: /* select_list ::= select_sublist */ yytestcase(yyruleno==353);
-{ yylhsminor.yy220 = yymsp[0].minor.yy220; }
-  yymsp[0].minor.yy220 = yylhsminor.yy220;
+      case 354: /* select_list ::= select_sublist */ yytestcase(yyruleno==354);
+{ yylhsminor.yy334 = yymsp[0].minor.yy334; }
+  yymsp[0].minor.yy334 = yylhsminor.yy334;
         break;
       case 151: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */
-{ yymsp[-3].minor.yy220 = yymsp[-1].minor.yy220; }
+{ yymsp[-3].minor.yy334 = yymsp[-1].minor.yy334; }
         break;
       case 152: /* table_options ::= */
-{ yymsp[1].minor.yy140 = createTableOptions(pCxt); }
+{ yymsp[1].minor.yy182 = createTableOptions(pCxt); }
         break;
       case 153: /* table_options ::= table_options COMMENT NK_STRING */
-{ ((STableOptions*)yymsp[-2].minor.yy140)->pComments = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-2].minor.yy182)->pComments = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 154: /* table_options ::= table_options KEEP integer_list */
-{ ((STableOptions*)yymsp[-2].minor.yy140)->pKeep = yymsp[0].minor.yy220; yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-2].minor.yy182)->pKeep = yymsp[0].minor.yy334; yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 155: /* table_options ::= table_options TTL NK_INTEGER */
-{ ((STableOptions*)yymsp[-2].minor.yy140)->pTtl = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-2].minor.yy182)->pTtl = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 156: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-{ ((STableOptions*)yymsp[-4].minor.yy140)->pSma = yymsp[-1].minor.yy220; yylhsminor.yy140 = yymsp[-4].minor.yy140; }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-4].minor.yy182)->pSma = yymsp[-1].minor.yy334; yylhsminor.yy182 = yymsp[-4].minor.yy182; }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 157: /* table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
-{ ((STableOptions*)yymsp[-4].minor.yy140)->pFuncs = yymsp[-1].minor.yy220; yylhsminor.yy140 = yymsp[-4].minor.yy140; }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-4].minor.yy182)->pFuncs = yymsp[-1].minor.yy334; yylhsminor.yy182 = yymsp[-4].minor.yy182; }
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
       case 158: /* table_options ::= table_options FILE_FACTOR NK_FLOAT */
-{ ((STableOptions*)yymsp[-2].minor.yy140)->pFilesFactor = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-2].minor.yy182)->pFilesFactor = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 159: /* table_options ::= table_options DELAY NK_INTEGER */
-{ ((STableOptions*)yymsp[-2].minor.yy140)->pDelay = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy140 = yymsp[-2].minor.yy140; }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ ((STableOptions*)yymsp[-2].minor.yy182)->pDelay = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); yylhsminor.yy182 = yymsp[-2].minor.yy182; }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 160: /* alter_table_options ::= alter_table_option */
-{ yylhsminor.yy140 = createTableOptions(pCxt); yylhsminor.yy140 = setTableAlterOption(pCxt, yylhsminor.yy140, &yymsp[0].minor.yy181); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createTableOptions(pCxt); yylhsminor.yy182 = setTableAlterOption(pCxt, yylhsminor.yy182, &yymsp[0].minor.yy515); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 161: /* alter_table_options ::= alter_table_options alter_table_option */
-{ yylhsminor.yy140 = setTableAlterOption(pCxt, yymsp[-1].minor.yy140, &yymsp[0].minor.yy181); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = setTableAlterOption(pCxt, yymsp[-1].minor.yy182, &yymsp[0].minor.yy515); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 162: /* alter_table_option ::= COMMENT NK_STRING */
-{ yymsp[-1].minor.yy181.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
         break;
       case 163: /* alter_table_option ::= KEEP integer_list */
-{ yymsp[-1].minor.yy181.type = TABLE_OPTION_KEEP; yymsp[-1].minor.yy181.pList = yymsp[0].minor.yy220; }
+{ yymsp[-1].minor.yy515.type = TABLE_OPTION_KEEP; yymsp[-1].minor.yy515.pList = yymsp[0].minor.yy334; }
         break;
       case 164: /* alter_table_option ::= TTL NK_INTEGER */
-{ yymsp[-1].minor.yy181.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy181.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy515.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy515.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 167: /* col_name ::= column_name */
-{ yylhsminor.yy140 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy253); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy29); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 168: /* cmd ::= SHOW DNODES */
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT, NULL, NULL); }
@@ -3140,13 +3555,13 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT, NULL, NULL); }
         break;
       case 171: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy140, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy182, yymsp[0].minor.yy182); }
         break;
       case 172: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy140, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy182, yymsp[0].minor.yy182); }
         break;
       case 173: /* cmd ::= SHOW db_name_cond_opt VGROUPS */
-{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy140, NULL); }
+{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy182, NULL); }
         break;
       case 174: /* cmd ::= SHOW MNODES */
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT, NULL, NULL); }
@@ -3161,7 +3576,7 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT, NULL, NULL); }
         break;
       case 178: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[-1].minor.yy140, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[-1].minor.yy182, yymsp[0].minor.yy182); }
         break;
       case 179: /* cmd ::= SHOW STREAMS */
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT, NULL, NULL); }
@@ -3180,13 +3595,13 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCE_STMT, NULL, NULL); }
         break;
       case 185: /* cmd ::= SHOW CREATE DATABASE db_name */
-{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy29); }
         break;
       case 186: /* cmd ::= SHOW CREATE TABLE full_table_name */
-{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy182); }
         break;
       case 187: /* cmd ::= SHOW CREATE STABLE full_table_name */
-{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy182); }
         break;
       case 188: /* cmd ::= SHOW QUERIES */
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT, NULL, NULL); }
@@ -3208,111 +3623,111 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 194: /* db_name_cond_opt ::= */
       case 199: /* from_db_opt ::= */ yytestcase(yyruleno==199);
-{ yymsp[1].minor.yy140 = createDefaultDatabaseCondValue(pCxt); }
+{ yymsp[1].minor.yy182 = createDefaultDatabaseCondValue(pCxt); }
         break;
       case 195: /* db_name_cond_opt ::= db_name NK_DOT */
-{ yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy253); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy29); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 196: /* like_pattern_opt ::= */
       case 207: /* index_options ::= */ yytestcase(yyruleno==207);
-      case 360: /* where_clause_opt ::= */ yytestcase(yyruleno==360);
-      case 364: /* twindow_clause_opt ::= */ yytestcase(yyruleno==364);
-      case 369: /* sliding_opt ::= */ yytestcase(yyruleno==369);
-      case 371: /* fill_opt ::= */ yytestcase(yyruleno==371);
-      case 383: /* having_clause_opt ::= */ yytestcase(yyruleno==383);
-      case 391: /* slimit_clause_opt ::= */ yytestcase(yyruleno==391);
-      case 395: /* limit_clause_opt ::= */ yytestcase(yyruleno==395);
-{ yymsp[1].minor.yy140 = NULL; }
+      case 361: /* where_clause_opt ::= */ yytestcase(yyruleno==361);
+      case 365: /* twindow_clause_opt ::= */ yytestcase(yyruleno==365);
+      case 370: /* sliding_opt ::= */ yytestcase(yyruleno==370);
+      case 372: /* fill_opt ::= */ yytestcase(yyruleno==372);
+      case 384: /* having_clause_opt ::= */ yytestcase(yyruleno==384);
+      case 392: /* slimit_clause_opt ::= */ yytestcase(yyruleno==392);
+      case 396: /* limit_clause_opt ::= */ yytestcase(yyruleno==396);
+{ yymsp[1].minor.yy182 = NULL; }
         break;
       case 197: /* like_pattern_opt ::= LIKE NK_STRING */
-{ yymsp[-1].minor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
         break;
       case 198: /* table_name_cond ::= table_name */
-{ yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy253); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy29); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 200: /* from_db_opt ::= FROM db_name */
-{ yymsp[-1].minor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy253); }
+{ yymsp[-1].minor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy29); }
         break;
       case 203: /* func_name ::= function_name */
-{ yylhsminor.yy140 = createFunctionNode(pCxt, &yymsp[0].minor.yy253, NULL); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createFunctionNode(pCxt, &yymsp[0].minor.yy29, NULL); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 204: /* cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
-{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy273, &yymsp[-3].minor.yy253, &yymsp[-1].minor.yy253, NULL, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy47, &yymsp[-3].minor.yy29, &yymsp[-1].minor.yy29, NULL, yymsp[0].minor.yy182); }
         break;
       case 205: /* cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
-{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_FULLTEXT, yymsp[-6].minor.yy273, &yymsp[-5].minor.yy253, &yymsp[-3].minor.yy253, yymsp[-1].minor.yy220, NULL); }
+{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_FULLTEXT, yymsp[-6].minor.yy47, &yymsp[-5].minor.yy29, &yymsp[-3].minor.yy29, yymsp[-1].minor.yy334, NULL); }
         break;
       case 206: /* cmd ::= DROP INDEX exists_opt index_name ON table_name */
-{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-3].minor.yy273, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-3].minor.yy47, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29); }
         break;
       case 208: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
-{ yymsp[-8].minor.yy140 = createIndexOption(pCxt, yymsp[-6].minor.yy220, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), NULL, yymsp[0].minor.yy140); }
+{ yymsp[-8].minor.yy182 = createIndexOption(pCxt, yymsp[-6].minor.yy334, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), NULL, yymsp[0].minor.yy182); }
         break;
       case 209: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
-{ yymsp[-10].minor.yy140 = createIndexOption(pCxt, yymsp[-8].minor.yy220, releaseRawExprNode(pCxt, yymsp[-4].minor.yy140), releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), yymsp[0].minor.yy140); }
+{ yymsp[-10].minor.yy182 = createIndexOption(pCxt, yymsp[-8].minor.yy334, releaseRawExprNode(pCxt, yymsp[-4].minor.yy182), releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), yymsp[0].minor.yy182); }
         break;
       case 212: /* func ::= function_name NK_LP expression_list NK_RP */
-{ yylhsminor.yy140 = createFunctionNode(pCxt, &yymsp[-3].minor.yy253, yymsp[-1].minor.yy220); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createFunctionNode(pCxt, &yymsp[-3].minor.yy29, yymsp[-1].minor.yy334); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
       case 213: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
-{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-3].minor.yy273, &yymsp[-2].minor.yy253, yymsp[0].minor.yy140, NULL); }
+{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-3].minor.yy47, &yymsp[-2].minor.yy29, yymsp[0].minor.yy182, NULL); }
         break;
       case 214: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS db_name */
-{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-3].minor.yy273, &yymsp[-2].minor.yy253, NULL, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createCreateTopicStmt(pCxt, yymsp[-3].minor.yy47, &yymsp[-2].minor.yy29, NULL, &yymsp[0].minor.yy29); }
         break;
       case 215: /* cmd ::= DROP TOPIC exists_opt topic_name */
-{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy273, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy47, &yymsp[0].minor.yy29); }
         break;
       case 216: /* cmd ::= DESC full_table_name */
       case 217: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==217);
-{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy182); }
         break;
       case 218: /* cmd ::= RESET QUERY CACHE */
 { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); }
         break;
       case 219: /* cmd ::= EXPLAIN analyze_opt explain_options query_expression */
-{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy273, yymsp[-1].minor.yy140, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy47, yymsp[-1].minor.yy182, yymsp[0].minor.yy182); }
         break;
       case 221: /* analyze_opt ::= ANALYZE */
       case 229: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==229);
-      case 350: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==350);
-{ yymsp[0].minor.yy273 = true; }
+      case 351: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==351);
+{ yymsp[0].minor.yy47 = true; }
         break;
       case 222: /* explain_options ::= */
-{ yymsp[1].minor.yy140 = createDefaultExplainOptions(pCxt); }
+{ yymsp[1].minor.yy182 = createDefaultExplainOptions(pCxt); }
         break;
       case 223: /* explain_options ::= explain_options VERBOSE NK_BOOL */
-{ yylhsminor.yy140 = setExplainVerbose(pCxt, yymsp[-2].minor.yy140, &yymsp[0].minor.yy0); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = setExplainVerbose(pCxt, yymsp[-2].minor.yy182, &yymsp[0].minor.yy0); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 224: /* explain_options ::= explain_options RATIO NK_FLOAT */
-{ yylhsminor.yy140 = setExplainRatio(pCxt, yymsp[-2].minor.yy140, &yymsp[0].minor.yy0); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = setExplainRatio(pCxt, yymsp[-2].minor.yy182, &yymsp[0].minor.yy0); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 225: /* cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
-{ pCxt->pRootNode = createCompactStmt(pCxt, yymsp[-1].minor.yy220); }
+{ pCxt->pRootNode = createCompactStmt(pCxt, yymsp[-1].minor.yy334); }
         break;
       case 226: /* cmd ::= CREATE agg_func_opt FUNCTION function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
-{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy273, &yymsp[-5].minor.yy253, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy368, yymsp[0].minor.yy528); }
+{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy47, &yymsp[-5].minor.yy29, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy574, yymsp[0].minor.yy550); }
         break;
       case 227: /* cmd ::= DROP FUNCTION function_name */
-{ pCxt->pRootNode = createDropFunctionStmt(pCxt, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropFunctionStmt(pCxt, &yymsp[0].minor.yy29); }
         break;
       case 230: /* bufsize_opt ::= */
-{ yymsp[1].minor.yy528 = 0; }
+{ yymsp[1].minor.yy550 = 0; }
         break;
       case 231: /* bufsize_opt ::= BUFSIZE NK_INTEGER */
-{ yymsp[-1].minor.yy528 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy550 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
       case 232: /* cmd ::= CREATE STREAM stream_name INTO table_name AS query_expression */
-{ pCxt->pRootNode = createCreateStreamStmt(pCxt, &yymsp[-4].minor.yy253, &yymsp[-2].minor.yy253, yymsp[0].minor.yy140); }
+{ pCxt->pRootNode = createCreateStreamStmt(pCxt, &yymsp[-4].minor.yy29, &yymsp[-2].minor.yy29, yymsp[0].minor.yy182); }
         break;
       case 233: /* cmd ::= DROP STREAM stream_name */
-{ pCxt->pRootNode = createDropStreamStmt(pCxt, &yymsp[0].minor.yy253); }
+{ pCxt->pRootNode = createDropStreamStmt(pCxt, &yymsp[0].minor.yy29); }
         break;
       case 234: /* cmd ::= KILL CONNECTION NK_INTEGER */
 { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); }
@@ -3324,36 +3739,36 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
         break;
       case 237: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy220); }
+{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy334); }
         break;
       case 238: /* cmd ::= SPLIT VGROUP NK_INTEGER */
 { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); }
         break;
       case 239: /* dnode_list ::= DNODE NK_INTEGER */
-{ yymsp[-1].minor.yy220 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+{ yymsp[-1].minor.yy334 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
         break;
       case 241: /* cmd ::= SYNCDB db_name REPLICA */
-{ pCxt->pRootNode = createSyncdbStmt(pCxt, &yymsp[-1].minor.yy253); }
+{ pCxt->pRootNode = createSyncdbStmt(pCxt, &yymsp[-1].minor.yy29); }
         break;
       case 243: /* literal ::= NK_INTEGER */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 244: /* literal ::= NK_FLOAT */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 245: /* literal ::= NK_STRING */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 246: /* literal ::= NK_BOOL */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 247: /* literal ::= TIMESTAMP NK_STRING */
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 248: /* literal ::= duration_literal */
       case 257: /* signed_literal ::= signed */ yytestcase(yyruleno==257);
@@ -3361,460 +3776,461 @@ static YYACTIONTYPE yy_reduce(
       case 278: /* expression ::= pseudo_column */ yytestcase(yyruleno==278);
       case 279: /* expression ::= column_reference */ yytestcase(yyruleno==279);
       case 283: /* expression ::= subquery */ yytestcase(yyruleno==283);
-      case 323: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==323);
-      case 327: /* boolean_primary ::= predicate */ yytestcase(yyruleno==327);
-      case 329: /* common_expression ::= expression */ yytestcase(yyruleno==329);
-      case 330: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==330);
-      case 332: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==332);
-      case 334: /* table_reference ::= table_primary */ yytestcase(yyruleno==334);
-      case 335: /* table_reference ::= joined_table */ yytestcase(yyruleno==335);
-      case 339: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==339);
-      case 386: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==386);
-      case 388: /* query_primary ::= query_specification */ yytestcase(yyruleno==388);
-{ yylhsminor.yy140 = yymsp[0].minor.yy140; }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+      case 324: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==324);
+      case 328: /* boolean_primary ::= predicate */ yytestcase(yyruleno==328);
+      case 330: /* common_expression ::= expression */ yytestcase(yyruleno==330);
+      case 331: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==331);
+      case 333: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==333);
+      case 335: /* table_reference ::= table_primary */ yytestcase(yyruleno==335);
+      case 336: /* table_reference ::= joined_table */ yytestcase(yyruleno==336);
+      case 340: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==340);
+      case 387: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==387);
+      case 389: /* query_primary ::= query_specification */ yytestcase(yyruleno==389);
+{ yylhsminor.yy182 = yymsp[0].minor.yy182; }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 249: /* literal ::= NULL */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 250: /* duration_literal ::= NK_VARIABLE */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 251: /* signed ::= NK_INTEGER */
-{ yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 252: /* signed ::= NK_PLUS NK_INTEGER */
-{ yymsp[-1].minor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
         break;
       case 253: /* signed ::= NK_MINUS NK_INTEGER */
 { 
                                                                                     SToken t = yymsp[-1].minor.yy0;
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
-                                                                                    yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t);
+                                                                                    yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t);
                                                                                   }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 254: /* signed ::= NK_FLOAT */
-{ yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 255: /* signed ::= NK_PLUS NK_FLOAT */
-{ yymsp[-1].minor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
         break;
       case 256: /* signed ::= NK_MINUS NK_FLOAT */
 { 
                                                                                     SToken t = yymsp[-1].minor.yy0;
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
-                                                                                    yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t);
+                                                                                    yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t);
                                                                                   }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 258: /* signed_literal ::= NK_STRING */
-{ yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 259: /* signed_literal ::= NK_BOOL */
-{ yylhsminor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 260: /* signed_literal ::= TIMESTAMP NK_STRING */
-{ yymsp[-1].minor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
+{ yymsp[-1].minor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
         break;
       case 261: /* signed_literal ::= duration_literal */
-      case 356: /* select_item ::= common_expression */ yytestcase(yyruleno==356);
-      case 400: /* search_condition ::= common_expression */ yytestcase(yyruleno==400);
-{ yylhsminor.yy140 = releaseRawExprNode(pCxt, yymsp[0].minor.yy140); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+      case 357: /* select_item ::= common_expression */ yytestcase(yyruleno==357);
+      case 401: /* search_condition ::= common_expression */ yytestcase(yyruleno==401);
+{ yylhsminor.yy182 = releaseRawExprNode(pCxt, yymsp[0].minor.yy182); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 262: /* signed_literal ::= NULL */
-{ yymsp[0].minor.yy140 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL); }
+{ yymsp[0].minor.yy182 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL); }
         break;
       case 280: /* expression ::= function_name NK_LP expression_list NK_RP */
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy253, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy253, yymsp[-1].minor.yy220)); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy29, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy29, yymsp[-1].minor.yy334)); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
       case 281: /* expression ::= function_name NK_LP NK_STAR NK_RP */
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy253, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy253, createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy0)))); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy29, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy29, createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy0)))); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
       case 282: /* expression ::= function_name NK_LP expression AS type_name NK_RP */
 {
-                                                                                    SNodeList *p = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy140));
-                                                                                    p = addValueNodeFromTypeToList(pCxt, yymsp[-1].minor.yy368, p);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy253, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-5].minor.yy253, p));
+                                                                                    SNodeList *p = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy182));
+                                                                                    p = addValueNodeFromTypeToList(pCxt, yymsp[-1].minor.yy574, p);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy29, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-5].minor.yy29, p));
                                                                                   }
-  yymsp[-5].minor.yy140 = yylhsminor.yy140;
+  yymsp[-5].minor.yy182 = yylhsminor.yy182;
         break;
       case 284: /* expression ::= NK_LP expression NK_RP */
-      case 328: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==328);
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy140)); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 329: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==329);
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy182)); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 285: /* expression ::= NK_PLUS expression */
 {
-                                                                                    SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy140));
+                                                                                    SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy182));
                                                                                   }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 286: /* expression ::= NK_MINUS expression */
 {
-                                                                                    SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy140), NULL));
+                                                                                    SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy182), NULL));
                                                                                   }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
       case 287: /* expression ::= expression NK_PLUS expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); 
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); 
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 288: /* expression ::= expression NK_MINUS expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); 
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); 
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 289: /* expression ::= expression NK_STAR expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); 
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); 
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 290: /* expression ::= expression NK_SLASH expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); 
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); 
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 291: /* expression ::= expression NK_REM expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MOD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); 
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MOD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); 
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 292: /* expression_list ::= expression */
-{ yylhsminor.yy220 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy140)); }
-  yymsp[0].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy182)); }
+  yymsp[0].minor.yy334 = yylhsminor.yy334;
         break;
       case 293: /* expression_list ::= expression_list NK_COMMA expression */
-{ yylhsminor.yy220 = addNodeToList(pCxt, yymsp[-2].minor.yy220, releaseRawExprNode(pCxt, yymsp[0].minor.yy140)); }
-  yymsp[-2].minor.yy220 = yylhsminor.yy220;
+{ yylhsminor.yy334 = addNodeToList(pCxt, yymsp[-2].minor.yy334, releaseRawExprNode(pCxt, yymsp[0].minor.yy182)); }
+  yymsp[-2].minor.yy334 = yylhsminor.yy334;
         break;
       case 294: /* column_reference ::= column_name */
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy253, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy253)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy29, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy29)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
       case 295: /* column_reference ::= table_name NK_DOT column_name */
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy253, createColumnNode(pCxt, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy253)); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29, createColumnNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29)); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
       case 296: /* pseudo_column ::= NOW */
-      case 297: /* pseudo_column ::= ROWTS */ yytestcase(yyruleno==297);
-      case 298: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==298);
-      case 299: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==299);
-      case 300: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==300);
-      case 301: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==301);
-      case 302: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==302);
-      case 303: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==303);
-{ yylhsminor.yy140 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
-  yymsp[0].minor.yy140 = yylhsminor.yy140;
+      case 297: /* pseudo_column ::= TODAY */ yytestcase(yyruleno==297);
+      case 298: /* pseudo_column ::= ROWTS */ yytestcase(yyruleno==298);
+      case 299: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==299);
+      case 300: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==300);
+      case 301: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==301);
+      case 302: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==302);
+      case 303: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==303);
+      case 304: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==304);
+{ yylhsminor.yy182 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
+  yymsp[0].minor.yy182 = yylhsminor.yy182;
         break;
-      case 304: /* predicate ::= expression compare_op expression */
-      case 309: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==309);
+      case 305: /* predicate ::= expression compare_op expression */
+      case 310: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==310);
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy480, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140)));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy380, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182)));
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 305: /* predicate ::= expression BETWEEN expression AND expression */
+      case 306: /* predicate ::= expression BETWEEN expression AND expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy140), releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140)));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy182), releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182)));
                                                                                   }
-  yymsp[-4].minor.yy140 = yylhsminor.yy140;
+  yymsp[-4].minor.yy182 = yylhsminor.yy182;
         break;
-      case 306: /* predicate ::= expression NOT BETWEEN expression AND expression */
+      case 307: /* predicate ::= expression NOT BETWEEN expression AND expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[-5].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140)));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[-5].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182)));
                                                                                   }
-  yymsp[-5].minor.yy140 = yylhsminor.yy140;
+  yymsp[-5].minor.yy182 = yylhsminor.yy182;
         break;
-      case 307: /* predicate ::= expression IS NULL */
+      case 308: /* predicate ::= expression IS NULL */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), NULL));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), NULL));
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 308: /* predicate ::= expression IS NOT NULL */
+      case 309: /* predicate ::= expression IS NOT NULL */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy140), NULL));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy182), NULL));
                                                                                   }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
-      case 310: /* compare_op ::= NK_LT */
-{ yymsp[0].minor.yy480 = OP_TYPE_LOWER_THAN; }
+      case 311: /* compare_op ::= NK_LT */
+{ yymsp[0].minor.yy380 = OP_TYPE_LOWER_THAN; }
         break;
-      case 311: /* compare_op ::= NK_GT */
-{ yymsp[0].minor.yy480 = OP_TYPE_GREATER_THAN; }
+      case 312: /* compare_op ::= NK_GT */
+{ yymsp[0].minor.yy380 = OP_TYPE_GREATER_THAN; }
         break;
-      case 312: /* compare_op ::= NK_LE */
-{ yymsp[0].minor.yy480 = OP_TYPE_LOWER_EQUAL; }
+      case 313: /* compare_op ::= NK_LE */
+{ yymsp[0].minor.yy380 = OP_TYPE_LOWER_EQUAL; }
         break;
-      case 313: /* compare_op ::= NK_GE */
-{ yymsp[0].minor.yy480 = OP_TYPE_GREATER_EQUAL; }
+      case 314: /* compare_op ::= NK_GE */
+{ yymsp[0].minor.yy380 = OP_TYPE_GREATER_EQUAL; }
         break;
-      case 314: /* compare_op ::= NK_NE */
-{ yymsp[0].minor.yy480 = OP_TYPE_NOT_EQUAL; }
+      case 315: /* compare_op ::= NK_NE */
+{ yymsp[0].minor.yy380 = OP_TYPE_NOT_EQUAL; }
         break;
-      case 315: /* compare_op ::= NK_EQ */
-{ yymsp[0].minor.yy480 = OP_TYPE_EQUAL; }
+      case 316: /* compare_op ::= NK_EQ */
+{ yymsp[0].minor.yy380 = OP_TYPE_EQUAL; }
         break;
-      case 316: /* compare_op ::= LIKE */
-{ yymsp[0].minor.yy480 = OP_TYPE_LIKE; }
+      case 317: /* compare_op ::= LIKE */
+{ yymsp[0].minor.yy380 = OP_TYPE_LIKE; }
         break;
-      case 317: /* compare_op ::= NOT LIKE */
-{ yymsp[-1].minor.yy480 = OP_TYPE_NOT_LIKE; }
+      case 318: /* compare_op ::= NOT LIKE */
+{ yymsp[-1].minor.yy380 = OP_TYPE_NOT_LIKE; }
         break;
-      case 318: /* compare_op ::= MATCH */
-{ yymsp[0].minor.yy480 = OP_TYPE_MATCH; }
+      case 319: /* compare_op ::= MATCH */
+{ yymsp[0].minor.yy380 = OP_TYPE_MATCH; }
         break;
-      case 319: /* compare_op ::= NMATCH */
-{ yymsp[0].minor.yy480 = OP_TYPE_NMATCH; }
+      case 320: /* compare_op ::= NMATCH */
+{ yymsp[0].minor.yy380 = OP_TYPE_NMATCH; }
         break;
-      case 320: /* in_op ::= IN */
-{ yymsp[0].minor.yy480 = OP_TYPE_IN; }
+      case 321: /* in_op ::= IN */
+{ yymsp[0].minor.yy380 = OP_TYPE_IN; }
         break;
-      case 321: /* in_op ::= NOT IN */
-{ yymsp[-1].minor.yy480 = OP_TYPE_NOT_IN; }
+      case 322: /* in_op ::= NOT IN */
+{ yymsp[-1].minor.yy380 = OP_TYPE_NOT_IN; }
         break;
-      case 322: /* in_predicate_value ::= NK_LP expression_list NK_RP */
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy220)); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 323: /* in_predicate_value ::= NK_LP expression_list NK_RP */
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy334)); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 324: /* boolean_value_expression ::= NOT boolean_primary */
+      case 325: /* boolean_value_expression ::= NOT boolean_primary */
 {
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy140), NULL));
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy182), NULL));
                                                                                   }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
-      case 325: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+      case 326: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140)));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182)));
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 326: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+      case 327: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
 {
-                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy140);
-                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy140);
-                                                                                    yylhsminor.yy140 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), releaseRawExprNode(pCxt, yymsp[0].minor.yy140)));
+                                                                                    SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy182);
+                                                                                    SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy182);
+                                                                                    yylhsminor.yy182 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), releaseRawExprNode(pCxt, yymsp[0].minor.yy182)));
                                                                                   }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 331: /* from_clause ::= FROM table_reference_list */
-      case 361: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==361);
-      case 384: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==384);
-{ yymsp[-1].minor.yy140 = yymsp[0].minor.yy140; }
+      case 332: /* from_clause ::= FROM table_reference_list */
+      case 362: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==362);
+      case 385: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==385);
+{ yymsp[-1].minor.yy182 = yymsp[0].minor.yy182; }
         break;
-      case 333: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
-{ yylhsminor.yy140 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy140, yymsp[0].minor.yy140, NULL); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 334: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
+{ yylhsminor.yy182 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy182, yymsp[0].minor.yy182, NULL); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 336: /* table_primary ::= table_name alias_opt */
-{ yylhsminor.yy140 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy253, &yymsp[0].minor.yy253); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+      case 337: /* table_primary ::= table_name alias_opt */
+{ yylhsminor.yy182 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
-      case 337: /* table_primary ::= db_name NK_DOT table_name alias_opt */
-{ yylhsminor.yy140 = createRealTableNode(pCxt, &yymsp[-3].minor.yy253, &yymsp[-1].minor.yy253, &yymsp[0].minor.yy253); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+      case 338: /* table_primary ::= db_name NK_DOT table_name alias_opt */
+{ yylhsminor.yy182 = createRealTableNode(pCxt, &yymsp[-3].minor.yy29, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
-      case 338: /* table_primary ::= subquery alias_opt */
-{ yylhsminor.yy140 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy140), &yymsp[0].minor.yy253); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+      case 339: /* table_primary ::= subquery alias_opt */
+{ yylhsminor.yy182 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy182), &yymsp[0].minor.yy29); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
-      case 340: /* alias_opt ::= */
-{ yymsp[1].minor.yy253 = nil_token;  }
+      case 341: /* alias_opt ::= */
+{ yymsp[1].minor.yy29 = nil_token;  }
         break;
-      case 341: /* alias_opt ::= table_alias */
-{ yylhsminor.yy253 = yymsp[0].minor.yy253; }
-  yymsp[0].minor.yy253 = yylhsminor.yy253;
+      case 342: /* alias_opt ::= table_alias */
+{ yylhsminor.yy29 = yymsp[0].minor.yy29; }
+  yymsp[0].minor.yy29 = yylhsminor.yy29;
         break;
-      case 342: /* alias_opt ::= AS table_alias */
-{ yymsp[-1].minor.yy253 = yymsp[0].minor.yy253; }
+      case 343: /* alias_opt ::= AS table_alias */
+{ yymsp[-1].minor.yy29 = yymsp[0].minor.yy29; }
         break;
-      case 343: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-      case 344: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==344);
-{ yymsp[-2].minor.yy140 = yymsp[-1].minor.yy140; }
+      case 344: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+      case 345: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==345);
+{ yymsp[-2].minor.yy182 = yymsp[-1].minor.yy182; }
         break;
-      case 345: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-{ yylhsminor.yy140 = createJoinTableNode(pCxt, yymsp[-4].minor.yy224, yymsp[-5].minor.yy140, yymsp[-2].minor.yy140, yymsp[0].minor.yy140); }
-  yymsp[-5].minor.yy140 = yylhsminor.yy140;
+      case 346: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+{ yylhsminor.yy182 = createJoinTableNode(pCxt, yymsp[-4].minor.yy162, yymsp[-5].minor.yy182, yymsp[-2].minor.yy182, yymsp[0].minor.yy182); }
+  yymsp[-5].minor.yy182 = yylhsminor.yy182;
         break;
-      case 346: /* join_type ::= */
-{ yymsp[1].minor.yy224 = JOIN_TYPE_INNER; }
+      case 347: /* join_type ::= */
+{ yymsp[1].minor.yy162 = JOIN_TYPE_INNER; }
         break;
-      case 347: /* join_type ::= INNER */
-{ yymsp[0].minor.yy224 = JOIN_TYPE_INNER; }
+      case 348: /* join_type ::= INNER */
+{ yymsp[0].minor.yy162 = JOIN_TYPE_INNER; }
         break;
-      case 348: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+      case 349: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
 { 
-                                                                                    yymsp[-8].minor.yy140 = createSelectStmt(pCxt, yymsp[-7].minor.yy273, yymsp[-6].minor.yy220, yymsp[-5].minor.yy140);
-                                                                                    yymsp[-8].minor.yy140 = addWhereClause(pCxt, yymsp[-8].minor.yy140, yymsp[-4].minor.yy140);
-                                                                                    yymsp[-8].minor.yy140 = addPartitionByClause(pCxt, yymsp[-8].minor.yy140, yymsp[-3].minor.yy220);
-                                                                                    yymsp[-8].minor.yy140 = addWindowClauseClause(pCxt, yymsp[-8].minor.yy140, yymsp[-2].minor.yy140);
-                                                                                    yymsp[-8].minor.yy140 = addGroupByClause(pCxt, yymsp[-8].minor.yy140, yymsp[-1].minor.yy220);
-                                                                                    yymsp[-8].minor.yy140 = addHavingClause(pCxt, yymsp[-8].minor.yy140, yymsp[0].minor.yy140);
+                                                                                    yymsp[-8].minor.yy182 = createSelectStmt(pCxt, yymsp[-7].minor.yy47, yymsp[-6].minor.yy334, yymsp[-5].minor.yy182);
+                                                                                    yymsp[-8].minor.yy182 = addWhereClause(pCxt, yymsp[-8].minor.yy182, yymsp[-4].minor.yy182);
+                                                                                    yymsp[-8].minor.yy182 = addPartitionByClause(pCxt, yymsp[-8].minor.yy182, yymsp[-3].minor.yy334);
+                                                                                    yymsp[-8].minor.yy182 = addWindowClauseClause(pCxt, yymsp[-8].minor.yy182, yymsp[-2].minor.yy182);
+                                                                                    yymsp[-8].minor.yy182 = addGroupByClause(pCxt, yymsp[-8].minor.yy182, yymsp[-1].minor.yy334);
+                                                                                    yymsp[-8].minor.yy182 = addHavingClause(pCxt, yymsp[-8].minor.yy182, yymsp[0].minor.yy182);
                                                                                   }
         break;
-      case 351: /* set_quantifier_opt ::= ALL */
-{ yymsp[0].minor.yy273 = false; }
+      case 352: /* set_quantifier_opt ::= ALL */
+{ yymsp[0].minor.yy47 = false; }
         break;
-      case 352: /* select_list ::= NK_STAR */
-{ yymsp[0].minor.yy220 = NULL; }
+      case 353: /* select_list ::= NK_STAR */
+{ yymsp[0].minor.yy334 = NULL; }
         break;
-      case 357: /* select_item ::= common_expression column_alias */
-{ yylhsminor.yy140 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy140), &yymsp[0].minor.yy253); }
-  yymsp[-1].minor.yy140 = yylhsminor.yy140;
+      case 358: /* select_item ::= common_expression column_alias */
+{ yylhsminor.yy182 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy182), &yymsp[0].minor.yy29); }
+  yymsp[-1].minor.yy182 = yylhsminor.yy182;
         break;
-      case 358: /* select_item ::= common_expression AS column_alias */
-{ yylhsminor.yy140 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), &yymsp[0].minor.yy253); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 359: /* select_item ::= common_expression AS column_alias */
+{ yylhsminor.yy182 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), &yymsp[0].minor.yy29); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 359: /* select_item ::= table_name NK_DOT NK_STAR */
-{ yylhsminor.yy140 = createColumnNode(pCxt, &yymsp[-2].minor.yy253, &yymsp[0].minor.yy0); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 360: /* select_item ::= table_name NK_DOT NK_STAR */
+{ yylhsminor.yy182 = createColumnNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 363: /* partition_by_clause_opt ::= PARTITION BY expression_list */
-      case 380: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==380);
-      case 390: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==390);
-{ yymsp[-2].minor.yy220 = yymsp[0].minor.yy220; }
+      case 364: /* partition_by_clause_opt ::= PARTITION BY expression_list */
+      case 381: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==381);
+      case 391: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==391);
+{ yymsp[-2].minor.yy334 = yymsp[0].minor.yy334; }
         break;
-      case 365: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-{ yymsp[-5].minor.yy140 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy140), releaseRawExprNode(pCxt, yymsp[-1].minor.yy140)); }
+      case 366: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+{ yymsp[-5].minor.yy182 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy182), releaseRawExprNode(pCxt, yymsp[-1].minor.yy182)); }
         break;
-      case 366: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-{ yymsp[-3].minor.yy140 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy140)); }
+      case 367: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+{ yymsp[-3].minor.yy182 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy182)); }
         break;
-      case 367: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-{ yymsp[-5].minor.yy140 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy140), NULL, yymsp[-1].minor.yy140, yymsp[0].minor.yy140); }
+      case 368: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+{ yymsp[-5].minor.yy182 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy182), NULL, yymsp[-1].minor.yy182, yymsp[0].minor.yy182); }
         break;
-      case 368: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-{ yymsp[-7].minor.yy140 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy140), releaseRawExprNode(pCxt, yymsp[-3].minor.yy140), yymsp[-1].minor.yy140, yymsp[0].minor.yy140); }
+      case 369: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+{ yymsp[-7].minor.yy182 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy182), releaseRawExprNode(pCxt, yymsp[-3].minor.yy182), yymsp[-1].minor.yy182, yymsp[0].minor.yy182); }
         break;
-      case 370: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-{ yymsp[-3].minor.yy140 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy140); }
+      case 371: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+{ yymsp[-3].minor.yy182 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy182); }
         break;
-      case 372: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
-{ yymsp[-3].minor.yy140 = createFillNode(pCxt, yymsp[-1].minor.yy174, NULL); }
+      case 373: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
+{ yymsp[-3].minor.yy182 = createFillNode(pCxt, yymsp[-1].minor.yy144, NULL); }
         break;
-      case 373: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-{ yymsp[-5].minor.yy140 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy220)); }
+      case 374: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+{ yymsp[-5].minor.yy182 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy334)); }
         break;
-      case 374: /* fill_mode ::= NONE */
-{ yymsp[0].minor.yy174 = FILL_MODE_NONE; }
+      case 375: /* fill_mode ::= NONE */
+{ yymsp[0].minor.yy144 = FILL_MODE_NONE; }
         break;
-      case 375: /* fill_mode ::= PREV */
-{ yymsp[0].minor.yy174 = FILL_MODE_PREV; }
+      case 376: /* fill_mode ::= PREV */
+{ yymsp[0].minor.yy144 = FILL_MODE_PREV; }
         break;
-      case 376: /* fill_mode ::= NULL */
-{ yymsp[0].minor.yy174 = FILL_MODE_NULL; }
+      case 377: /* fill_mode ::= NULL */
+{ yymsp[0].minor.yy144 = FILL_MODE_NULL; }
         break;
-      case 377: /* fill_mode ::= LINEAR */
-{ yymsp[0].minor.yy174 = FILL_MODE_LINEAR; }
+      case 378: /* fill_mode ::= LINEAR */
+{ yymsp[0].minor.yy144 = FILL_MODE_LINEAR; }
         break;
-      case 378: /* fill_mode ::= NEXT */
-{ yymsp[0].minor.yy174 = FILL_MODE_NEXT; }
+      case 379: /* fill_mode ::= NEXT */
+{ yymsp[0].minor.yy144 = FILL_MODE_NEXT; }
         break;
-      case 381: /* group_by_list ::= expression */
-{ yylhsminor.yy220 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); }
-  yymsp[0].minor.yy220 = yylhsminor.yy220;
+      case 382: /* group_by_list ::= expression */
+{ yylhsminor.yy334 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); }
+  yymsp[0].minor.yy334 = yylhsminor.yy334;
         break;
-      case 382: /* group_by_list ::= group_by_list NK_COMMA expression */
-{ yylhsminor.yy220 = addNodeToList(pCxt, yymsp[-2].minor.yy220, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy140))); }
-  yymsp[-2].minor.yy220 = yylhsminor.yy220;
+      case 383: /* group_by_list ::= group_by_list NK_COMMA expression */
+{ yylhsminor.yy334 = addNodeToList(pCxt, yymsp[-2].minor.yy334, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy182))); }
+  yymsp[-2].minor.yy334 = yylhsminor.yy334;
         break;
-      case 385: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+      case 386: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
 { 
-                                                                                    yylhsminor.yy140 = addOrderByClause(pCxt, yymsp[-3].minor.yy140, yymsp[-2].minor.yy220);
-                                                                                    yylhsminor.yy140 = addSlimitClause(pCxt, yylhsminor.yy140, yymsp[-1].minor.yy140);
-                                                                                    yylhsminor.yy140 = addLimitClause(pCxt, yylhsminor.yy140, yymsp[0].minor.yy140);
+                                                                                    yylhsminor.yy182 = addOrderByClause(pCxt, yymsp[-3].minor.yy182, yymsp[-2].minor.yy334);
+                                                                                    yylhsminor.yy182 = addSlimitClause(pCxt, yylhsminor.yy182, yymsp[-1].minor.yy182);
+                                                                                    yylhsminor.yy182 = addLimitClause(pCxt, yylhsminor.yy182, yymsp[0].minor.yy182);
                                                                                   }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
-      case 387: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-{ yylhsminor.yy140 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy140, yymsp[0].minor.yy140); }
-  yymsp[-3].minor.yy140 = yylhsminor.yy140;
+      case 388: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+{ yylhsminor.yy182 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy182, yymsp[0].minor.yy182); }
+  yymsp[-3].minor.yy182 = yylhsminor.yy182;
         break;
-      case 392: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
-      case 396: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==396);
-{ yymsp[-1].minor.yy140 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
+      case 393: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
+      case 397: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==397);
+{ yymsp[-1].minor.yy182 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
         break;
-      case 393: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-      case 397: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==397);
-{ yymsp[-3].minor.yy140 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
+      case 394: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+      case 398: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==398);
+{ yymsp[-3].minor.yy182 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
         break;
-      case 394: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-      case 398: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==398);
-{ yymsp[-3].minor.yy140 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
+      case 395: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+      case 399: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==399);
+{ yymsp[-3].minor.yy182 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
         break;
-      case 399: /* subquery ::= NK_LP query_expression NK_RP */
-{ yylhsminor.yy140 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy140); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 400: /* subquery ::= NK_LP query_expression NK_RP */
+{ yylhsminor.yy182 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy182); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 403: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-{ yylhsminor.yy140 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy140), yymsp[-1].minor.yy238, yymsp[0].minor.yy69); }
-  yymsp[-2].minor.yy140 = yylhsminor.yy140;
+      case 404: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+{ yylhsminor.yy182 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy182), yymsp[-1].minor.yy218, yymsp[0].minor.yy487); }
+  yymsp[-2].minor.yy182 = yylhsminor.yy182;
         break;
-      case 404: /* ordering_specification_opt ::= */
-{ yymsp[1].minor.yy238 = ORDER_ASC; }
+      case 405: /* ordering_specification_opt ::= */
+{ yymsp[1].minor.yy218 = ORDER_ASC; }
         break;
-      case 405: /* ordering_specification_opt ::= ASC */
-{ yymsp[0].minor.yy238 = ORDER_ASC; }
+      case 406: /* ordering_specification_opt ::= ASC */
+{ yymsp[0].minor.yy218 = ORDER_ASC; }
         break;
-      case 406: /* ordering_specification_opt ::= DESC */
-{ yymsp[0].minor.yy238 = ORDER_DESC; }
+      case 407: /* ordering_specification_opt ::= DESC */
+{ yymsp[0].minor.yy218 = ORDER_DESC; }
         break;
-      case 407: /* null_ordering_opt ::= */
-{ yymsp[1].minor.yy69 = NULL_ORDER_DEFAULT; }
+      case 408: /* null_ordering_opt ::= */
+{ yymsp[1].minor.yy487 = NULL_ORDER_DEFAULT; }
         break;
-      case 408: /* null_ordering_opt ::= NULLS FIRST */
-{ yymsp[-1].minor.yy69 = NULL_ORDER_FIRST; }
+      case 409: /* null_ordering_opt ::= NULLS FIRST */
+{ yymsp[-1].minor.yy487 = NULL_ORDER_FIRST; }
         break;
-      case 409: /* null_ordering_opt ::= NULLS LAST */
-{ yymsp[-1].minor.yy69 = NULL_ORDER_LAST; }
+      case 410: /* null_ordering_opt ::= NULLS LAST */
+{ yymsp[-1].minor.yy487 = NULL_ORDER_LAST; }
         break;
       default:
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
-  yygoto = yyRuleInfo[yyruleno].lhs;
-  yysize = yyRuleInfo[yyruleno].nrhs;
+  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
+  yygoto = yyRuleInfoLhs[yyruleno];
+  yysize = yyRuleInfoNRhs[yyruleno];
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -4102,11 +4518,10 @@ void Parse(
 */
 int ParseFallback(int iToken){
 #ifdef YYFALLBACK
-  if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){
-    return yyFallback[iToken];
-  }
+  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
+  return yyFallback[iToken];
 #else
   (void)iToken;
-#endif
   return 0;
+#endif
 }

From d4f71ebf769628b77efee69a1db3bf90827e07e5 Mon Sep 17 00:00:00 2001
From: Liu Jicong <liujicong@qq.com>
Date: Wed, 13 Apr 2022 21:09:35 +0800
Subject: [PATCH 07/11] temporary remove case

---
 tests/script/jenkins/basic.txt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 730937333b..35476980b1 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -59,13 +59,13 @@
 ./test.sh -f tsim/tmq/oneTopic.sim
 ./test.sh -f tsim/tmq/multiTopic.sim
 
-./test.sh -f tsim/tmq/mainConsumerInMultiTopic.sim
-./test.sh -f tsim/tmq/mainConsumerInOneTopic.sim
+#./test.sh -f tsim/tmq/mainConsumerInMultiTopic.sim
+#./test.sh -f tsim/tmq/mainConsumerInOneTopic.sim
 
 #fail ./test.sh -f tsim/tmq/main2Con1Cgrp1TopicFrCtb.sim
 #fail ./test.sh -f tsim/tmq/main2Con1Cgrp1TopicFrStb.sim
-./test.sh -f tsim/tmq/main2Con1Cgrp2TopicFrCtb.sim
-./test.sh -f tsim/tmq/main2Con1Cgrp2TopicFrStb.sim
+#./test.sh -f tsim/tmq/main2Con1Cgrp2TopicFrCtb.sim
+#./test.sh -f tsim/tmq/main2Con1Cgrp2TopicFrStb.sim
 
 
 # --- stable

From b932b5bca64abbb9e427553ed0f0b560c2eceb57 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Thu, 14 Apr 2022 02:01:04 +0000
Subject: [PATCH 08/11] refact header file

---
 source/dnode/vnode/inc/vnode.h            | 471 ++++++----------------
 source/dnode/vnode/src/tsdb/tsdbOptions.c |   9 -
 source/dnode/vnode/src/vnd/vnodeCfg.c     |  13 +-
 3 files changed, 128 insertions(+), 365 deletions(-)

diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index a93e1741bb..40be3f1299 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -25,82 +25,83 @@
 #include "tfs.h"
 #include "wal.h"
 
+#include "tcommon.h"
+#include "tfs.h"
 #include "tmallocator.h"
 #include "tmsg.h"
 #include "trow.h"
-#include "tmallocator.h"
-#include "tcommon.h"
-#include "tfs.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* ------------------------ TYPES EXPOSED ------------------------ */
-typedef struct SMgmtWrapper SMgmtWrapper;
-typedef struct SVnode       SVnode;
+// types
+typedef struct SVnode         SVnode;
+typedef struct SMetaCfg       SMetaCfg;  // todo: remove
+typedef struct STsdbCfg       STsdbCfg;  // todo: remove
+typedef struct STqCfg         STqCfg;    // todo: remove
+typedef struct SVnodeCfg      SVnodeCfg;
+typedef struct STqReadHandle  STqReadHandle;
+typedef struct SMTbCursor     SMTbCursor;   // todo: remove
+typedef struct SMCtbCursor    SMCtbCursor;  // todo: remove
+typedef struct SMSmaCursor    SMSmaCursor;  // todo: remove
+typedef void                 *tsdbReaderT;
+typedef struct STsdbQueryCond STsdbQueryCond;
+typedef struct SDataStatis    SDataStatis;
 
-#define META_SUPER_TABLE  TD_SUPER_TABLE
-#define META_CHILD_TABLE  TD_CHILD_TABLE
-#define META_NORMAL_TABLE TD_NORMAL_TABLE
+// vnode
+int     vnodeInit();
+void    vnodeCleanup();
+SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg);
+void    vnodeClose(SVnode *pVnode);
+void    vnodeDestroy(const char *path);
+void    vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs);
+int     vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+int     vnodeProcessCMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+int     vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+int     vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg);
+int     vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo);
+int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);
+int32_t vnodeCompact(SVnode *pVnode);
+int32_t vnodeSync(SVnode *pVnode);
+int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
 
-// Types exported
-typedef struct SMeta SMeta;
+// meta
+typedef struct SMeta SMeta;  // todo: remove
 
-typedef struct SMetaCfg {
-  /// LRU cache size
-  uint64_t lruSize;
-} SMetaCfg;
-
-typedef struct SMTbCursor  SMTbCursor;
-typedef struct SMCtbCursor SMCtbCursor;
-typedef struct SMSmaCursor SMSmaCursor;
-
-typedef SVCreateTbReq   STbCfg;
-typedef SVCreateTSmaReq SSmaCfg;
-
-typedef struct SDataStatis {
-  int16_t colId;
-  int16_t maxIndex;
-  int16_t minIndex;
-  int16_t numOfNull;
-  int64_t sum;
-  int64_t max;
-  int64_t min;
-} SDataStatis;
-
-typedef struct STsdbQueryCond {
-  STimeWindow  twindow;
-  int32_t      order;             // desc|asc order to iterate the data block
-  int32_t      numOfCols;
-  SColumnInfo *colList;
-  bool         loadExternalRows;  // load external rows or not
-  int32_t      type;              // data block load type:
-} STsdbQueryCond;
-
-typedef struct {
-  TSKEY    lastKey;
-  uint64_t uid;
-} STableKeyInfo;
-
-
-typedef struct STable {
-  uint64_t  tid;
-  uint64_t  uid;
-  STSchema *pSchema;
-} STable;
-
-#define BLOCK_LOAD_OFFSET_SEQ_ORDER   1
-#define BLOCK_LOAD_TABLE_SEQ_ORDER    2
-#define BLOCK_LOAD_TABLE_RR_ORDER     3
-
-#define TABLE_TID(t) (t)->tid
-#define TABLE_UID(t) (t)->uid
-
-// TYPES EXPOSED
+// tsdb
 typedef struct STsdb STsdb;
 
-typedef struct STsdbCfg {
+tsdbReaderT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
+                             uint64_t taskId);
+tsdbReaderT  tsdbQueryCacheLast(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId,
+                                void *pMemRef);
+int32_t      tsdbGetFileBlocksDistInfo(tsdbReaderT *pReader, STableBlockDistInfo *pTableBlockInfo);
+bool         isTsdbCacheLastRow(tsdbReaderT *pReader);
+int32_t      tsdbQuerySTableByTagCond(void *pMeta, uint64_t uid, TSKEY skey, const char *pTagCond, size_t len,
+                                      int16_t tagNameRelType, const char *tbnameCond, STableGroupInfo *pGroupInfo,
+                                      SColIndex *pColIndex, int32_t numOfCols, uint64_t reqId, uint64_t taskId);
+int64_t      tsdbGetNumOfRowsInMemTable(tsdbReaderT *pHandle);
+bool         tsdbNextDataBlock(tsdbReaderT pTsdbReadHandle);
+void         tsdbRetrieveDataBlockInfo(tsdbReaderT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
+int32_t      tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SDataStatis **pBlockStatis);
+SArray      *tsdbRetrieveDataBlock(tsdbReaderT *pTsdbReadHandle, SArray *pColumnIdList);
+void         tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
+int32_t      tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
+int32_t      tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
+void         tsdbCleanupReadHandle(tsdbReaderT queryHandle);
+
+// tq
+
+// need to remove
+int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
+
+// structs
+struct SMetaCfg {
+  uint64_t lruSize;
+};
+
+struct STsdbCfg {
   int8_t   precision;
   int8_t   update;
   int8_t   compression;
@@ -112,15 +113,13 @@ typedef struct STsdbCfg {
   int32_t  keep2;
   uint64_t lruCacheSize;
   SArray  *retentions;
-} STsdbCfg;
+};
 
-
-typedef struct {
-  // TODO
+struct STqCfg {
   int32_t reserved;
-} STqCfg;
+};
 
-typedef struct {
+struct SVnodeCfg {
   int32_t  vgId;
   uint64_t dbId;
   STfs    *pTfs;
@@ -140,9 +139,9 @@ typedef struct {
   uint32_t hashBegin;
   uint32_t hashEnd;
   int8_t   hashMethod;
-} SVnodeCfg;
+};
 
-typedef struct {
+struct STqReadHandle {
   int64_t           ver;
   int64_t           tbUid;
   SHashObj         *tbIdHash;
@@ -155,127 +154,62 @@ typedef struct {
   int32_t           sver;
   SSchemaWrapper   *pSchemaWrapper;
   STSchema         *pSchema;
-} STqReadHandle;
+};
+
+// ---------------------------- OLD ----------------------------
+typedef struct SMgmtWrapper SMgmtWrapper;
+
+#define META_SUPER_TABLE  TD_SUPER_TABLE
+#define META_CHILD_TABLE  TD_CHILD_TABLE
+#define META_NORMAL_TABLE TD_NORMAL_TABLE
+
+// Types exported
+
+typedef SVCreateTbReq   STbCfg;
+typedef SVCreateTSmaReq SSmaCfg;
+
+typedef struct SDataStatis {
+  int16_t colId;
+  int16_t maxIndex;
+  int16_t minIndex;
+  int16_t numOfNull;
+  int64_t sum;
+  int64_t max;
+  int64_t min;
+} SDataStatis;
+
+struct STsdbQueryCond {
+  STimeWindow  twindow;
+  int32_t      order;  // desc|asc order to iterate the data block
+  int32_t      numOfCols;
+  SColumnInfo *colList;
+  bool         loadExternalRows;  // load external rows or not
+  int32_t      type;              // data block load type:
+};
+
+typedef struct {
+  TSKEY    lastKey;
+  uint64_t uid;
+} STableKeyInfo;
+
+typedef struct STable {
+  uint64_t  tid;
+  uint64_t  uid;
+  STSchema *pSchema;
+} STable;
+
+#define BLOCK_LOAD_OFFSET_SEQ_ORDER 1
+#define BLOCK_LOAD_TABLE_SEQ_ORDER  2
+#define BLOCK_LOAD_TABLE_RR_ORDER   3
+
+#define TABLE_TID(t) (t)->tid
+#define TABLE_UID(t) (t)->uid
 
 /* ------------------------ SVnode ------------------------ */
-/**
- * @brief Initialize the vnode module
- *
- * @return int 0 for success and -1 for failure
- */
-int vnodeInit();
-
-/**
- * @brief Cleanup the vnode module
- *
- */
-void vnodeCleanup();
-
-/**
- * @brief Open a VNODE.
- *
- * @param path path of the vnode
- * @param pVnodeCfg options of the vnode
- * @return SVnode* The vnode object
- */
-SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg);
-
-/**
- * @brief Close a VNODE
- *
- * @param pVnode The vnode object to close
- */
-void vnodeClose(SVnode *pVnode);
-
-/**
- * @brief Destroy a VNODE.
- *
- * @param path Path of the VNODE.
- */
-void vnodeDestroy(const char *path);
-
-/**
- * @brief Process an array of write messages.
- *
- * @param pVnode The vnode object.
- * @param pMsgs The array of SRpcMsg
- */
-void vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs);
-
-/**
- * @brief Apply a write request message.
- *
- * @param pVnode The vnode object.
- * @param pMsg The request message
- * @param pRsp The response message
- * @return int 0 for success, -1 for failure
- */
-int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
-
-/**
- * @brief Process a consume message.
- *
- * @param pVnode The vnode object.
- * @param pMsg The request message
- * @param pRsp The response message
- * @return int 0 for success, -1 for failure
- */
-int vnodeProcessCMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
-
-/**
- * @brief Process the sync request
- *
- * @param pVnode
- * @param pMsg
- * @param pRsp
- * @return int
- */
-int vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
-
-/**
- * @brief Process a query message.
- *
- * @param pVnode The vnode object.
- * @param pMsg The request message
- * @return int 0 for success, -1 for failure
- */
-int vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg);
-
-/**
- * @brief Process a fetch message.
- *
- * @param pVnode The vnode object.
- * @param pMsg The request message
- * @return int 0 for success, -1 for failure
- */
-int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo);
-
-/* ------------------------ SVnodeCfg ------------------------ */
-/**
- * @brief Initialize VNODE options.
- *
- * @param pOptions The options object to be initialized. It should not be NULL.
- */
-void vnodeOptionsInit(SVnodeCfg *pOptions);
-
-/**
- * @brief Clear VNODE options.
- *
- * @param pOptions Options to clear.
- */
-void vnodeOptionsClear(SVnodeCfg *pOptions);
-
 int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName);
 
 /* ------------------------ FOR COMPILE ------------------------ */
 
-int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);
-int32_t vnodeCompact(SVnode *pVnode);
-int32_t vnodeSync(SVnode *pVnode);
-int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
-
-/* ------------------------- TQ READ --------------------------- */
-
 enum {
   TQ_STREAM_TOKEN__DATA = 1,
   TQ_STREAM_TOKEN__WATERMARK,
@@ -378,14 +312,14 @@ void metaOptionsClear(SMetaCfg *pMetaCfg);
 
 // query condition to build multi-table data block iterator
 // STsdb
-STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta, STfs *pTfs);
+STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
+                STfs *pTfs);
 void   tsdbClose(STsdb *);
 void   tsdbRemove(const char *path);
 int    tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp);
 int    tsdbPrepareCommit(STsdb *pTsdb);
 int    tsdbCommit(STsdb *pTsdb);
 
-
 int32_t tsdbInitSma(STsdb *pTsdb);
 int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg);
 int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg);
@@ -411,10 +345,10 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
 
 /**
  * @brief Drop tSma data and local cache.
- * 
- * @param pTsdb 
- * @param indexUid 
- * @return int32_t 
+ *
+ * @param pTsdb
+ * @param indexUid
+ * @return int32_t
  */
 int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
 
@@ -427,159 +361,6 @@ int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
  */
 int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 
-// TODO: This is the basic params, and should wrap the params to a queryHandle.
-/**
- * @brief Get tSma(Time-range-wise SMA) data.
- * 
- * @param pTsdb 
- * @param pData 
- * @param indexUid 
- * @param querySKey 
- * @param nMaxResult 
- * @return int32_t 
- */
-int32_t tsdbGetTSmaData(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult);
-
-// STsdbCfg
-int  tsdbOptionsInit(STsdbCfg *);
-void tsdbOptionsClear(STsdbCfg *);
-
-typedef void* tsdbReaderT;
-
-/**
- * Get the data block iterator, starting from position according to the query condition
- *
- * @param tsdb       tsdb handle
- * @param pCond      query condition, including time window, result set order, and basic required columns for each block
- * @param tableInfoGroup  table object list in the form of set, grouped into different sets according to the
- *                        group by condition
- * @param qinfo      query info handle from query processor
- * @return
- */
-tsdbReaderT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId, uint64_t taskId);
-
-/**
- * Get the last row of the given query time window for all the tables in STableGroupInfo object.
- * Note that only one data block with only row will be returned while invoking retrieve data block function for
- * all tables in this group.
- *
- * @param tsdb   tsdb handle
- * @param pCond  query condition, including time window, result set order, and basic required columns for each block
- * @param tableInfo  table list.
- * @return
- */
-//tsdbReaderT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
-//                                  SMemRef *pRef);
-
-
-tsdbReaderT tsdbQueryCacheLast(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, void* pMemRef);
-
-int32_t tsdbGetFileBlocksDistInfo(tsdbReaderT* pReader, STableBlockDistInfo* pTableBlockInfo);
-
-bool isTsdbCacheLastRow(tsdbReaderT* pReader);
-
-/**
- *
- * @param tsdb
- * @param uid
- * @param skey
- * @param pTagCond
- * @param len
- * @param tagNameRelType
- * @param tbnameCond
- * @param pGroupInfo
- * @param pColIndex
- * @param numOfCols
- * @param reqId
- * @return
- */
-int32_t tsdbQuerySTableByTagCond(void* pMeta, uint64_t uid, TSKEY skey, const char* pTagCond, size_t len,
-                                 int16_t tagNameRelType, const char* tbnameCond, STableGroupInfo* pGroupInfo,
-                                 SColIndex* pColIndex, int32_t numOfCols, uint64_t reqId, uint64_t taskId);
-/**
- * get num of rows in mem table
- *
- * @param pHandle
- * @return row size
- */
-
-int64_t tsdbGetNumOfRowsInMemTable(tsdbReaderT* pHandle);
-
-/**
- * move to next block if exists
- *
- * @param pTsdbReadHandle
- * @return
- */
-bool tsdbNextDataBlock(tsdbReaderT pTsdbReadHandle);
-
-/**
- * Get current data block information
- *
- * @param pTsdbReadHandle
- * @param pBlockInfo
- * @return
- */
-void tsdbRetrieveDataBlockInfo(tsdbReaderT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
-
-/**
- *
- * Get the pre-calculated information w.r.t. current data block.
- *
- * In case of data block in cache, the pBlockStatis will always be NULL.
- * If a block is not completed loaded from disk, the pBlockStatis will be NULL.
-
- * @pBlockStatis the pre-calculated value for current data blocks. if the block is a cache block, always return 0
- * @return
- */
-int32_t tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SDataStatis **pBlockStatis);
-
-/**
- *
- * The query condition with primary timestamp is passed to iterator during its constructor function,
- * the returned data block must be satisfied with the time window condition in any cases,
- * which means the SData data block is not actually the completed disk data blocks.
- *
- * @param pTsdbReadHandle      query handle
- * @param pColumnIdList     required data columns id list
- * @return
- */
-SArray *tsdbRetrieveDataBlock(tsdbReaderT *pTsdbReadHandle, SArray *pColumnIdList);
-
-/**
- * destroy the created table group list, which is generated by tag query
- * @param pGroupList
- */
-void tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
-
-/**
- * create the table group result including only one table, used to handle the normal table query
- *
- * @param tsdb        tsdbHandle
- * @param uid         table uid
- * @param pGroupInfo  the generated result
- * @return
- */
-int32_t tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
-
-/**
- *
- * @param tsdb
- * @param pTableIdList
- * @param pGroupInfo
- * @return
- */
-int32_t tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
-
-/**
- * clean up the query handle
- * @param queryHandle
- */
-void tsdbCleanupReadHandle(tsdbReaderT queryHandle);
-
-int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
-
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/vnode/src/tsdb/tsdbOptions.c b/source/dnode/vnode/src/tsdb/tsdbOptions.c
index da7a1d393f..2c57a7406e 100644
--- a/source/dnode/vnode/src/tsdb/tsdbOptions.c
+++ b/source/dnode/vnode/src/tsdb/tsdbOptions.c
@@ -26,15 +26,6 @@ const STsdbCfg defautlTsdbOptions = {.precision = 0,
                                      .update = 0,
                                      .compression = TWO_STAGE_COMP};
 
-int tsdbOptionsInit(STsdbCfg *pTsdbOptions) {
-  // TODO
-  return 0;
-}
-
-void tsdbOptionsClear(STsdbCfg *pTsdbOptions) {
-  // TODO
-}
-
 int tsdbValidateOptions(const STsdbCfg *pTsdbOptions) {
   // TODO
   return 0;
diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c
index 4a70738e86..ef417cabc6 100644
--- a/source/dnode/vnode/src/vnd/vnodeCfg.c
+++ b/source/dnode/vnode/src/vnd/vnodeCfg.c
@@ -18,13 +18,6 @@
 const SVnodeCfg defaultVnodeOptions = {
     .wsize = 96 * 1024 * 1024, .ssize = 1 * 1024 * 1024, .lsize = 1024, .walCfg = {.level = TAOS_WAL_WRITE}}; /* TODO */
 
-void vnodeOptionsInit(SVnodeCfg *pVnodeOptions) { /* TODO */
-  vnodeOptionsCopy(pVnodeOptions, &defaultVnodeOptions);
-}
-
-void vnodeOptionsClear(SVnodeCfg *pVnodeOptions) { /* TODO */
-}
-
 int vnodeValidateOptions(const SVnodeCfg *pVnodeOptions) {
   // TODO
   return 0;
@@ -36,14 +29,14 @@ void vnodeOptionsCopy(SVnodeCfg *pDest, const SVnodeCfg *pSrc) {
 
 int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName) {
   uint32_t hashValue = 0;
-  
+
   switch (pVnodeOptions->hashMethod) {
     default:
       hashValue = MurmurHash3_32(tableFName, strlen(tableFName));
       break;
   }
 
-  // TODO OPEN THIS !!!!!!!
+    // TODO OPEN THIS !!!!!!!
 #if 0
   if (hashValue < pVnodeOptions->hashBegin || hashValue > pVnodeOptions->hashEnd) {
     terrno = TSDB_CODE_VND_HASH_MISMATCH;
@@ -53,5 +46,3 @@ int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName) {
 
   return TSDB_CODE_SUCCESS;
 }
-
-

From 272d0ec74adefc02b963d734a156b5b1b1215292 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Thu, 14 Apr 2022 02:10:56 +0000
Subject: [PATCH 09/11] refact vnode

---
 source/dnode/vnode/inc/vnode.h     | 193 +++++++++++------------------
 source/dnode/vnode/src/tq/tqRead.c |  40 +++++-
 2 files changed, 113 insertions(+), 120 deletions(-)

diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 40be3f1299..80fcde0f70 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -35,21 +35,13 @@
 extern "C" {
 #endif
 
-// types
-typedef struct SVnode         SVnode;
-typedef struct SMetaCfg       SMetaCfg;  // todo: remove
-typedef struct STsdbCfg       STsdbCfg;  // todo: remove
-typedef struct STqCfg         STqCfg;    // todo: remove
-typedef struct SVnodeCfg      SVnodeCfg;
-typedef struct STqReadHandle  STqReadHandle;
-typedef struct SMTbCursor     SMTbCursor;   // todo: remove
-typedef struct SMCtbCursor    SMCtbCursor;  // todo: remove
-typedef struct SMSmaCursor    SMSmaCursor;  // todo: remove
-typedef void                 *tsdbReaderT;
-typedef struct STsdbQueryCond STsdbQueryCond;
-typedef struct SDataStatis    SDataStatis;
-
 // vnode
+typedef struct SVnode    SVnode;
+typedef struct SMetaCfg  SMetaCfg;  // todo: remove
+typedef struct STsdbCfg  STsdbCfg;  // todo: remove
+typedef struct STqCfg    STqCfg;    // todo: remove
+typedef struct SVnodeCfg SVnodeCfg;
+
 int     vnodeInit();
 void    vnodeCleanup();
 SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg);
@@ -65,12 +57,59 @@ int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);
 int32_t vnodeCompact(SVnode *pVnode);
 int32_t vnodeSync(SVnode *pVnode);
 int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
+int     vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName);
 
 // meta
-typedef struct SMeta SMeta;  // todo: remove
+typedef struct SMeta       SMeta;        // todo: remove
+typedef struct SMTbCursor  SMTbCursor;   // todo: remove
+typedef struct SMCtbCursor SMCtbCursor;  // todo: remove
+typedef struct SMSmaCursor SMSmaCursor;  // todo: remove
+
+#define META_SUPER_TABLE  TD_SUPER_TABLE
+#define META_CHILD_TABLE  TD_CHILD_TABLE
+#define META_NORMAL_TABLE TD_NORMAL_TABLE
+
+typedef SVCreateTbReq   STbCfg;
+typedef SVCreateTSmaReq SSmaCfg;
+
+SMeta          *metaOpen(const char *path, const SMetaCfg *pMetaCfg, SMemAllocatorFactory *pMAF);
+void            metaClose(SMeta *pMeta);
+void            metaRemove(const char *path);
+int             metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg);
+int             metaDropTable(SMeta *pMeta, tb_uid_t uid);
+int             metaCommit(SMeta *pMeta);
+int32_t         metaCreateTSma(SMeta *pMeta, SSmaCfg *pCfg);
+int32_t         metaDropTSma(SMeta *pMeta, int64_t indexUid);
+STbCfg         *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid);
+STbCfg         *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid);
+SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline);
+STSchema       *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver);
+void           *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid, bool isDecode);
+STSmaWrapper   *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid);
+SArray         *metaGetSmaTbUids(SMeta *pMeta, bool isDup);
+int             metaGetTbNum(SMeta *pMeta);
+SMTbCursor     *metaOpenTbCursor(SMeta *pMeta);
+void            metaCloseTbCursor(SMTbCursor *pTbCur);
+char           *metaTbCursorNext(SMTbCursor *pTbCur);
+SMCtbCursor    *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid);
+void            metaCloseCtbCurosr(SMCtbCursor *pCtbCur);
+tb_uid_t        metaCtbCursorNext(SMCtbCursor *pCtbCur);
+
+SMSmaCursor *metaOpenSmaCursor(SMeta *pMeta, tb_uid_t uid);
+void         metaCloseSmaCursor(SMSmaCursor *pSmaCur);
+int64_t      metaSmaCursorNext(SMSmaCursor *pSmaCur);
 
 // tsdb
-typedef struct STsdb STsdb;
+typedef struct STsdb          STsdb;
+typedef struct SDataStatis    SDataStatis;
+typedef struct STsdbQueryCond STsdbQueryCond;
+typedef void                 *tsdbReaderT;
+
+#define BLOCK_LOAD_OFFSET_SEQ_ORDER 1
+#define BLOCK_LOAD_TABLE_SEQ_ORDER  2
+#define BLOCK_LOAD_TABLE_RR_ORDER   3
+#define TABLE_TID(t)                (t)->tid
+#define TABLE_UID(t)                (t)->uid
 
 tsdbReaderT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
                              uint64_t taskId);
@@ -92,6 +131,23 @@ int32_t      tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STab
 void         tsdbCleanupReadHandle(tsdbReaderT queryHandle);
 
 // tq
+enum {
+  TQ_STREAM_TOKEN__DATA = 1,
+  TQ_STREAM_TOKEN__WATERMARK,
+  TQ_STREAM_TOKEN__CHECKPOINT,
+};
+
+typedef struct STqReadHandle STqReadHandle;
+
+STqReadHandle *tqInitSubmitMsgScanner(SMeta *pMeta);
+
+void    tqReadHandleSetColIdList(STqReadHandle *pReadHandle, SArray *pColIdList);
+int     tqReadHandleSetTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
+int     tqReadHandleAddTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
+int32_t tqReadHandleSetMsg(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
+bool    tqNextDataBlock(STqReadHandle *pHandle);
+int     tqRetrieveDataBlockInfo(STqReadHandle *pHandle, SDataBlockInfo *pBlockInfo);
+SArray *tqRetrieveDataBlock(STqReadHandle *pHandle);
 
 // need to remove
 int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
@@ -159,16 +215,9 @@ struct STqReadHandle {
 // ---------------------------- OLD ----------------------------
 typedef struct SMgmtWrapper SMgmtWrapper;
 
-#define META_SUPER_TABLE  TD_SUPER_TABLE
-#define META_CHILD_TABLE  TD_CHILD_TABLE
-#define META_NORMAL_TABLE TD_NORMAL_TABLE
-
 // Types exported
 
-typedef SVCreateTbReq   STbCfg;
-typedef SVCreateTSmaReq SSmaCfg;
-
-typedef struct SDataStatis {
+struct SDataStatis {
   int16_t colId;
   int16_t maxIndex;
   int16_t minIndex;
@@ -176,7 +225,7 @@ typedef struct SDataStatis {
   int64_t sum;
   int64_t max;
   int64_t min;
-} SDataStatis;
+};
 
 struct STsdbQueryCond {
   STimeWindow  twindow;
@@ -198,24 +247,8 @@ typedef struct STable {
   STSchema *pSchema;
 } STable;
 
-#define BLOCK_LOAD_OFFSET_SEQ_ORDER 1
-#define BLOCK_LOAD_TABLE_SEQ_ORDER  2
-#define BLOCK_LOAD_TABLE_RR_ORDER   3
-
-#define TABLE_TID(t) (t)->tid
-#define TABLE_UID(t) (t)->uid
-
-/* ------------------------ SVnode ------------------------ */
-int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName);
-
 /* ------------------------ FOR COMPILE ------------------------ */
 
-enum {
-  TQ_STREAM_TOKEN__DATA = 1,
-  TQ_STREAM_TOKEN__WATERMARK,
-  TQ_STREAM_TOKEN__CHECKPOINT,
-};
-
 typedef struct {
   int8_t type;
   int8_t reserved[7];
@@ -226,85 +259,7 @@ typedef struct {
   };
 } STqStreamToken;
 
-STqReadHandle *tqInitSubmitMsgScanner(SMeta *pMeta);
-
-static FORCE_INLINE void tqReadHandleSetColIdList(STqReadHandle *pReadHandle, SArray *pColIdList) {
-  pReadHandle->pColIdList = pColIdList;
-}
-
-// static FORCE_INLINE void tqReadHandleSetTbUid(STqReadHandle* pHandle, int64_t tbUid) {
-// pHandle->tbUid = tbUid;
-//}
-
-static FORCE_INLINE int tqReadHandleSetTbUidList(STqReadHandle *pHandle, const SArray *tbUidList) {
-  if (pHandle->tbIdHash) {
-    taosHashClear(pHandle->tbIdHash);
-  }
-
-  pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
-  if (pHandle->tbIdHash == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  for (int i = 0; i < taosArrayGetSize(tbUidList); i++) {
-    int64_t *pKey = (int64_t *)taosArrayGet(tbUidList, i);
-    taosHashPut(pHandle->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
-  }
-
-  return 0;
-}
-
-static FORCE_INLINE int tqReadHandleAddTbUidList(STqReadHandle *pHandle, const SArray *tbUidList) {
-  if (pHandle->tbIdHash == NULL) {
-    pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
-    if (pHandle->tbIdHash == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-  }
-
-  for (int i = 0; i < taosArrayGetSize(tbUidList); i++) {
-    int64_t *pKey = (int64_t *)taosArrayGet(tbUidList, i);
-    taosHashPut(pHandle->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
-  }
-
-  return 0;
-}
-
-int32_t tqReadHandleSetMsg(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
-bool    tqNextDataBlock(STqReadHandle *pHandle);
-int     tqRetrieveDataBlockInfo(STqReadHandle *pHandle, SDataBlockInfo *pBlockInfo);
-// return SArray<SColumnInfoData>
-SArray *tqRetrieveDataBlock(STqReadHandle *pHandle);
-
 // meta.h
-SMeta          *metaOpen(const char *path, const SMetaCfg *pMetaCfg, SMemAllocatorFactory *pMAF);
-void            metaClose(SMeta *pMeta);
-void            metaRemove(const char *path);
-int             metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg);
-int             metaDropTable(SMeta *pMeta, tb_uid_t uid);
-int             metaCommit(SMeta *pMeta);
-int32_t         metaCreateTSma(SMeta *pMeta, SSmaCfg *pCfg);
-int32_t         metaDropTSma(SMeta *pMeta, int64_t indexUid);
-STbCfg         *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid);
-STbCfg         *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid);
-SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline);
-STSchema       *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver);
-void           *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid, bool isDecode);
-STSmaWrapper   *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid);
-SArray         *metaGetSmaTbUids(SMeta *pMeta, bool isDup);
-int             metaGetTbNum(SMeta *pMeta);
-SMTbCursor     *metaOpenTbCursor(SMeta *pMeta);
-void            metaCloseTbCursor(SMTbCursor *pTbCur);
-char           *metaTbCursorNext(SMTbCursor *pTbCur);
-SMCtbCursor    *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid);
-void            metaCloseCtbCurosr(SMCtbCursor *pCtbCur);
-tb_uid_t        metaCtbCursorNext(SMCtbCursor *pCtbCur);
-
-SMSmaCursor *metaOpenSmaCursor(SMeta *pMeta, tb_uid_t uid);
-void         metaCloseSmaCursor(SMSmaCursor *pSmaCur);
-int64_t      metaSmaCursorNext(SMSmaCursor *pSmaCur);
 
 // Options
 void metaOptionsInit(SMetaCfg *pMetaCfg);
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index c69f8ce09a..21dc6e35e8 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -88,7 +88,7 @@ int tqRetrieveDataBlockInfo(STqReadHandle* pHandle, SDataBlockInfo* pBlockInfo)
 
   pBlockInfo->numOfCols = taosArrayGetSize(pHandle->pColIdList);
   pBlockInfo->rows = pHandle->pBlock->numOfRows;
-//  pBlockInfo->uid = pHandle->pBlock->uid; // the uid can not be assigned to pBlockData.
+  //  pBlockInfo->uid = pHandle->pBlock->uid; // the uid can not be assigned to pBlockData.
   return 0;
 }
 
@@ -177,3 +177,41 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
   }
   return pArray;
 }
+
+void tqReadHandleSetColIdList(STqReadHandle* pReadHandle, SArray* pColIdList) { pReadHandle->pColIdList = pColIdList; }
+
+int tqReadHandleSetTbUidList(STqReadHandle* pHandle, const SArray* tbUidList) {
+  if (pHandle->tbIdHash) {
+    taosHashClear(pHandle->tbIdHash);
+  }
+
+  pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
+  if (pHandle->tbIdHash == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  for (int i = 0; i < taosArrayGetSize(tbUidList); i++) {
+    int64_t* pKey = (int64_t*)taosArrayGet(tbUidList, i);
+    taosHashPut(pHandle->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
+  }
+
+  return 0;
+}
+
+int tqReadHandleAddTbUidList(STqReadHandle* pHandle, const SArray* tbUidList) {
+  if (pHandle->tbIdHash == NULL) {
+    pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
+    if (pHandle->tbIdHash == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+  }
+
+  for (int i = 0; i < taosArrayGetSize(tbUidList); i++) {
+    int64_t* pKey = (int64_t*)taosArrayGet(tbUidList, i);
+    taosHashPut(pHandle->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
+  }
+
+  return 0;
+}

From 10b8756c6bdabd45e598359dfefe0f47bcb921f2 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Thu, 14 Apr 2022 02:13:47 +0000
Subject: [PATCH 10/11] refact vnode

---
 source/dnode/vnode/inc/vnode.h        | 83 ++++++---------------------
 source/dnode/vnode/src/meta/metaCfg.c |  5 --
 2 files changed, 17 insertions(+), 71 deletions(-)

diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 80fcde0f70..29ed075030 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -110,7 +110,16 @@ typedef void                 *tsdbReaderT;
 #define BLOCK_LOAD_TABLE_RR_ORDER   3
 #define TABLE_TID(t)                (t)->tid
 #define TABLE_UID(t)                (t)->uid
-
+STsdb  *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
+                 STfs *pTfs);
+void    tsdbClose(STsdb *);
+void    tsdbRemove(const char *path);
+int     tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp);
+int     tsdbPrepareCommit(STsdb *pTsdb);
+int     tsdbCommit(STsdb *pTsdb);
+int32_t tsdbInitSma(STsdb *pTsdb);
+int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg);
+int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg);
 tsdbReaderT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
                              uint64_t taskId);
 tsdbReaderT  tsdbQueryCacheLast(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId,
@@ -129,6 +138,10 @@ void         tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
 int32_t      tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
 int32_t      tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
 void         tsdbCleanupReadHandle(tsdbReaderT queryHandle);
+int32_t      tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
+int32_t      tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
+int32_t      tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
+int32_t      tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 
 // tq
 enum {
@@ -149,7 +162,9 @@ bool    tqNextDataBlock(STqReadHandle *pHandle);
 int     tqRetrieveDataBlockInfo(STqReadHandle *pHandle, SDataBlockInfo *pBlockInfo);
 SArray *tqRetrieveDataBlock(STqReadHandle *pHandle);
 
-// need to remove
+// need to reposition
+typedef struct SMgmtWrapper SMgmtWrapper;
+
 int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
 
 // structs
@@ -212,11 +227,6 @@ struct STqReadHandle {
   STSchema         *pSchema;
 };
 
-// ---------------------------- OLD ----------------------------
-typedef struct SMgmtWrapper SMgmtWrapper;
-
-// Types exported
-
 struct SDataStatis {
   int16_t colId;
   int16_t maxIndex;
@@ -247,8 +257,6 @@ typedef struct STable {
   STSchema *pSchema;
 } STable;
 
-/* ------------------------ FOR COMPILE ------------------------ */
-
 typedef struct {
   int8_t type;
   int8_t reserved[7];
@@ -259,63 +267,6 @@ typedef struct {
   };
 } STqStreamToken;
 
-// meta.h
-
-// Options
-void metaOptionsInit(SMetaCfg *pMetaCfg);
-void metaOptionsClear(SMetaCfg *pMetaCfg);
-
-// query condition to build multi-table data block iterator
-// STsdb
-STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
-                STfs *pTfs);
-void   tsdbClose(STsdb *);
-void   tsdbRemove(const char *path);
-int    tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp);
-int    tsdbPrepareCommit(STsdb *pTsdb);
-int    tsdbCommit(STsdb *pTsdb);
-
-int32_t tsdbInitSma(STsdb *pTsdb);
-int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg);
-int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg);
-/**
- * @brief When submit msg received, update the relative expired window synchronously.
- *
- * @param pTsdb
- * @param pMsg
- * @param version
- * @return int32_t
- */
-int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
-
-/**
- * @brief Insert tSma(Time-range-wise SMA) data from stream computing engine
- *
- * @param pTsdb
- * @param indexUid
- * @param msg
- * @return int32_t
- */
-int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
-
-/**
- * @brief Drop tSma data and local cache.
- *
- * @param pTsdb
- * @param indexUid
- * @return int32_t
- */
-int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
-
-/**
- * @brief Insert RSma(Rollup SMA) data.
- *
- * @param pTsdb
- * @param msg
- * @return int32_t
- */
-int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/vnode/src/meta/metaCfg.c b/source/dnode/vnode/src/meta/metaCfg.c
index a5fcb32698..371c20f157 100644
--- a/source/dnode/vnode/src/meta/metaCfg.c
+++ b/source/dnode/vnode/src/meta/metaCfg.c
@@ -18,11 +18,6 @@
 const SMetaCfg defaultMetaOptions = {.lruSize = 0};
 
 /* ------------------------ EXPOSED METHODS ------------------------ */
-void metaOptionsInit(SMetaCfg *pMetaOptions) { metaOptionsCopy(pMetaOptions, &defaultMetaOptions); }
-
-void metaOptionsClear(SMetaCfg *pMetaOptions) {
-  // TODO
-}
 
 int metaValidateOptions(const SMetaCfg *pMetaOptions) {
   // TODO

From bb6806b59e026c42614611dbb5402756d2358230 Mon Sep 17 00:00:00 2001
From: Hongze Cheng <hzcheng@taosdata.com>
Date: Thu, 14 Apr 2022 02:25:49 +0000
Subject: [PATCH 11/11] refact vnode

---
 source/dnode/vnode/inc/vnode.h            | 10 ----
 source/dnode/vnode/src/inc/meta.h         | 11 ++++
 source/dnode/vnode/src/inc/vnodeInt.h     |  6 +-
 source/dnode/vnode/src/meta/metaBDBImpl.c | 21 +++----
 source/dnode/vnode/src/meta/metaQuery.c   |  4 +-
 source/dnode/vnode/src/meta/metaTDBImpl.c | 70 +++++++++++------------
 source/dnode/vnode/src/meta/metaTbCfg.c   |  1 -
 source/dnode/vnode/src/meta/metaTbTag.c   |  4 +-
 source/dnode/vnode/src/tq/tq.c            |  3 -
 source/dnode/vnode/src/tq/tqCommit.c      |  2 +
 source/dnode/vnode/src/tq/tqMetaStore.c   | 10 ++--
 source/dnode/vnode/src/tq/tqRead.c        |  3 +-
 source/dnode/vnode/src/tsdb/tsdbBDBImpl.c |  6 +-
 source/dnode/vnode/src/tsdb/tsdbFS.c      | 50 ++++++++--------
 source/dnode/vnode/src/tsdb/tsdbRead.c    | 12 ----
 source/dnode/vnode/src/vnd/vnodeInt.c     |  1 -
 source/dnode/vnode/src/vnd/vnodeMgr.c     |  1 -
 source/dnode/vnode/src/vnd/vnodeQuery.c   |  1 -
 source/dnode/vnode/src/vnd/vnodeWrite.c   | 16 +++---
 19 files changed, 107 insertions(+), 125 deletions(-)

diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 29ed075030..6e85c4df64 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -72,16 +72,6 @@ typedef struct SMSmaCursor SMSmaCursor;  // todo: remove
 typedef SVCreateTbReq   STbCfg;
 typedef SVCreateTSmaReq SSmaCfg;
 
-SMeta          *metaOpen(const char *path, const SMetaCfg *pMetaCfg, SMemAllocatorFactory *pMAF);
-void            metaClose(SMeta *pMeta);
-void            metaRemove(const char *path);
-int             metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg);
-int             metaDropTable(SMeta *pMeta, tb_uid_t uid);
-int             metaCommit(SMeta *pMeta);
-int32_t         metaCreateTSma(SMeta *pMeta, SSmaCfg *pCfg);
-int32_t         metaDropTSma(SMeta *pMeta, int64_t indexUid);
-STbCfg         *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid);
-STbCfg         *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid);
 SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline);
 STSchema       *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver);
 void           *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid, bool isDecode);
diff --git a/source/dnode/vnode/src/inc/meta.h b/source/dnode/vnode/src/inc/meta.h
index b04364daf8..b3553f5d2d 100644
--- a/source/dnode/vnode/src/inc/meta.h
+++ b/source/dnode/vnode/src/inc/meta.h
@@ -24,6 +24,17 @@ typedef struct SMetaCache SMetaCache;
 typedef struct SMetaIdx   SMetaIdx;
 typedef struct SMetaDB    SMetaDB;
 
+SMeta*  metaOpen(const char* path, const SMetaCfg* pMetaCfg, SMemAllocatorFactory* pMAF);
+void    metaClose(SMeta* pMeta);
+void    metaRemove(const char* path);
+int     metaCreateTable(SMeta* pMeta, STbCfg* pTbCfg);
+int     metaDropTable(SMeta* pMeta, tb_uid_t uid);
+int     metaCommit(SMeta* pMeta);
+int32_t metaCreateTSma(SMeta* pMeta, SSmaCfg* pCfg);
+int32_t metaDropTSma(SMeta* pMeta, int64_t indexUid);
+STbCfg* metaGetTbInfoByUid(SMeta* pMeta, tb_uid_t uid);
+STbCfg* metaGetTbInfoByName(SMeta* pMeta, char* tbname, tb_uid_t* uid);
+
 // SMetaDB
 int  metaOpenDB(SMeta* pMeta);
 void metaCloseDB(SMeta* pMeta);
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 29a45723c4..7168493666 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -17,6 +17,9 @@
 #define _TD_VNODE_DEF_H_
 
 #include "executor.h"
+#include "filter.h"
+#include "qworker.h"
+#include "sync.h"
 #include "tchecksum.h"
 #include "tcoding.h"
 #include "tcompression.h"
@@ -25,14 +28,15 @@
 #include "tglobal.h"
 #include "tlist.h"
 #include "tlockfree.h"
+#include "tlosertree.h"
 #include "tmacro.h"
 #include "tmallocator.h"
 #include "tskiplist.h"
+#include "tstream.h"
 #include "ttime.h"
 #include "ttimer.h"
 #include "vnode.h"
 #include "wal.h"
-#include "qworker.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/source/dnode/vnode/src/meta/metaBDBImpl.c b/source/dnode/vnode/src/meta/metaBDBImpl.c
index a8270f746d..249e489029 100644
--- a/source/dnode/vnode/src/meta/metaBDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaBDBImpl.c
@@ -16,10 +16,7 @@
 #define ALLOW_FORBID_FUNC
 #include "db.h"
 
-#include "metaDef.h"
-
-#include "tcoding.h"
-#include "thash.h"
+#include "vnodeInt.h"
 
 #define IMPL_WITH_LOCK 1
 // #if IMPL_WITH_LOCK
@@ -262,7 +259,7 @@ int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
   return 0;
 }
 
-int metaRemoveSmaFromDb(SMeta *pMeta,  int64_t indexUid) {
+int metaRemoveSmaFromDb(SMeta *pMeta, int64_t indexUid) {
   // TODO
 #if 0
   DBT key = {0};
@@ -668,7 +665,7 @@ STbCfg *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid) {
 }
 
 void *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid, bool isDecode) {
-  STSma *  pCfg = NULL;
+  STSma   *pCfg = NULL;
   SMetaDB *pDB = pMeta->pDB;
   DBT      key = {0};
   DBT      value = {0};
@@ -711,9 +708,9 @@ static SSchemaWrapper *metaGetTableSchemaImpl(SMeta *pMeta, tb_uid_t uid, int32_
   int             ret;
   void           *pBuf;
   // SSchema        *pSchema;
-  SSchemaKey      schemaKey = {uid, sver, 0};
-  DBT             key = {0};
-  DBT             value = {0};
+  SSchemaKey schemaKey = {uid, sver, 0};
+  DBT        key = {0};
+  DBT        value = {0};
 
   // Set key/value properties
   key.data = &schemaKey;
@@ -761,14 +758,14 @@ SMTbCursor *metaOpenTbCursor(SMeta *pMeta) {
 }
 
 int metaGetTbNum(SMeta *pMeta) {
-  SMetaDB    *pDB = pMeta->pDB;
+  SMetaDB *pDB = pMeta->pDB;
 
   DB_BTREE_STAT *sp1;
   pDB->pTbDB->stat(pDB->pNtbIdx, NULL, &sp1, 0);
-  
+
   DB_BTREE_STAT *sp2;
   pDB->pTbDB->stat(pDB->pCtbIdx, NULL, &sp2, 0);
-  
+
   return sp1->bt_nkeys + sp2->bt_nkeys;
 }
 
diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c
index 6dea4a4e57..5022d0e050 100644
--- a/source/dnode/vnode/src/meta/metaQuery.c
+++ b/source/dnode/vnode/src/meta/metaQuery.c
@@ -11,4 +11,6 @@
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
\ No newline at end of file
+ */
+
+#include "vnodeInt.h"
\ No newline at end of file
diff --git a/source/dnode/vnode/src/meta/metaTDBImpl.c b/source/dnode/vnode/src/meta/metaTDBImpl.c
index 6f218ad72b..9b9f54b5ba 100644
--- a/source/dnode/vnode/src/meta/metaTDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaTDBImpl.c
@@ -15,7 +15,6 @@
 
 #include "vnodeInt.h"
 
-#include "tdbInt.h"
 typedef struct SPoolMem {
   int64_t          size;
   struct SPoolMem *prev;
@@ -27,18 +26,18 @@ typedef struct SPoolMem {
 static SPoolMem *openPool();
 static void      clearPool(SPoolMem *pPool);
 static void      closePool(SPoolMem *pPool);
-static void *    poolMalloc(void *arg, size_t size);
+static void     *poolMalloc(void *arg, size_t size);
 static void      poolFree(void *arg, void *ptr);
 
 struct SMetaDB {
   TXN       txn;
-  TENV *    pEnv;
-  TDB *     pTbDB;
-  TDB *     pSchemaDB;
-  TDB *     pNameIdx;
-  TDB *     pStbIdx;
-  TDB *     pNtbIdx;
-  TDB *     pCtbIdx;
+  TENV     *pEnv;
+  TDB      *pTbDB;
+  TDB      *pSchemaDB;
+  TDB      *pNameIdx;
+  TDB      *pStbIdx;
+  TDB      *pNtbIdx;
+  TDB      *pCtbIdx;
   SPoolMem *pPool;
 #ifdef META_TDB_SMA_TEST
   TDB *pSmaDB;
@@ -52,7 +51,7 @@ typedef struct __attribute__((__packed__)) {
 } SSchemaDbKey;
 
 typedef struct {
-  char *   name;
+  char    *name;
   tb_uid_t uid;
 } SNameIdxKey;
 
@@ -251,14 +250,14 @@ void metaCloseDB(SMeta *pMeta) {
 
 int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
   tb_uid_t       uid;
-  SMetaDB *      pMetaDb;
-  void *         pKey;
-  void *         pVal;
+  SMetaDB       *pMetaDb;
+  void          *pKey;
+  void          *pVal;
   int            kLen;
   int            vLen;
   int            ret;
   char           buf[512];
-  void *         pBuf;
+  void          *pBuf;
   SCtbIdxKey     ctbIdxKey;
   SSchemaDbKey   schemaDbKey;
   SSchemaWrapper schemaWrapper;
@@ -375,11 +374,11 @@ int metaRemoveTableFromDb(SMeta *pMeta, tb_uid_t uid) {
 STbCfg *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid) {
   int      ret;
   SMetaDB *pMetaDb = pMeta->pDB;
-  void *   pKey;
-  void *   pVal;
+  void    *pKey;
+  void    *pVal;
   int      kLen;
   int      vLen;
-  STbCfg * pTbCfg;
+  STbCfg  *pTbCfg;
 
   // Fetch
   pKey = &uid;
@@ -431,14 +430,14 @@ SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, boo
 }
 
 static SSchemaWrapper *metaGetTableSchemaImpl(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline, bool isGetEx) {
-  void *          pKey;
-  void *          pVal;
+  void           *pKey;
+  void           *pVal;
   int             kLen;
   int             vLen;
   int             ret;
   SSchemaDbKey    schemaDbKey;
   SSchemaWrapper *pSchemaWrapper;
-  void *          pBuf;
+  void           *pBuf;
 
   // fetch
   schemaDbKey.uid = uid;
@@ -465,9 +464,9 @@ STSchema *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver) {
   tb_uid_t        quid;
   SSchemaWrapper *pSW;
   STSchemaBuilder sb;
-  SSchemaEx *     pSchema;
-  STSchema *      pTSchema;
-  STbCfg *        pTbCfg;
+  SSchemaEx      *pSchema;
+  STSchema       *pTSchema;
+  STbCfg         *pTbCfg;
 
   pTbCfg = metaGetTbInfoByUid(pMeta, uid);
   if (pTbCfg->type == META_CHILD_TABLE) {
@@ -498,7 +497,7 @@ struct SMTbCursor {
 
 SMTbCursor *metaOpenTbCursor(SMeta *pMeta) {
   SMTbCursor *pTbCur = NULL;
-  SMetaDB *   pDB = pMeta->pDB;
+  SMetaDB    *pDB = pMeta->pDB;
 
   pTbCur = (SMTbCursor *)taosMemoryCalloc(1, sizeof(*pTbCur));
   if (pTbCur == NULL) {
@@ -520,12 +519,12 @@ void metaCloseTbCursor(SMTbCursor *pTbCur) {
 }
 
 char *metaTbCursorNext(SMTbCursor *pTbCur) {
-  void * pKey = NULL;
-  void * pVal = NULL;
+  void  *pKey = NULL;
+  void  *pVal = NULL;
   int    kLen;
   int    vLen;
   int    ret;
-  void * pBuf;
+  void  *pBuf;
   STbCfg tbCfg;
 
   for (;;) {
@@ -548,17 +547,17 @@ char *metaTbCursorNext(SMTbCursor *pTbCur) {
 }
 
 struct SMCtbCursor {
-  TDBC *   pCur;
+  TDBC    *pCur;
   tb_uid_t suid;
-  void *   pKey;
-  void *   pVal;
+  void    *pKey;
+  void    *pVal;
   int      kLen;
   int      vLen;
 };
 
 SMCtbCursor *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid) {
   SMCtbCursor *pCtbCur = NULL;
-  SMetaDB *    pDB = pMeta->pDB;
+  SMetaDB     *pDB = pMeta->pDB;
   int          ret;
 
   pCtbCur = (SMCtbCursor *)taosMemoryCalloc(1, sizeof(*pCtbCur));
@@ -654,7 +653,6 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
         continue;
       }
 
-
       ++pSW->number;
       STSma *tptr = (STSma *)taosMemoryRealloc(pSW->tSma, pSW->number * sizeof(STSma));
       if (tptr == NULL) {
@@ -709,10 +707,10 @@ int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
   // ASSERT(0);
 
 #ifdef META_TDB_SMA_TEST
-  int32_t ret = 0;
+  int32_t  ret = 0;
   SMetaDB *pMetaDb = pMeta->pDB;
-  void   *pBuf = NULL, *qBuf = NULL;
-  void   *key = {0}, *val = {0};
+  void    *pBuf = NULL, *qBuf = NULL;
+  void    *key = {0}, *val = {0};
 
   // save sma info
   int32_t len = tEncodeTSma(NULL, pSmaCfg);
@@ -1103,7 +1101,7 @@ static void closePool(SPoolMem *pPool) {
 }
 
 static void *poolMalloc(void *arg, size_t size) {
-  void *    ptr = NULL;
+  void     *ptr = NULL;
   SPoolMem *pPool = (SPoolMem *)arg;
   SPoolMem *pMem;
 
diff --git a/source/dnode/vnode/src/meta/metaTbCfg.c b/source/dnode/vnode/src/meta/metaTbCfg.c
index 8ecc808786..9d5012c17f 100644
--- a/source/dnode/vnode/src/meta/metaTbCfg.c
+++ b/source/dnode/vnode/src/meta/metaTbCfg.c
@@ -14,7 +14,6 @@
  */
 
 #include "vnodeInt.h"
-#include "tcoding.h"
 
 int metaValidateTbCfg(SMeta *pMeta, const STbCfg *pTbOptions) {
   // TODO
diff --git a/source/dnode/vnode/src/meta/metaTbTag.c b/source/dnode/vnode/src/meta/metaTbTag.c
index 6dea4a4e57..5022d0e050 100644
--- a/source/dnode/vnode/src/meta/metaTbTag.c
+++ b/source/dnode/vnode/src/meta/metaTbTag.c
@@ -11,4 +11,6 @@
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
\ No newline at end of file
+ */
+
+#include "vnodeInt.h"
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index f48262deba..f57103aab4 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -13,9 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tcompare.h"
-#include "tdatablock.h"
-#include "tstream.h"
 #include "vnodeInt.h"
 
 int32_t tqInit() { return tqPushMgrInit(); }
diff --git a/source/dnode/vnode/src/tq/tqCommit.c b/source/dnode/vnode/src/tq/tqCommit.c
index f2f48bbc8a..8e59243a9c 100644
--- a/source/dnode/vnode/src/tq/tqCommit.c
+++ b/source/dnode/vnode/src/tq/tqCommit.c
@@ -12,3 +12,5 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+
+#include "vnodeInt.h"
diff --git a/source/dnode/vnode/src/tq/tqMetaStore.c b/source/dnode/vnode/src/tq/tqMetaStore.c
index 84f12f93c6..357917e0ba 100644
--- a/source/dnode/vnode/src/tq/tqMetaStore.c
+++ b/source/dnode/vnode/src/tq/tqMetaStore.c
@@ -14,13 +14,13 @@
  */
 #include "vnodeInt.h"
 // TODO:replace by an abstract file layer
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include "osDir.h"
+// #include <fcntl.h>
+// #include <string.h>
+// #include <unistd.h>
+// #include "osDir.h"
 
 #define TQ_META_NAME "tq.meta"
-#define TQ_IDX_NAME "tq.idx"
+#define TQ_IDX_NAME  "tq.idx"
 
 static int32_t tqHandlePutCommitted(STqMetaStore*, int64_t key, void* value);
 static void*   tqHandleGetUncommitted(STqMetaStore*, int64_t key);
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index 21dc6e35e8..9282f7197e 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -13,8 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tdatablock.h"
-#include "vnode.h"
+#include "vnodeInt.h"
 
 STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) {
   STqReadHandle* pReadHandle = taosMemoryMalloc(sizeof(STqReadHandle));
diff --git a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
index 0deef2e4c9..acd9c2dcaa 100644
--- a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
+++ b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
@@ -16,9 +16,7 @@
 #define ALLOW_FORBID_FUNC
 #include "db.h"
 
-#include "taoserror.h"
-#include "tcoding.h"
-#include "thash.h"
+#include "vnodeInt.h"
 
 #define IMPL_WITH_LOCK 1
 
@@ -139,7 +137,7 @@ int32_t tsdbSaveSmaToDB(SDBFile *pDBF, void *key, uint32_t keySize, void *data,
   return 0;
 }
 
-void *tsdbGetSmaDataByKey(SDBFile *pDBF, void* key, uint32_t keySize, uint32_t *valueSize) {
+void *tsdbGetSmaDataByKey(SDBFile *pDBF, void *key, uint32_t keySize, uint32_t *valueSize) {
   void *result = NULL;
   DBT   key1 = {0};
   DBT   value1 = {0};
diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c
index eff350ddda..bd3888864d 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFS.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFS.c
@@ -13,9 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <regex.h>
 #include "vnodeInt.h"
-#include "os.h"
 
 typedef enum { TSDB_TXN_TEMP_FILE = 0, TSDB_TXN_CURR_FILE } TSDB_TXN_FILE_T;
 static const char *tsdbTxnFname[] = {"current.t", "current"};
@@ -97,8 +95,8 @@ static int tsdbEncodeDFileSetArray(void **buf, SArray *pArray) {
   return tlen;
 }
 
-static void *tsdbDecodeDFileSetArray(STsdb*pRepo, void *buf, SArray *pArray) {
-  uint64_t  nset = 0;
+static void *tsdbDecodeDFileSetArray(STsdb *pRepo, void *buf, SArray *pArray) {
+  uint64_t nset = 0;
 
   taosArrayClear(pArray);
 
@@ -122,7 +120,7 @@ static int tsdbEncodeFSStatus(void **buf, SFSStatus *pStatus) {
   return tlen;
 }
 
-static void *tsdbDecodeFSStatus(STsdb*pRepo, void *buf, SFSStatus *pStatus) {
+static void *tsdbDecodeFSStatus(STsdb *pRepo, void *buf, SFSStatus *pStatus) {
   tsdbResetFSStatus(pStatus);
 
   // pStatus->pmf = &(pStatus->mf);
@@ -407,8 +405,8 @@ int tsdbUpdateDFileSet(STsdbFS *pfs, const SDFileSet *pSet) { return tsdbAddDFil
 
 static int tsdbSaveFSStatus(STsdb *pRepo, SFSStatus *pStatus) {
   SFSHeader fsheader;
-  void *    pBuf = NULL;
-  void *    ptr;
+  void     *pBuf = NULL;
+  void     *ptr;
   char      hbuf[TSDB_FILE_HEAD_SIZE] = "\0";
   char      tfname[TSDB_FILENAME_LEN] = "\0";
   char      cfname[TSDB_FILENAME_LEN] = "\0";
@@ -592,7 +590,7 @@ void tsdbFSIterSeek(SFSIter *pIter, int fid) {
 }
 
 SDFileSet *tsdbFSIterNext(SFSIter *pIter) {
-  STsdbFS *  pfs = pIter->pfs;
+  STsdbFS   *pfs = pIter->pfs;
   SDFileSet *pSet;
 
   if (pIter->index < 0) {
@@ -651,12 +649,12 @@ static void tsdbGetTxnFname(STsdb *pRepo, TSDB_TXN_FILE_T ftype, char fname[]) {
 }
 
 static int tsdbOpenFSFromCurrent(STsdb *pRepo) {
-  STsdbFS * pfs = REPO_FS(pRepo);
+  STsdbFS  *pfs = REPO_FS(pRepo);
   TdFilePtr pFile = NULL;
-  void *    buffer = NULL;
+  void     *buffer = NULL;
   SFSHeader fsheader;
   char      current[TSDB_FILENAME_LEN] = "\0";
-  void *    ptr;
+  void     *ptr;
 
   tsdbGetTxnFname(pRepo, TSDB_TXN_CURR_FILE, current);
 
@@ -746,7 +744,7 @@ _err:
 
 // Scan and try to fix incorrect files
 static int tsdbScanAndTryFixFS(STsdb *pRepo) {
-  STsdbFS *  pfs = REPO_FS(pRepo);
+  STsdbFS   *pfs = REPO_FS(pRepo);
   SFSStatus *pStatus = pfs->cstatus;
 
   // if (tsdbScanAndTryFixMFile(pRepo) < 0) {
@@ -908,9 +906,9 @@ static int tsdbScanAndTryFixFS(STsdb *pRepo) {
 // }
 
 static int tsdbScanRootDir(STsdb *pRepo) {
-  char         rootDir[TSDB_FILENAME_LEN];
-  char         bname[TSDB_FILENAME_LEN];
-  STsdbFS *    pfs = REPO_FS(pRepo);
+  char            rootDir[TSDB_FILENAME_LEN];
+  char            bname[TSDB_FILENAME_LEN];
+  STsdbFS        *pfs = REPO_FS(pRepo);
   const STfsFile *pf;
 
   tsdbGetRootDir(REPO_ID(pRepo), rootDir);
@@ -942,9 +940,9 @@ static int tsdbScanRootDir(STsdb *pRepo) {
 }
 
 static int tsdbScanDataDir(STsdb *pRepo) {
-  char         dataDir[TSDB_FILENAME_LEN];
-  char         bname[TSDB_FILENAME_LEN];
-  STsdbFS *    pfs = REPO_FS(pRepo);
+  char            dataDir[TSDB_FILENAME_LEN];
+  char            bname[TSDB_FILENAME_LEN];
+  STsdbFS        *pfs = REPO_FS(pRepo);
   const STfsFile *pf;
 
   tsdbGetDataDir(REPO_ID(pRepo), dataDir);
@@ -1107,14 +1105,14 @@ static bool tsdbIsTFileInFS(STsdbFS *pfs, const STfsFile *pf) {
 // }
 
 static int tsdbRestoreDFileSet(STsdb *pRepo) {
-  char         dataDir[TSDB_FILENAME_LEN];
-  char         bname[TSDB_FILENAME_LEN];
-  STfsDir *       tdir = NULL;
+  char            dataDir[TSDB_FILENAME_LEN];
+  char            bname[TSDB_FILENAME_LEN];
+  STfsDir        *tdir = NULL;
   const STfsFile *pf = NULL;
-  const char * pattern = "^v[0-9]+f[0-9]+\\.(head|data|last|smad|smal)(-ver[0-9]+)?$";
-  SArray *     fArray = NULL;
-  regex_t      regex;
-  STsdbFS *    pfs = REPO_FS(pRepo);
+  const char     *pattern = "^v[0-9]+f[0-9]+\\.(head|data|last|smad|smal)(-ver[0-9]+)?$";
+  SArray         *fArray = NULL;
+  regex_t         regex;
+  STsdbFS        *pfs = REPO_FS(pRepo);
 
   tsdbGetDataDir(REPO_ID(pRepo), dataDir);
 
@@ -1327,7 +1325,7 @@ static int tsdbComparTFILE(const void *arg1, const void *arg2) {
 }
 
 static void tsdbScanAndTryFixDFilesHeader(STsdb *pRepo, int32_t *nExpired) {
-  STsdbFS *  pfs = REPO_FS(pRepo);
+  STsdbFS   *pfs = REPO_FS(pRepo);
   SFSStatus *pStatus = pfs->cstatus;
   SDFInfo    info;
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 550e7cd183..9509dfa462 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -13,18 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
-#include "talgo.h"
-#include "tcompare.h"
-#include "tdatablock.h"
-#include "tdataformat.h"
-#include "texception.h"
-#include "vnodeInt.h"
-
-#include "filter.h"
-#include "taosdef.h"
-#include "tlosertree.h"
-#include "tmsg.h"
 #include "vnodeInt.h"
 
 #define EXTRA_BYTES                2
diff --git a/source/dnode/vnode/src/vnd/vnodeInt.c b/source/dnode/vnode/src/vnd/vnodeInt.c
index 24294c4b58..270dc377b9 100644
--- a/source/dnode/vnode/src/vnd/vnodeInt.c
+++ b/source/dnode/vnode/src/vnd/vnodeInt.c
@@ -14,7 +14,6 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "sync.h"
 #include "vnodeInt.h"
 // #include "vnodeInt.h"
 
diff --git a/source/dnode/vnode/src/vnd/vnodeMgr.c b/source/dnode/vnode/src/vnd/vnodeMgr.c
index 40f43bcd12..df5e2ceffa 100644
--- a/source/dnode/vnode/src/vnd/vnodeMgr.c
+++ b/source/dnode/vnode/src/vnd/vnodeMgr.c
@@ -14,7 +14,6 @@
  */
 
 #include "vnodeInt.h"
-#include "tglobal.h"
 
 SVnodeMgr vnodeMgr = {.vnodeInitFlag = TD_MOD_UNINITIALIZED};
 
diff --git a/source/dnode/vnode/src/vnd/vnodeQuery.c b/source/dnode/vnode/src/vnd/vnodeQuery.c
index f56ded9f15..965dff59e1 100644
--- a/source/dnode/vnode/src/vnd/vnodeQuery.c
+++ b/source/dnode/vnode/src/vnd/vnodeQuery.c
@@ -13,7 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "executor.h"
 #include "vnodeInt.h"
 
 static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg);
diff --git a/source/dnode/vnode/src/vnd/vnodeWrite.c b/source/dnode/vnode/src/vnd/vnodeWrite.c
index 0449319dc2..24b5d4bae5 100644
--- a/source/dnode/vnode/src/vnd/vnodeWrite.c
+++ b/source/dnode/vnode/src/vnd/vnodeWrite.c
@@ -81,7 +81,7 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       // TODO: to encapsule a free API
       taosMemoryFree(vCreateTbReq.stbCfg.pSchema);
       taosMemoryFree(vCreateTbReq.stbCfg.pTagSchema);
-      if(vCreateTbReq.stbCfg.pRSmaParam) {
+      if (vCreateTbReq.stbCfg.pRSmaParam) {
         taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->pFuncIds);
         taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam);
       }
@@ -235,13 +235,13 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       if (tsdbCreateTSma(pVnode->pTsdb, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead))) < 0) {
         // TODO
       }
-    // } break;
-    // case TDMT_VND_CANCEL_SMA: {  // timeRangeSMA
-    // } break;
-    // case TDMT_VND_DROP_SMA: {  // timeRangeSMA
-    //   if (tsdbDropTSma(pVnode->pTsdb, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead))) < 0) {
-    //     // TODO
-    //   }
+      // } break;
+      // case TDMT_VND_CANCEL_SMA: {  // timeRangeSMA
+      // } break;
+      // case TDMT_VND_DROP_SMA: {  // timeRangeSMA
+      //   if (tsdbDropTSma(pVnode->pTsdb, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead))) < 0) {
+      //     // TODO
+      //   }
 #if 0    
       tsdbTSmaSub(pVnode->pTsdb, 1);
       SVDropTSmaReq vDropSmaReq = {0};