From 591f36f3254ecd14ea0dc83bfa56e6fd31427e75 Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Thu, 3 Sep 2020 18:32:06 +0800
Subject: [PATCH 01/21] td-804: fix infinite SQL parse retry

---
 src/client/inc/tsclient.h       |  1 +
 src/client/src/tscAsync.c       |  1 +
 src/client/src/tscParseInsert.c | 12 ++++--------
 3 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 78544b9b99..5f4a46ddad 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -348,6 +348,7 @@ typedef struct SSqlObj {
   void *           pStream;
   void *           pSubscription;
   char *           sqlstr;
+  char             parseRetry;
   char             retry;
   char             maxRetry;
   SRpcEpSet        epSet;
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 650f101645..d07089539a 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -43,6 +43,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
   pSql->signature = pSql;
   pSql->param     = param;
   pSql->pTscObj   = pObj;
+  pSql->parseRetry= 0;
   pSql->maxRetry  = TSDB_MAX_REPLICA;
   pSql->fp        = fp;
   pSql->fetchFp   = fp;
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 7f8fd7f4fe..09eb8f167e 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1335,13 +1335,13 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
     // make a backup as tsParseInsertSql may modify the string
     char* sqlstr = strdup(pSql->sqlstr);
     ret = tsParseInsertSql(pSql);
-    if (sqlstr == NULL || pSql->retry >= 1 || ret != TSDB_CODE_TSC_INVALID_SQL) {
+    if (sqlstr == NULL || pSql->parseRetry >= 1 || ret != TSDB_CODE_TSC_INVALID_SQL) {
       free(sqlstr);
     } else {
       tscResetSqlCmdObj(pCmd, true);
       free(pSql->sqlstr);
       pSql->sqlstr = sqlstr;
-      pSql->retry++;
+      pSql->parseRetry++;
       if ((ret = tsInsertInitialCheck(pSql)) == TSDB_CODE_SUCCESS) {
         ret = tsParseInsertSql(pSql);
       }
@@ -1349,18 +1349,14 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
   } else {
     SSqlInfo SQLInfo = qSQLParse(pSql->sqlstr);
     ret = tscToSQLCmd(pSql, &SQLInfo);
-    if (ret == TSDB_CODE_TSC_INVALID_SQL && pSql->retry == 0 && SQLInfo.type == TSDB_SQL_NULL) {
+    if (ret == TSDB_CODE_TSC_INVALID_SQL && pSql->parseRetry == 0 && SQLInfo.type == TSDB_SQL_NULL) {
       tscResetSqlCmdObj(pCmd, true);
-      pSql->retry++;
+      pSql->parseRetry++;
       ret = tscToSQLCmd(pSql, &SQLInfo);
     }
     SQLInfoDestroy(&SQLInfo);
   }
 
-  if (ret == TSDB_CODE_SUCCESS) {
-    pSql->retry = 0;
-  }
-
   /*
    * the pRes->code may be modified or released by another thread in tscTableMetaCallBack function,
    * so do NOT use pRes->code to determine if the getTableMeta function

From 39e55b20218ba7dcf6c9bd8a7eb04841eea1a4cf Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 10:33:57 +0800
Subject: [PATCH 02/21] [td-1315]

---
 src/util/src/tcache.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index e5526647cb..281576b507 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -364,16 +364,22 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
      * that tries to do the same thing.
      */
     if (inTrashCan) {
-      ref = T_REF_DEC(pNode);
+      ref = T_REF_VAL_GET(pNode);
 
-      if (ref == 0) {
+      if (ref == 1) {  // it is the last ref,
         assert(pNode->pTNodeHeader->pData == pNode);
 
         __cache_wr_lock(pCacheObj);
         doRemoveElemInTrashcan(pCacheObj, pNode->pTNodeHeader);
         __cache_unlock(pCacheObj);
 
+        ref = T_REF_DEC(pNode);
+        assert(ref == 0);
+
         doDestroyTrashcanElem(pCacheObj, pNode->pTNodeHeader);
+      } else {
+        ref = T_REF_DEC(pNode);
+        assert(ref > 0);
       }
     } else {
       // NOTE: remove it from hash in the first place, otherwise, the pNode may have been released by other thread

From 510be650285947921ee1d98f69aef6e0099b975e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 11:50:57 +0800
Subject: [PATCH 03/21] [td-1315]

---
 src/util/src/tcache.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 281576b507..e440e70b06 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -366,7 +366,9 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     if (inTrashCan) {
       ref = T_REF_VAL_GET(pNode);
 
-      if (ref == 1) {  // it is the last ref,
+      if (ref == 1) {
+        // If it is the last ref, remove it from trashcan linked-list first, and then destroy it.Otherwise, it may be
+        // destroyed by refresh worker if decrease ref count before removing it from linked-list.
         assert(pNode->pTNodeHeader->pData == pNode);
 
         __cache_wr_lock(pCacheObj);
@@ -379,7 +381,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
         doDestroyTrashcanElem(pCacheObj, pNode->pTNodeHeader);
       } else {
         ref = T_REF_DEC(pNode);
-        assert(ref > 0);
+        assert(ref >= 0);
       }
     } else {
       // NOTE: remove it from hash in the first place, otherwise, the pNode may have been released by other thread

From bf8c9f7df3265154d25453f9b2b9c71b8a528ba6 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 13:20:56 +0800
Subject: [PATCH 04/21] [td-225]

---
 src/util/src/tcache.c | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index e440e70b06..c34e9536a5 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -98,7 +98,7 @@ static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheDataNo
   int32_t size = (int32_t)taosHashGetSize(pCacheObj->pHashTable);
   assert(size > 0);
 
-  uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
+  uError("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
          pCacheObj->name, pNode->key, pNode->data, pNode->size, size - 1, pCacheObj->totalSize);
 
   if (pCacheObj->freeFp) {
@@ -205,7 +205,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
   int32_t succ = taosHashPut(pCacheObj->pHashTable, key, keyLen, &pNode1, sizeof(void *));
   if (succ == 0) {
     atomic_add_fetch_64(&pCacheObj->totalSize, pNode1->size);
-    uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
+    uError("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
            ", totalNum:%d totalSize:%" PRId64 "bytes size:%" PRId64 "bytes",
            pCacheObj->name, key, pNode1->data, pNode1->addedTime, pNode1->expireTime,
            (int32_t)taosHashGetSize(pCacheObj->pHashTable), pCacheObj->totalSize, (int64_t)dataSize);
@@ -224,7 +224,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
           taosTFree(p);
         } else {
           taosAddToTrash(pCacheObj, p);
-          uDebug("cache:%s, key:%p, %p exist in cache, updated old:%p", pCacheObj->name, key, pNode1->data, p);
+          uError("cache:%s, key:%p, %p exist in cache, updated old:%p", pCacheObj->name, key, pNode1->data, p);
         }
       }
 
@@ -234,7 +234,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
       if (ret == 0) {
         atomic_add_fetch_64(&pCacheObj->totalSize, pNode1->size);
 
-        uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
+        uError("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
                ", totalNum:%d totalSize:%" PRId64 "bytes size:%" PRId64 "bytes",
                pCacheObj->name, key, pNode1->data, pNode1->addedTime, pNode1->expireTime,
                (int32_t)taosHashGetSize(pCacheObj->pHashTable), pCacheObj->totalSize, (int64_t)dataSize);
@@ -275,10 +275,10 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen
 
   if (pData != NULL) {
     atomic_add_fetch_32(&pCacheObj->statistics.hitCount, 1);
-    uDebug("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(*ptNode));
+    uError("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(*ptNode));
   } else {
     atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
-    uDebug("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
+    uError("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
   }
 
   atomic_add_fetch_32(&pCacheObj->statistics.totalAccess, 1);
@@ -297,7 +297,7 @@ void *taosCacheAcquireByData(SCacheObj *pCacheObj, void *data) {
   }
 
   int32_t ref = T_REF_INC(ptNode);
-  uDebug("cache:%s, data: %p acquired by data in cache, refcnt:%d", pCacheObj->name, ptNode->data, ref);
+  uError("cache:%s, data: %p acquired by data in cache, refcnt:%d", pCacheObj->name, ptNode->data, ref);
 
   // the data if referenced by at least one object, so the reference count must be greater than the value of 2.
   assert(ref >= 2);
@@ -345,7 +345,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
 
   if (pCacheObj->extendLifespan && (!inTrashCan) && (!_remove)) {
     atomic_store_64(&pNode->expireTime, pNode->lifespan + taosGetTimestampMs());
-    uDebug("cache:%s data:%p extend expire time: %"PRId64, pCacheObj->name, pNode->data, pNode->expireTime);
+    uError("cache:%s data:%p extend expire time: %"PRId64, pCacheObj->name, pNode->data, pNode->expireTime);
   }
 
   if (_remove) {
@@ -354,7 +354,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* d = pNode->data;
 
     int32_t ref = T_REF_VAL_GET(pNode);
-    uDebug("cache:%s, key:%p, %p is released, refcnt:%d, intrash:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
+    uError("cache:%s, key:%p, %p is released, refcnt:%d, intrash:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
 
     /*
      * If it is not referenced by other users, remove it immediately. Otherwise move this node to trashcan wait for all users
@@ -394,13 +394,13 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
       // note that the remove operation can be executed only once.
       if (ret == 0) {
         if (p != pNode) {
-          uDebug( "cache:%s, key:%p, successfully removed a new entry:%p, refcnt:%d, prev entry:%p has been removed by "
+          uError( "cache:%s, key:%p, successfully removed a new entry:%p, refcnt:%d, prev entry:%p has been removed by "
               "others already", pCacheObj->name, pNode->key, p->data, T_REF_VAL_GET(p), pNode->data);
 
           assert(p->pTNodeHeader == NULL);
           taosAddToTrash(pCacheObj, p);
         } else {
-          uDebug("cache:%s, key:%p, %p successfully removed from hash table, refcnt:%d", pCacheObj->name, pNode->key,
+          uError("cache:%s, key:%p, %p successfully removed from hash table, refcnt:%d", pCacheObj->name, pNode->key,
                  pNode->data, ref);
           if (ref > 0) {
             assert(pNode->pTNodeHeader == NULL);
@@ -410,7 +410,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
             atomic_sub_fetch_64(&pCacheObj->totalSize, pNode->size);
 
             int32_t size = (int32_t)taosHashGetSize(pCacheObj->pHashTable);
-            uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
+            uError("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
                    pCacheObj->name, pNode->key, pNode->data, pNode->size, size, pCacheObj->totalSize);
 
             if (pCacheObj->freeFp) {
@@ -421,7 +421,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
           }
         }
       } else {
-        uDebug("cache:%s, key:%p, %p has been removed from hash table by other thread already, refcnt:%d",
+        uError("cache:%s, key:%p, %p has been removed from hash table by other thread already, refcnt:%d",
                pCacheObj->name, pNode->key, pNode->data, ref);
       }
     }
@@ -432,7 +432,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* p = pNode->data;
 
     int32_t ref = T_REF_DEC(pNode);
-    uDebug("cache:%s, key:%p, %p released, refcnt:%d, data in trancan:%d", pCacheObj->name, key, p, ref, inTrashCan);
+    uError("cache:%s, key:%p, %p released, refcnt:%d, data in trashcan:%d", pCacheObj->name, key, p, ref, inTrashCan);
   }
 }
 
@@ -524,7 +524,7 @@ void taosAddToTrash(SCacheObj *pCacheObj, SCacheDataNode *pNode) {
   pCacheObj->numOfElemsInTrash++;
   __cache_unlock(pCacheObj);
 
-  uDebug("cache:%s key:%p, %p move to trash, numOfElem in trash:%d", pCacheObj->name, pNode->key, pNode->data,
+  uError("cache:%s key:%p, %p move to trash, numOfElem in trash:%d", pCacheObj->name, pNode->key, pNode->data,
       pCacheObj->numOfElemsInTrash);
 }
 
@@ -550,7 +550,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
     }
 
     if (force || (T_REF_VAL_GET(pElem->pData) == 0)) {
-      uDebug("key:%p, %p removed from trash. numOfElem in trash:%d", pElem->pData->key, pElem->pData->data,
+      uError("key:%p, %p removed from trash. numOfElem in trash:%d", pElem->pData->key, pElem->pData->data,
              pCacheObj->numOfElemsInTrash - 1);
 
       STrashElem *p = pElem;
@@ -611,7 +611,7 @@ static void doCacheRefresh(SCacheObj* pCacheObj, int64_t time, __cache_free_fn_t
 void* taosCacheTimedRefresh(void *handle) {
   SCacheObj* pCacheObj = handle;
   if (pCacheObj == NULL) {
-    uDebug("object is destroyed. no refresh retry");
+    uError("object is destroyed. no refresh retry");
     return NULL;
   }
 
@@ -624,7 +624,7 @@ void* taosCacheTimedRefresh(void *handle) {
 
     // check if current cache object will be deleted every 500ms.
     if (pCacheObj->deleting) {
-      uDebug("%s refresh threads quit", pCacheObj->name);
+      uError("%s refresh threads quit", pCacheObj->name);
       break;
     }
 

From e9c0e7d2f1e1369f6e04abe71d9f6d96d2ed3103 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 14:04:30 +0800
Subject: [PATCH 05/21] [td-225]

---
 src/util/src/tcache.c | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index c34e9536a5..08b5d473a3 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -90,7 +90,6 @@ static void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force);
 static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheDataNode *pNode) {
   if (pNode->signature != (uint64_t)pNode) {
     uError("key:%s, %p data is invalid, or has been released", pNode->key, pNode);
-    assert(0);
     return;
   }
 
@@ -98,7 +97,7 @@ static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheDataNo
   int32_t size = (int32_t)taosHashGetSize(pCacheObj->pHashTable);
   assert(size > 0);
 
-  uError("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
+  uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
          pCacheObj->name, pNode->key, pNode->data, pNode->size, size - 1, pCacheObj->totalSize);
 
   if (pCacheObj->freeFp) {
@@ -275,10 +274,10 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen
 
   if (pData != NULL) {
     atomic_add_fetch_32(&pCacheObj->statistics.hitCount, 1);
-    uError("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(*ptNode));
+    uDebug("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(*ptNode));
   } else {
     atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
-    uError("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
+    uDebug("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
   }
 
   atomic_add_fetch_32(&pCacheObj->statistics.totalAccess, 1);
@@ -292,12 +291,12 @@ void *taosCacheAcquireByData(SCacheObj *pCacheObj, void *data) {
   SCacheDataNode *ptNode = (SCacheDataNode *)((char *)data - offset);
   
   if (ptNode->signature != (uint64_t)ptNode) {
-    uError("key: %p the data from cache is invalid", ptNode);
+    uError("cache:%s, key: %p the data from cache is invalid", pCacheObj->name, ptNode);
     return NULL;
   }
 
   int32_t ref = T_REF_INC(ptNode);
-  uError("cache:%s, data: %p acquired by data in cache, refcnt:%d", pCacheObj->name, ptNode->data, ref);
+  uDebug("cache:%s, data: %p acquired by data in cache, refcnt:%d", pCacheObj->name, ptNode->data, ref);
 
   // the data if referenced by at least one object, so the reference count must be greater than the value of 2.
   assert(ref >= 2);
@@ -311,7 +310,7 @@ void *taosCacheTransfer(SCacheObj *pCacheObj, void **data) {
   SCacheDataNode *ptNode = (SCacheDataNode *)((char *)(*data) - offset);
   
   if (ptNode->signature != (uint64_t)ptNode) {
-    uError("key: %p the data from cache is invalid", ptNode);
+    uError("cache:%s, key: %p the data from cache is invalid", pCacheObj->name, ptNode);
     return NULL;
   }
   
@@ -345,7 +344,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
 
   if (pCacheObj->extendLifespan && (!inTrashCan) && (!_remove)) {
     atomic_store_64(&pNode->expireTime, pNode->lifespan + taosGetTimestampMs());
-    uError("cache:%s data:%p extend expire time: %"PRId64, pCacheObj->name, pNode->data, pNode->expireTime);
+    uDebug("cache:%s data:%p extend expire time: %"PRId64, pCacheObj->name, pNode->data, pNode->expireTime);
   }
 
   if (_remove) {
@@ -354,7 +353,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* d = pNode->data;
 
     int32_t ref = T_REF_VAL_GET(pNode);
-    uError("cache:%s, key:%p, %p is released, refcnt:%d, intrash:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
+    uError("cache:%s, key:%p, %p is released, refcnt:%d, in trashcan:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
 
     /*
      * If it is not referenced by other users, remove it immediately. Otherwise move this node to trashcan wait for all users
@@ -432,7 +431,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* p = pNode->data;
 
     int32_t ref = T_REF_DEC(pNode);
-    uError("cache:%s, key:%p, %p released, refcnt:%d, data in trashcan:%d", pCacheObj->name, key, p, ref, inTrashCan);
+    uDebug("cache:%s, key:%p, %p released, refcnt:%d, data in trashcan:%d", pCacheObj->name, key, p, ref, inTrashCan);
   }
 }
 
@@ -524,7 +523,7 @@ void taosAddToTrash(SCacheObj *pCacheObj, SCacheDataNode *pNode) {
   pCacheObj->numOfElemsInTrash++;
   __cache_unlock(pCacheObj);
 
-  uError("cache:%s key:%p, %p move to trash, numOfElem in trash:%d", pCacheObj->name, pNode->key, pNode->data,
+  uDebug("cache:%s key:%p, %p move to trash, numOfElem in trash:%d", pCacheObj->name, pNode->key, pNode->data,
       pCacheObj->numOfElemsInTrash);
 }
 
@@ -533,7 +532,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
 
   if (pCacheObj->numOfElemsInTrash == 0) {
     if (pCacheObj->pTrash != NULL) {
-      uError("key:inconsistency data in cache, numOfElem in trash:%d", pCacheObj->numOfElemsInTrash);
+      uError("cache:%s, key:inconsistency data in cache, numOfElem in trash:%d", pCacheObj->name, pCacheObj->numOfElemsInTrash);
     }
 
     pCacheObj->pTrash = NULL;
@@ -550,7 +549,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
     }
 
     if (force || (T_REF_VAL_GET(pElem->pData) == 0)) {
-      uError("key:%p, %p removed from trash. numOfElem in trash:%d", pElem->pData->key, pElem->pData->data,
+      uError("cache:%s, key:%p, %p removed from trash. numOfElem in trash:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
              pCacheObj->numOfElemsInTrash - 1);
 
       STrashElem *p = pElem;
@@ -611,7 +610,7 @@ static void doCacheRefresh(SCacheObj* pCacheObj, int64_t time, __cache_free_fn_t
 void* taosCacheTimedRefresh(void *handle) {
   SCacheObj* pCacheObj = handle;
   if (pCacheObj == NULL) {
-    uError("object is destroyed. no refresh retry");
+    uDebug("object is destroyed. no refresh retry");
     return NULL;
   }
 
@@ -624,7 +623,7 @@ void* taosCacheTimedRefresh(void *handle) {
 
     // check if current cache object will be deleted every 500ms.
     if (pCacheObj->deleting) {
-      uError("%s refresh threads quit", pCacheObj->name);
+      uDebug("%s refresh threads quit", pCacheObj->name);
       break;
     }
 

From 379d574d7d51dbdbd3fa11d94ef92d0d789d6336 Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Fri, 4 Sep 2020 18:29:51 +0800
Subject: [PATCH 06/21] fix TD-1334: select count(*) returns wrong result

github #3334
---
 src/tsdb/src/tsdbRead.c | 59 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 52 insertions(+), 7 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index ac7eba72b2..7e10e7c6d6 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -734,6 +734,10 @@ static int32_t doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* p
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t copyDataFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end);
+static void moveDataToFront(STsdbQueryHandle* pQueryHandle, int32_t numOfRows, int32_t numOfCols);
+static void doCheckGeneratedBlockRange(STsdbQueryHandle* pQueryHandle);
+
 static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock, STableCheckInfo* pCheckInfo){
   SQueryFilePos* cur = &pQueryHandle->cur;
   SDataBlockInfo binfo = GET_FILE_DATA_BLOCK_INFO(pCheckInfo, pBlock);
@@ -745,7 +749,6 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
   TSKEY key = (row != NULL)? dataRowKey(row):TSKEY_INITIAL_VAL;
   tsdbDebug("%p key in mem:%"PRId64", %p", pQueryHandle, key, pQueryHandle->qinfo);
 
-  cur->pos = ASCENDING_TRAVERSE(pQueryHandle->order)? 0:(binfo.rows-1);
 
   if ((ASCENDING_TRAVERSE(pQueryHandle->order) && (key != TSKEY_INITIAL_VAL && key <= binfo.window.ekey)) ||
       (!ASCENDING_TRAVERSE(pQueryHandle->order) && (key != TSKEY_INITIAL_VAL && key >= binfo.window.skey))) {
@@ -784,14 +787,54 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
      *
      * Here the buffer is not enough, so only part of file block can be loaded into memory buffer
      */
-    assert(pQueryHandle->outputCapacity >= binfo.rows);
-    pQueryHandle->realNumOfRows = binfo.rows;
+   assert(pQueryHandle->outputCapacity >= binfo.rows);
+
+    if ((cur->pos == 0 && ASCENDING_TRAVERSE(pQueryHandle->order)) ||
+        (cur->pos == (binfo.rows - 1) && (!ASCENDING_TRAVERSE(pQueryHandle->order)))) {
+      pQueryHandle->realNumOfRows = binfo.rows;
+
+      cur->rows = binfo.rows;
+      cur->win  = binfo.window;
+      cur->mixBlock = false;
+      cur->lastKey = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.window.ekey + 1): (binfo.window.skey -1);
+    } else {
+
+      SDataCols* pCols = pQueryHandle->rhelper.pDataCols[0];
+      TSKEY* tsArray = pCols->cols[0].pData;
+
+      assert(pCols->cols[0].type == TSDB_DATA_TYPE_TIMESTAMP && pCols->cols[0].colId == PRIMARYKEY_TIMESTAMP_COL_INDEX &&
+             cur->pos >= 0 && cur->pos < pBlock->numOfRows &&
+             (tsArray[0] == binfo.window.skey && tsArray[binfo.rows - 1] == binfo.window.ekey));
+
+      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+        cur->rows = binfo.rows - cur->pos;
+
+        cur->win.skey = tsArray[cur->pos];
+        cur->win.ekey = binfo.window.ekey;
+
+        cur->lastKey = binfo.window.ekey + 1;
+        int32_t numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, cur->pos, binfo.rows-1);
+        assert(numOfRows == cur->rows);
+      } else {
+        cur->rows = cur->pos + 1;
+
+        cur->win.skey = binfo.window.skey;
+        cur->win.ekey = tsArray[cur->pos];
+
+        cur->lastKey = binfo.window.skey - 1;
+        int32_t numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, 0, cur->pos);
+        assert(numOfRows == cur->rows);
+
+        int32_t numOfCols = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+        moveDataToFront(pQueryHandle, numOfRows, numOfCols);
+        doCheckGeneratedBlockRange(pQueryHandle);
+      }
+
+      pQueryHandle->realNumOfRows = cur->rows;
+      cur->mixBlock = true;
+    }
 
-    cur->rows = binfo.rows;
-    cur->win  = binfo.window;
-    cur->mixBlock = false;
     cur->blockCompleted = true;
-    cur->lastKey = binfo.window.ekey + (ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1);
     pCheckInfo->lastKey = cur->lastKey;
   }
 
@@ -823,6 +866,7 @@ static int32_t loadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBl
       assert(pCheckInfo->lastKey <= pBlock->keyLast);
       doMergeTwoLevelData(pQueryHandle, pCheckInfo, pBlock);
     } else {  // the whole block is loaded in to buffer
+      cur->pos = ASCENDING_TRAVERSE(pQueryHandle->order)? 0:(pBlock->numOfRows-1);
       code = handleDataMergeIfNeeded(pQueryHandle, pBlock, pCheckInfo);
     }
   } else {  //desc order, query ended in current block
@@ -842,6 +886,7 @@ static int32_t loadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBl
       assert(pCheckInfo->lastKey >= pBlock->keyFirst);
       doMergeTwoLevelData(pQueryHandle, pCheckInfo, pBlock);
     } else {
+      cur->pos = ASCENDING_TRAVERSE(pQueryHandle->order)? 0:(pBlock->numOfRows-1);
       code = handleDataMergeIfNeeded(pQueryHandle, pBlock, pCheckInfo);
     }
   }

From bcee3a4ae96a64e31cdc78bcd662638ea1d2c857 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 22:26:49 +0800
Subject: [PATCH 07/21] [td-1334] refactor codes.

---
 src/tsdb/src/tsdbRead.c | 125 +++++++++++++++++++---------------------
 1 file changed, 58 insertions(+), 67 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 7e10e7c6d6..462d540c51 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -737,6 +737,7 @@ static int32_t doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* p
 static int32_t copyDataFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end);
 static void moveDataToFront(STsdbQueryHandle* pQueryHandle, int32_t numOfRows, int32_t numOfCols);
 static void doCheckGeneratedBlockRange(STsdbQueryHandle* pQueryHandle);
+static void copyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SDataBlockInfo* pBlockInfo, int32_t endPos);
 
 static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock, STableCheckInfo* pCheckInfo){
   SQueryFilePos* cur = &pQueryHandle->cur;
@@ -746,10 +747,11 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
   /*bool hasData = */ initTableMemIterator(pQueryHandle, pCheckInfo);
   SDataRow row = getSDataRowInTableMem(pCheckInfo, pQueryHandle->order);
 
+  assert(cur->pos >= 0 && cur->pos <= binfo.rows);
+
   TSKEY key = (row != NULL)? dataRowKey(row):TSKEY_INITIAL_VAL;
   tsdbDebug("%p key in mem:%"PRId64", %p", pQueryHandle, key, pQueryHandle->qinfo);
 
-
   if ((ASCENDING_TRAVERSE(pQueryHandle->order) && (key != TSKEY_INITIAL_VAL && key <= binfo.window.ekey)) ||
       (!ASCENDING_TRAVERSE(pQueryHandle->order) && (key != TSKEY_INITIAL_VAL && key >= binfo.window.skey))) {
 
@@ -787,7 +789,7 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
      *
      * Here the buffer is not enough, so only part of file block can be loaded into memory buffer
      */
-   assert(pQueryHandle->outputCapacity >= binfo.rows);
+    assert(pQueryHandle->outputCapacity >= binfo.rows);
 
     if ((cur->pos == 0 && ASCENDING_TRAVERSE(pQueryHandle->order)) ||
         (cur->pos == (binfo.rows - 1) && (!ASCENDING_TRAVERSE(pQueryHandle->order)))) {
@@ -797,45 +799,15 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
       cur->win  = binfo.window;
       cur->mixBlock = false;
       cur->lastKey = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.window.ekey + 1): (binfo.window.skey -1);
-    } else {
-
-      SDataCols* pCols = pQueryHandle->rhelper.pDataCols[0];
-      TSKEY* tsArray = pCols->cols[0].pData;
-
-      assert(pCols->cols[0].type == TSDB_DATA_TYPE_TIMESTAMP && pCols->cols[0].colId == PRIMARYKEY_TIMESTAMP_COL_INDEX &&
-             cur->pos >= 0 && cur->pos < pBlock->numOfRows &&
-             (tsArray[0] == binfo.window.skey && tsArray[binfo.rows - 1] == binfo.window.ekey));
-
-      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-        cur->rows = binfo.rows - cur->pos;
-
-        cur->win.skey = tsArray[cur->pos];
-        cur->win.ekey = binfo.window.ekey;
-
-        cur->lastKey = binfo.window.ekey + 1;
-        int32_t numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, cur->pos, binfo.rows-1);
-        assert(numOfRows == cur->rows);
-      } else {
-        cur->rows = cur->pos + 1;
-
-        cur->win.skey = binfo.window.skey;
-        cur->win.ekey = tsArray[cur->pos];
-
-        cur->lastKey = binfo.window.skey - 1;
-        int32_t numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, 0, cur->pos);
-        assert(numOfRows == cur->rows);
-
-        int32_t numOfCols = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
-        moveDataToFront(pQueryHandle, numOfRows, numOfCols);
-        doCheckGeneratedBlockRange(pQueryHandle);
-      }
-
-      pQueryHandle->realNumOfRows = cur->rows;
+    } else { // partially copy to dest buffer
+      int32_t endPos = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.rows - 1): 0;
+      copyRowsFromFileBlock(pQueryHandle, pCheckInfo, &binfo, endPos);
       cur->mixBlock = true;
     }
 
-    cur->blockCompleted = true;
-    pCheckInfo->lastKey = cur->lastKey;
+    assert(cur->blockCompleted);
+    tsdbDebug("create data block from remain file block, brange:%"PRId64"-%"PRId64", rows:%d, lastKey:%"PRId64", %p",
+        cur->win.skey, cur->win.ekey, cur->rows, cur->lastKey, pQueryHandle);
   }
 
   return code;
@@ -866,7 +838,7 @@ static int32_t loadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBl
       assert(pCheckInfo->lastKey <= pBlock->keyLast);
       doMergeTwoLevelData(pQueryHandle, pCheckInfo, pBlock);
     } else {  // the whole block is loaded in to buffer
-      cur->pos = ASCENDING_TRAVERSE(pQueryHandle->order)? 0:(pBlock->numOfRows-1);
+      cur->pos = ASCENDING_TRAVERSE(pQueryHandle->order)? 0:(pBlock->numOfRows - 1);
       code = handleDataMergeIfNeeded(pQueryHandle, pBlock, pCheckInfo);
     }
   } else {  //desc order, query ended in current block
@@ -957,7 +929,7 @@ static int doBinarySearchKey(char* pValue, int num, TSKEY key, int order) {
   return midPos;
 }
 
-static int32_t copyDataFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end) {
+int32_t copyDataFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end) {
   char* pData = NULL;
   int32_t step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1 : -1;
 
@@ -1182,6 +1154,49 @@ static void doCheckGeneratedBlockRange(STsdbQueryHandle* pQueryHandle) {
   }
 }
 
+static void copyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SDataBlockInfo* pBlockInfo, int32_t endPos) {
+  SQueryFilePos* cur = &pQueryHandle->cur;
+
+  SDataCols* pCols = pQueryHandle->rhelper.pDataCols[0];
+  TSKEY* tsArray = pCols->cols[0].pData;
+
+  int32_t step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
+  int32_t numOfCols = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+
+  int32_t pos = cur->pos;
+
+  int32_t start = cur->pos;
+  int32_t end = endPos;
+
+  if (!ASCENDING_TRAVERSE(pQueryHandle->order)) {
+    assert(start >= end);
+    SWAP(start, end, int32_t);
+  }
+
+  int32_t numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, start, end);
+
+  // the time window should always be ascending order: skey <= ekey
+  cur->win = (STimeWindow) {.skey = tsArray[start], .ekey = tsArray[end]};
+  cur->mixBlock = (start == 0 && end == pBlockInfo->rows - 1);
+  cur->lastKey = tsArray[endPos] + step;
+
+  pos += endPos + step;
+
+  cur->blockCompleted =
+      (((pos >= endPos || cur->lastKey > pQueryHandle->window.ekey) && ASCENDING_TRAVERSE(pQueryHandle->order)) ||
+       ((pos <= endPos || cur->lastKey < pQueryHandle->window.ekey) && !ASCENDING_TRAVERSE(pQueryHandle->order)));
+
+  // if the buffer is not full in case of descending order query, move the data in the front of the buffer
+  moveDataToFront(pQueryHandle, numOfRows, numOfCols);
+  updateInfoAfterMerge(pQueryHandle, pCheckInfo, numOfRows, pos);
+  doCheckGeneratedBlockRange(pQueryHandle);
+
+  tsdbDebug("%p uid:%" PRIu64",tid:%d data block created, mixblock:%d, brange:%"PRIu64"-%"PRIu64" rows:%d, %p",
+            pQueryHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, cur->mixBlock, cur->win.skey,
+            cur->win.ekey, cur->rows, pQueryHandle->qinfo);
+}
+
+
 // only return the qualified data to client in terms of query time window, data rows in the same block but do not
 // be included in the query time window will be discarded
 static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SCompBlock* pBlock) {
@@ -1224,37 +1239,13 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
 
   // compared with the data from in-memory buffer, to generate the correct timestamp array list
   int32_t numOfRows = 0;
+
   int32_t pos = cur->pos;
   cur->win = TSWINDOW_INITIALIZER;
 
   // no data in buffer, load data from file directly
   if (pCheckInfo->iiter == NULL && pCheckInfo->iter == NULL) {
-    int32_t start = cur->pos;
-    int32_t end = endPos;
-
-    if (!ASCENDING_TRAVERSE(pQueryHandle->order)) {
-      SWAP(start, end, int32_t);
-    }
-
-    numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, numOfRows, start, end);
-
-    // the time window should always be right order: skey <= ekey
-    cur->win = (STimeWindow) {.skey = tsArray[start], .ekey = tsArray[end]};
-    cur->lastKey = tsArray[endPos];
-    pos += (end - start + 1) * step;
-
-    cur->blockCompleted =
-        (((pos >= endPos || cur->lastKey > pQueryHandle->window.ekey) && ASCENDING_TRAVERSE(pQueryHandle->order)) ||
-         ((pos <= endPos || cur->lastKey < pQueryHandle->window.ekey) && !ASCENDING_TRAVERSE(pQueryHandle->order)));
-
-    // if the buffer is not full in case of descending order query, move the data in the front of the buffer
-    moveDataToFront(pQueryHandle, numOfRows, numOfCols);
-    updateInfoAfterMerge(pQueryHandle, pCheckInfo, numOfRows, pos);
-    doCheckGeneratedBlockRange(pQueryHandle);
-
-    tsdbDebug("%p uid:%" PRIu64",tid:%d data block created, mixblock:%d, brange:%"PRIu64"-%"PRIu64" rows:%d, %p",
-              pQueryHandle, pCheckInfo->tableId.uid, pCheckInfo->tableId.tid, cur->mixBlock, cur->win.skey,
-              cur->win.ekey, cur->rows, pQueryHandle->qinfo);
+    copyRowsFromFileBlock(pQueryHandle, pCheckInfo, &blockInfo, endPos);
     return;
   } else if (pCheckInfo->iter != NULL || pCheckInfo->iiter != NULL) {
     SSkipListNode* node = NULL;
@@ -1703,7 +1694,7 @@ static int32_t getDataBlocksInFiles(STsdbQueryHandle* pQueryHandle, bool* exists
         return loadFileDataBlock(pQueryHandle, pNext->compBlock, pNext->pTableCheckInfo, exists);
       }
     } else {
-      tsdbDebug("%p continue in current data block, index:%d, %p", pQueryHandle, cur->slot, pQueryHandle->qinfo);
+      tsdbDebug("%p continue in current data block, index:%d, pos:%d, %p", pQueryHandle, cur->slot, cur->pos, pQueryHandle->qinfo);
       int32_t code = handleDataMergeIfNeeded(pQueryHandle, pBlockInfo->compBlock, pCheckInfo);
       *exists = pQueryHandle->realNumOfRows > 0;
 

From 10af6ae3501a887f2da7c10fb4edaa779bb6c1c8 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 22:31:12 +0800
Subject: [PATCH 08/21] [td-225]

---
 src/util/src/tcache.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 08b5d473a3..1bc539f328 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -109,7 +109,7 @@ static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheDataNo
 
 static FORCE_INLINE void doRemoveElemInTrashcan(SCacheObj* pCacheObj, STrashElem *pElem) {
   if (pElem->pData->signature != (uint64_t) pElem->pData) {
-    uError("key:sig:0x%" PRIx64 " %p data has been released, ignore", pElem->pData->signature, pElem->pData);
+    uWarn("key:sig:0x%" PRIx64 " %p data has been released, ignore", pElem->pData->signature, pElem->pData);
     return;
   }
 
@@ -204,7 +204,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
   int32_t succ = taosHashPut(pCacheObj->pHashTable, key, keyLen, &pNode1, sizeof(void *));
   if (succ == 0) {
     atomic_add_fetch_64(&pCacheObj->totalSize, pNode1->size);
-    uError("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
+    uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
            ", totalNum:%d totalSize:%" PRId64 "bytes size:%" PRId64 "bytes",
            pCacheObj->name, key, pNode1->data, pNode1->addedTime, pNode1->expireTime,
            (int32_t)taosHashGetSize(pCacheObj->pHashTable), pCacheObj->totalSize, (int64_t)dataSize);
@@ -233,7 +233,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
       if (ret == 0) {
         atomic_add_fetch_64(&pCacheObj->totalSize, pNode1->size);
 
-        uError("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
+        uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64
                ", totalNum:%d totalSize:%" PRId64 "bytes size:%" PRId64 "bytes",
                pCacheObj->name, key, pNode1->data, pNode1->addedTime, pNode1->expireTime,
                (int32_t)taosHashGetSize(pCacheObj->pHashTable), pCacheObj->totalSize, (int64_t)dataSize);
@@ -353,7 +353,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* d = pNode->data;
 
     int32_t ref = T_REF_VAL_GET(pNode);
-    uError("cache:%s, key:%p, %p is released, refcnt:%d, in trashcan:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
+    uDebug("cache:%s, key:%p, %p is released, refcnt:%d, in trashcan:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
 
     /*
      * If it is not referenced by other users, remove it immediately. Otherwise move this node to trashcan wait for all users
@@ -393,13 +393,13 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
       // note that the remove operation can be executed only once.
       if (ret == 0) {
         if (p != pNode) {
-          uError( "cache:%s, key:%p, successfully removed a new entry:%p, refcnt:%d, prev entry:%p has been removed by "
+          uDebug( "cache:%s, key:%p, successfully removed a new entry:%p, refcnt:%d, prev entry:%p has been removed by "
               "others already", pCacheObj->name, pNode->key, p->data, T_REF_VAL_GET(p), pNode->data);
 
           assert(p->pTNodeHeader == NULL);
           taosAddToTrash(pCacheObj, p);
         } else {
-          uError("cache:%s, key:%p, %p successfully removed from hash table, refcnt:%d", pCacheObj->name, pNode->key,
+          uDebug("cache:%s, key:%p, %p successfully removed from hash table, refcnt:%d", pCacheObj->name, pNode->key,
                  pNode->data, ref);
           if (ref > 0) {
             assert(pNode->pTNodeHeader == NULL);
@@ -409,7 +409,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
             atomic_sub_fetch_64(&pCacheObj->totalSize, pNode->size);
 
             int32_t size = (int32_t)taosHashGetSize(pCacheObj->pHashTable);
-            uError("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
+            uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
                    pCacheObj->name, pNode->key, pNode->data, pNode->size, size, pCacheObj->totalSize);
 
             if (pCacheObj->freeFp) {
@@ -420,7 +420,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
           }
         }
       } else {
-        uError("cache:%s, key:%p, %p has been removed from hash table by other thread already, refcnt:%d",
+        uDebug("cache:%s, key:%p, %p has been removed from hash table by others already, refcnt:%d",
                pCacheObj->name, pNode->key, pNode->data, ref);
       }
     }
@@ -549,7 +549,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
     }
 
     if (force || (T_REF_VAL_GET(pElem->pData) == 0)) {
-      uError("cache:%s, key:%p, %p removed from trash. numOfElem in trash:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
+      uError("cache:%s, key:%p, %p removed from trashcan. numOfElem in trash:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
              pCacheObj->numOfElemsInTrash - 1);
 
       STrashElem *p = pElem;

From 8795d190096f074b08f9cd4d03d0e816f9c20d01 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 22:47:37 +0800
Subject: [PATCH 09/21] [td-225]

---
 src/tsdb/src/tsdbRead.c | 33 ++++++++++++++++-----------------
 src/util/src/tcache.c   |  4 ++--
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 462d540c51..60f59e46f7 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -734,10 +734,10 @@ static int32_t doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* p
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t copyDataFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end);
+static int32_t doCopyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end);
 static void moveDataToFront(STsdbQueryHandle* pQueryHandle, int32_t numOfRows, int32_t numOfCols);
 static void doCheckGeneratedBlockRange(STsdbQueryHandle* pQueryHandle);
-static void copyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SDataBlockInfo* pBlockInfo, int32_t endPos);
+static void copyAllRemainRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SDataBlockInfo* pBlockInfo, int32_t endPos);
 
 static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock, STableCheckInfo* pCheckInfo){
   SQueryFilePos* cur = &pQueryHandle->cur;
@@ -801,7 +801,7 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
       cur->lastKey = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.window.ekey + 1): (binfo.window.skey -1);
     } else { // partially copy to dest buffer
       int32_t endPos = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.rows - 1): 0;
-      copyRowsFromFileBlock(pQueryHandle, pCheckInfo, &binfo, endPos);
+      copyAllRemainRowsFromFileBlock(pQueryHandle, pCheckInfo, &binfo, endPos);
       cur->mixBlock = true;
     }
 
@@ -929,7 +929,7 @@ static int doBinarySearchKey(char* pValue, int num, TSKEY key, int order) {
   return midPos;
 }
 
-int32_t copyDataFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end) {
+int32_t doCopyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, int32_t start, int32_t end) {
   char* pData = NULL;
   int32_t step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1 : -1;
 
@@ -1154,7 +1154,7 @@ static void doCheckGeneratedBlockRange(STsdbQueryHandle* pQueryHandle) {
   }
 }
 
-static void copyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SDataBlockInfo* pBlockInfo, int32_t endPos) {
+static void copyAllRemainRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SDataBlockInfo* pBlockInfo, int32_t endPos) {
   SQueryFilePos* cur = &pQueryHandle->cur;
 
   SDataCols* pCols = pQueryHandle->rhelper.pDataCols[0];
@@ -1173,21 +1173,20 @@ static void copyRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STableCheckInf
     SWAP(start, end, int32_t);
   }
 
-  int32_t numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, start, end);
+  assert(pQueryHandle->outputCapacity >= (end - start + 1));
+  int32_t numOfRows = doCopyRowsFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, 0, start, end);
 
   // the time window should always be ascending order: skey <= ekey
   cur->win = (STimeWindow) {.skey = tsArray[start], .ekey = tsArray[end]};
-  cur->mixBlock = (start == 0 && end == pBlockInfo->rows - 1);
+  cur->mixBlock = (start > 0 && end < pBlockInfo->rows - 1);
   cur->lastKey = tsArray[endPos] + step;
-
-  pos += endPos + step;
-
-  cur->blockCompleted =
-      (((pos >= endPos || cur->lastKey > pQueryHandle->window.ekey) && ASCENDING_TRAVERSE(pQueryHandle->order)) ||
-       ((pos <= endPos || cur->lastKey < pQueryHandle->window.ekey) && !ASCENDING_TRAVERSE(pQueryHandle->order)));
+  cur->blockCompleted = true;
 
   // if the buffer is not full in case of descending order query, move the data in the front of the buffer
   moveDataToFront(pQueryHandle, numOfRows, numOfCols);
+
+  // The value of pos may be -1 or pBlockInfo->rows, and it is invalid in both cases.
+  pos = endPos + step;
   updateInfoAfterMerge(pQueryHandle, pCheckInfo, numOfRows, pos);
   doCheckGeneratedBlockRange(pQueryHandle);
 
@@ -1245,7 +1244,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
 
   // no data in buffer, load data from file directly
   if (pCheckInfo->iiter == NULL && pCheckInfo->iter == NULL) {
-    copyRowsFromFileBlock(pQueryHandle, pCheckInfo, &blockInfo, endPos);
+    copyAllRemainRowsFromFileBlock(pQueryHandle, pCheckInfo, &blockInfo, endPos);
     return;
   } else if (pCheckInfo->iter != NULL || pCheckInfo->iiter != NULL) {
     SSkipListNode* node = NULL;
@@ -1297,7 +1296,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
         int32_t qstart = 0, qend = 0;
         getQualifiedRowsPos(pQueryHandle, pos, end, numOfRows, &qstart, &qend);
 
-        numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, numOfRows, qstart, qend);
+        numOfRows = doCopyRowsFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, numOfRows, qstart, qend);
         pos += (qend - qstart + 1) * step;
 
         cur->win.ekey = ASCENDING_TRAVERSE(pQueryHandle->order)? tsArray[qend]:tsArray[qstart];
@@ -1321,7 +1320,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
         int32_t start = -1, end = -1;
         getQualifiedRowsPos(pQueryHandle, pos, endPos, numOfRows, &start, &end);
 
-        numOfRows = copyDataFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, numOfRows, start, end);
+        numOfRows = doCopyRowsFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, numOfRows, start, end);
         pos += (end - start + 1) * step;
 
         cur->win.ekey = ASCENDING_TRAVERSE(pQueryHandle->order)? tsArray[end]:tsArray[start];
@@ -2192,7 +2191,7 @@ SArray* tsdbRetrieveDataBlock(TsdbQueryHandleT* pQueryHandle, SArray* pIdList) {
         }
 
         // todo refactor
-        int32_t numOfRows = copyDataFromFileBlock(pHandle, pHandle->outputCapacity, 0, 0, pBlock->numOfRows - 1);
+        int32_t numOfRows = doCopyRowsFromFileBlock(pHandle, pHandle->outputCapacity, 0, 0, pBlock->numOfRows - 1);
 
         // if the buffer is not full in case of descending order query, move the data in the front of the buffer
         if (!ASCENDING_TRAVERSE(pHandle->order) && numOfRows < pHandle->outputCapacity) {
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 1bc539f328..9872898468 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -532,7 +532,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
 
   if (pCacheObj->numOfElemsInTrash == 0) {
     if (pCacheObj->pTrash != NULL) {
-      uError("cache:%s, key:inconsistency data in cache, numOfElem in trash:%d", pCacheObj->name, pCacheObj->numOfElemsInTrash);
+      uError("cache:%s, key:inconsistency data in cache, numOfElem in trashcan:%d", pCacheObj->name, pCacheObj->numOfElemsInTrash);
     }
 
     pCacheObj->pTrash = NULL;
@@ -549,7 +549,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
     }
 
     if (force || (T_REF_VAL_GET(pElem->pData) == 0)) {
-      uError("cache:%s, key:%p, %p removed from trashcan. numOfElem in trash:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
+      uError("cache:%s, key:%p, %p removed from trashcan. numOfElem in trashcan:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
              pCacheObj->numOfElemsInTrash - 1);
 
       STrashElem *p = pElem;

From cf031759164099eaf4351b24c9f0ea2f81c51356 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 4 Sep 2020 22:55:07 +0800
Subject: [PATCH 10/21] [td-225]

---
 src/tsdb/src/tsdbRead.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 60f59e46f7..506d185d1c 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -798,7 +798,15 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBloc
       cur->rows = binfo.rows;
       cur->win  = binfo.window;
       cur->mixBlock = false;
-      cur->lastKey = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.window.ekey + 1): (binfo.window.skey -1);
+      cur->blockCompleted = true;
+
+      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+        cur->lastKey = binfo.window.ekey + 1;
+        cur->pos = binfo.rows;
+      } else {
+        cur->lastKey = binfo.window.skey - 1;
+        cur->pos = -1;
+      }
     } else { // partially copy to dest buffer
       int32_t endPos = ASCENDING_TRAVERSE(pQueryHandle->order)? (binfo.rows - 1): 0;
       copyAllRemainRowsFromFileBlock(pQueryHandle, pCheckInfo, &binfo, endPos);
@@ -1195,7 +1203,6 @@ static void copyAllRemainRowsFromFileBlock(STsdbQueryHandle* pQueryHandle, STabl
             cur->win.ekey, cur->rows, pQueryHandle->qinfo);
 }
 
-
 // only return the qualified data to client in terms of query time window, data rows in the same block but do not
 // be included in the query time window will be discarded
 static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SCompBlock* pBlock) {

From 657fd611970b51fcd9993dbde585e6275afabfbe Mon Sep 17 00:00:00 2001
From: Ping Xiao <pxiao@taosdata.com>
Date: Sat, 5 Sep 2020 09:49:58 +0800
Subject: [PATCH 11/21] TD-1182: imporove test report

---
 tests/perftest-scripts/coverage_test.sh | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/tests/perftest-scripts/coverage_test.sh b/tests/perftest-scripts/coverage_test.sh
index 6644cc62a3..a0c8fe4b3f 100755
--- a/tests/perftest-scripts/coverage_test.sh
+++ b/tests/perftest-scripts/coverage_test.sh
@@ -74,21 +74,36 @@ function runTest {
 
 	runGeneralCaseOneByOne jenkins/basic.txt
 
-	totalSuccess=`grep 'success' $TDENGINE_COVERAGE_REPORT | wc -l`
+	sed -i "1i\SIM cases test result" $TDENGINE_COVERAGE_REPORT
 
+	totalSuccess=`grep 'success' $TDENGINE_COVERAGE_REPORT | wc -l`
 	if [ "$totalSuccess" -gt "0" ]; then
-		echo -e "\n${GREEN} ### Total $totalSuccess coverage test case(s) succeed! ### ${NC}" | tee -a $TDENGINE_COVERAGE_REPORT
+		sed -i -e "2i\ ### Total $totalSuccess SIM test case(s) succeed! ###"  $TDENGINE_COVERAGE_REPORT
 	fi
 
 	totalFailed=`grep 'failed\|fault' $TDENGINE_COVERAGE_REPORT | wc -l`
 	if [ "$totalFailed" -ne "0" ]; then
-		echo -e "${RED} ### Total $totalFailed coverage test case(s) failed! ### ${NC}\n" | tee -a $TDENGINE_COVERAGE_REPORT
-#  exit $totalPyFailed
+		sed -i '3i\### Total $totalFailed SIM test case(s) failed! ###'  $TDENGINE_COVERAGE_REPORT
+	else
+		sed -i '3i\\n'  $TDENGINE_COVERAGE_REPORT
 	fi
 
 	cd $TDENGINE_DIR/tests
 	rm -rf ../sim
 	./test-all.sh full python | tee -a $TDENGINE_COVERAGE_REPORT
+	
+	sed -i "4i\Python cases test result" $TDENGINE_COVERAGE_REPORT
+	totalPySuccess=`grep 'python case(s) succeed!' $TDENGINE_COVERAGE_REPORT | awk '{print $4}'`
+	if [ "$totalPySuccess" -gt "0" ]; then
+                sed -i -e "5i\ ### Total $totalPySuccess Python test case(s) succeed! ###"  $TDENGINE_COVERAGE_REPORT
+        fi
+
+	totalPyFailed=`grep 'python case(s) failed!' $TDENGINE_COVERAGE_REPORT | awk '{print $4}'`
+        if [ -z $totalPyFailed ]; then
+		sed -i '6i\\n'  $TDENGINE_COVERAGE_REPORT
+        else
+		sed -i '6i\### Total $totalPyFailed Python test case(s) failed! ###'  $TDENGINE_COVERAGE_REPORT
+        fi
 
 	# Test Connector
 	stopTaosd

From f8dd744267900f331b688f62b841a69516dca3b6 Mon Sep 17 00:00:00 2001
From: Ping Xiao <pxiao@taosdata.com>
Date: Sat, 5 Sep 2020 10:18:29 +0800
Subject: [PATCH 12/21] TD-1177: Add performance test into daily test

---
 tests/perftest-scripts/perftest-taosdemo.sh | 20 ++++-
 tests/pytest/query/queryPerformance.py      | 82 +++++++++++++++++++++
 2 files changed, 98 insertions(+), 4 deletions(-)
 create mode 100644 tests/pytest/query/queryPerformance.py

diff --git a/tests/perftest-scripts/perftest-taosdemo.sh b/tests/perftest-scripts/perftest-taosdemo.sh
index e459769512..ae9e8dd737 100755
--- a/tests/perftest-scripts/perftest-taosdemo.sh
+++ b/tests/perftest-scripts/perftest-taosdemo.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
 
 WORK_DIR=/mnt/root
+TDENGINE_DIR=/root/TDengine
 
 walLevel=`grep "^walLevel" /etc/taos/taos.cfg | awk '{print $2}'`
 if [[ "$walLevel" -eq "2" ]]; then
@@ -71,9 +72,17 @@ function runCreateTableThenInsert {
 	restartTaosd
 
 	/usr/bin/time -f "Total: %e" -o totaltime.out bash -c "yes | taosdemo 2>&1 | tee -a taosdemo-$walPostfix-$today.log"
-	demoTableAndInsert=`grep "Total:" totaltime.out|awk '{print $2}'`
-	demoRPS=`grep "records\/second" taosdemo-$walPostfix-$today.log | tail -n1 | awk '{print $13}'`
-}	
+	demoTableAndInsert=`grep "Total:" totaltime.out|awk '{print $2}'`	
+	demoRPS=`grep "records\/second" taosdemo-$walPostfix-$today.log | tail -n1 | awk '{print $13}'`	
+}
+
+function queryPerformance {
+	echoInfo "Restart Taosd"
+	restartTaosd
+	
+	cd $TDENGINE_DIR/tests/pytest
+	python3 query/queryPerformance.py
+}
 
 function generateTaosdemoPlot {
 	echo "${today} $walPostfix, demoCreateTableOnly: ${demoCreateTableOnly}, demoDeleteTableOnly: ${demoDeleteTableOnly}, demoTableAndInsert: ${demoTableAndInsert}" | tee -a taosdemo-$today.log
@@ -101,13 +110,16 @@ today=`date +"%Y%m%d"`
 cd $WORK_DIR
 echoInfo "Test Create Table Only "
 runCreateTableOnly
-echoInfo "Test Create Table then Insert data"
+echoInfo "Test Delete Table Only"
 runDeleteTableOnly
 echoInfo "Test Create Table then Insert data"
 runCreateTableThenInsert
+echoInfo "Query Performance for 10 Billion Records"
+queryPerformance
 echoInfo "Generate plot for taosdemo"
 generateTaosdemoPlot
 
+
 tar czf $WORK_DIR/taos-log-taosdemo-$today.tar.gz $logDir/*
 
 echoInfo "End of TaosDemo Test" | tee -a $WORK_DIR/cron.log
diff --git a/tests/pytest/query/queryPerformance.py b/tests/pytest/query/queryPerformance.py
new file mode 100644
index 0000000000..a7fc08c5a3
--- /dev/null
+++ b/tests/pytest/query/queryPerformance.py
@@ -0,0 +1,82 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import os
+import taos
+import time
+
+
+class taosdemoQueryPerformace:
+    def initConnection(self):
+        self.host = "127.0.0.1"
+        self.user = "root"
+        self.password = "taosdata"
+        self.config = "/etc/taos"
+        self.conn = taos.connect(
+            self.host,
+            self.user,
+            self.password,
+            self.config)
+
+
+    def query(self): 
+        cursor = self.conn.cursor()                  
+        cursor.execute("use test")        
+
+        totalTime = 0
+        for i in range(100):
+            startTime = time.time()
+            cursor.execute("select count(*) from test.meters")
+            totalTime += time.time() - startTime
+        print("query time for: select count(*) from test.meters %f seconds" % (totalTime / 100))
+
+        totalTime = 0
+        for i in range(100):
+            startTime = time.time()
+            cursor.execute("select avg(f1), max(f2), min(f3) from test.meters")
+            totalTime += time.time() - startTime
+        print("query time for: select avg(f1), max(f2), min(f3) from test.meters %f seconds" % (totalTime / 100))
+
+        totalTime = 0
+        for i in range(100):
+            startTime = time.time()
+            cursor.execute("select count(*) from test.meters where loc='beijing'")
+            totalTime += time.time() - startTime
+        print("query time for: select count(*) from test.meters where loc='beijing' %f seconds" % (totalTime / 100))
+
+        totalTime = 0
+        for i in range(100):
+            startTime = time.time()
+            cursor.execute("select avg(f1), max(f2), min(f3) from test.meters where areaid=10")
+            totalTime += time.time() - startTime
+        print("query time for: select avg(f1), max(f2), min(f3) from test.meters where areaid=10 %f seconds" % (totalTime / 100))
+
+        totalTime = 0
+        for i in range(100):
+            startTime = time.time()
+            cursor.execute("select avg(f1), max(f2), min(f3) from test.t10 interval(10s)")
+            totalTime += time.time() - startTime
+        print("query time for: select avg(f1), max(f2), min(f3) from test.t10 interval(10s) %f seconds" % (totalTime / 100))
+
+        totalTime = 0
+        for i in range(100):
+            startTime = time.time()
+            cursor.execute("select last_row(*) from meters")
+            totalTime += time.time() - startTime
+        print("query time for: select last_row(*) from meters %f seconds" % (totalTime / 100))
+
+if __name__ == '__main__':
+    perftest = taosdemoQueryPerformace()
+    perftest.initConnection()
+    perftest.query()
\ No newline at end of file

From 563a90f46a73cc3bd2821bec16639343eaaac4b3 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Sat, 5 Sep 2020 10:57:38 +0800
Subject: [PATCH 13/21] update the version

---
 cmake/version.inc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/version.inc b/cmake/version.inc
index c620d753a6..52d62fca65 100644
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.2.0")
+  SET(TD_VER_NUMBER "2.0.3.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

From eb9a1f9655e41a8e51c1bb5d5dff409272c930ae Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Sat, 5 Sep 2020 12:58:36 +0800
Subject: [PATCH 14/21] [issue:3375]

---
 cmake/platform.inc            |  5 ++++-
 src/os/inc/os.h               |  2 +-
 src/os/inc/osAlpine.h         |  4 ++--
 src/os/inc/osLinux64.h        |  2 ++
 src/os/src/detail/osSysinfo.c | 10 +++++++++-
 src/util/src/tnote.c          |  2 +-
 6 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/cmake/platform.inc b/cmake/platform.inc
index 7834a35411..889f6c73cf 100755
--- a/cmake/platform.inc
+++ b/cmake/platform.inc
@@ -114,6 +114,9 @@ ELSEIF (${OSTYPE} MATCHES "Ningsi80")
   MESSAGE(STATUS "input osType: Ningsi80")
 ELSEIF (${OSTYPE} MATCHES "Linux")
   MESSAGE(STATUS "input osType: Linux")
+ELSEIF (${OSTYPE} MATCHES "Alpine")
+  MESSAGE(STATUS "input osType: Alpine")
+  SET(TD_APLHINE TRUE)
 ELSE ()
   MESSAGE(STATUS "input osType unknown: " ${OSTYPE})
-ENDIF ()
\ No newline at end of file
+ENDIF ()
diff --git a/src/os/inc/os.h b/src/os/inc/os.h
index df4b847fbb..d4b71173a0 100644
--- a/src/os/inc/os.h
+++ b/src/os/inc/os.h
@@ -36,7 +36,7 @@ extern "C" {
 #include "osLinux32.h"
 #endif
 
-#ifdef _TD_ALPINE
+#ifdef _ALPINE
 #include "osAlpine.h"
 #endif
 
diff --git a/src/os/inc/osAlpine.h b/src/os/inc/osAlpine.h
index b8212373ce..d939adfb6d 100644
--- a/src/os/inc/osAlpine.h
+++ b/src/os/inc/osAlpine.h
@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_OS_LINUX64_H
-#define TDENGINE_OS_LINUX64_H
+#ifndef TDENGINE_OS_ALPINE_H
+#define TDENGINE_OS_ALPINE_H
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/os/inc/osLinux64.h b/src/os/inc/osLinux64.h
index 0a99f4b745..c0841c41bd 100644
--- a/src/os/inc/osLinux64.h
+++ b/src/os/inc/osLinux64.h
@@ -75,7 +75,9 @@ extern "C" {
 #include <fcntl.h>
 #include <sys/utsname.h>
 #include <sys/resource.h>
+#ifndef _ALPINE
 #include <error.h>
+#endif
 #include <linux/sysctl.h>
 
 #ifdef __cplusplus
diff --git a/src/os/src/detail/osSysinfo.c b/src/os/src/detail/osSysinfo.c
index c75e254b0e..83ecd85809 100644
--- a/src/os/src/detail/osSysinfo.c
+++ b/src/os/src/detail/osSysinfo.c
@@ -579,7 +579,11 @@ void taosSetCoreDump() {
   struct rlimit rlim;
   struct rlimit rlim_new;
   if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
+    #ifndef _ALPINE
     uInfo("the old unlimited para: rlim_cur=%" PRIu64 ", rlim_max=%" PRIu64, rlim.rlim_cur, rlim.rlim_max);
+    #else
+    uInfo("the old unlimited para: rlim_cur=%llu, rlim_max=%llu", rlim.rlim_cur, rlim.rlim_max);
+    #endif
     rlim_new.rlim_cur = RLIM_INFINITY;
     rlim_new.rlim_max = RLIM_INFINITY;
     if (setrlimit(RLIMIT_CORE, &rlim_new) != 0) {
@@ -591,7 +595,11 @@ void taosSetCoreDump() {
   }
 
   if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
+    #ifndef _ALPINE
     uInfo("the new unlimited para: rlim_cur=%" PRIu64 ", rlim_max=%" PRIu64, rlim.rlim_cur, rlim.rlim_max);
+    #else
+    uInfo("the new unlimited para: rlim_cur=%llu, rlim_max=%llu", rlim.rlim_cur, rlim.rlim_max);
+    #endif
   }
 
 #ifndef _TD_ARM_
@@ -659,4 +667,4 @@ bool taosGetSystemUid(char *uid) {
   return false;
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/util/src/tnote.c b/src/util/src/tnote.c
index ea09709449..4f05277a84 100644
--- a/src/util/src/tnote.c
+++ b/src/util/src/tnote.c
@@ -253,7 +253,7 @@ void taosNotePrint(taosNoteInfo * pNote, const char * const format, ...)
                 ptm->tm_min, ptm->tm_sec, (int)timeSecs.tv_usec, taosGetPthreadId());
 #else
   len = sprintf(buffer, "%02d/%02d %02d:%02d:%02d.%06d %lx ", ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min,
-                ptm->tm_sec, (int)timeSecs.tv_usec, pthread_self());
+                ptm->tm_sec, (int)timeSecs.tv_usec, (unsigned long int)pthread_self());
 #endif
     va_start(argpointer, format);
     len += vsnprintf(buffer + len, MAX_NOTE_LINE_SIZE - len, format, argpointer);

From 0f9543994a81c393d2ab4d109978ab19d727061d Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 5 Sep 2020 13:24:35 +0800
Subject: [PATCH 15/21] [td-1315]

---
 src/util/inc/hash.h   | 12 +++++++++++-
 src/util/src/hash.c   | 11 +++++++----
 src/util/src/tcache.c | 17 +++++++----------
 3 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/src/util/inc/hash.h b/src/util/inc/hash.h
index f289a4e8c3..2a58bec883 100644
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
@@ -110,7 +110,17 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da
  */
 void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen);
 
-void *taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void(*fp)(void*));
+/**
+ * apply the udf before return the result
+ * @param pHashObj
+ * @param key
+ * @param keyLen
+ * @param fp
+ * @param d
+ * @param dsize
+ * @return
+ */
+void* taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void* d, size_t dsize);
 
 /**
  * remove item with the specified key
diff --git a/src/util/src/hash.c b/src/util/src/hash.c
index cc96f83f44..7427a2e4f3 100644
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.c
@@ -255,10 +255,10 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da
 }
 
 void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen) {
-  return taosHashGetCB(pHashObj, key, keyLen, NULL);
+  return taosHashGetCB(pHashObj, key, keyLen, NULL, NULL, 0);
 }
 
-void *taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *)) {
+void* taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void* d, size_t dsize) {
   if (pHashObj->size <= 0 || keyLen == 0 || key == NULL) {
     return NULL;
   }
@@ -273,7 +273,6 @@ void *taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void (*f
 
   // no data, return directly
   if (atomic_load_32(&pe->num) == 0) {
-
     __rd_unlock(&pHashObj->lock, pHashObj->type);
     return NULL;
   }
@@ -297,7 +296,11 @@ void *taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void (*f
       fp(pNode->data);
     }
 
-    data = pNode->data;
+    if (d != NULL) {
+      memcpy(d, pNode->data, dsize);
+    } else {
+      data = pNode->data;
+    }
   }
 
   if (pHashObj->type == HASH_ENTRY_LOCK) {
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 9872898468..9c7a48bced 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -223,7 +223,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
           taosTFree(p);
         } else {
           taosAddToTrash(pCacheObj, p);
-          uError("cache:%s, key:%p, %p exist in cache, updated old:%p", pCacheObj->name, key, pNode1->data, p);
+          uDebug("cache:%s, key:%p, %p exist in cache, updated old:%p", pCacheObj->name, key, pNode1->data, p->data);
         }
       }
 
@@ -264,17 +264,14 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen
     return NULL;
   }
 
-  SCacheDataNode **ptNode = (SCacheDataNode **)taosHashGetCB(pCacheObj->pHashTable, key, keyLen, incRefFn);
-  if (ptNode != NULL) {
-    assert ((*ptNode) != NULL && (int64_t) ((*ptNode)->data) != 0x40);
-  }
+  SCacheDataNode* ptNode = NULL;
+  taosHashGetCB(pCacheObj->pHashTable, key, keyLen, incRefFn, &ptNode, sizeof(void*));
 
-  void* pData = (ptNode != NULL)? (*ptNode)->data:NULL;
-  assert((int64_t)pData != 0x40);
+  void* pData = (ptNode != NULL)? ptNode->data:NULL;
 
   if (pData != NULL) {
     atomic_add_fetch_32(&pCacheObj->statistics.hitCount, 1);
-    uDebug("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(*ptNode));
+    uDebug("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(ptNode));
   } else {
     atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
     uDebug("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
@@ -333,7 +330,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
   
   SCacheDataNode *pNode = (SCacheDataNode *)((char *)(*data) - offset);
   if (pNode->signature != (uint64_t)pNode) {
-    uError("%p, release invalid cache data", pNode);
+    uError("cache:%s, %p, release invalid cache data", pCacheObj->name, pNode);
     return;
   }
 
@@ -549,7 +546,7 @@ void taosTrashCanEmpty(SCacheObj *pCacheObj, bool force) {
     }
 
     if (force || (T_REF_VAL_GET(pElem->pData) == 0)) {
-      uError("cache:%s, key:%p, %p removed from trashcan. numOfElem in trashcan:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
+      uDebug("cache:%s, key:%p, %p removed from trashcan. numOfElem in trashcan:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data,
              pCacheObj->numOfElemsInTrash - 1);
 
       STrashElem *p = pElem;

From b98ed27fe468d69eff24f9f94c15fa4941cc2851 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 5 Sep 2020 13:27:19 +0800
Subject: [PATCH 16/21] [td-1315]

---
 src/client/src/tscUtil.c |  2 ++
 src/util/inc/tcache.h    |  2 +-
 src/util/src/tcache.c    | 14 +++++++-------
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index b45d40f49c..80e3828c9d 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -718,6 +718,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
   return TSDB_CODE_SUCCESS;
 }
 
+// TODO: all subqueries should be freed correctly before close this connection.
 void tscCloseTscObj(STscObj* pObj) {
   assert(pObj != NULL);
   
@@ -727,6 +728,7 @@ void tscCloseTscObj(STscObj* pObj) {
   
   if (pObj->pDnodeConn != NULL) {
     rpcClose(pObj->pDnodeConn);
+    pObj->pDnodeConn = NULL;
   }
   
   tscDebug("%p DB connection is closed, dnodeConn:%p", pObj, pObj->pDnodeConn);
diff --git a/src/util/inc/tcache.h b/src/util/inc/tcache.h
index 3d6f9705ee..af5f30c7c3 100644
--- a/src/util/inc/tcache.h
+++ b/src/util/inc/tcache.h
@@ -42,7 +42,7 @@ typedef struct SCacheDataNode {
   uint64_t           signature;
   struct STrashElem *pTNodeHeader; // point to trash node head
   uint16_t           keySize: 15;  // max key size: 32kb
-  bool               inTrashCan: 1;// denote if it is in trash or not
+  bool               inTrashcan: 1;// denote if it is in trash or not
   uint32_t           size;         // allocated size for current SCacheDataNode
   T_REF_DECLARE()
   char              *key;
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 9c7a48bced..ab489e2e46 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -337,9 +337,9 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
   *data = NULL;
 
   // note: extend lifespan before dec ref count
-  bool inTrashCan = pNode->inTrashCan;
+  bool inTrashcan = pNode->inTrashcan;
 
-  if (pCacheObj->extendLifespan && (!inTrashCan) && (!_remove)) {
+  if (pCacheObj->extendLifespan && (!inTrashcan) && (!_remove)) {
     atomic_store_64(&pNode->expireTime, pNode->lifespan + taosGetTimestampMs());
     uDebug("cache:%s data:%p extend expire time: %"PRId64, pCacheObj->name, pNode->data, pNode->expireTime);
   }
@@ -350,7 +350,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* d = pNode->data;
 
     int32_t ref = T_REF_VAL_GET(pNode);
-    uDebug("cache:%s, key:%p, %p is released, refcnt:%d, in trashcan:%d", pCacheObj->name, key, d, ref - 1, inTrashCan);
+    uDebug("cache:%s, key:%p, %p is released, refcnt:%d, in trashcan:%d", pCacheObj->name, key, d, ref - 1, inTrashcan);
 
     /*
      * If it is not referenced by other users, remove it immediately. Otherwise move this node to trashcan wait for all users
@@ -359,7 +359,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
      * NOTE: previous ref is 0, and current ref is still 0, remove it. If previous is not 0, there is another thread
      * that tries to do the same thing.
      */
-    if (inTrashCan) {
+    if (inTrashcan) {
       ref = T_REF_VAL_GET(pNode);
 
       if (ref == 1) {
@@ -428,7 +428,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) {
     char* p = pNode->data;
 
     int32_t ref = T_REF_DEC(pNode);
-    uDebug("cache:%s, key:%p, %p released, refcnt:%d, data in trashcan:%d", pCacheObj->name, key, p, ref, inTrashCan);
+    uDebug("cache:%s, key:%p, %p released, refcnt:%d, data in trashcan:%d", pCacheObj->name, key, p, ref, inTrashcan);
   }
 }
 
@@ -499,7 +499,7 @@ SCacheDataNode *taosCreateCacheNode(const char *key, size_t keyLen, const char *
 }
 
 void taosAddToTrash(SCacheObj *pCacheObj, SCacheDataNode *pNode) {
-  if (pNode->inTrashCan) { /* node is already in trash */
+  if (pNode->inTrashcan) { /* node is already in trash */
     assert(pNode->pTNodeHeader != NULL && pNode->pTNodeHeader->pData == pNode);
     return;
   }
@@ -507,7 +507,7 @@ void taosAddToTrash(SCacheObj *pCacheObj, SCacheDataNode *pNode) {
   STrashElem *pElem = calloc(1, sizeof(STrashElem));
   pElem->pData = pNode;
   pElem->prev  = NULL;
-  pNode->inTrashCan = true;
+  pNode->inTrashcan = true;
   pNode->pTNodeHeader = pElem;
 
   __cache_wr_lock(pCacheObj);

From 3a54e379ad25aed6410185bb320d900f43145779 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 5 Sep 2020 14:52:15 +0800
Subject: [PATCH 17/21] [td-1333]

---
 src/client/src/tscSQLParser.c |    2 +-
 src/client/src/tscServer.c    |    2 +-
 src/query/inc/sql.y           |    3 -
 src/query/src/qTokenizer.c    |    1 -
 src/query/src/sql.c           | 2357 ++++++++++++++++-----------------
 5 files changed, 1172 insertions(+), 1193 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index de608961c2..48980fefb6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -5088,7 +5088,7 @@ static int32_t setTimePrecision(SSqlCmd* pCmd, SCMCreateDbMsg* pMsg, SCreateDBIn
 }
 
 static void setCreateDBOption(SCMCreateDbMsg* pMsg, SCreateDBInfo* pCreateDb) {
-  pMsg->maxTables = htonl(pCreateDb->maxTablesPerVnode);
+  pMsg->maxTables = htonl(-1);  // max tables can not be set anymore
   pMsg->cacheBlockSize = htonl(pCreateDb->cacheBlockSize);
   pMsg->totalBlocks = htonl(pCreateDb->numOfBlocks);
   pMsg->daysPerFile = htonl(pCreateDb->daysPerFile);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 16e3458e13..fbc02cc40e 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -406,7 +406,7 @@ int doProcessSql(SSqlObj *pSql) {
   if (code != TSDB_CODE_SUCCESS) {
     pRes->code = code;
     tscQueueAsyncRes(pSql);
-    return pRes->code;
+    return code;
   }
   
   return TSDB_CODE_SUCCESS;
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index 7500dcba56..79aec2f349 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -217,7 +217,6 @@ acct_optr(Y) ::= pps(C) tseries(D) storage(P) streams(F) qtime(Q) dbs(E) users(K
 %destructor keep {tVariantListDestroy($$);}
 keep(Y)    ::= KEEP tagitemlist(X).           { Y = X; }
 
-tables(Y)  ::= MAXTABLES INTEGER(X).          { Y = X; }
 cache(Y)   ::= CACHE INTEGER(X).              { Y = X; }
 replica(Y) ::= REPLICA INTEGER(X).            { Y = X; }
 quorum(Y)  ::= QUORUM INTEGER(X).             { Y = X; }
@@ -234,7 +233,6 @@ prec(Y)    ::= PRECISION STRING(X).           { Y = X; }
 %type db_optr {SCreateDBInfo}
 db_optr(Y) ::= . {setDefaultCreateDbOption(&Y);}
 
-db_optr(Y) ::= db_optr(Z) tables(X).         { Y = Z; Y.maxTablesPerVnode = strtol(X.z, NULL, 10); }
 db_optr(Y) ::= db_optr(Z) cache(X).          { Y = Z; Y.cacheBlockSize = strtol(X.z, NULL, 10); }
 db_optr(Y) ::= db_optr(Z) replica(X).        { Y = Z; Y.replica = strtol(X.z, NULL, 10); }
 db_optr(Y) ::= db_optr(Z) quorum(X).         { Y = Z; Y.quorum = strtol(X.z, NULL, 10); }
@@ -254,7 +252,6 @@ alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y);}
 
 alter_db_optr(Y) ::= alter_db_optr(Z) replica(X).     { Y = Z; Y.replica = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) quorum(X).      { Y = Z; Y.quorum = strtol(X.z, NULL, 10); }
-alter_db_optr(Y) ::= alter_db_optr(Z) tables(X).      { Y = Z; Y.maxTablesPerVnode = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) keep(X).        { Y = Z; Y.keep = X; }
 alter_db_optr(Y) ::= alter_db_optr(Z) blocks(X).      { Y = Z; Y.numOfBlocks = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) comp(X).        { Y = Z; Y.compressionLevel = strtol(X.z, NULL, 10); }
diff --git a/src/query/src/qTokenizer.c b/src/query/src/qTokenizer.c
index 5fdabca166..0c9f92786f 100644
--- a/src/query/src/qTokenizer.c
+++ b/src/query/src/qTokenizer.c
@@ -121,7 +121,6 @@ static SKeyword keywordTable[] = {
     {"MINROWS",      TK_MINROWS},
     {"MAXROWS",      TK_MAXROWS},
     {"BLOCKS",       TK_BLOCKS},
-    {"MAXTABLES",    TK_MAXTABLES},
     {"CACHE",        TK_CACHE},
     {"CTIME",        TK_CTIME},
     {"WAL",          TK_WAL},
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index f3f55791b0..373e57963c 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -97,26 +97,26 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 274
+#define YYNOCODE 272
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  int yy46;
-  tSQLExpr* yy64;
-  tVariant yy134;
-  SCreateAcctSQL yy149;
-  int64_t yy207;
-  SLimitVal yy216;
-  TAOS_FIELD yy223;
-  SSubclauseInfo* yy231;
-  SCreateDBInfo yy268;
-  tSQLExprList* yy290;
-  SQuerySQL* yy414;
-  SCreateTableSQL* yy470;
-  tVariantList* yy498;
-  tFieldList* yy523;
+  SSubclauseInfo* yy25;
+  tSQLExpr* yy66;
+  SCreateAcctSQL yy73;
+  int yy82;
+  SQuerySQL* yy150;
+  SCreateDBInfo yy158;
+  TAOS_FIELD yy181;
+  SLimitVal yy188;
+  tSQLExprList* yy224;
+  int64_t yy271;
+  tVariant yy312;
+  SCreateTableSQL* yy374;
+  tFieldList* yy449;
+  tVariantList* yy494;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -126,17 +126,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             245
-#define YYNRULE              228
-#define YYNTOKEN             207
-#define YY_MAX_SHIFT         244
-#define YY_MIN_SHIFTREDUCE   407
-#define YY_MAX_SHIFTREDUCE   634
-#define YY_ERROR_ACTION      635
-#define YY_ACCEPT_ACTION     636
-#define YY_NO_ACTION         637
-#define YY_MIN_REDUCE        638
-#define YY_MAX_REDUCE        865
+#define YYNSTATE             244
+#define YYNRULE              225
+#define YYNTOKEN             206
+#define YY_MAX_SHIFT         243
+#define YY_MIN_SHIFTREDUCE   403
+#define YY_MAX_SHIFTREDUCE   627
+#define YY_ERROR_ACTION      628
+#define YY_ACCEPT_ACTION     629
+#define YY_NO_ACTION         630
+#define YY_MIN_REDUCE        631
+#define YY_MAX_REDUCE        855
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -202,219 +202,217 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (554)
+#define YY_ACTTAB_COUNT (549)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   105,  448,  137,  677,  636,  244,  128,  517,  137,  449,
- /*    10 */   137,  160,  853,   41,   43,   11,   35,   36,  852,  159,
- /*    20 */   853,   29,  136,  448,  199,   39,   37,   40,   38,  157,
- /*    30 */   105,  449,  141,   34,   33,  219,  218,   32,   31,   30,
- /*    40 */    41,   43,  771,   35,   36,   32,   31,   30,   29,  760,
- /*    50 */   448,  199,   39,   37,   40,   38,  184,  808,  449,  194,
- /*    60 */    34,   33,   21,   21,   32,   31,   30,  408,  409,  410,
- /*    70 */   411,  412,  413,  414,  415,  416,  417,  418,  419,  243,
- /*    80 */    41,   43,  230,   35,   36,  196,  849,   60,   29,   21,
- /*    90 */   848,  199,   39,   37,   40,   38,  168,  169,  757,  757,
- /*   100 */    34,   33,  170,   56,   32,   31,   30,  782,  847,   16,
- /*   110 */   237,  210,  236,  235,  209,  208,  207,  234,  206,  233,
- /*   120 */   232,  231,  205,  217,  153,  757,  736,  590,  723,  724,
- /*   130 */   725,  726,  727,  728,  729,  730,  731,  732,  733,  734,
- /*   140 */   735,   43,    8,   35,   36,   63,  115,   21,   29,  155,
- /*   150 */   242,  199,   39,   37,   40,   38,  241,  240,   97,  779,
- /*   160 */    34,   33,  167,  101,   32,   31,   30,  171,   35,   36,
- /*   170 */   216,  215,  596,   29,  599,  105,  199,   39,   37,   40,
- /*   180 */    38,  222,  760,  757,  238,   34,   33,  177,   12,   32,
- /*   190 */    31,   30,  164,  603,  181,  180,  594,  771,  597,  105,
- /*   200 */   600,  163,  164,  603,  760,   17,  594,  150,  597,  154,
- /*   210 */   600,  156,   26,   90,   89,  144,  187,  571,  572,   16,
- /*   220 */   237,  149,  236,  235,  161,  162,  221,  234,  198,  233,
- /*   230 */   232,  231,  807,   78,  161,  162,  164,  603,  549,  230,
- /*   240 */   594,    3,  597,   17,  600,   76,   80,   85,   88,   79,
- /*   250 */    26,   39,   37,   40,   38,   82,   61,  758,   21,   34,
- /*   260 */    33,  546,   62,   32,   31,   30,   18,  142,  161,  162,
- /*   270 */   183,  741,  541,  740,   27,  738,  739,  152,  686,  186,
- /*   280 */   742,  128,  744,  745,  743,  678,  533,  143,  128,  530,
- /*   290 */    42,  531,  562,  532,  756,  595,   46,  598,   34,   33,
- /*   300 */    42,  602,   32,   31,   30,  118,  119,   70,   66,   69,
- /*   310 */   592,  602,  145,   50,   75,   74,  601,  172,  173,  132,
- /*   320 */   130,   93,   92,   91,  100,   47,  601,  146,  563,  620,
- /*   330 */    51,   26,   14,   13,   42,  147,  604,  523,  522,  203,
- /*   340 */    13,   46,   22,   22,   48,  602,  593,   10,    9,  537,
- /*   350 */   535,  538,  536,   87,   86,  148,  139,  135,  862,  140,
- /*   360 */   601,  138,  759,  818,  817,  165,  814,  813,  166,  781,
- /*   370 */   751,  220,  800,  786,  788,  773,  102,  799,   26,  116,
- /*   380 */   114,  117,  688,  185,  204,  133,   24,  213,  685,  534,
- /*   390 */   214,  861,   95,   72,  860,  858,  558,  120,  706,   25,
- /*   400 */    23,  134,   52,  188,  675,   81,  673,   83,   84,  671,
- /*   410 */   670,  174,  192,  129,  668,  667,  666,  665,  664,  656,
- /*   420 */    49,  131,  662,  660,  658,  770,   57,   58,  801,   44,
- /*   430 */   197,  195,  193,  191,  189,   28,  106,  212,   77,  223,
- /*   440 */   224,  225,  226,  201,   53,  227,  228,  229,  239,   64,
- /*   450 */    67,  634,  151,  175,  176,  633,  178,  179,  632,  669,
- /*   460 */   186,  625,   94,   96,  123,  127,    2,  122,  707,  755,
- /*   470 */   121,  124,  125,  111,  107,  108,  126,  109,  110,  112,
- /*   480 */   663,  113,  182,    1,  543,   55,   59,  559,  103,  158,
- /*   490 */   564,    5,  190,  104,    6,   65,  490,  605,    4,   19,
- /*   500 */    20,   15,  200,    7,  202,  486,  484,  483,  482,  479,
- /*   510 */   452,  211,   68,   45,   22,   71,   73,  519,  518,  516,
- /*   520 */    54,  473,  471,  463,  469,  465,  467,  461,  459,  489,
- /*   530 */   488,  487,  485,  481,  480,  478,   46,  450,  423,  421,
- /*   540 */   638,  637,  637,  637,  637,  637,  637,  637,  637,  637,
- /*   550 */   637,  637,   98,   99,
+ /*     0 */   731,  444,  221,  729,  730,  629,  243,  510,  732,  445,
+ /*    10 */   734,  735,  733,   41,   43,  526,   35,   36,  523,   11,
+ /*    20 */   524,   29,  525,  444,  199,   39,   37,   40,   38,  155,
+ /*    30 */   241,  445,  748,   34,   33,  219,  218,   32,   31,   30,
+ /*    40 */    41,   43,  761,   35,   36,  136,  172,  173,   29,  137,
+ /*    50 */    21,  199,   39,   37,   40,   38,  184,  141,  160,  843,
+ /*    60 */    34,   33,  839,  772,   32,   31,   30,  404,  405,  406,
+ /*    70 */   407,  408,  409,  410,  411,  412,  413,  414,  415,  242,
+ /*    80 */    41,   43,  230,   35,   36,  746,   62,  137,   29,  137,
+ /*    90 */    21,  199,   39,   37,   40,   38,  159,  843,   27,  842,
+ /*   100 */    34,   33,   56,  838,   32,   31,   30,  105,   43,    8,
+ /*   110 */    35,   36,   63,  115,  769,   29,  761,  527,  199,   39,
+ /*   120 */    37,   40,   38,  168,  539,  747,  583,   34,   33,   18,
+ /*   130 */   156,   32,   31,   30,   16,  210,  236,  235,  209,  208,
+ /*   140 */   207,  234,  206,  233,  232,  231,  205,  727,  105,  715,
+ /*   150 */   716,  717,  718,  719,  720,  721,  722,  723,  724,  725,
+ /*   160 */   726,   35,   36,  798,  837,  194,   29,  177,  157,  199,
+ /*   170 */    39,   37,   40,   38,  181,  180,   21,   21,   34,   33,
+ /*   180 */   444,   12,   32,   31,   30,  164,  596,  750,  445,  587,
+ /*   190 */   153,  590,  154,  593,  105,  164,  596,   21,   17,  587,
+ /*   200 */   150,  590,  196,  593,   60,   26,   90,   89,  144,  169,
+ /*   210 */   217,  747,  747,   16,  149,  236,  235,  161,  162,  167,
+ /*   220 */   234,  198,  233,  232,  231,  142,  670,  161,  162,  128,
+ /*   230 */   222,  542,  747,  164,  596,   17,  143,  587,  750,  590,
+ /*   240 */   105,  593,   26,   39,   37,   40,   38,  100,  170,  145,
+ /*   250 */   797,   34,   33,  101,   26,   32,   31,   30,   32,   31,
+ /*   260 */    30,   78,  183,  564,  565,  161,  162,  230,  589,  152,
+ /*   270 */   592,   76,   80,   85,   88,   79,  240,  239,   97,   34,
+ /*   280 */    33,   82,   42,   32,   31,   30,  118,  119,   70,   66,
+ /*   290 */    69,  237,   42,  595,  679,  163,   61,  128,  132,  130,
+ /*   300 */    93,   92,   91,  595,  671,  187,  585,  128,  594,  588,
+ /*   310 */   750,  591,  171,  534,   47,  216,  215,  146,  594,  555,
+ /*   320 */   186,  147,  556,   46,  613,  148,   14,  597,   13,  139,
+ /*   330 */    42,   13,   50,   48,    3,  135,   75,   74,  140,  516,
+ /*   340 */   515,  595,  586,   46,   22,  138,  203,   10,    9,   51,
+ /*   350 */    22,  852,  530,  528,  531,  529,  594,   87,   86,  749,
+ /*   360 */   808,  807,  165,  804,  803,  166,  771,  741,  220,  776,
+ /*   370 */   763,  778,  102,  790,  789,  116,  117,  114,  681,  204,
+ /*   380 */   133,   24,  213,  678,  214,  851,   72,  850,  848,   26,
+ /*   390 */   120,  699,   25,   23,  185,   95,  134,  668,   81,  551,
+ /*   400 */   666,   83,   84,  664,  188,  663,  174,  129,  661,  660,
+ /*   410 */   659,  658,  657,  649,  131,  655,  653,  192,   52,  651,
+ /*   420 */   760,   57,   49,   58,  791,   44,  197,  195,  193,  191,
+ /*   430 */   189,   28,  212,   77,  223,  224,  225,  226,  227,  228,
+ /*   440 */   229,  238,  627,  176,  175,  626,  201,  178,  179,   53,
+ /*   450 */   625,  618,  182,  536,   64,  151,  186,   67,  552,   55,
+ /*   460 */   103,  158,  662,   59,  200,   94,   96,  123,  700,  121,
+ /*   470 */   126,  106,  107,  122,  124,  125,  127,  112,  108,  109,
+ /*   480 */   113,  745,  110,  656,  111,    1,    2,  190,    5,  557,
+ /*   490 */   104,   19,    6,  598,   20,    4,   15,    7,   65,  485,
+ /*   500 */   202,  481,  479,  478,  477,  474,  448,  211,   68,   45,
+ /*   510 */    71,   73,   22,  512,  511,  509,   54,  469,  467,  459,
+ /*   520 */   465,  461,  463,  457,  455,  484,  483,  482,  480,  476,
+ /*   530 */   475,   46,  446,  419,  417,  631,  630,  630,  630,  630,
+ /*   540 */   630,  630,  630,  630,  630,  630,  630,   98,   99,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   211,    1,  262,  215,  208,  209,  218,    5,  262,    9,
- /*    10 */   262,  271,  272,   13,   14,  262,   16,   17,  272,  271,
- /*    20 */   272,   21,  262,    1,   24,   25,   26,   27,   28,  228,
- /*    30 */   211,    9,  262,   33,   34,   33,   34,   37,   38,   39,
- /*    40 */    13,   14,  246,   16,   17,   37,   38,   39,   21,  248,
- /*    50 */     1,   24,   25,   26,   27,   28,  260,  268,    9,  270,
- /*    60 */    33,   34,  211,  211,   37,   38,   39,   45,   46,   47,
+ /*     0 */   226,    1,  210,  229,  230,  207,  208,    5,  234,    9,
+ /*    10 */   236,  237,  238,   13,   14,    2,   16,   17,    5,  260,
+ /*    20 */     7,   21,    9,    1,   24,   25,   26,   27,   28,  209,
+ /*    30 */   210,    9,  240,   33,   34,   33,   34,   37,   38,   39,
+ /*    40 */    13,   14,  244,   16,   17,  260,   33,   34,   21,  260,
+ /*    50 */   210,   24,   25,   26,   27,   28,  258,  260,  269,  270,
+ /*    60 */    33,   34,  260,  210,   37,   38,   39,   45,   46,   47,
  /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    80 */    13,   14,   78,   16,   17,  266,  262,  268,   21,  211,
- /*    90 */   262,   24,   25,   26,   27,   28,  245,  245,  247,  247,
- /*   100 */    33,   34,   63,  103,   37,   38,   39,  211,  262,   85,
- /*   110 */    86,   87,   88,   89,   90,   91,   92,   93,   94,   95,
- /*   120 */    96,   97,   98,  245,  262,  247,  227,  100,  229,  230,
- /*   130 */   231,  232,  233,  234,  235,  236,  237,  238,  239,  240,
- /*   140 */   241,   14,   99,   16,   17,  102,  103,  211,   21,  210,
- /*   150 */   211,   24,   25,   26,   27,   28,   60,   61,   62,  263,
- /*   160 */    33,   34,  228,  211,   37,   38,   39,  128,   16,   17,
- /*   170 */   131,  132,    5,   21,    7,  211,   24,   25,   26,   27,
- /*   180 */    28,  245,  248,  247,  228,   33,   34,  127,   44,   37,
- /*   190 */    38,   39,    1,    2,  134,  135,    5,  246,    7,  211,
- /*   200 */     9,   59,    1,    2,  248,   99,    5,   63,    7,  262,
- /*   210 */     9,  260,  106,   69,   70,   71,  264,  116,  117,   85,
- /*   220 */    86,   77,   88,   89,   33,   34,  211,   93,   37,   95,
- /*   230 */    96,   97,  268,   72,   33,   34,    1,    2,   37,   78,
- /*   240 */     5,   99,    7,   99,    9,   64,   65,   66,   67,   68,
- /*   250 */   106,   25,   26,   27,   28,   74,  268,  242,  211,   33,
- /*   260 */    34,  104,  249,   37,   38,   39,  109,  262,   33,   34,
- /*   270 */   126,  227,  100,  229,  261,  231,  232,  133,  215,  107,
- /*   280 */   236,  218,  238,  239,  240,  215,    2,  262,  218,    5,
- /*   290 */    99,    7,  100,    9,  247,    5,  104,    7,   33,   34,
- /*   300 */    99,  110,   37,   38,   39,   64,   65,   66,   67,   68,
- /*   310 */     1,  110,  262,  104,  129,  130,  125,   33,   34,   64,
- /*   320 */    65,   66,   67,   68,   99,  104,  125,  262,  100,  100,
- /*   330 */   121,  106,  104,  104,   99,  262,  100,  100,  100,  100,
- /*   340 */   104,  104,  104,  104,  123,  110,   37,  129,  130,    5,
- /*   350 */     5,    7,    7,   72,   73,  262,  262,  262,  248,  262,
- /*   360 */   125,  262,  248,  243,  243,  243,  243,  243,  243,  211,
- /*   370 */   244,  243,  269,  211,  211,  246,  211,  269,  106,  211,
- /*   380 */   250,  211,  211,  246,  211,  211,  211,  211,  211,  105,
- /*   390 */   211,  211,   59,  211,  211,  211,  110,  211,  211,  211,
- /*   400 */   211,  211,  120,  265,  211,  211,  211,  211,  211,  211,
- /*   410 */   211,  211,  265,  211,  211,  211,  211,  211,  211,  211,
- /*   420 */   122,  211,  211,  211,  211,  259,  212,  212,  212,  119,
- /*   430 */   114,  118,  113,  112,  111,  124,  258,   75,   84,   83,
- /*   440 */    49,   80,   82,  212,  212,   53,   81,   79,   75,  216,
- /*   450 */   216,    5,  212,  136,    5,    5,  136,    5,    5,  212,
- /*   460 */   107,   87,  213,  213,  220,  219,  214,  224,  226,  246,
- /*   470 */   225,  223,  221,  253,  257,  256,  222,  255,  254,  252,
- /*   480 */   212,  251,  127,  217,  100,  108,  104,  100,   99,    1,
- /*   490 */   100,  115,   99,   99,  115,   72,    9,  100,   99,  104,
- /*   500 */   104,   99,  101,   99,  101,    5,    5,    5,    5,    5,
- /*   510 */    76,   15,   72,   16,  104,  130,  130,    5,    5,  100,
- /*   520 */    99,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   530 */     5,    5,    5,    5,    5,    5,  104,   76,   59,   58,
- /*   540 */     0,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   550 */   273,  273,   21,   21,  273,  273,  273,  273,  273,  273,
- /*   560 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   570 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   580 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   590 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   600 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   610 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   620 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   630 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   640 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   650 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   660 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   670 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   680 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   690 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   700 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   710 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   720 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   730 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   740 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   750 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   760 */   273,
+ /*    80 */    13,   14,   78,   16,   17,  245,  247,  260,   21,  260,
+ /*    90 */   210,   24,   25,   26,   27,   28,  269,  270,  259,  270,
+ /*   100 */    33,   34,  102,  260,   37,   38,   39,  210,   14,   98,
+ /*   110 */    16,   17,  101,  102,  261,   21,  244,  104,   24,   25,
+ /*   120 */    26,   27,   28,  243,  103,  245,   99,   33,   34,  108,
+ /*   130 */   258,   37,   38,   39,   85,   86,   87,   88,   89,   90,
+ /*   140 */    91,   92,   93,   94,   95,   96,   97,  226,  210,  228,
+ /*   150 */   229,  230,  231,  232,  233,  234,  235,  236,  237,  238,
+ /*   160 */   239,   16,   17,  266,  260,  268,   21,  126,  227,   24,
+ /*   170 */    25,   26,   27,   28,  133,  134,  210,  210,   33,   34,
+ /*   180 */     1,   44,   37,   38,   39,    1,    2,  246,    9,    5,
+ /*   190 */   260,    7,  260,    9,  210,    1,    2,  210,   98,    5,
+ /*   200 */    63,    7,  264,    9,  266,  105,   69,   70,   71,  243,
+ /*   210 */   243,  245,  245,   85,   77,   87,   88,   33,   34,  227,
+ /*   220 */    92,   37,   94,   95,   96,  260,  214,   33,   34,  217,
+ /*   230 */   243,   37,  245,    1,    2,   98,  260,    5,  246,    7,
+ /*   240 */   210,    9,  105,   25,   26,   27,   28,   98,   63,  260,
+ /*   250 */   266,   33,   34,  210,  105,   37,   38,   39,   37,   38,
+ /*   260 */    39,   72,  125,  115,  116,   33,   34,   78,    5,  132,
+ /*   270 */     7,   64,   65,   66,   67,   68,   60,   61,   62,   33,
+ /*   280 */    34,   74,   98,   37,   38,   39,   64,   65,   66,   67,
+ /*   290 */    68,  227,   98,  109,  214,   59,  266,  217,   64,   65,
+ /*   300 */    66,   67,   68,  109,  214,  262,    1,  217,  124,    5,
+ /*   310 */   246,    7,  127,   99,  103,  130,  131,  260,  124,   99,
+ /*   320 */   106,  260,   99,  103,   99,  260,  103,   99,  103,  260,
+ /*   330 */    98,  103,  103,  122,   98,  260,  128,  129,  260,   99,
+ /*   340 */    99,  109,   37,  103,  103,  260,   99,  128,  129,  120,
+ /*   350 */   103,  246,    5,    5,    7,    7,  124,   72,   73,  246,
+ /*   360 */   241,  241,  241,  241,  241,  241,  210,  242,  241,  210,
+ /*   370 */   244,  210,  210,  267,  267,  210,  210,  248,  210,  210,
+ /*   380 */   210,  210,  210,  210,  210,  210,  210,  210,  210,  105,
+ /*   390 */   210,  210,  210,  210,  244,   59,  210,  210,  210,  109,
+ /*   400 */   210,  210,  210,  210,  263,  210,  210,  210,  210,  210,
+ /*   410 */   210,  210,  210,  210,  210,  210,  210,  263,  119,  210,
+ /*   420 */   257,  211,  121,  211,  211,  118,  113,  117,  112,  111,
+ /*   430 */   110,  123,   75,   84,   83,   49,   80,   82,   53,   81,
+ /*   440 */    79,   75,    5,    5,  135,    5,  211,  135,    5,  211,
+ /*   450 */     5,   86,  126,   99,  215,  211,  106,  215,   99,  107,
+ /*   460 */    98,    1,  211,  103,  100,  212,  212,  219,  225,  224,
+ /*   470 */   221,  256,  255,  223,  222,  220,  218,  250,  254,  253,
+ /*   480 */   249,  244,  252,  211,  251,  216,  213,   98,  114,   99,
+ /*   490 */    98,  103,  114,   99,  103,   98,   98,   98,   72,    9,
+ /*   500 */   100,    5,    5,    5,    5,    5,   76,   15,   72,   16,
+ /*   510 */   129,  129,  103,    5,    5,   99,   98,    5,    5,    5,
+ /*   520 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+ /*   530 */     5,  103,   76,   59,   58,    0,  271,  271,  271,  271,
+ /*   540 */   271,  271,  271,  271,  271,  271,  271,   21,   21,  271,
+ /*   550 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   560 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   570 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   580 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   590 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   600 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   610 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   620 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   630 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   640 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   650 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   660 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   670 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   680 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   690 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   700 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   710 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   720 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   730 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   740 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   750 */   271,  271,  271,  271,  271,
 };
-#define YY_SHIFT_COUNT    (244)
+#define YY_SHIFT_COUNT    (243)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (540)
+#define YY_SHIFT_MAX      (535)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   144,   24,  134,  191,  235,   49,   49,   49,   49,   49,
- /*    10 */    49,    0,   22,  235,  284,  284,  284,  106,   49,   49,
- /*    20 */    49,   49,   49,  161,    4,    4,  554,  201,  235,  235,
- /*    30 */   235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
- /*    40 */   235,  235,  235,  235,  235,  284,  284,    2,    2,    2,
- /*    50 */     2,    2,    2,   43,    2,  225,   49,   49,   49,   49,
- /*    60 */   101,  101,  157,   49,   49,   49,   49,   49,   49,   49,
- /*    70 */    49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
- /*    80 */    49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
- /*    90 */    49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
- /*   100 */   272,  333,  333,  286,  286,  333,  282,  298,  310,  316,
- /*   110 */   313,  319,  321,  323,  311,  272,  333,  333,  362,  362,
- /*   120 */   333,  354,  356,  391,  361,  360,  392,  365,  368,  333,
- /*   130 */   373,  333,  373,  554,  554,   27,   67,   67,   67,  127,
- /*   140 */   152,  226,  226,  226,  181,  265,  265,  265,  265,  241,
- /*   150 */   255,   39,   60,    8,    8,   96,  172,  192,  228,  229,
- /*   160 */   236,  167,  290,  309,  142,  221,  209,  237,  238,  239,
- /*   170 */   185,  218,  344,  345,  281,  446,  317,  449,  450,  320,
- /*   180 */   452,  453,  374,  355,  353,  384,  377,  382,  387,  389,
- /*   190 */   488,  393,  390,  394,  395,  376,  396,  379,  397,  399,
- /*   200 */   402,  401,  404,  403,  423,  487,  500,  501,  502,  503,
- /*   210 */   504,  434,  496,  440,  497,  385,  386,  410,  512,  513,
- /*   220 */   419,  421,  410,  516,  517,  518,  519,  520,  521,  522,
- /*   230 */   523,  524,  525,  526,  527,  528,  529,  530,  432,  461,
- /*   240 */   531,  532,  479,  481,  540,
+ /*     0 */   137,   49,  128,  184,  232,  179,  179,  179,  179,  179,
+ /*    10 */   179,    0,   22,  232,   13,   13,   13,  100,  179,  179,
+ /*    20 */   179,  179,  179,  189,    4,    4,  549,  194,  232,  232,
+ /*    30 */   232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+ /*    40 */   232,  232,  232,  232,  232,   13,   13,    2,    2,    2,
+ /*    50 */     2,    2,    2,   11,    2,  149,  179,  179,  179,  179,
+ /*    60 */   148,  148,   21,  179,  179,  179,  179,  179,  179,  179,
+ /*    70 */   179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
+ /*    80 */   179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
+ /*    90 */   179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
+ /*   100 */   284,  336,  336,  290,  290,  336,  299,  301,  307,  313,
+ /*   110 */   310,  316,  318,  320,  308,  284,  336,  336,  357,  357,
+ /*   120 */   336,  349,  351,  386,  356,  355,  385,  358,  361,  336,
+ /*   130 */   366,  336,  366,  549,  549,   27,   67,   67,   67,   94,
+ /*   140 */   145,  218,  218,  218,  207,  246,  246,  246,  246,  222,
+ /*   150 */   234,  185,   41,  221,  221,  216,  214,  220,  223,  225,
+ /*   160 */   228,  263,  304,  305,  236,  211,  229,  240,  241,  247,
+ /*   170 */   208,  219,  347,  348,  285,  437,  309,  438,  440,  312,
+ /*   180 */   443,  445,  365,  326,  350,  354,  352,  360,  359,  362,
+ /*   190 */   460,  389,  390,  392,  388,  374,  391,  378,  394,  397,
+ /*   200 */   398,  364,  399,  400,  426,  490,  496,  497,  498,  499,
+ /*   210 */   500,  430,  492,  436,  493,  381,  382,  409,  508,  509,
+ /*   220 */   416,  418,  409,  512,  513,  514,  515,  516,  517,  518,
+ /*   230 */   519,  520,  521,  522,  523,  524,  525,  428,  456,  526,
+ /*   240 */   527,  474,  476,  535,
 };
 #define YY_REDUCE_COUNT (134)
-#define YY_REDUCE_MIN   (-260)
-#define YY_REDUCE_MAX   (268)
+#define YY_REDUCE_MIN   (-241)
+#define YY_REDUCE_MAX   (273)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -204, -101,   44, -260, -252, -211, -181, -149, -148, -122,
- /*    10 */   -64, -104,  -61, -254, -199,  -66,  -44,  -49,  -48,  -36,
- /*    20 */   -12,   15,   47, -212,   63,   70,   13, -247, -240, -230,
- /*    30 */  -176, -172, -154, -138,  -53,    5,   25,   50,   65,   73,
- /*    40 */    93,   94,   95,   97,   99,  110,  114,  120,  121,  122,
- /*    50 */   123,  124,  125,  126,  128,  129,  158,  162,  163,  165,
- /*    60 */   103,  108,  130,  168,  170,  171,  173,  174,  175,  176,
- /*    70 */   177,  179,  180,  182,  183,  184,  186,  187,  188,  189,
- /*    80 */   190,  193,  194,  195,  196,  197,  198,  199,  200,  202,
- /*    90 */   203,  204,  205,  206,  207,  208,  210,  211,  212,  213,
- /*   100 */   137,  214,  215,  138,  147,  216,  166,  178,  217,  219,
- /*   110 */   222,  224,  220,  227,  230,  223,  231,  232,  233,  234,
- /*   120 */   240,  242,  245,  243,  244,  248,  251,  254,  246,  247,
- /*   130 */   249,  268,  250,  266,  252,
+ /*     0 */  -202,  -79, -226, -211, -173, -103,  -62, -120,  -34,  -33,
+ /*    10 */   -13, -147, -180, -171,  -59,   -8,   64, -128,   43,  -16,
+ /*    20 */    30, -208, -160,   12,   80,   90, -161, -241, -215, -203,
+ /*    30 */  -198, -157,  -96,  -70,  -68,  -35,  -24,  -11,   57,   61,
+ /*    40 */    65,   69,   75,   78,   85,  105,  113,  119,  120,  121,
+ /*    50 */   122,  123,  124,  125,  127,  126,  156,  159,  161,  162,
+ /*    60 */   106,  107,  129,  165,  166,  168,  169,  170,  171,  172,
+ /*    70 */   173,  174,  175,  176,  177,  178,  180,  181,  182,  183,
+ /*    80 */   186,  187,  188,  190,  191,  192,  193,  195,  196,  197,
+ /*    90 */   198,  199,  200,  201,  202,  203,  204,  205,  206,  209,
+ /*   100 */   150,  210,  212,  141,  154,  213,  163,  215,  217,  224,
+ /*   110 */   226,  230,  233,  227,  231,  237,  235,  238,  239,  242,
+ /*   120 */   244,  243,  245,  250,  248,  252,  255,  249,  258,  251,
+ /*   130 */   253,  272,  254,  269,  273,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   635,  687,  676,  855,  855,  635,  635,  635,  635,  635,
- /*    10 */   635,  783,  653,  855,  635,  635,  635,  635,  635,  635,
- /*    20 */   635,  635,  635,  689,  689,  689,  778,  635,  635,  635,
- /*    30 */   635,  635,  635,  635,  635,  635,  635,  635,  635,  635,
- /*    40 */   635,  635,  635,  635,  635,  635,  635,  635,  635,  635,
- /*    50 */   635,  635,  635,  635,  635,  635,  635,  785,  787,  635,
- /*    60 */   804,  804,  776,  635,  635,  635,  635,  635,  635,  635,
- /*    70 */   635,  635,  635,  635,  635,  635,  635,  635,  635,  635,
- /*    80 */   635,  674,  635,  672,  635,  635,  635,  635,  635,  635,
- /*    90 */   635,  635,  635,  635,  635,  635,  635,  661,  635,  635,
- /*   100 */   635,  655,  655,  635,  635,  655,  811,  815,  809,  797,
- /*   110 */   805,  796,  792,  791,  819,  635,  655,  655,  684,  684,
- /*   120 */   655,  705,  703,  701,  693,  699,  695,  697,  691,  655,
- /*   130 */   682,  655,  682,  722,  737,  635,  820,  854,  810,  838,
- /*   140 */   837,  850,  844,  843,  635,  842,  841,  840,  839,  635,
- /*   150 */   635,  635,  635,  846,  845,  635,  635,  635,  635,  635,
- /*   160 */   635,  635,  635,  635,  822,  816,  812,  635,  635,  635,
- /*   170 */   635,  635,  635,  635,  635,  635,  635,  635,  635,  635,
- /*   180 */   635,  635,  635,  635,  775,  635,  635,  784,  635,  635,
- /*   190 */   635,  635,  635,  635,  806,  635,  798,  635,  635,  635,
- /*   200 */   635,  635,  635,  752,  635,  635,  635,  635,  635,  635,
- /*   210 */   635,  635,  635,  635,  635,  635,  635,  859,  635,  635,
- /*   220 */   635,  746,  857,  635,  635,  635,  635,  635,  635,  635,
- /*   230 */   635,  635,  635,  635,  635,  635,  635,  635,  708,  635,
- /*   240 */   659,  657,  635,  651,  635,
+ /*     0 */   628,  680,  669,  845,  845,  628,  628,  628,  628,  628,
+ /*    10 */   628,  773,  646,  845,  628,  628,  628,  628,  628,  628,
+ /*    20 */   628,  628,  628,  682,  682,  682,  768,  628,  628,  628,
+ /*    30 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
+ /*    40 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
+ /*    50 */   628,  628,  628,  628,  628,  628,  628,  775,  777,  628,
+ /*    60 */   794,  794,  766,  628,  628,  628,  628,  628,  628,  628,
+ /*    70 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
+ /*    80 */   628,  667,  628,  665,  628,  628,  628,  628,  628,  628,
+ /*    90 */   628,  628,  628,  628,  628,  628,  628,  654,  628,  628,
+ /*   100 */   628,  648,  648,  628,  628,  648,  801,  805,  799,  787,
+ /*   110 */   795,  786,  782,  781,  809,  628,  648,  648,  677,  677,
+ /*   120 */   648,  698,  696,  694,  686,  692,  688,  690,  684,  648,
+ /*   130 */   675,  648,  675,  714,  728,  628,  810,  844,  800,  828,
+ /*   140 */   827,  840,  834,  833,  628,  832,  831,  830,  829,  628,
+ /*   150 */   628,  628,  628,  836,  835,  628,  628,  628,  628,  628,
+ /*   160 */   628,  628,  628,  628,  812,  806,  802,  628,  628,  628,
+ /*   170 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
+ /*   180 */   628,  628,  628,  628,  765,  628,  628,  774,  628,  628,
+ /*   190 */   628,  628,  628,  628,  796,  628,  788,  628,  628,  628,
+ /*   200 */   628,  628,  628,  742,  628,  628,  628,  628,  628,  628,
+ /*   210 */   628,  628,  628,  628,  628,  628,  628,  849,  628,  628,
+ /*   220 */   628,  736,  847,  628,  628,  628,  628,  628,  628,  628,
+ /*   230 */   628,  628,  628,  628,  628,  628,  628,  701,  628,  652,
+ /*   240 */   650,  628,  644,  628,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -520,7 +518,6 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*      CONNS => nothing */
     0,  /*      STATE => nothing */
     0,  /*       KEEP => nothing */
-    0,  /*  MAXTABLES => nothing */
     0,  /*      CACHE => nothing */
     0,  /*    REPLICA => nothing */
     0,  /*     QUORUM => nothing */
@@ -813,193 +810,191 @@ static const char *const yyTokenName[] = {
   /*   83 */ "CONNS",
   /*   84 */ "STATE",
   /*   85 */ "KEEP",
-  /*   86 */ "MAXTABLES",
-  /*   87 */ "CACHE",
-  /*   88 */ "REPLICA",
-  /*   89 */ "QUORUM",
-  /*   90 */ "DAYS",
-  /*   91 */ "MINROWS",
-  /*   92 */ "MAXROWS",
-  /*   93 */ "BLOCKS",
-  /*   94 */ "CTIME",
-  /*   95 */ "WAL",
-  /*   96 */ "FSYNC",
-  /*   97 */ "COMP",
-  /*   98 */ "PRECISION",
-  /*   99 */ "LP",
-  /*  100 */ "RP",
-  /*  101 */ "TAGS",
-  /*  102 */ "USING",
-  /*  103 */ "AS",
-  /*  104 */ "COMMA",
-  /*  105 */ "NULL",
-  /*  106 */ "SELECT",
-  /*  107 */ "UNION",
-  /*  108 */ "ALL",
-  /*  109 */ "FROM",
-  /*  110 */ "VARIABLE",
-  /*  111 */ "INTERVAL",
-  /*  112 */ "FILL",
-  /*  113 */ "SLIDING",
-  /*  114 */ "ORDER",
-  /*  115 */ "BY",
-  /*  116 */ "ASC",
-  /*  117 */ "DESC",
-  /*  118 */ "GROUP",
-  /*  119 */ "HAVING",
-  /*  120 */ "LIMIT",
-  /*  121 */ "OFFSET",
-  /*  122 */ "SLIMIT",
-  /*  123 */ "SOFFSET",
-  /*  124 */ "WHERE",
-  /*  125 */ "NOW",
-  /*  126 */ "RESET",
-  /*  127 */ "QUERY",
-  /*  128 */ "ADD",
-  /*  129 */ "COLUMN",
-  /*  130 */ "TAG",
-  /*  131 */ "CHANGE",
-  /*  132 */ "SET",
-  /*  133 */ "KILL",
-  /*  134 */ "CONNECTION",
-  /*  135 */ "STREAM",
-  /*  136 */ "COLON",
-  /*  137 */ "ABORT",
-  /*  138 */ "AFTER",
-  /*  139 */ "ATTACH",
-  /*  140 */ "BEFORE",
-  /*  141 */ "BEGIN",
-  /*  142 */ "CASCADE",
-  /*  143 */ "CLUSTER",
-  /*  144 */ "CONFLICT",
-  /*  145 */ "COPY",
-  /*  146 */ "DEFERRED",
-  /*  147 */ "DELIMITERS",
-  /*  148 */ "DETACH",
-  /*  149 */ "EACH",
-  /*  150 */ "END",
-  /*  151 */ "EXPLAIN",
-  /*  152 */ "FAIL",
-  /*  153 */ "FOR",
-  /*  154 */ "IGNORE",
-  /*  155 */ "IMMEDIATE",
-  /*  156 */ "INITIALLY",
-  /*  157 */ "INSTEAD",
-  /*  158 */ "MATCH",
-  /*  159 */ "KEY",
-  /*  160 */ "OF",
-  /*  161 */ "RAISE",
-  /*  162 */ "REPLACE",
-  /*  163 */ "RESTRICT",
-  /*  164 */ "ROW",
-  /*  165 */ "STATEMENT",
-  /*  166 */ "TRIGGER",
-  /*  167 */ "VIEW",
-  /*  168 */ "COUNT",
-  /*  169 */ "SUM",
-  /*  170 */ "AVG",
-  /*  171 */ "MIN",
-  /*  172 */ "MAX",
-  /*  173 */ "FIRST",
-  /*  174 */ "LAST",
-  /*  175 */ "TOP",
-  /*  176 */ "BOTTOM",
-  /*  177 */ "STDDEV",
-  /*  178 */ "PERCENTILE",
-  /*  179 */ "APERCENTILE",
-  /*  180 */ "LEASTSQUARES",
-  /*  181 */ "HISTOGRAM",
-  /*  182 */ "DIFF",
-  /*  183 */ "SPREAD",
-  /*  184 */ "TWA",
-  /*  185 */ "INTERP",
-  /*  186 */ "LAST_ROW",
-  /*  187 */ "RATE",
-  /*  188 */ "IRATE",
-  /*  189 */ "SUM_RATE",
-  /*  190 */ "SUM_IRATE",
-  /*  191 */ "AVG_RATE",
-  /*  192 */ "AVG_IRATE",
-  /*  193 */ "TBID",
-  /*  194 */ "SEMI",
-  /*  195 */ "NONE",
-  /*  196 */ "PREV",
-  /*  197 */ "LINEAR",
-  /*  198 */ "IMPORT",
-  /*  199 */ "METRIC",
-  /*  200 */ "TBNAME",
-  /*  201 */ "JOIN",
-  /*  202 */ "METRICS",
-  /*  203 */ "STABLE",
-  /*  204 */ "INSERT",
-  /*  205 */ "INTO",
-  /*  206 */ "VALUES",
-  /*  207 */ "error",
-  /*  208 */ "program",
-  /*  209 */ "cmd",
-  /*  210 */ "dbPrefix",
-  /*  211 */ "ids",
-  /*  212 */ "cpxName",
-  /*  213 */ "ifexists",
-  /*  214 */ "alter_db_optr",
-  /*  215 */ "acct_optr",
-  /*  216 */ "ifnotexists",
-  /*  217 */ "db_optr",
-  /*  218 */ "pps",
-  /*  219 */ "tseries",
-  /*  220 */ "dbs",
-  /*  221 */ "streams",
-  /*  222 */ "storage",
-  /*  223 */ "qtime",
-  /*  224 */ "users",
-  /*  225 */ "conns",
-  /*  226 */ "state",
-  /*  227 */ "keep",
-  /*  228 */ "tagitemlist",
-  /*  229 */ "tables",
-  /*  230 */ "cache",
-  /*  231 */ "replica",
-  /*  232 */ "quorum",
-  /*  233 */ "days",
-  /*  234 */ "minrows",
-  /*  235 */ "maxrows",
-  /*  236 */ "blocks",
-  /*  237 */ "ctime",
-  /*  238 */ "wal",
-  /*  239 */ "fsync",
-  /*  240 */ "comp",
-  /*  241 */ "prec",
-  /*  242 */ "typename",
-  /*  243 */ "signed",
-  /*  244 */ "create_table_args",
-  /*  245 */ "columnlist",
-  /*  246 */ "select",
-  /*  247 */ "column",
-  /*  248 */ "tagitem",
-  /*  249 */ "selcollist",
-  /*  250 */ "from",
-  /*  251 */ "where_opt",
-  /*  252 */ "interval_opt",
-  /*  253 */ "fill_opt",
-  /*  254 */ "sliding_opt",
-  /*  255 */ "groupby_opt",
-  /*  256 */ "orderby_opt",
-  /*  257 */ "having_opt",
-  /*  258 */ "slimit_opt",
-  /*  259 */ "limit_opt",
-  /*  260 */ "union",
-  /*  261 */ "sclp",
-  /*  262 */ "expr",
-  /*  263 */ "as",
-  /*  264 */ "tablelist",
-  /*  265 */ "tmvar",
-  /*  266 */ "sortlist",
-  /*  267 */ "sortitem",
-  /*  268 */ "item",
-  /*  269 */ "sortorder",
-  /*  270 */ "grouplist",
-  /*  271 */ "exprlist",
-  /*  272 */ "expritem",
+  /*   86 */ "CACHE",
+  /*   87 */ "REPLICA",
+  /*   88 */ "QUORUM",
+  /*   89 */ "DAYS",
+  /*   90 */ "MINROWS",
+  /*   91 */ "MAXROWS",
+  /*   92 */ "BLOCKS",
+  /*   93 */ "CTIME",
+  /*   94 */ "WAL",
+  /*   95 */ "FSYNC",
+  /*   96 */ "COMP",
+  /*   97 */ "PRECISION",
+  /*   98 */ "LP",
+  /*   99 */ "RP",
+  /*  100 */ "TAGS",
+  /*  101 */ "USING",
+  /*  102 */ "AS",
+  /*  103 */ "COMMA",
+  /*  104 */ "NULL",
+  /*  105 */ "SELECT",
+  /*  106 */ "UNION",
+  /*  107 */ "ALL",
+  /*  108 */ "FROM",
+  /*  109 */ "VARIABLE",
+  /*  110 */ "INTERVAL",
+  /*  111 */ "FILL",
+  /*  112 */ "SLIDING",
+  /*  113 */ "ORDER",
+  /*  114 */ "BY",
+  /*  115 */ "ASC",
+  /*  116 */ "DESC",
+  /*  117 */ "GROUP",
+  /*  118 */ "HAVING",
+  /*  119 */ "LIMIT",
+  /*  120 */ "OFFSET",
+  /*  121 */ "SLIMIT",
+  /*  122 */ "SOFFSET",
+  /*  123 */ "WHERE",
+  /*  124 */ "NOW",
+  /*  125 */ "RESET",
+  /*  126 */ "QUERY",
+  /*  127 */ "ADD",
+  /*  128 */ "COLUMN",
+  /*  129 */ "TAG",
+  /*  130 */ "CHANGE",
+  /*  131 */ "SET",
+  /*  132 */ "KILL",
+  /*  133 */ "CONNECTION",
+  /*  134 */ "STREAM",
+  /*  135 */ "COLON",
+  /*  136 */ "ABORT",
+  /*  137 */ "AFTER",
+  /*  138 */ "ATTACH",
+  /*  139 */ "BEFORE",
+  /*  140 */ "BEGIN",
+  /*  141 */ "CASCADE",
+  /*  142 */ "CLUSTER",
+  /*  143 */ "CONFLICT",
+  /*  144 */ "COPY",
+  /*  145 */ "DEFERRED",
+  /*  146 */ "DELIMITERS",
+  /*  147 */ "DETACH",
+  /*  148 */ "EACH",
+  /*  149 */ "END",
+  /*  150 */ "EXPLAIN",
+  /*  151 */ "FAIL",
+  /*  152 */ "FOR",
+  /*  153 */ "IGNORE",
+  /*  154 */ "IMMEDIATE",
+  /*  155 */ "INITIALLY",
+  /*  156 */ "INSTEAD",
+  /*  157 */ "MATCH",
+  /*  158 */ "KEY",
+  /*  159 */ "OF",
+  /*  160 */ "RAISE",
+  /*  161 */ "REPLACE",
+  /*  162 */ "RESTRICT",
+  /*  163 */ "ROW",
+  /*  164 */ "STATEMENT",
+  /*  165 */ "TRIGGER",
+  /*  166 */ "VIEW",
+  /*  167 */ "COUNT",
+  /*  168 */ "SUM",
+  /*  169 */ "AVG",
+  /*  170 */ "MIN",
+  /*  171 */ "MAX",
+  /*  172 */ "FIRST",
+  /*  173 */ "LAST",
+  /*  174 */ "TOP",
+  /*  175 */ "BOTTOM",
+  /*  176 */ "STDDEV",
+  /*  177 */ "PERCENTILE",
+  /*  178 */ "APERCENTILE",
+  /*  179 */ "LEASTSQUARES",
+  /*  180 */ "HISTOGRAM",
+  /*  181 */ "DIFF",
+  /*  182 */ "SPREAD",
+  /*  183 */ "TWA",
+  /*  184 */ "INTERP",
+  /*  185 */ "LAST_ROW",
+  /*  186 */ "RATE",
+  /*  187 */ "IRATE",
+  /*  188 */ "SUM_RATE",
+  /*  189 */ "SUM_IRATE",
+  /*  190 */ "AVG_RATE",
+  /*  191 */ "AVG_IRATE",
+  /*  192 */ "TBID",
+  /*  193 */ "SEMI",
+  /*  194 */ "NONE",
+  /*  195 */ "PREV",
+  /*  196 */ "LINEAR",
+  /*  197 */ "IMPORT",
+  /*  198 */ "METRIC",
+  /*  199 */ "TBNAME",
+  /*  200 */ "JOIN",
+  /*  201 */ "METRICS",
+  /*  202 */ "STABLE",
+  /*  203 */ "INSERT",
+  /*  204 */ "INTO",
+  /*  205 */ "VALUES",
+  /*  206 */ "error",
+  /*  207 */ "program",
+  /*  208 */ "cmd",
+  /*  209 */ "dbPrefix",
+  /*  210 */ "ids",
+  /*  211 */ "cpxName",
+  /*  212 */ "ifexists",
+  /*  213 */ "alter_db_optr",
+  /*  214 */ "acct_optr",
+  /*  215 */ "ifnotexists",
+  /*  216 */ "db_optr",
+  /*  217 */ "pps",
+  /*  218 */ "tseries",
+  /*  219 */ "dbs",
+  /*  220 */ "streams",
+  /*  221 */ "storage",
+  /*  222 */ "qtime",
+  /*  223 */ "users",
+  /*  224 */ "conns",
+  /*  225 */ "state",
+  /*  226 */ "keep",
+  /*  227 */ "tagitemlist",
+  /*  228 */ "cache",
+  /*  229 */ "replica",
+  /*  230 */ "quorum",
+  /*  231 */ "days",
+  /*  232 */ "minrows",
+  /*  233 */ "maxrows",
+  /*  234 */ "blocks",
+  /*  235 */ "ctime",
+  /*  236 */ "wal",
+  /*  237 */ "fsync",
+  /*  238 */ "comp",
+  /*  239 */ "prec",
+  /*  240 */ "typename",
+  /*  241 */ "signed",
+  /*  242 */ "create_table_args",
+  /*  243 */ "columnlist",
+  /*  244 */ "select",
+  /*  245 */ "column",
+  /*  246 */ "tagitem",
+  /*  247 */ "selcollist",
+  /*  248 */ "from",
+  /*  249 */ "where_opt",
+  /*  250 */ "interval_opt",
+  /*  251 */ "fill_opt",
+  /*  252 */ "sliding_opt",
+  /*  253 */ "groupby_opt",
+  /*  254 */ "orderby_opt",
+  /*  255 */ "having_opt",
+  /*  256 */ "slimit_opt",
+  /*  257 */ "limit_opt",
+  /*  258 */ "union",
+  /*  259 */ "sclp",
+  /*  260 */ "expr",
+  /*  261 */ "as",
+  /*  262 */ "tablelist",
+  /*  263 */ "tmvar",
+  /*  264 */ "sortlist",
+  /*  265 */ "sortitem",
+  /*  266 */ "item",
+  /*  267 */ "sortorder",
+  /*  268 */ "grouplist",
+  /*  269 */ "exprlist",
+  /*  270 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1078,163 +1073,160 @@ static const char *const yyRuleName[] = {
  /*  68 */ "state ::= STATE ids",
  /*  69 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
  /*  70 */ "keep ::= KEEP tagitemlist",
- /*  71 */ "tables ::= MAXTABLES INTEGER",
- /*  72 */ "cache ::= CACHE INTEGER",
- /*  73 */ "replica ::= REPLICA INTEGER",
- /*  74 */ "quorum ::= QUORUM INTEGER",
- /*  75 */ "days ::= DAYS INTEGER",
- /*  76 */ "minrows ::= MINROWS INTEGER",
- /*  77 */ "maxrows ::= MAXROWS INTEGER",
- /*  78 */ "blocks ::= BLOCKS INTEGER",
- /*  79 */ "ctime ::= CTIME INTEGER",
- /*  80 */ "wal ::= WAL INTEGER",
- /*  81 */ "fsync ::= FSYNC INTEGER",
- /*  82 */ "comp ::= COMP INTEGER",
- /*  83 */ "prec ::= PRECISION STRING",
- /*  84 */ "db_optr ::=",
- /*  85 */ "db_optr ::= db_optr tables",
- /*  86 */ "db_optr ::= db_optr cache",
- /*  87 */ "db_optr ::= db_optr replica",
- /*  88 */ "db_optr ::= db_optr quorum",
- /*  89 */ "db_optr ::= db_optr days",
- /*  90 */ "db_optr ::= db_optr minrows",
- /*  91 */ "db_optr ::= db_optr maxrows",
- /*  92 */ "db_optr ::= db_optr blocks",
- /*  93 */ "db_optr ::= db_optr ctime",
- /*  94 */ "db_optr ::= db_optr wal",
- /*  95 */ "db_optr ::= db_optr fsync",
- /*  96 */ "db_optr ::= db_optr comp",
- /*  97 */ "db_optr ::= db_optr prec",
- /*  98 */ "db_optr ::= db_optr keep",
- /*  99 */ "alter_db_optr ::=",
- /* 100 */ "alter_db_optr ::= alter_db_optr replica",
- /* 101 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 102 */ "alter_db_optr ::= alter_db_optr tables",
- /* 103 */ "alter_db_optr ::= alter_db_optr keep",
- /* 104 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 105 */ "alter_db_optr ::= alter_db_optr comp",
- /* 106 */ "alter_db_optr ::= alter_db_optr wal",
- /* 107 */ "alter_db_optr ::= alter_db_optr fsync",
- /* 108 */ "typename ::= ids",
- /* 109 */ "typename ::= ids LP signed RP",
- /* 110 */ "signed ::= INTEGER",
- /* 111 */ "signed ::= PLUS INTEGER",
- /* 112 */ "signed ::= MINUS INTEGER",
- /* 113 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
- /* 114 */ "create_table_args ::= LP columnlist RP",
- /* 115 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
- /* 116 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
- /* 117 */ "create_table_args ::= AS select",
- /* 118 */ "columnlist ::= columnlist COMMA column",
- /* 119 */ "columnlist ::= column",
- /* 120 */ "column ::= ids typename",
- /* 121 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 122 */ "tagitemlist ::= tagitem",
- /* 123 */ "tagitem ::= INTEGER",
- /* 124 */ "tagitem ::= FLOAT",
- /* 125 */ "tagitem ::= STRING",
- /* 126 */ "tagitem ::= BOOL",
- /* 127 */ "tagitem ::= NULL",
- /* 128 */ "tagitem ::= MINUS INTEGER",
- /* 129 */ "tagitem ::= MINUS FLOAT",
- /* 130 */ "tagitem ::= PLUS INTEGER",
- /* 131 */ "tagitem ::= PLUS FLOAT",
- /* 132 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
- /* 133 */ "union ::= select",
- /* 134 */ "union ::= LP union RP",
- /* 135 */ "union ::= union UNION ALL select",
- /* 136 */ "union ::= union UNION ALL LP select RP",
- /* 137 */ "cmd ::= union",
- /* 138 */ "select ::= SELECT selcollist",
- /* 139 */ "sclp ::= selcollist COMMA",
- /* 140 */ "sclp ::=",
- /* 141 */ "selcollist ::= sclp expr as",
- /* 142 */ "selcollist ::= sclp STAR",
- /* 143 */ "as ::= AS ids",
- /* 144 */ "as ::= ids",
- /* 145 */ "as ::=",
- /* 146 */ "from ::= FROM tablelist",
- /* 147 */ "tablelist ::= ids cpxName",
- /* 148 */ "tablelist ::= ids cpxName ids",
- /* 149 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 150 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 151 */ "tmvar ::= VARIABLE",
- /* 152 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 153 */ "interval_opt ::=",
- /* 154 */ "fill_opt ::=",
- /* 155 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 156 */ "fill_opt ::= FILL LP ID RP",
- /* 157 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 158 */ "sliding_opt ::=",
- /* 159 */ "orderby_opt ::=",
- /* 160 */ "orderby_opt ::= ORDER BY sortlist",
- /* 161 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 162 */ "sortlist ::= item sortorder",
- /* 163 */ "item ::= ids cpxName",
- /* 164 */ "sortorder ::= ASC",
- /* 165 */ "sortorder ::= DESC",
- /* 166 */ "sortorder ::=",
- /* 167 */ "groupby_opt ::=",
- /* 168 */ "groupby_opt ::= GROUP BY grouplist",
- /* 169 */ "grouplist ::= grouplist COMMA item",
- /* 170 */ "grouplist ::= item",
- /* 171 */ "having_opt ::=",
- /* 172 */ "having_opt ::= HAVING expr",
- /* 173 */ "limit_opt ::=",
- /* 174 */ "limit_opt ::= LIMIT signed",
- /* 175 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 176 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 177 */ "slimit_opt ::=",
- /* 178 */ "slimit_opt ::= SLIMIT signed",
- /* 179 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 180 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 181 */ "where_opt ::=",
- /* 182 */ "where_opt ::= WHERE expr",
- /* 183 */ "expr ::= LP expr RP",
- /* 184 */ "expr ::= ID",
- /* 185 */ "expr ::= ID DOT ID",
- /* 186 */ "expr ::= ID DOT STAR",
- /* 187 */ "expr ::= INTEGER",
- /* 188 */ "expr ::= MINUS INTEGER",
- /* 189 */ "expr ::= PLUS INTEGER",
- /* 190 */ "expr ::= FLOAT",
- /* 191 */ "expr ::= MINUS FLOAT",
- /* 192 */ "expr ::= PLUS FLOAT",
- /* 193 */ "expr ::= STRING",
- /* 194 */ "expr ::= NOW",
- /* 195 */ "expr ::= VARIABLE",
- /* 196 */ "expr ::= BOOL",
- /* 197 */ "expr ::= ID LP exprlist RP",
- /* 198 */ "expr ::= ID LP STAR RP",
- /* 199 */ "expr ::= expr AND expr",
- /* 200 */ "expr ::= expr OR expr",
- /* 201 */ "expr ::= expr LT expr",
- /* 202 */ "expr ::= expr GT expr",
- /* 203 */ "expr ::= expr LE expr",
- /* 204 */ "expr ::= expr GE expr",
- /* 205 */ "expr ::= expr NE expr",
- /* 206 */ "expr ::= expr EQ expr",
- /* 207 */ "expr ::= expr PLUS expr",
- /* 208 */ "expr ::= expr MINUS expr",
- /* 209 */ "expr ::= expr STAR expr",
- /* 210 */ "expr ::= expr SLASH expr",
- /* 211 */ "expr ::= expr REM expr",
- /* 212 */ "expr ::= expr LIKE expr",
- /* 213 */ "expr ::= expr IN LP exprlist RP",
- /* 214 */ "exprlist ::= exprlist COMMA expritem",
- /* 215 */ "exprlist ::= expritem",
- /* 216 */ "expritem ::= expr",
- /* 217 */ "expritem ::=",
- /* 218 */ "cmd ::= RESET QUERY CACHE",
- /* 219 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 220 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 221 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 222 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 223 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 224 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 225 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 226 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 227 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /*  71 */ "cache ::= CACHE INTEGER",
+ /*  72 */ "replica ::= REPLICA INTEGER",
+ /*  73 */ "quorum ::= QUORUM INTEGER",
+ /*  74 */ "days ::= DAYS INTEGER",
+ /*  75 */ "minrows ::= MINROWS INTEGER",
+ /*  76 */ "maxrows ::= MAXROWS INTEGER",
+ /*  77 */ "blocks ::= BLOCKS INTEGER",
+ /*  78 */ "ctime ::= CTIME INTEGER",
+ /*  79 */ "wal ::= WAL INTEGER",
+ /*  80 */ "fsync ::= FSYNC INTEGER",
+ /*  81 */ "comp ::= COMP INTEGER",
+ /*  82 */ "prec ::= PRECISION STRING",
+ /*  83 */ "db_optr ::=",
+ /*  84 */ "db_optr ::= db_optr cache",
+ /*  85 */ "db_optr ::= db_optr replica",
+ /*  86 */ "db_optr ::= db_optr quorum",
+ /*  87 */ "db_optr ::= db_optr days",
+ /*  88 */ "db_optr ::= db_optr minrows",
+ /*  89 */ "db_optr ::= db_optr maxrows",
+ /*  90 */ "db_optr ::= db_optr blocks",
+ /*  91 */ "db_optr ::= db_optr ctime",
+ /*  92 */ "db_optr ::= db_optr wal",
+ /*  93 */ "db_optr ::= db_optr fsync",
+ /*  94 */ "db_optr ::= db_optr comp",
+ /*  95 */ "db_optr ::= db_optr prec",
+ /*  96 */ "db_optr ::= db_optr keep",
+ /*  97 */ "alter_db_optr ::=",
+ /*  98 */ "alter_db_optr ::= alter_db_optr replica",
+ /*  99 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 100 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 101 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 102 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 103 */ "alter_db_optr ::= alter_db_optr wal",
+ /* 104 */ "alter_db_optr ::= alter_db_optr fsync",
+ /* 105 */ "typename ::= ids",
+ /* 106 */ "typename ::= ids LP signed RP",
+ /* 107 */ "signed ::= INTEGER",
+ /* 108 */ "signed ::= PLUS INTEGER",
+ /* 109 */ "signed ::= MINUS INTEGER",
+ /* 110 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
+ /* 111 */ "create_table_args ::= LP columnlist RP",
+ /* 112 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
+ /* 113 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
+ /* 114 */ "create_table_args ::= AS select",
+ /* 115 */ "columnlist ::= columnlist COMMA column",
+ /* 116 */ "columnlist ::= column",
+ /* 117 */ "column ::= ids typename",
+ /* 118 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 119 */ "tagitemlist ::= tagitem",
+ /* 120 */ "tagitem ::= INTEGER",
+ /* 121 */ "tagitem ::= FLOAT",
+ /* 122 */ "tagitem ::= STRING",
+ /* 123 */ "tagitem ::= BOOL",
+ /* 124 */ "tagitem ::= NULL",
+ /* 125 */ "tagitem ::= MINUS INTEGER",
+ /* 126 */ "tagitem ::= MINUS FLOAT",
+ /* 127 */ "tagitem ::= PLUS INTEGER",
+ /* 128 */ "tagitem ::= PLUS FLOAT",
+ /* 129 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 130 */ "union ::= select",
+ /* 131 */ "union ::= LP union RP",
+ /* 132 */ "union ::= union UNION ALL select",
+ /* 133 */ "union ::= union UNION ALL LP select RP",
+ /* 134 */ "cmd ::= union",
+ /* 135 */ "select ::= SELECT selcollist",
+ /* 136 */ "sclp ::= selcollist COMMA",
+ /* 137 */ "sclp ::=",
+ /* 138 */ "selcollist ::= sclp expr as",
+ /* 139 */ "selcollist ::= sclp STAR",
+ /* 140 */ "as ::= AS ids",
+ /* 141 */ "as ::= ids",
+ /* 142 */ "as ::=",
+ /* 143 */ "from ::= FROM tablelist",
+ /* 144 */ "tablelist ::= ids cpxName",
+ /* 145 */ "tablelist ::= ids cpxName ids",
+ /* 146 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 147 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 148 */ "tmvar ::= VARIABLE",
+ /* 149 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 150 */ "interval_opt ::=",
+ /* 151 */ "fill_opt ::=",
+ /* 152 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 153 */ "fill_opt ::= FILL LP ID RP",
+ /* 154 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 155 */ "sliding_opt ::=",
+ /* 156 */ "orderby_opt ::=",
+ /* 157 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 158 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 159 */ "sortlist ::= item sortorder",
+ /* 160 */ "item ::= ids cpxName",
+ /* 161 */ "sortorder ::= ASC",
+ /* 162 */ "sortorder ::= DESC",
+ /* 163 */ "sortorder ::=",
+ /* 164 */ "groupby_opt ::=",
+ /* 165 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 166 */ "grouplist ::= grouplist COMMA item",
+ /* 167 */ "grouplist ::= item",
+ /* 168 */ "having_opt ::=",
+ /* 169 */ "having_opt ::= HAVING expr",
+ /* 170 */ "limit_opt ::=",
+ /* 171 */ "limit_opt ::= LIMIT signed",
+ /* 172 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 173 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 174 */ "slimit_opt ::=",
+ /* 175 */ "slimit_opt ::= SLIMIT signed",
+ /* 176 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 177 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 178 */ "where_opt ::=",
+ /* 179 */ "where_opt ::= WHERE expr",
+ /* 180 */ "expr ::= LP expr RP",
+ /* 181 */ "expr ::= ID",
+ /* 182 */ "expr ::= ID DOT ID",
+ /* 183 */ "expr ::= ID DOT STAR",
+ /* 184 */ "expr ::= INTEGER",
+ /* 185 */ "expr ::= MINUS INTEGER",
+ /* 186 */ "expr ::= PLUS INTEGER",
+ /* 187 */ "expr ::= FLOAT",
+ /* 188 */ "expr ::= MINUS FLOAT",
+ /* 189 */ "expr ::= PLUS FLOAT",
+ /* 190 */ "expr ::= STRING",
+ /* 191 */ "expr ::= NOW",
+ /* 192 */ "expr ::= VARIABLE",
+ /* 193 */ "expr ::= BOOL",
+ /* 194 */ "expr ::= ID LP exprlist RP",
+ /* 195 */ "expr ::= ID LP STAR RP",
+ /* 196 */ "expr ::= expr AND expr",
+ /* 197 */ "expr ::= expr OR expr",
+ /* 198 */ "expr ::= expr LT expr",
+ /* 199 */ "expr ::= expr GT expr",
+ /* 200 */ "expr ::= expr LE expr",
+ /* 201 */ "expr ::= expr GE expr",
+ /* 202 */ "expr ::= expr NE expr",
+ /* 203 */ "expr ::= expr EQ expr",
+ /* 204 */ "expr ::= expr PLUS expr",
+ /* 205 */ "expr ::= expr MINUS expr",
+ /* 206 */ "expr ::= expr STAR expr",
+ /* 207 */ "expr ::= expr SLASH expr",
+ /* 208 */ "expr ::= expr REM expr",
+ /* 209 */ "expr ::= expr LIKE expr",
+ /* 210 */ "expr ::= expr IN LP exprlist RP",
+ /* 211 */ "exprlist ::= exprlist COMMA expritem",
+ /* 212 */ "exprlist ::= expritem",
+ /* 213 */ "expritem ::= expr",
+ /* 214 */ "expritem ::=",
+ /* 215 */ "cmd ::= RESET QUERY CACHE",
+ /* 216 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 217 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 218 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 219 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 220 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 221 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 222 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 223 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 224 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1355,50 +1347,50 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 227: /* keep */
-    case 228: /* tagitemlist */
-    case 253: /* fill_opt */
-    case 255: /* groupby_opt */
-    case 256: /* orderby_opt */
-    case 266: /* sortlist */
-    case 270: /* grouplist */
+    case 226: /* keep */
+    case 227: /* tagitemlist */
+    case 251: /* fill_opt */
+    case 253: /* groupby_opt */
+    case 254: /* orderby_opt */
+    case 264: /* sortlist */
+    case 268: /* grouplist */
 {
-tVariantListDestroy((yypminor->yy498));
+tVariantListDestroy((yypminor->yy494));
 }
       break;
-    case 245: /* columnlist */
+    case 243: /* columnlist */
 {
-tFieldListDestroy((yypminor->yy523));
+tFieldListDestroy((yypminor->yy449));
 }
       break;
-    case 246: /* select */
+    case 244: /* select */
 {
-doDestroyQuerySql((yypminor->yy414));
+doDestroyQuerySql((yypminor->yy150));
 }
       break;
-    case 249: /* selcollist */
-    case 261: /* sclp */
-    case 271: /* exprlist */
+    case 247: /* selcollist */
+    case 259: /* sclp */
+    case 269: /* exprlist */
 {
-tSQLExprListDestroy((yypminor->yy290));
+tSQLExprListDestroy((yypminor->yy224));
 }
       break;
-    case 251: /* where_opt */
-    case 257: /* having_opt */
-    case 262: /* expr */
-    case 272: /* expritem */
+    case 249: /* where_opt */
+    case 255: /* having_opt */
+    case 260: /* expr */
+    case 270: /* expritem */
 {
-tSQLExprDestroy((yypminor->yy64));
+tSQLExprDestroy((yypminor->yy66));
 }
       break;
-    case 260: /* union */
+    case 258: /* union */
 {
-destroyAllSelectClause((yypminor->yy231));
+destroyAllSelectClause((yypminor->yy25));
 }
       break;
-    case 267: /* sortitem */
+    case 265: /* sortitem */
 {
-tVariantDestroy(&(yypminor->yy134));
+tVariantDestroy(&(yypminor->yy312));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1692,234 +1684,231 @@ 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,   -1 }, /* (0) program ::= cmd */
-  {  209,   -2 }, /* (1) cmd ::= SHOW DATABASES */
-  {  209,   -2 }, /* (2) cmd ::= SHOW MNODES */
-  {  209,   -2 }, /* (3) cmd ::= SHOW DNODES */
-  {  209,   -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
-  {  209,   -2 }, /* (5) cmd ::= SHOW USERS */
-  {  209,   -2 }, /* (6) cmd ::= SHOW MODULES */
-  {  209,   -2 }, /* (7) cmd ::= SHOW QUERIES */
-  {  209,   -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
-  {  209,   -2 }, /* (9) cmd ::= SHOW STREAMS */
-  {  209,   -2 }, /* (10) cmd ::= SHOW VARIABLES */
-  {  209,   -2 }, /* (11) cmd ::= SHOW SCORES */
-  {  209,   -2 }, /* (12) cmd ::= SHOW GRANTS */
-  {  209,   -2 }, /* (13) cmd ::= SHOW VNODES */
-  {  209,   -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
-  {  210,    0 }, /* (15) dbPrefix ::= */
-  {  210,   -2 }, /* (16) dbPrefix ::= ids DOT */
-  {  212,    0 }, /* (17) cpxName ::= */
-  {  212,   -2 }, /* (18) cpxName ::= DOT ids */
-  {  209,   -3 }, /* (19) cmd ::= SHOW dbPrefix TABLES */
-  {  209,   -5 }, /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-  {  209,   -3 }, /* (21) cmd ::= SHOW dbPrefix STABLES */
-  {  209,   -5 }, /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-  {  209,   -3 }, /* (23) cmd ::= SHOW dbPrefix VGROUPS */
-  {  209,   -4 }, /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
-  {  209,   -5 }, /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  209,   -4 }, /* (26) cmd ::= DROP DATABASE ifexists ids */
-  {  209,   -3 }, /* (27) cmd ::= DROP DNODE ids */
-  {  209,   -3 }, /* (28) cmd ::= DROP USER ids */
-  {  209,   -3 }, /* (29) cmd ::= DROP ACCOUNT ids */
-  {  209,   -2 }, /* (30) cmd ::= USE ids */
-  {  209,   -3 }, /* (31) cmd ::= DESCRIBE ids cpxName */
-  {  209,   -5 }, /* (32) cmd ::= ALTER USER ids PASS ids */
-  {  209,   -5 }, /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  209,   -4 }, /* (34) cmd ::= ALTER DNODE ids ids */
-  {  209,   -5 }, /* (35) cmd ::= ALTER DNODE ids ids ids */
-  {  209,   -3 }, /* (36) cmd ::= ALTER LOCAL ids */
-  {  209,   -4 }, /* (37) cmd ::= ALTER LOCAL ids ids */
-  {  209,   -4 }, /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  209,   -4 }, /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  209,   -6 }, /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  211,   -1 }, /* (41) ids ::= ID */
-  {  211,   -1 }, /* (42) ids ::= STRING */
-  {  213,   -2 }, /* (43) ifexists ::= IF EXISTS */
-  {  213,    0 }, /* (44) ifexists ::= */
-  {  216,   -3 }, /* (45) ifnotexists ::= IF NOT EXISTS */
-  {  216,    0 }, /* (46) ifnotexists ::= */
-  {  209,   -3 }, /* (47) cmd ::= CREATE DNODE ids */
-  {  209,   -6 }, /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  209,   -5 }, /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  209,   -5 }, /* (50) cmd ::= CREATE USER ids PASS ids */
-  {  218,    0 }, /* (51) pps ::= */
-  {  218,   -2 }, /* (52) pps ::= PPS INTEGER */
-  {  219,    0 }, /* (53) tseries ::= */
-  {  219,   -2 }, /* (54) tseries ::= TSERIES INTEGER */
-  {  220,    0 }, /* (55) dbs ::= */
-  {  220,   -2 }, /* (56) dbs ::= DBS INTEGER */
-  {  221,    0 }, /* (57) streams ::= */
-  {  221,   -2 }, /* (58) streams ::= STREAMS INTEGER */
-  {  222,    0 }, /* (59) storage ::= */
-  {  222,   -2 }, /* (60) storage ::= STORAGE INTEGER */
-  {  223,    0 }, /* (61) qtime ::= */
-  {  223,   -2 }, /* (62) qtime ::= QTIME INTEGER */
-  {  224,    0 }, /* (63) users ::= */
-  {  224,   -2 }, /* (64) users ::= USERS INTEGER */
-  {  225,    0 }, /* (65) conns ::= */
-  {  225,   -2 }, /* (66) conns ::= CONNS INTEGER */
-  {  226,    0 }, /* (67) state ::= */
-  {  226,   -2 }, /* (68) state ::= STATE ids */
-  {  215,   -9 }, /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  227,   -2 }, /* (70) keep ::= KEEP tagitemlist */
-  {  229,   -2 }, /* (71) tables ::= MAXTABLES INTEGER */
-  {  230,   -2 }, /* (72) cache ::= CACHE INTEGER */
-  {  231,   -2 }, /* (73) replica ::= REPLICA INTEGER */
-  {  232,   -2 }, /* (74) quorum ::= QUORUM INTEGER */
-  {  233,   -2 }, /* (75) days ::= DAYS INTEGER */
-  {  234,   -2 }, /* (76) minrows ::= MINROWS INTEGER */
-  {  235,   -2 }, /* (77) maxrows ::= MAXROWS INTEGER */
-  {  236,   -2 }, /* (78) blocks ::= BLOCKS INTEGER */
-  {  237,   -2 }, /* (79) ctime ::= CTIME INTEGER */
-  {  238,   -2 }, /* (80) wal ::= WAL INTEGER */
-  {  239,   -2 }, /* (81) fsync ::= FSYNC INTEGER */
-  {  240,   -2 }, /* (82) comp ::= COMP INTEGER */
-  {  241,   -2 }, /* (83) prec ::= PRECISION STRING */
-  {  217,    0 }, /* (84) db_optr ::= */
-  {  217,   -2 }, /* (85) db_optr ::= db_optr tables */
-  {  217,   -2 }, /* (86) db_optr ::= db_optr cache */
-  {  217,   -2 }, /* (87) db_optr ::= db_optr replica */
-  {  217,   -2 }, /* (88) db_optr ::= db_optr quorum */
-  {  217,   -2 }, /* (89) db_optr ::= db_optr days */
-  {  217,   -2 }, /* (90) db_optr ::= db_optr minrows */
-  {  217,   -2 }, /* (91) db_optr ::= db_optr maxrows */
-  {  217,   -2 }, /* (92) db_optr ::= db_optr blocks */
-  {  217,   -2 }, /* (93) db_optr ::= db_optr ctime */
-  {  217,   -2 }, /* (94) db_optr ::= db_optr wal */
-  {  217,   -2 }, /* (95) db_optr ::= db_optr fsync */
-  {  217,   -2 }, /* (96) db_optr ::= db_optr comp */
-  {  217,   -2 }, /* (97) db_optr ::= db_optr prec */
-  {  217,   -2 }, /* (98) db_optr ::= db_optr keep */
-  {  214,    0 }, /* (99) alter_db_optr ::= */
-  {  214,   -2 }, /* (100) alter_db_optr ::= alter_db_optr replica */
-  {  214,   -2 }, /* (101) alter_db_optr ::= alter_db_optr quorum */
-  {  214,   -2 }, /* (102) alter_db_optr ::= alter_db_optr tables */
-  {  214,   -2 }, /* (103) alter_db_optr ::= alter_db_optr keep */
-  {  214,   -2 }, /* (104) alter_db_optr ::= alter_db_optr blocks */
-  {  214,   -2 }, /* (105) alter_db_optr ::= alter_db_optr comp */
-  {  214,   -2 }, /* (106) alter_db_optr ::= alter_db_optr wal */
-  {  214,   -2 }, /* (107) alter_db_optr ::= alter_db_optr fsync */
-  {  242,   -1 }, /* (108) typename ::= ids */
-  {  242,   -4 }, /* (109) typename ::= ids LP signed RP */
-  {  243,   -1 }, /* (110) signed ::= INTEGER */
-  {  243,   -2 }, /* (111) signed ::= PLUS INTEGER */
-  {  243,   -2 }, /* (112) signed ::= MINUS INTEGER */
-  {  209,   -6 }, /* (113) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
-  {  244,   -3 }, /* (114) create_table_args ::= LP columnlist RP */
-  {  244,   -7 }, /* (115) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
-  {  244,   -7 }, /* (116) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
-  {  244,   -2 }, /* (117) create_table_args ::= AS select */
-  {  245,   -3 }, /* (118) columnlist ::= columnlist COMMA column */
-  {  245,   -1 }, /* (119) columnlist ::= column */
-  {  247,   -2 }, /* (120) column ::= ids typename */
-  {  228,   -3 }, /* (121) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  228,   -1 }, /* (122) tagitemlist ::= tagitem */
-  {  248,   -1 }, /* (123) tagitem ::= INTEGER */
-  {  248,   -1 }, /* (124) tagitem ::= FLOAT */
-  {  248,   -1 }, /* (125) tagitem ::= STRING */
-  {  248,   -1 }, /* (126) tagitem ::= BOOL */
-  {  248,   -1 }, /* (127) tagitem ::= NULL */
-  {  248,   -2 }, /* (128) tagitem ::= MINUS INTEGER */
-  {  248,   -2 }, /* (129) tagitem ::= MINUS FLOAT */
-  {  248,   -2 }, /* (130) tagitem ::= PLUS INTEGER */
-  {  248,   -2 }, /* (131) tagitem ::= PLUS FLOAT */
-  {  246,  -12 }, /* (132) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-  {  260,   -1 }, /* (133) union ::= select */
-  {  260,   -3 }, /* (134) union ::= LP union RP */
-  {  260,   -4 }, /* (135) union ::= union UNION ALL select */
-  {  260,   -6 }, /* (136) union ::= union UNION ALL LP select RP */
-  {  209,   -1 }, /* (137) cmd ::= union */
-  {  246,   -2 }, /* (138) select ::= SELECT selcollist */
-  {  261,   -2 }, /* (139) sclp ::= selcollist COMMA */
-  {  261,    0 }, /* (140) sclp ::= */
-  {  249,   -3 }, /* (141) selcollist ::= sclp expr as */
-  {  249,   -2 }, /* (142) selcollist ::= sclp STAR */
-  {  263,   -2 }, /* (143) as ::= AS ids */
-  {  263,   -1 }, /* (144) as ::= ids */
-  {  263,    0 }, /* (145) as ::= */
-  {  250,   -2 }, /* (146) from ::= FROM tablelist */
-  {  264,   -2 }, /* (147) tablelist ::= ids cpxName */
-  {  264,   -3 }, /* (148) tablelist ::= ids cpxName ids */
-  {  264,   -4 }, /* (149) tablelist ::= tablelist COMMA ids cpxName */
-  {  264,   -5 }, /* (150) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  265,   -1 }, /* (151) tmvar ::= VARIABLE */
-  {  252,   -4 }, /* (152) interval_opt ::= INTERVAL LP tmvar RP */
-  {  252,    0 }, /* (153) interval_opt ::= */
-  {  253,    0 }, /* (154) fill_opt ::= */
-  {  253,   -6 }, /* (155) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  253,   -4 }, /* (156) fill_opt ::= FILL LP ID RP */
-  {  254,   -4 }, /* (157) sliding_opt ::= SLIDING LP tmvar RP */
-  {  254,    0 }, /* (158) sliding_opt ::= */
-  {  256,    0 }, /* (159) orderby_opt ::= */
-  {  256,   -3 }, /* (160) orderby_opt ::= ORDER BY sortlist */
-  {  266,   -4 }, /* (161) sortlist ::= sortlist COMMA item sortorder */
-  {  266,   -2 }, /* (162) sortlist ::= item sortorder */
-  {  268,   -2 }, /* (163) item ::= ids cpxName */
-  {  269,   -1 }, /* (164) sortorder ::= ASC */
-  {  269,   -1 }, /* (165) sortorder ::= DESC */
-  {  269,    0 }, /* (166) sortorder ::= */
-  {  255,    0 }, /* (167) groupby_opt ::= */
-  {  255,   -3 }, /* (168) groupby_opt ::= GROUP BY grouplist */
-  {  270,   -3 }, /* (169) grouplist ::= grouplist COMMA item */
-  {  270,   -1 }, /* (170) grouplist ::= item */
-  {  257,    0 }, /* (171) having_opt ::= */
-  {  257,   -2 }, /* (172) having_opt ::= HAVING expr */
-  {  259,    0 }, /* (173) limit_opt ::= */
-  {  259,   -2 }, /* (174) limit_opt ::= LIMIT signed */
-  {  259,   -4 }, /* (175) limit_opt ::= LIMIT signed OFFSET signed */
-  {  259,   -4 }, /* (176) limit_opt ::= LIMIT signed COMMA signed */
-  {  258,    0 }, /* (177) slimit_opt ::= */
-  {  258,   -2 }, /* (178) slimit_opt ::= SLIMIT signed */
-  {  258,   -4 }, /* (179) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  258,   -4 }, /* (180) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  251,    0 }, /* (181) where_opt ::= */
-  {  251,   -2 }, /* (182) where_opt ::= WHERE expr */
-  {  262,   -3 }, /* (183) expr ::= LP expr RP */
-  {  262,   -1 }, /* (184) expr ::= ID */
-  {  262,   -3 }, /* (185) expr ::= ID DOT ID */
-  {  262,   -3 }, /* (186) expr ::= ID DOT STAR */
-  {  262,   -1 }, /* (187) expr ::= INTEGER */
-  {  262,   -2 }, /* (188) expr ::= MINUS INTEGER */
-  {  262,   -2 }, /* (189) expr ::= PLUS INTEGER */
-  {  262,   -1 }, /* (190) expr ::= FLOAT */
-  {  262,   -2 }, /* (191) expr ::= MINUS FLOAT */
-  {  262,   -2 }, /* (192) expr ::= PLUS FLOAT */
-  {  262,   -1 }, /* (193) expr ::= STRING */
-  {  262,   -1 }, /* (194) expr ::= NOW */
-  {  262,   -1 }, /* (195) expr ::= VARIABLE */
-  {  262,   -1 }, /* (196) expr ::= BOOL */
-  {  262,   -4 }, /* (197) expr ::= ID LP exprlist RP */
-  {  262,   -4 }, /* (198) expr ::= ID LP STAR RP */
-  {  262,   -3 }, /* (199) expr ::= expr AND expr */
-  {  262,   -3 }, /* (200) expr ::= expr OR expr */
-  {  262,   -3 }, /* (201) expr ::= expr LT expr */
-  {  262,   -3 }, /* (202) expr ::= expr GT expr */
-  {  262,   -3 }, /* (203) expr ::= expr LE expr */
-  {  262,   -3 }, /* (204) expr ::= expr GE expr */
-  {  262,   -3 }, /* (205) expr ::= expr NE expr */
-  {  262,   -3 }, /* (206) expr ::= expr EQ expr */
-  {  262,   -3 }, /* (207) expr ::= expr PLUS expr */
-  {  262,   -3 }, /* (208) expr ::= expr MINUS expr */
-  {  262,   -3 }, /* (209) expr ::= expr STAR expr */
-  {  262,   -3 }, /* (210) expr ::= expr SLASH expr */
-  {  262,   -3 }, /* (211) expr ::= expr REM expr */
-  {  262,   -3 }, /* (212) expr ::= expr LIKE expr */
-  {  262,   -5 }, /* (213) expr ::= expr IN LP exprlist RP */
-  {  271,   -3 }, /* (214) exprlist ::= exprlist COMMA expritem */
-  {  271,   -1 }, /* (215) exprlist ::= expritem */
-  {  272,   -1 }, /* (216) expritem ::= expr */
-  {  272,    0 }, /* (217) expritem ::= */
-  {  209,   -3 }, /* (218) cmd ::= RESET QUERY CACHE */
-  {  209,   -7 }, /* (219) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  209,   -7 }, /* (220) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  209,   -7 }, /* (221) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  209,   -7 }, /* (222) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  209,   -8 }, /* (223) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  209,   -9 }, /* (224) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  209,   -3 }, /* (225) cmd ::= KILL CONNECTION INTEGER */
-  {  209,   -5 }, /* (226) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  209,   -5 }, /* (227) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  207,   -1 }, /* (0) program ::= cmd */
+  {  208,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  208,   -2 }, /* (2) cmd ::= SHOW MNODES */
+  {  208,   -2 }, /* (3) cmd ::= SHOW DNODES */
+  {  208,   -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
+  {  208,   -2 }, /* (5) cmd ::= SHOW USERS */
+  {  208,   -2 }, /* (6) cmd ::= SHOW MODULES */
+  {  208,   -2 }, /* (7) cmd ::= SHOW QUERIES */
+  {  208,   -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
+  {  208,   -2 }, /* (9) cmd ::= SHOW STREAMS */
+  {  208,   -2 }, /* (10) cmd ::= SHOW VARIABLES */
+  {  208,   -2 }, /* (11) cmd ::= SHOW SCORES */
+  {  208,   -2 }, /* (12) cmd ::= SHOW GRANTS */
+  {  208,   -2 }, /* (13) cmd ::= SHOW VNODES */
+  {  208,   -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
+  {  209,    0 }, /* (15) dbPrefix ::= */
+  {  209,   -2 }, /* (16) dbPrefix ::= ids DOT */
+  {  211,    0 }, /* (17) cpxName ::= */
+  {  211,   -2 }, /* (18) cpxName ::= DOT ids */
+  {  208,   -3 }, /* (19) cmd ::= SHOW dbPrefix TABLES */
+  {  208,   -5 }, /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+  {  208,   -3 }, /* (21) cmd ::= SHOW dbPrefix STABLES */
+  {  208,   -5 }, /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+  {  208,   -3 }, /* (23) cmd ::= SHOW dbPrefix VGROUPS */
+  {  208,   -4 }, /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
+  {  208,   -5 }, /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  208,   -4 }, /* (26) cmd ::= DROP DATABASE ifexists ids */
+  {  208,   -3 }, /* (27) cmd ::= DROP DNODE ids */
+  {  208,   -3 }, /* (28) cmd ::= DROP USER ids */
+  {  208,   -3 }, /* (29) cmd ::= DROP ACCOUNT ids */
+  {  208,   -2 }, /* (30) cmd ::= USE ids */
+  {  208,   -3 }, /* (31) cmd ::= DESCRIBE ids cpxName */
+  {  208,   -5 }, /* (32) cmd ::= ALTER USER ids PASS ids */
+  {  208,   -5 }, /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  208,   -4 }, /* (34) cmd ::= ALTER DNODE ids ids */
+  {  208,   -5 }, /* (35) cmd ::= ALTER DNODE ids ids ids */
+  {  208,   -3 }, /* (36) cmd ::= ALTER LOCAL ids */
+  {  208,   -4 }, /* (37) cmd ::= ALTER LOCAL ids ids */
+  {  208,   -4 }, /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  208,   -4 }, /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  208,   -6 }, /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  210,   -1 }, /* (41) ids ::= ID */
+  {  210,   -1 }, /* (42) ids ::= STRING */
+  {  212,   -2 }, /* (43) ifexists ::= IF EXISTS */
+  {  212,    0 }, /* (44) ifexists ::= */
+  {  215,   -3 }, /* (45) ifnotexists ::= IF NOT EXISTS */
+  {  215,    0 }, /* (46) ifnotexists ::= */
+  {  208,   -3 }, /* (47) cmd ::= CREATE DNODE ids */
+  {  208,   -6 }, /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  208,   -5 }, /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  208,   -5 }, /* (50) cmd ::= CREATE USER ids PASS ids */
+  {  217,    0 }, /* (51) pps ::= */
+  {  217,   -2 }, /* (52) pps ::= PPS INTEGER */
+  {  218,    0 }, /* (53) tseries ::= */
+  {  218,   -2 }, /* (54) tseries ::= TSERIES INTEGER */
+  {  219,    0 }, /* (55) dbs ::= */
+  {  219,   -2 }, /* (56) dbs ::= DBS INTEGER */
+  {  220,    0 }, /* (57) streams ::= */
+  {  220,   -2 }, /* (58) streams ::= STREAMS INTEGER */
+  {  221,    0 }, /* (59) storage ::= */
+  {  221,   -2 }, /* (60) storage ::= STORAGE INTEGER */
+  {  222,    0 }, /* (61) qtime ::= */
+  {  222,   -2 }, /* (62) qtime ::= QTIME INTEGER */
+  {  223,    0 }, /* (63) users ::= */
+  {  223,   -2 }, /* (64) users ::= USERS INTEGER */
+  {  224,    0 }, /* (65) conns ::= */
+  {  224,   -2 }, /* (66) conns ::= CONNS INTEGER */
+  {  225,    0 }, /* (67) state ::= */
+  {  225,   -2 }, /* (68) state ::= STATE ids */
+  {  214,   -9 }, /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  226,   -2 }, /* (70) keep ::= KEEP tagitemlist */
+  {  228,   -2 }, /* (71) cache ::= CACHE INTEGER */
+  {  229,   -2 }, /* (72) replica ::= REPLICA INTEGER */
+  {  230,   -2 }, /* (73) quorum ::= QUORUM INTEGER */
+  {  231,   -2 }, /* (74) days ::= DAYS INTEGER */
+  {  232,   -2 }, /* (75) minrows ::= MINROWS INTEGER */
+  {  233,   -2 }, /* (76) maxrows ::= MAXROWS INTEGER */
+  {  234,   -2 }, /* (77) blocks ::= BLOCKS INTEGER */
+  {  235,   -2 }, /* (78) ctime ::= CTIME INTEGER */
+  {  236,   -2 }, /* (79) wal ::= WAL INTEGER */
+  {  237,   -2 }, /* (80) fsync ::= FSYNC INTEGER */
+  {  238,   -2 }, /* (81) comp ::= COMP INTEGER */
+  {  239,   -2 }, /* (82) prec ::= PRECISION STRING */
+  {  216,    0 }, /* (83) db_optr ::= */
+  {  216,   -2 }, /* (84) db_optr ::= db_optr cache */
+  {  216,   -2 }, /* (85) db_optr ::= db_optr replica */
+  {  216,   -2 }, /* (86) db_optr ::= db_optr quorum */
+  {  216,   -2 }, /* (87) db_optr ::= db_optr days */
+  {  216,   -2 }, /* (88) db_optr ::= db_optr minrows */
+  {  216,   -2 }, /* (89) db_optr ::= db_optr maxrows */
+  {  216,   -2 }, /* (90) db_optr ::= db_optr blocks */
+  {  216,   -2 }, /* (91) db_optr ::= db_optr ctime */
+  {  216,   -2 }, /* (92) db_optr ::= db_optr wal */
+  {  216,   -2 }, /* (93) db_optr ::= db_optr fsync */
+  {  216,   -2 }, /* (94) db_optr ::= db_optr comp */
+  {  216,   -2 }, /* (95) db_optr ::= db_optr prec */
+  {  216,   -2 }, /* (96) db_optr ::= db_optr keep */
+  {  213,    0 }, /* (97) alter_db_optr ::= */
+  {  213,   -2 }, /* (98) alter_db_optr ::= alter_db_optr replica */
+  {  213,   -2 }, /* (99) alter_db_optr ::= alter_db_optr quorum */
+  {  213,   -2 }, /* (100) alter_db_optr ::= alter_db_optr keep */
+  {  213,   -2 }, /* (101) alter_db_optr ::= alter_db_optr blocks */
+  {  213,   -2 }, /* (102) alter_db_optr ::= alter_db_optr comp */
+  {  213,   -2 }, /* (103) alter_db_optr ::= alter_db_optr wal */
+  {  213,   -2 }, /* (104) alter_db_optr ::= alter_db_optr fsync */
+  {  240,   -1 }, /* (105) typename ::= ids */
+  {  240,   -4 }, /* (106) typename ::= ids LP signed RP */
+  {  241,   -1 }, /* (107) signed ::= INTEGER */
+  {  241,   -2 }, /* (108) signed ::= PLUS INTEGER */
+  {  241,   -2 }, /* (109) signed ::= MINUS INTEGER */
+  {  208,   -6 }, /* (110) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+  {  242,   -3 }, /* (111) create_table_args ::= LP columnlist RP */
+  {  242,   -7 }, /* (112) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+  {  242,   -7 }, /* (113) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+  {  242,   -2 }, /* (114) create_table_args ::= AS select */
+  {  243,   -3 }, /* (115) columnlist ::= columnlist COMMA column */
+  {  243,   -1 }, /* (116) columnlist ::= column */
+  {  245,   -2 }, /* (117) column ::= ids typename */
+  {  227,   -3 }, /* (118) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  227,   -1 }, /* (119) tagitemlist ::= tagitem */
+  {  246,   -1 }, /* (120) tagitem ::= INTEGER */
+  {  246,   -1 }, /* (121) tagitem ::= FLOAT */
+  {  246,   -1 }, /* (122) tagitem ::= STRING */
+  {  246,   -1 }, /* (123) tagitem ::= BOOL */
+  {  246,   -1 }, /* (124) tagitem ::= NULL */
+  {  246,   -2 }, /* (125) tagitem ::= MINUS INTEGER */
+  {  246,   -2 }, /* (126) tagitem ::= MINUS FLOAT */
+  {  246,   -2 }, /* (127) tagitem ::= PLUS INTEGER */
+  {  246,   -2 }, /* (128) tagitem ::= PLUS FLOAT */
+  {  244,  -12 }, /* (129) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+  {  258,   -1 }, /* (130) union ::= select */
+  {  258,   -3 }, /* (131) union ::= LP union RP */
+  {  258,   -4 }, /* (132) union ::= union UNION ALL select */
+  {  258,   -6 }, /* (133) union ::= union UNION ALL LP select RP */
+  {  208,   -1 }, /* (134) cmd ::= union */
+  {  244,   -2 }, /* (135) select ::= SELECT selcollist */
+  {  259,   -2 }, /* (136) sclp ::= selcollist COMMA */
+  {  259,    0 }, /* (137) sclp ::= */
+  {  247,   -3 }, /* (138) selcollist ::= sclp expr as */
+  {  247,   -2 }, /* (139) selcollist ::= sclp STAR */
+  {  261,   -2 }, /* (140) as ::= AS ids */
+  {  261,   -1 }, /* (141) as ::= ids */
+  {  261,    0 }, /* (142) as ::= */
+  {  248,   -2 }, /* (143) from ::= FROM tablelist */
+  {  262,   -2 }, /* (144) tablelist ::= ids cpxName */
+  {  262,   -3 }, /* (145) tablelist ::= ids cpxName ids */
+  {  262,   -4 }, /* (146) tablelist ::= tablelist COMMA ids cpxName */
+  {  262,   -5 }, /* (147) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  263,   -1 }, /* (148) tmvar ::= VARIABLE */
+  {  250,   -4 }, /* (149) interval_opt ::= INTERVAL LP tmvar RP */
+  {  250,    0 }, /* (150) interval_opt ::= */
+  {  251,    0 }, /* (151) fill_opt ::= */
+  {  251,   -6 }, /* (152) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  251,   -4 }, /* (153) fill_opt ::= FILL LP ID RP */
+  {  252,   -4 }, /* (154) sliding_opt ::= SLIDING LP tmvar RP */
+  {  252,    0 }, /* (155) sliding_opt ::= */
+  {  254,    0 }, /* (156) orderby_opt ::= */
+  {  254,   -3 }, /* (157) orderby_opt ::= ORDER BY sortlist */
+  {  264,   -4 }, /* (158) sortlist ::= sortlist COMMA item sortorder */
+  {  264,   -2 }, /* (159) sortlist ::= item sortorder */
+  {  266,   -2 }, /* (160) item ::= ids cpxName */
+  {  267,   -1 }, /* (161) sortorder ::= ASC */
+  {  267,   -1 }, /* (162) sortorder ::= DESC */
+  {  267,    0 }, /* (163) sortorder ::= */
+  {  253,    0 }, /* (164) groupby_opt ::= */
+  {  253,   -3 }, /* (165) groupby_opt ::= GROUP BY grouplist */
+  {  268,   -3 }, /* (166) grouplist ::= grouplist COMMA item */
+  {  268,   -1 }, /* (167) grouplist ::= item */
+  {  255,    0 }, /* (168) having_opt ::= */
+  {  255,   -2 }, /* (169) having_opt ::= HAVING expr */
+  {  257,    0 }, /* (170) limit_opt ::= */
+  {  257,   -2 }, /* (171) limit_opt ::= LIMIT signed */
+  {  257,   -4 }, /* (172) limit_opt ::= LIMIT signed OFFSET signed */
+  {  257,   -4 }, /* (173) limit_opt ::= LIMIT signed COMMA signed */
+  {  256,    0 }, /* (174) slimit_opt ::= */
+  {  256,   -2 }, /* (175) slimit_opt ::= SLIMIT signed */
+  {  256,   -4 }, /* (176) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  256,   -4 }, /* (177) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  249,    0 }, /* (178) where_opt ::= */
+  {  249,   -2 }, /* (179) where_opt ::= WHERE expr */
+  {  260,   -3 }, /* (180) expr ::= LP expr RP */
+  {  260,   -1 }, /* (181) expr ::= ID */
+  {  260,   -3 }, /* (182) expr ::= ID DOT ID */
+  {  260,   -3 }, /* (183) expr ::= ID DOT STAR */
+  {  260,   -1 }, /* (184) expr ::= INTEGER */
+  {  260,   -2 }, /* (185) expr ::= MINUS INTEGER */
+  {  260,   -2 }, /* (186) expr ::= PLUS INTEGER */
+  {  260,   -1 }, /* (187) expr ::= FLOAT */
+  {  260,   -2 }, /* (188) expr ::= MINUS FLOAT */
+  {  260,   -2 }, /* (189) expr ::= PLUS FLOAT */
+  {  260,   -1 }, /* (190) expr ::= STRING */
+  {  260,   -1 }, /* (191) expr ::= NOW */
+  {  260,   -1 }, /* (192) expr ::= VARIABLE */
+  {  260,   -1 }, /* (193) expr ::= BOOL */
+  {  260,   -4 }, /* (194) expr ::= ID LP exprlist RP */
+  {  260,   -4 }, /* (195) expr ::= ID LP STAR RP */
+  {  260,   -3 }, /* (196) expr ::= expr AND expr */
+  {  260,   -3 }, /* (197) expr ::= expr OR expr */
+  {  260,   -3 }, /* (198) expr ::= expr LT expr */
+  {  260,   -3 }, /* (199) expr ::= expr GT expr */
+  {  260,   -3 }, /* (200) expr ::= expr LE expr */
+  {  260,   -3 }, /* (201) expr ::= expr GE expr */
+  {  260,   -3 }, /* (202) expr ::= expr NE expr */
+  {  260,   -3 }, /* (203) expr ::= expr EQ expr */
+  {  260,   -3 }, /* (204) expr ::= expr PLUS expr */
+  {  260,   -3 }, /* (205) expr ::= expr MINUS expr */
+  {  260,   -3 }, /* (206) expr ::= expr STAR expr */
+  {  260,   -3 }, /* (207) expr ::= expr SLASH expr */
+  {  260,   -3 }, /* (208) expr ::= expr REM expr */
+  {  260,   -3 }, /* (209) expr ::= expr LIKE expr */
+  {  260,   -5 }, /* (210) expr ::= expr IN LP exprlist RP */
+  {  269,   -3 }, /* (211) exprlist ::= exprlist COMMA expritem */
+  {  269,   -1 }, /* (212) exprlist ::= expritem */
+  {  270,   -1 }, /* (213) expritem ::= expr */
+  {  270,    0 }, /* (214) expritem ::= */
+  {  208,   -3 }, /* (215) cmd ::= RESET QUERY CACHE */
+  {  208,   -7 }, /* (216) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  208,   -7 }, /* (217) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  208,   -7 }, /* (218) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  208,   -7 }, /* (219) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  208,   -8 }, /* (220) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  208,   -9 }, /* (221) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  208,   -3 }, /* (222) cmd ::= KILL CONNECTION INTEGER */
+  {  208,   -5 }, /* (223) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  208,   -5 }, /* (224) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2139,13 +2128,13 @@ static void yy_reduce(
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
       case 38: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &t);}
+{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy158, &t);}
         break;
       case 39: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy149);}
+{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy73);}
         break;
       case 40: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy149);}
+{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy73);}
         break;
       case 41: /* ids ::= ID */
       case 42: /* ids ::= STRING */ yytestcase(yyruleno==42);
@@ -2166,10 +2155,10 @@ static void yy_reduce(
 { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 48: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy149);}
+{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy73);}
         break;
       case 49: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &yymsp[-2].minor.yy0);}
+{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy158, &yymsp[-2].minor.yy0);}
         break;
       case 50: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSQL(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
@@ -2198,562 +2187,556 @@ static void yy_reduce(
         break;
       case 69: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy149.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy149.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy149.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy149.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy149.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy149.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy149.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy149.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy149.stat    = yymsp[0].minor.yy0;
+    yylhsminor.yy73.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy73.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy73.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy73.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy73.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy73.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy73.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy73.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy73.stat    = yymsp[0].minor.yy0;
 }
-  yymsp[-8].minor.yy149 = yylhsminor.yy149;
+  yymsp[-8].minor.yy73 = yylhsminor.yy73;
         break;
       case 70: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy498 = yymsp[0].minor.yy498; }
+{ yymsp[-1].minor.yy494 = yymsp[0].minor.yy494; }
         break;
-      case 71: /* tables ::= MAXTABLES INTEGER */
-      case 72: /* cache ::= CACHE INTEGER */ yytestcase(yyruleno==72);
-      case 73: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==73);
-      case 74: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==74);
-      case 75: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==75);
-      case 76: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==76);
-      case 77: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==77);
-      case 78: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==78);
-      case 79: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==79);
-      case 80: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==80);
-      case 81: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==81);
-      case 82: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==82);
-      case 83: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==83);
+      case 71: /* cache ::= CACHE INTEGER */
+      case 72: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==72);
+      case 73: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==73);
+      case 74: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==74);
+      case 75: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==75);
+      case 76: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==76);
+      case 77: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==77);
+      case 78: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==78);
+      case 79: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==79);
+      case 80: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==80);
+      case 81: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==81);
+      case 82: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==82);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 84: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy268);}
+      case 83: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
         break;
-      case 85: /* db_optr ::= db_optr tables */
-      case 102: /* alter_db_optr ::= alter_db_optr tables */ yytestcase(yyruleno==102);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.maxTablesPerVnode = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 84: /* db_optr ::= db_optr cache */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 86: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 85: /* db_optr ::= db_optr replica */
+      case 98: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==98);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 87: /* db_optr ::= db_optr replica */
-      case 100: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==100);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 86: /* db_optr ::= db_optr quorum */
+      case 99: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==99);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 88: /* db_optr ::= db_optr quorum */
-      case 101: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==101);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 87: /* db_optr ::= db_optr days */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 89: /* db_optr ::= db_optr days */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 88: /* db_optr ::= db_optr minrows */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 90: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 89: /* db_optr ::= db_optr maxrows */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 91: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 90: /* db_optr ::= db_optr blocks */
+      case 101: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==101);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 92: /* db_optr ::= db_optr blocks */
-      case 104: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==104);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 91: /* db_optr ::= db_optr ctime */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 93: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 92: /* db_optr ::= db_optr wal */
+      case 103: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==103);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 94: /* db_optr ::= db_optr wal */
-      case 106: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==106);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 93: /* db_optr ::= db_optr fsync */
+      case 104: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==104);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 95: /* db_optr ::= db_optr fsync */
-      case 107: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==107);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 94: /* db_optr ::= db_optr comp */
+      case 102: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==102);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 96: /* db_optr ::= db_optr comp */
-      case 105: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==105);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 95: /* db_optr ::= db_optr prec */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 97: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 96: /* db_optr ::= db_optr keep */
+      case 100: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==100);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.keep = yymsp[0].minor.yy494; }
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 98: /* db_optr ::= db_optr keep */
-      case 103: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==103);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.keep = yymsp[0].minor.yy498; }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+      case 97: /* alter_db_optr ::= */
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
         break;
-      case 99: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy268);}
-        break;
-      case 108: /* typename ::= ids */
+      case 105: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
-  tSQLSetColumnType (&yylhsminor.yy223, &yymsp[0].minor.yy0); 
+  tSQLSetColumnType (&yylhsminor.yy181, &yymsp[0].minor.yy0); 
 }
-  yymsp[0].minor.yy223 = yylhsminor.yy223;
+  yymsp[0].minor.yy181 = yylhsminor.yy181;
         break;
-      case 109: /* typename ::= ids LP signed RP */
+      case 106: /* typename ::= ids LP signed RP */
 {
-    if (yymsp[-1].minor.yy207 <= 0) {
+    if (yymsp[-1].minor.yy271 <= 0) {
       yymsp[-3].minor.yy0.type = 0;
-      tSQLSetColumnType(&yylhsminor.yy223, &yymsp[-3].minor.yy0);
+      tSQLSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
     } else {
-      yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy207;          // negative value of name length
-      tSQLSetColumnType(&yylhsminor.yy223, &yymsp[-3].minor.yy0);
+      yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy271;          // negative value of name length
+      tSQLSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
     }
 }
-  yymsp[-3].minor.yy223 = yylhsminor.yy223;
+  yymsp[-3].minor.yy181 = yylhsminor.yy181;
         break;
-      case 110: /* signed ::= INTEGER */
-{ yylhsminor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy207 = yylhsminor.yy207;
+      case 107: /* signed ::= INTEGER */
+{ yylhsminor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy271 = yylhsminor.yy271;
         break;
-      case 111: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+      case 108: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 112: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy207 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+      case 109: /* signed ::= MINUS INTEGER */
+{ yymsp[-1].minor.yy271 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
-      case 113: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+      case 110: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
 {
     yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
     setCreatedTableName(pInfo, &yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0);
 }
         break;
-      case 114: /* create_table_args ::= LP columnlist RP */
+      case 111: /* create_table_args ::= LP columnlist RP */
 {
-    yymsp[-2].minor.yy470 = tSetCreateSQLElems(yymsp[-1].minor.yy523, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
-    setSQLInfo(pInfo, yymsp[-2].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+    yymsp[-2].minor.yy374 = tSetCreateSQLElems(yymsp[-1].minor.yy449, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
+    setSQLInfo(pInfo, yymsp[-2].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 115: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+      case 112: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
 {
-    yymsp[-6].minor.yy470 = tSetCreateSQLElems(yymsp[-5].minor.yy523, yymsp[-1].minor.yy523, NULL, NULL, NULL, TSQL_CREATE_STABLE);
-    setSQLInfo(pInfo, yymsp[-6].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+    yymsp[-6].minor.yy374 = tSetCreateSQLElems(yymsp[-5].minor.yy449, yymsp[-1].minor.yy449, NULL, NULL, NULL, TSQL_CREATE_STABLE);
+    setSQLInfo(pInfo, yymsp[-6].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 116: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+      case 113: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
-    yymsp[-6].minor.yy470 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy498, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
-    setSQLInfo(pInfo, yymsp[-6].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+    yymsp[-6].minor.yy374 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy494, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
+    setSQLInfo(pInfo, yymsp[-6].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 117: /* create_table_args ::= AS select */
+      case 114: /* create_table_args ::= AS select */
 {
-    yymsp[-1].minor.yy470 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy414, TSQL_CREATE_STREAM);
-    setSQLInfo(pInfo, yymsp[-1].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+    yymsp[-1].minor.yy374 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy150, TSQL_CREATE_STREAM);
+    setSQLInfo(pInfo, yymsp[-1].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 118: /* columnlist ::= columnlist COMMA column */
-{yylhsminor.yy523 = tFieldListAppend(yymsp[-2].minor.yy523, &yymsp[0].minor.yy223);   }
-  yymsp[-2].minor.yy523 = yylhsminor.yy523;
+      case 115: /* columnlist ::= columnlist COMMA column */
+{yylhsminor.yy449 = tFieldListAppend(yymsp[-2].minor.yy449, &yymsp[0].minor.yy181);   }
+  yymsp[-2].minor.yy449 = yylhsminor.yy449;
         break;
-      case 119: /* columnlist ::= column */
-{yylhsminor.yy523 = tFieldListAppend(NULL, &yymsp[0].minor.yy223);}
-  yymsp[0].minor.yy523 = yylhsminor.yy523;
+      case 116: /* columnlist ::= column */
+{yylhsminor.yy449 = tFieldListAppend(NULL, &yymsp[0].minor.yy181);}
+  yymsp[0].minor.yy449 = yylhsminor.yy449;
         break;
-      case 120: /* column ::= ids typename */
+      case 117: /* column ::= ids typename */
 {
-    tSQLSetColumnInfo(&yylhsminor.yy223, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy223);
+    tSQLSetColumnInfo(&yylhsminor.yy181, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy181);
 }
-  yymsp[-1].minor.yy223 = yylhsminor.yy223;
+  yymsp[-1].minor.yy181 = yylhsminor.yy181;
         break;
-      case 121: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy498 = tVariantListAppend(yymsp[-2].minor.yy498, &yymsp[0].minor.yy134, -1);    }
-  yymsp[-2].minor.yy498 = yylhsminor.yy498;
+      case 118: /* tagitemlist ::= tagitemlist COMMA tagitem */
+{ yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);    }
+  yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 122: /* tagitemlist ::= tagitem */
-{ yylhsminor.yy498 = tVariantListAppend(NULL, &yymsp[0].minor.yy134, -1); }
-  yymsp[0].minor.yy498 = yylhsminor.yy498;
+      case 119: /* tagitemlist ::= tagitem */
+{ yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1); }
+  yymsp[0].minor.yy494 = yylhsminor.yy494;
         break;
-      case 123: /* tagitem ::= INTEGER */
-      case 124: /* tagitem ::= FLOAT */ yytestcase(yyruleno==124);
-      case 125: /* tagitem ::= STRING */ yytestcase(yyruleno==125);
-      case 126: /* tagitem ::= BOOL */ yytestcase(yyruleno==126);
-{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy134, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy134 = yylhsminor.yy134;
+      case 120: /* tagitem ::= INTEGER */
+      case 121: /* tagitem ::= FLOAT */ yytestcase(yyruleno==121);
+      case 122: /* tagitem ::= STRING */ yytestcase(yyruleno==122);
+      case 123: /* tagitem ::= BOOL */ yytestcase(yyruleno==123);
+{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy312, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy312 = yylhsminor.yy312;
         break;
-      case 127: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy134, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy134 = yylhsminor.yy134;
+      case 124: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy312, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy312 = yylhsminor.yy312;
         break;
-      case 128: /* tagitem ::= MINUS INTEGER */
-      case 129: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==129);
-      case 130: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==130);
-      case 131: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==131);
+      case 125: /* tagitem ::= MINUS INTEGER */
+      case 126: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==126);
+      case 127: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==127);
+      case 128: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==128);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy134, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy312, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy134 = yylhsminor.yy134;
+  yymsp[-1].minor.yy312 = yylhsminor.yy312;
         break;
-      case 132: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+      case 129: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy414 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy290, yymsp[-9].minor.yy498, yymsp[-8].minor.yy64, yymsp[-4].minor.yy498, yymsp[-3].minor.yy498, &yymsp[-7].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy498, &yymsp[0].minor.yy216, &yymsp[-1].minor.yy216);
+  yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy224, yymsp[-9].minor.yy494, yymsp[-8].minor.yy66, yymsp[-4].minor.yy494, yymsp[-3].minor.yy494, &yymsp[-7].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy494, &yymsp[0].minor.yy188, &yymsp[-1].minor.yy188);
 }
-  yymsp[-11].minor.yy414 = yylhsminor.yy414;
+  yymsp[-11].minor.yy150 = yylhsminor.yy150;
         break;
-      case 133: /* union ::= select */
-{ yylhsminor.yy231 = setSubclause(NULL, yymsp[0].minor.yy414); }
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+      case 130: /* union ::= select */
+{ yylhsminor.yy25 = setSubclause(NULL, yymsp[0].minor.yy150); }
+  yymsp[0].minor.yy25 = yylhsminor.yy25;
         break;
-      case 134: /* union ::= LP union RP */
-{ yymsp[-2].minor.yy231 = yymsp[-1].minor.yy231; }
+      case 131: /* union ::= LP union RP */
+{ yymsp[-2].minor.yy25 = yymsp[-1].minor.yy25; }
         break;
-      case 135: /* union ::= union UNION ALL select */
-{ yylhsminor.yy231 = appendSelectClause(yymsp[-3].minor.yy231, yymsp[0].minor.yy414); }
-  yymsp[-3].minor.yy231 = yylhsminor.yy231;
+      case 132: /* union ::= union UNION ALL select */
+{ yylhsminor.yy25 = appendSelectClause(yymsp[-3].minor.yy25, yymsp[0].minor.yy150); }
+  yymsp[-3].minor.yy25 = yylhsminor.yy25;
         break;
-      case 136: /* union ::= union UNION ALL LP select RP */
-{ yylhsminor.yy231 = appendSelectClause(yymsp[-5].minor.yy231, yymsp[-1].minor.yy414); }
-  yymsp[-5].minor.yy231 = yylhsminor.yy231;
+      case 133: /* union ::= union UNION ALL LP select RP */
+{ yylhsminor.yy25 = appendSelectClause(yymsp[-5].minor.yy25, yymsp[-1].minor.yy150); }
+  yymsp[-5].minor.yy25 = yylhsminor.yy25;
         break;
-      case 137: /* cmd ::= union */
-{ setSQLInfo(pInfo, yymsp[0].minor.yy231, NULL, TSDB_SQL_SELECT); }
+      case 134: /* cmd ::= union */
+{ setSQLInfo(pInfo, yymsp[0].minor.yy25, NULL, TSDB_SQL_SELECT); }
         break;
-      case 138: /* select ::= SELECT selcollist */
+      case 135: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy414 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy290, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy224, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy414 = yylhsminor.yy414;
+  yymsp[-1].minor.yy150 = yylhsminor.yy150;
         break;
-      case 139: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy290 = yymsp[-1].minor.yy290;}
-  yymsp[-1].minor.yy290 = yylhsminor.yy290;
+      case 136: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy224 = yymsp[-1].minor.yy224;}
+  yymsp[-1].minor.yy224 = yylhsminor.yy224;
         break;
-      case 140: /* sclp ::= */
-{yymsp[1].minor.yy290 = 0;}
+      case 137: /* sclp ::= */
+{yymsp[1].minor.yy224 = 0;}
         break;
-      case 141: /* selcollist ::= sclp expr as */
+      case 138: /* selcollist ::= sclp expr as */
 {
-   yylhsminor.yy290 = tSQLExprListAppend(yymsp[-2].minor.yy290, yymsp[-1].minor.yy64, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224, yymsp[-1].minor.yy66, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-2].minor.yy290 = yylhsminor.yy290;
+  yymsp[-2].minor.yy224 = yylhsminor.yy224;
         break;
-      case 142: /* selcollist ::= sclp STAR */
+      case 139: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
-   yylhsminor.yy290 = tSQLExprListAppend(yymsp[-1].minor.yy290, pNode, 0);
+   yylhsminor.yy224 = tSQLExprListAppend(yymsp[-1].minor.yy224, pNode, 0);
 }
-  yymsp[-1].minor.yy290 = yylhsminor.yy290;
+  yymsp[-1].minor.yy224 = yylhsminor.yy224;
         break;
-      case 143: /* as ::= AS ids */
+      case 140: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 144: /* as ::= ids */
+      case 141: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 145: /* as ::= */
+      case 142: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 146: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy498 = yymsp[0].minor.yy498;}
+      case 143: /* from ::= FROM tablelist */
+{yymsp[-1].minor.yy494 = yymsp[0].minor.yy494;}
         break;
-      case 147: /* tablelist ::= ids cpxName */
+      case 144: /* tablelist ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy498 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy498 = tVariantListAppendToken(yylhsminor.yy498, &yymsp[-1].minor.yy0, -1);  // table alias name
+  yylhsminor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[-1].minor.yy0, -1);  // table alias name
 }
-  yymsp[-1].minor.yy498 = yylhsminor.yy498;
+  yymsp[-1].minor.yy494 = yylhsminor.yy494;
         break;
-      case 148: /* tablelist ::= ids cpxName ids */
+      case 145: /* tablelist ::= ids cpxName ids */
 {
    toTSDBType(yymsp[-2].minor.yy0.type);
    toTSDBType(yymsp[0].minor.yy0.type);
    yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-   yylhsminor.yy498 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-   yylhsminor.yy498 = tVariantListAppendToken(yylhsminor.yy498, &yymsp[0].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-2].minor.yy498 = yylhsminor.yy498;
+  yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 149: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 146: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy498 = tVariantListAppendToken(yymsp[-3].minor.yy498, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy498 = tVariantListAppendToken(yylhsminor.yy498, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy494 = tVariantListAppendToken(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[-1].minor.yy0, -1);
 }
-  yymsp[-3].minor.yy498 = yylhsminor.yy498;
+  yymsp[-3].minor.yy494 = yylhsminor.yy494;
         break;
-      case 150: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 147: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
    toTSDBType(yymsp[-2].minor.yy0.type);
    toTSDBType(yymsp[0].minor.yy0.type);
    yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-   yylhsminor.yy498 = tVariantListAppendToken(yymsp[-4].minor.yy498, &yymsp[-2].minor.yy0, -1);
-   yylhsminor.yy498 = tVariantListAppendToken(yylhsminor.yy498, &yymsp[0].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(yymsp[-4].minor.yy494, &yymsp[-2].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-4].minor.yy498 = yylhsminor.yy498;
+  yymsp[-4].minor.yy494 = yylhsminor.yy494;
         break;
-      case 151: /* tmvar ::= VARIABLE */
+      case 148: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 152: /* interval_opt ::= INTERVAL LP tmvar RP */
-      case 157: /* sliding_opt ::= SLIDING LP tmvar RP */ yytestcase(yyruleno==157);
+      case 149: /* interval_opt ::= INTERVAL LP tmvar RP */
+      case 154: /* sliding_opt ::= SLIDING LP tmvar RP */ yytestcase(yyruleno==154);
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 153: /* interval_opt ::= */
-      case 158: /* sliding_opt ::= */ yytestcase(yyruleno==158);
+      case 150: /* interval_opt ::= */
+      case 155: /* sliding_opt ::= */ yytestcase(yyruleno==155);
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 154: /* fill_opt ::= */
-{yymsp[1].minor.yy498 = 0;     }
+      case 151: /* fill_opt ::= */
+{yymsp[1].minor.yy494 = 0;     }
         break;
-      case 155: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 152: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy498, &A, -1, 0);
-    yymsp[-5].minor.yy498 = yymsp[-1].minor.yy498;
+    tVariantListInsert(yymsp[-1].minor.yy494, &A, -1, 0);
+    yymsp[-5].minor.yy494 = yymsp[-1].minor.yy494;
 }
         break;
-      case 156: /* fill_opt ::= FILL LP ID RP */
+      case 153: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy498 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 159: /* orderby_opt ::= */
-      case 167: /* groupby_opt ::= */ yytestcase(yyruleno==167);
-{yymsp[1].minor.yy498 = 0;}
+      case 156: /* orderby_opt ::= */
+      case 164: /* groupby_opt ::= */ yytestcase(yyruleno==164);
+{yymsp[1].minor.yy494 = 0;}
         break;
-      case 160: /* orderby_opt ::= ORDER BY sortlist */
-      case 168: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==168);
-{yymsp[-2].minor.yy498 = yymsp[0].minor.yy498;}
+      case 157: /* orderby_opt ::= ORDER BY sortlist */
+      case 165: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==165);
+{yymsp[-2].minor.yy494 = yymsp[0].minor.yy494;}
         break;
-      case 161: /* sortlist ::= sortlist COMMA item sortorder */
+      case 158: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy498 = tVariantListAppend(yymsp[-3].minor.yy498, &yymsp[-1].minor.yy134, yymsp[0].minor.yy46);
+    yylhsminor.yy494 = tVariantListAppend(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
-  yymsp[-3].minor.yy498 = yylhsminor.yy498;
+  yymsp[-3].minor.yy494 = yylhsminor.yy494;
         break;
-      case 162: /* sortlist ::= item sortorder */
+      case 159: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy498 = tVariantListAppend(NULL, &yymsp[-1].minor.yy134, yymsp[0].minor.yy46);
+  yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
-  yymsp[-1].minor.yy498 = yylhsminor.yy498;
+  yymsp[-1].minor.yy494 = yylhsminor.yy494;
         break;
-      case 163: /* item ::= ids cpxName */
+      case 160: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
 
-  tVariantCreate(&yylhsminor.yy134, &yymsp[-1].minor.yy0);
+  tVariantCreate(&yylhsminor.yy312, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy134 = yylhsminor.yy134;
+  yymsp[-1].minor.yy312 = yylhsminor.yy312;
         break;
-      case 164: /* sortorder ::= ASC */
-{yymsp[0].minor.yy46 = TSDB_ORDER_ASC; }
+      case 161: /* sortorder ::= ASC */
+{yymsp[0].minor.yy82 = TSDB_ORDER_ASC; }
         break;
-      case 165: /* sortorder ::= DESC */
-{yymsp[0].minor.yy46 = TSDB_ORDER_DESC;}
+      case 162: /* sortorder ::= DESC */
+{yymsp[0].minor.yy82 = TSDB_ORDER_DESC;}
         break;
-      case 166: /* sortorder ::= */
-{yymsp[1].minor.yy46 = TSDB_ORDER_ASC;}
+      case 163: /* sortorder ::= */
+{yymsp[1].minor.yy82 = TSDB_ORDER_ASC;}
         break;
-      case 169: /* grouplist ::= grouplist COMMA item */
+      case 166: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy498 = tVariantListAppend(yymsp[-2].minor.yy498, &yymsp[0].minor.yy134, -1);
+  yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);
 }
-  yymsp[-2].minor.yy498 = yylhsminor.yy498;
+  yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 170: /* grouplist ::= item */
+      case 167: /* grouplist ::= item */
 {
-  yylhsminor.yy498 = tVariantListAppend(NULL, &yymsp[0].minor.yy134, -1);
+  yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1);
 }
-  yymsp[0].minor.yy498 = yylhsminor.yy498;
+  yymsp[0].minor.yy494 = yylhsminor.yy494;
         break;
-      case 171: /* having_opt ::= */
-      case 181: /* where_opt ::= */ yytestcase(yyruleno==181);
-      case 217: /* expritem ::= */ yytestcase(yyruleno==217);
-{yymsp[1].minor.yy64 = 0;}
+      case 168: /* having_opt ::= */
+      case 178: /* where_opt ::= */ yytestcase(yyruleno==178);
+      case 214: /* expritem ::= */ yytestcase(yyruleno==214);
+{yymsp[1].minor.yy66 = 0;}
         break;
-      case 172: /* having_opt ::= HAVING expr */
-      case 182: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==182);
-{yymsp[-1].minor.yy64 = yymsp[0].minor.yy64;}
+      case 169: /* having_opt ::= HAVING expr */
+      case 179: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==179);
+{yymsp[-1].minor.yy66 = yymsp[0].minor.yy66;}
         break;
-      case 173: /* limit_opt ::= */
-      case 177: /* slimit_opt ::= */ yytestcase(yyruleno==177);
-{yymsp[1].minor.yy216.limit = -1; yymsp[1].minor.yy216.offset = 0;}
+      case 170: /* limit_opt ::= */
+      case 174: /* slimit_opt ::= */ yytestcase(yyruleno==174);
+{yymsp[1].minor.yy188.limit = -1; yymsp[1].minor.yy188.offset = 0;}
         break;
-      case 174: /* limit_opt ::= LIMIT signed */
-      case 178: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==178);
-{yymsp[-1].minor.yy216.limit = yymsp[0].minor.yy207;  yymsp[-1].minor.yy216.offset = 0;}
+      case 171: /* limit_opt ::= LIMIT signed */
+      case 175: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==175);
+{yymsp[-1].minor.yy188.limit = yymsp[0].minor.yy271;  yymsp[-1].minor.yy188.offset = 0;}
         break;
-      case 175: /* limit_opt ::= LIMIT signed OFFSET signed */
-      case 179: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==179);
-{yymsp[-3].minor.yy216.limit = yymsp[-2].minor.yy207;  yymsp[-3].minor.yy216.offset = yymsp[0].minor.yy207;}
+      case 172: /* limit_opt ::= LIMIT signed OFFSET signed */
+      case 176: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==176);
+{yymsp[-3].minor.yy188.limit = yymsp[-2].minor.yy271;  yymsp[-3].minor.yy188.offset = yymsp[0].minor.yy271;}
         break;
-      case 176: /* limit_opt ::= LIMIT signed COMMA signed */
-      case 180: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==180);
-{yymsp[-3].minor.yy216.limit = yymsp[0].minor.yy207;  yymsp[-3].minor.yy216.offset = yymsp[-2].minor.yy207;}
+      case 173: /* limit_opt ::= LIMIT signed COMMA signed */
+      case 177: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==177);
+{yymsp[-3].minor.yy188.limit = yymsp[0].minor.yy271;  yymsp[-3].minor.yy188.offset = yymsp[-2].minor.yy271;}
         break;
-      case 183: /* expr ::= LP expr RP */
-{yymsp[-2].minor.yy64 = yymsp[-1].minor.yy64; }
+      case 180: /* expr ::= LP expr RP */
+{yymsp[-2].minor.yy66 = yymsp[-1].minor.yy66; }
         break;
-      case 184: /* expr ::= ID */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 181: /* expr ::= ID */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 185: /* expr ::= ID DOT ID */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 182: /* expr ::= ID DOT ID */
+{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 186: /* expr ::= ID DOT STAR */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 183: /* expr ::= ID DOT STAR */
+{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 187: /* expr ::= INTEGER */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 184: /* expr ::= INTEGER */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 188: /* expr ::= MINUS INTEGER */
-      case 189: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==189);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy64 = yylhsminor.yy64;
+      case 185: /* expr ::= MINUS INTEGER */
+      case 186: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==186);
+{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy66 = yylhsminor.yy66;
         break;
-      case 190: /* expr ::= FLOAT */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 187: /* expr ::= FLOAT */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 191: /* expr ::= MINUS FLOAT */
-      case 192: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==192);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy64 = yylhsminor.yy64;
+      case 188: /* expr ::= MINUS FLOAT */
+      case 189: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==189);
+{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy66 = yylhsminor.yy66;
         break;
-      case 193: /* expr ::= STRING */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 190: /* expr ::= STRING */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 194: /* expr ::= NOW */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 191: /* expr ::= NOW */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 195: /* expr ::= VARIABLE */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 192: /* expr ::= VARIABLE */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 196: /* expr ::= BOOL */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 193: /* expr ::= BOOL */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 197: /* expr ::= ID LP exprlist RP */
+      case 194: /* expr ::= ID LP exprlist RP */
 {
-  yylhsminor.yy64 = tSQLExprCreateFunction(yymsp[-1].minor.yy290, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
+  yylhsminor.yy66 = tSQLExprCreateFunction(yymsp[-1].minor.yy224, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
 }
-  yymsp[-3].minor.yy64 = yylhsminor.yy64;
+  yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 198: /* expr ::= ID LP STAR RP */
+      case 195: /* expr ::= ID LP STAR RP */
 {
-  yylhsminor.yy64 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
+  yylhsminor.yy66 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
 }
-  yymsp[-3].minor.yy64 = yylhsminor.yy64;
+  yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 199: /* expr ::= expr AND expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_AND);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 196: /* expr ::= expr AND expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_AND);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 200: /* expr ::= expr OR expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_OR); }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 197: /* expr ::= expr OR expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_OR); }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 201: /* expr ::= expr LT expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LT);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 198: /* expr ::= expr LT expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LT);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 202: /* expr ::= expr GT expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_GT);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 199: /* expr ::= expr GT expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GT);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 203: /* expr ::= expr LE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 200: /* expr ::= expr LE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LE);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 204: /* expr ::= expr GE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_GE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 201: /* expr ::= expr GE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GE);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 205: /* expr ::= expr NE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_NE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 202: /* expr ::= expr NE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_NE);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 206: /* expr ::= expr EQ expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_EQ);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 203: /* expr ::= expr EQ expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_EQ);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 207: /* expr ::= expr PLUS expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_PLUS);  }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 204: /* expr ::= expr PLUS expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_PLUS);  }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 208: /* expr ::= expr MINUS expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_MINUS); }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 205: /* expr ::= expr MINUS expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_MINUS); }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 209: /* expr ::= expr STAR expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_STAR);  }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 206: /* expr ::= expr STAR expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_STAR);  }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 210: /* expr ::= expr SLASH expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_DIVIDE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 207: /* expr ::= expr SLASH expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_DIVIDE);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 211: /* expr ::= expr REM expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_REM);   }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 208: /* expr ::= expr REM expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_REM);   }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 212: /* expr ::= expr LIKE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LIKE);  }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 209: /* expr ::= expr LIKE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LIKE);  }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 213: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-4].minor.yy64, (tSQLExpr*)yymsp[-1].minor.yy290, TK_IN); }
-  yymsp[-4].minor.yy64 = yylhsminor.yy64;
+      case 210: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-4].minor.yy66, (tSQLExpr*)yymsp[-1].minor.yy224, TK_IN); }
+  yymsp[-4].minor.yy66 = yylhsminor.yy66;
         break;
-      case 214: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy290 = tSQLExprListAppend(yymsp[-2].minor.yy290,yymsp[0].minor.yy64,0);}
-  yymsp[-2].minor.yy290 = yylhsminor.yy290;
+      case 211: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224,yymsp[0].minor.yy66,0);}
+  yymsp[-2].minor.yy224 = yylhsminor.yy224;
         break;
-      case 215: /* exprlist ::= expritem */
-{yylhsminor.yy290 = tSQLExprListAppend(0,yymsp[0].minor.yy64,0);}
-  yymsp[0].minor.yy290 = yylhsminor.yy290;
+      case 212: /* exprlist ::= expritem */
+{yylhsminor.yy224 = tSQLExprListAppend(0,yymsp[0].minor.yy66,0);}
+  yymsp[0].minor.yy224 = yylhsminor.yy224;
         break;
-      case 216: /* expritem ::= expr */
-{yylhsminor.yy64 = yymsp[0].minor.yy64;}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 213: /* expritem ::= expr */
+{yylhsminor.yy66 = yymsp[0].minor.yy66;}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 218: /* cmd ::= RESET QUERY CACHE */
+      case 215: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 219: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 216: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy523, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 220: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 217: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2764,14 +2747,14 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 221: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 218: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy523, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 222: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 219: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2782,7 +2765,7 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 223: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 220: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2796,25 +2779,25 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 224: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 221: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     tVariantList* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy134, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy312, -1);
 
     SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 225: /* cmd ::= KILL CONNECTION INTEGER */
+      case 222: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 226: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 223: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSQL(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 227: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 224: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSQL(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:

From 401e72996147024be5b46c63d78596343bd1fb42 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 5 Sep 2020 14:53:59 +0800
Subject: [PATCH 18/21] [td-1333]

---
 src/inc/ttokendef.h | 241 ++++++++++++++++++++++----------------------
 1 file changed, 120 insertions(+), 121 deletions(-)

diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index c1579fe9e7..c5831a9b8a 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -101,127 +101,126 @@
 #define TK_CONNS                           83
 #define TK_STATE                           84
 #define TK_KEEP                            85
-#define TK_MAXTABLES                       86
-#define TK_CACHE                           87
-#define TK_REPLICA                         88
-#define TK_QUORUM                          89
-#define TK_DAYS                            90
-#define TK_MINROWS                         91
-#define TK_MAXROWS                         92
-#define TK_BLOCKS                          93
-#define TK_CTIME                           94
-#define TK_WAL                             95
-#define TK_FSYNC                           96
-#define TK_COMP                            97
-#define TK_PRECISION                       98
-#define TK_LP                              99
-#define TK_RP                             100
-#define TK_TAGS                           101
-#define TK_USING                          102
-#define TK_AS                             103
-#define TK_COMMA                          104
-#define TK_NULL                           105
-#define TK_SELECT                         106
-#define TK_UNION                          107
-#define TK_ALL                            108
-#define TK_FROM                           109
-#define TK_VARIABLE                       110
-#define TK_INTERVAL                       111
-#define TK_FILL                           112
-#define TK_SLIDING                        113
-#define TK_ORDER                          114
-#define TK_BY                             115
-#define TK_ASC                            116
-#define TK_DESC                           117
-#define TK_GROUP                          118
-#define TK_HAVING                         119
-#define TK_LIMIT                          120
-#define TK_OFFSET                         121
-#define TK_SLIMIT                         122
-#define TK_SOFFSET                        123
-#define TK_WHERE                          124
-#define TK_NOW                            125
-#define TK_RESET                          126
-#define TK_QUERY                          127
-#define TK_ADD                            128
-#define TK_COLUMN                         129
-#define TK_TAG                            130
-#define TK_CHANGE                         131
-#define TK_SET                            132
-#define TK_KILL                           133
-#define TK_CONNECTION                     134
-#define TK_STREAM                         135
-#define TK_COLON                          136
-#define TK_ABORT                          137
-#define TK_AFTER                          138
-#define TK_ATTACH                         139
-#define TK_BEFORE                         140
-#define TK_BEGIN                          141
-#define TK_CASCADE                        142
-#define TK_CLUSTER                        143
-#define TK_CONFLICT                       144
-#define TK_COPY                           145
-#define TK_DEFERRED                       146
-#define TK_DELIMITERS                     147
-#define TK_DETACH                         148
-#define TK_EACH                           149
-#define TK_END                            150
-#define TK_EXPLAIN                        151
-#define TK_FAIL                           152
-#define TK_FOR                            153
-#define TK_IGNORE                         154
-#define TK_IMMEDIATE                      155
-#define TK_INITIALLY                      156
-#define TK_INSTEAD                        157
-#define TK_MATCH                          158
-#define TK_KEY                            159
-#define TK_OF                             160
-#define TK_RAISE                          161
-#define TK_REPLACE                        162
-#define TK_RESTRICT                       163
-#define TK_ROW                            164
-#define TK_STATEMENT                      165
-#define TK_TRIGGER                        166
-#define TK_VIEW                           167
-#define TK_COUNT                          168
-#define TK_SUM                            169
-#define TK_AVG                            170
-#define TK_MIN                            171
-#define TK_MAX                            172
-#define TK_FIRST                          173
-#define TK_LAST                           174
-#define TK_TOP                            175
-#define TK_BOTTOM                         176
-#define TK_STDDEV                         177
-#define TK_PERCENTILE                     178
-#define TK_APERCENTILE                    179
-#define TK_LEASTSQUARES                   180
-#define TK_HISTOGRAM                      181
-#define TK_DIFF                           182
-#define TK_SPREAD                         183
-#define TK_TWA                            184
-#define TK_INTERP                         185
-#define TK_LAST_ROW                       186
-#define TK_RATE                           187
-#define TK_IRATE                          188
-#define TK_SUM_RATE                       189
-#define TK_SUM_IRATE                      190
-#define TK_AVG_RATE                       191
-#define TK_AVG_IRATE                      192
-#define TK_TBID                           193
-#define TK_SEMI                           194
-#define TK_NONE                           195
-#define TK_PREV                           196
-#define TK_LINEAR                         197
-#define TK_IMPORT                         198
-#define TK_METRIC                         199
-#define TK_TBNAME                         200
-#define TK_JOIN                           201
-#define TK_METRICS                        202
-#define TK_STABLE                         203
-#define TK_INSERT                         204
-#define TK_INTO                           205
-#define TK_VALUES                         206
+#define TK_CACHE                           86
+#define TK_REPLICA                         87
+#define TK_QUORUM                          88
+#define TK_DAYS                            89
+#define TK_MINROWS                         90
+#define TK_MAXROWS                         91
+#define TK_BLOCKS                          92
+#define TK_CTIME                           93
+#define TK_WAL                             94
+#define TK_FSYNC                           95
+#define TK_COMP                            96
+#define TK_PRECISION                       97
+#define TK_LP                              98
+#define TK_RP                              99
+#define TK_TAGS                           100
+#define TK_USING                          101
+#define TK_AS                             102
+#define TK_COMMA                          103
+#define TK_NULL                           104
+#define TK_SELECT                         105
+#define TK_UNION                          106
+#define TK_ALL                            107
+#define TK_FROM                           108
+#define TK_VARIABLE                       109
+#define TK_INTERVAL                       110
+#define TK_FILL                           111
+#define TK_SLIDING                        112
+#define TK_ORDER                          113
+#define TK_BY                             114
+#define TK_ASC                            115
+#define TK_DESC                           116
+#define TK_GROUP                          117
+#define TK_HAVING                         118
+#define TK_LIMIT                          119
+#define TK_OFFSET                         120
+#define TK_SLIMIT                         121
+#define TK_SOFFSET                        122
+#define TK_WHERE                          123
+#define TK_NOW                            124
+#define TK_RESET                          125
+#define TK_QUERY                          126
+#define TK_ADD                            127
+#define TK_COLUMN                         128
+#define TK_TAG                            129
+#define TK_CHANGE                         130
+#define TK_SET                            131
+#define TK_KILL                           132
+#define TK_CONNECTION                     133
+#define TK_STREAM                         134
+#define TK_COLON                          135
+#define TK_ABORT                          136
+#define TK_AFTER                          137
+#define TK_ATTACH                         138
+#define TK_BEFORE                         139
+#define TK_BEGIN                          140
+#define TK_CASCADE                        141
+#define TK_CLUSTER                        142
+#define TK_CONFLICT                       143
+#define TK_COPY                           144
+#define TK_DEFERRED                       145
+#define TK_DELIMITERS                     146
+#define TK_DETACH                         147
+#define TK_EACH                           148
+#define TK_END                            149
+#define TK_EXPLAIN                        150
+#define TK_FAIL                           151
+#define TK_FOR                            152
+#define TK_IGNORE                         153
+#define TK_IMMEDIATE                      154
+#define TK_INITIALLY                      155
+#define TK_INSTEAD                        156
+#define TK_MATCH                          157
+#define TK_KEY                            158
+#define TK_OF                             159
+#define TK_RAISE                          160
+#define TK_REPLACE                        161
+#define TK_RESTRICT                       162
+#define TK_ROW                            163
+#define TK_STATEMENT                      164
+#define TK_TRIGGER                        165
+#define TK_VIEW                           166
+#define TK_COUNT                          167
+#define TK_SUM                            168
+#define TK_AVG                            169
+#define TK_MIN                            170
+#define TK_MAX                            171
+#define TK_FIRST                          172
+#define TK_LAST                           173
+#define TK_TOP                            174
+#define TK_BOTTOM                         175
+#define TK_STDDEV                         176
+#define TK_PERCENTILE                     177
+#define TK_APERCENTILE                    178
+#define TK_LEASTSQUARES                   179
+#define TK_HISTOGRAM                      180
+#define TK_DIFF                           181
+#define TK_SPREAD                         182
+#define TK_TWA                            183
+#define TK_INTERP                         184
+#define TK_LAST_ROW                       185
+#define TK_RATE                           186
+#define TK_IRATE                          187
+#define TK_SUM_RATE                       188
+#define TK_SUM_IRATE                      189
+#define TK_AVG_RATE                       190
+#define TK_AVG_IRATE                      191
+#define TK_TBID                           192
+#define TK_SEMI                           193
+#define TK_NONE                           194
+#define TK_PREV                           195
+#define TK_LINEAR                         196
+#define TK_IMPORT                         197
+#define TK_METRIC                         198
+#define TK_TBNAME                         199
+#define TK_JOIN                           200
+#define TK_METRICS                        201
+#define TK_STABLE                         202
+#define TK_INSERT                         203
+#define TK_INTO                           204
+#define TK_VALUES                         205
 
 
 #define TK_SPACE                          300

From 56c8b5c7981dde4a228f9ddf935035dd5acdd7be Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Sat, 5 Sep 2020 15:40:32 +0800
Subject: [PATCH 19/21] [modify script]

---
 packaging/docker/dockerbuild.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packaging/docker/dockerbuild.sh b/packaging/docker/dockerbuild.sh
index a0ac49bed1..7532832c07 100755
--- a/packaging/docker/dockerbuild.sh
+++ b/packaging/docker/dockerbuild.sh
@@ -1,6 +1,5 @@
 #!/bin/bash
 set -x
-$1
 docker build --rm -f "Dockerfile" -t tdengine/tdengine:$1 "."
 docker login -u tdengine -p $2  #replace the docker registry username and password
 docker push tdengine/tdengine:$1

From 8cb141554e9c5736a3d0cf4ba12553121887ec54 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 5 Sep 2020 23:31:53 +0800
Subject: [PATCH 20/21] [td-225] update sim script

---
 tests/script/general/parser/auto_create_tb_drop_tb.sim | 3 ++-
 tests/script/general/stable/disk.sim                   | 2 +-
 tests/script/general/stable/vnode3.sim                 | 2 +-
 tests/script/general/table/vgroup.sim                  | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/tests/script/general/parser/auto_create_tb_drop_tb.sim b/tests/script/general/parser/auto_create_tb_drop_tb.sim
index f739f42a6e..68e9c5afb7 100644
--- a/tests/script/general/parser/auto_create_tb_drop_tb.sim
+++ b/tests/script/general/parser/auto_create_tb_drop_tb.sim
@@ -1,6 +1,7 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 1
 system sh/cfg.sh -n dnode1 -c ctime -v 30
 system sh/exec.sh -n dnode1 -s start
 sleep 3000
@@ -21,7 +22,7 @@ $stb = $stbPrefix . $i
 
 sql drop database $db -x step1
 step1:
-sql create database $db maxrows 200 cache 2 maxTables 4
+sql create database $db maxrows 200 cache 2
 print ====== create tables
 sql use $db
 
diff --git a/tests/script/general/stable/disk.sim b/tests/script/general/stable/disk.sim
index 8fc7931a73..f49d023928 100644
--- a/tests/script/general/stable/disk.sim
+++ b/tests/script/general/stable/disk.sim
@@ -23,7 +23,7 @@ $i = 0
 $db = $dbPrefix . $i
 $mt = $mtPrefix . $i
 
-sql create database $db maxTables 4
+sql create database $db
 sql use $db
 sql create table $mt (ts timestamp, tbcol int) TAGS(tgcol int)
 
diff --git a/tests/script/general/stable/vnode3.sim b/tests/script/general/stable/vnode3.sim
index ffe046d94a..560c5e38fc 100644
--- a/tests/script/general/stable/vnode3.sim
+++ b/tests/script/general/stable/vnode3.sim
@@ -22,7 +22,7 @@ $i = 0
 $db = $dbPrefix . $i
 $mt = $mtPrefix . $i
 
-sql create database $db maxTables 4
+sql create database $db
 sql use $db
 sql create table $mt (ts timestamp, tbcol int) TAGS(tgcol int)
 
diff --git a/tests/script/general/table/vgroup.sim b/tests/script/general/table/vgroup.sim
index 9a86c3ef31..75fda328f3 100644
--- a/tests/script/general/table/vgroup.sim
+++ b/tests/script/general/table/vgroup.sim
@@ -15,7 +15,7 @@ $db = $dbPrefix . $i
 $tb = $tbPrefix . $i
 
 print =================== step 1
-sql create database $db maxTables 4
+sql create database $db
 sql use $db
 sql show vgroups
 if $rows != 0 then 

From 97e328b239ff5a9200b66ac285b8e389311f2fb7 Mon Sep 17 00:00:00 2001
From: yangzhiyu <yangzhiyu90@126.com>
Date: Sun, 6 Sep 2020 23:06:34 +0800
Subject: [PATCH 21/21] jdbcDemo use the taos-jdbcdriver-2.0.4

---
 tests/examples/JDBC/JDBCDemo/pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/examples/JDBC/JDBCDemo/pom.xml b/tests/examples/JDBC/JDBCDemo/pom.xml
index 50313a0a0c..f0234f2bd7 100644
--- a/tests/examples/JDBC/JDBCDemo/pom.xml
+++ b/tests/examples/JDBC/JDBCDemo/pom.xml
@@ -63,7 +63,7 @@
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>
-            <version>2.0.2</version>
+            <version>2.0.4</version>
         </dependency>
     </dependencies>
 </project>