diff --git a/include/common/tcommon.h b/include/common/tcommon.h
index 3d15e8b087..d8264ac5b5 100644
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@@ -108,6 +108,7 @@ typedef struct SDataBlockInfo {
   // TODO: optimize and remove following
   int32_t     childId;  // used for stream, do not serialize
   EStreamType type;     // used for stream, do not serialize
+  STimeWindow calWin;   // used for stream, do not serialize
 } SDataBlockInfo;
 
 typedef struct SSDataBlock {
diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h
index 783193db49..630e983f81 100644
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -42,25 +42,28 @@ typedef struct SReadHandle {
   bool    initTqReader;
 } SReadHandle;
 
+// in queue mode, data streams are seperated by msg
 typedef enum {
   OPTR_EXEC_MODEL_BATCH = 0x1,
   OPTR_EXEC_MODEL_STREAM = 0x2,
+  OPTR_EXEC_MODEL_QUEUE = 0x3,
 } EOPTR_EXEC_MODEL;
 
 /**
- * Create the exec task for streaming mode
+ * Create the exec task for stream mode
  * @param pMsg
- * @param streamReadHandle
+ * @param SReadHandle
  * @return
  */
 qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers);
 
 /**
- * Switch the stream scan to snapshot mode
- * @param tinfo
+ * Create the exec task for queue mode
+ * @param pMsg
+ * @param SReadHandle
  * @return
  */
-int32_t qStreamScanSnapshot(qTaskInfo_t tinfo);
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers);
 
 /**
  * Set the input data block for the stream scan.
@@ -111,7 +114,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
  * @return
  */
 int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
-                                      int32_t* tversion);
+                                    int32_t* tversion);
 
 /**
  * The main task execution function, including query on both table and multiple tables,
diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index d6cb2c27b0..ac9784b91b 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -14,6 +14,7 @@
  */
 
 #include "os.h"
+#include "query.h"
 #include "tdatablock.h"
 #include "tmsg.h"
 #include "tmsgcb.h"
@@ -119,6 +120,7 @@ static FORCE_INLINE void* streamQueueCurItem(SStreamQueue* queue) { return queue
 static FORCE_INLINE void* streamQueueNextItem(SStreamQueue* queue) {
   int8_t dequeueFlag = atomic_exchange_8(&queue->status, STREAM_QUEUE__PROCESSING);
   if (dequeueFlag == STREAM_QUEUE__FAILED) {
+    ASSERT(0);
     ASSERT(queue->qItem != NULL);
     return streamQueueCurItem(queue);
   } else {
@@ -305,6 +307,7 @@ static FORCE_INLINE int32_t streamTaskInput(SStreamTask* pTask, SStreamQueueItem
       atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__FAILED);
       return -1;
     }
+    qInfo("task %d %p submit enqueue %p %p %p", pTask->taskId, pTask, pItem, pSubmitClone, pSubmitClone->data);
     taosWriteQitem(pTask->inputQueue->queue, pSubmitClone);
   } else if (pItem->type == STREAM_INPUT__DATA_BLOCK || pItem->type == STREAM_INPUT__DATA_RETRIEVE) {
     taosWriteQitem(pTask->inputQueue->queue, pItem);
diff --git a/include/util/tlog.h b/include/util/tlog.h
index a8c9eeabde..d186c32841 100644
--- a/include/util/tlog.h
+++ b/include/util/tlog.h
@@ -94,7 +94,7 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
 #define pError(...) { taosPrintLog("APP ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }
 #define pPrint(...) { taosPrintLog("APP ", DEBUG_INFO, 255, __VA_ARGS__); }
 // clang-format on
-#define BUF_PAGE_DEBUG
+//#define BUF_PAGE_DEBUG
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index 91f21f6e6a..641d235dd1 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -169,6 +169,7 @@ typedef struct SReqResultInfo {
   uint32_t       numOfRows;
   uint64_t       totalRows;
   uint32_t       current;
+  bool           localResultFetched;
   bool           completed;
   int32_t        precision;
   bool           convertUcs4;
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 25ba63fd34..3605f49a5c 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -1905,6 +1905,10 @@ int32_t appendTbToReq(SArray* pList, int32_t pos1, int32_t len1, int32_t pos2, i
     tbLen = len1;
   }
 
+  if (dbLen <= 0 || tbLen <= 0) {
+    return -1;
+  }
+
   if (tNameSetDbName(&name, acctId, dbName, dbLen)) {
     return -1;
   }
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index 12de522cbc..d3fdfa7a39 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -852,23 +852,33 @@ void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
   }
 
   // all data has returned to App already, no need to try again
-  if ((pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) && pResultInfo->completed) {
+  if (pResultInfo->completed && (pRequest->body.queryJob != 0)) {
     pResultInfo->numOfRows = 0;
     pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows);
     return;
   }
 
   // it is a local executed query, no need to do async fetch
-  if (pResultInfo->current < pResultInfo->numOfRows && pRequest->body.queryJob == 0) {
-    pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows);
+  if (pRequest->body.queryJob == 0) {
+    ASSERT(pResultInfo->completed && pResultInfo->numOfRows >= 0);
+    if (pResultInfo->localResultFetched) {
+      pResultInfo->numOfRows = 0;
+      pResultInfo->current = 0;
+      pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows);
+    } else {
+      pResultInfo->localResultFetched = true;
+      pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows);
+    }
     return;
   }
 
+
   SSchedulerReq req = {
     .syncReq = false,
     .fetchFp = fetchCallback,
     .cbParam = pRequest,
   };
+
   schedulerFetchRows(pRequest->body.queryJob, &req);
 }
 
@@ -880,10 +890,10 @@ void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
   SReqResultInfo *pResultInfo = &pRequest->body.resInfo;
 
   // set the current block is all consumed
-  pResultInfo->current = pResultInfo->numOfRows;
   pResultInfo->convertUcs4 = false;
 
-  taos_fetch_rows_a(res, fp, param);
+  // it is a local executed query, no need to do async fetch
+  taos_fetch_rows_a(pRequest, fp, param);
 }
 
 const void *taos_get_raw_block(TAOS_RES *res) {
diff --git a/source/client/src/tmq.c b/source/client/src/tmq.c
index 110b839216..b0542e350f 100644
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@@ -1149,11 +1149,10 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
     tDecoderInit(&decoder, POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pMsg->len - sizeof(SMqRspHead));
     tDecodeSMqDataRsp(&decoder, &pRspWrapper->dataRsp);
     memcpy(&pRspWrapper->dataRsp, pMsg->pData, sizeof(SMqRspHead));
-    /*tDecodeSMqDataBlkRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRspWrapper->dataRsp);*/
   } else {
     ASSERT(rspType == TMQ_MSG_TYPE__POLL_META_RSP);
-    memcpy(&pRspWrapper->metaRsp, pMsg->pData, sizeof(SMqRspHead));
     tDecodeSMqMetaRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRspWrapper->metaRsp);
+    memcpy(&pRspWrapper->metaRsp, pMsg->pData, sizeof(SMqRspHead));
   }
 
   taosMemoryFree(pMsg->pData);
@@ -2427,15 +2426,15 @@ static void destroyCreateTbReqBatch(void* data) {
   taosArrayDestroy(pTbBatch->req.pArray);
 }
 
-static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
-  SVCreateTbBatchReq  req             = {0};
-  SDecoder            coder           = {0};
-  int32_t             code            = TSDB_CODE_SUCCESS;
-  SRequestObj        *pRequest        = NULL;
-  SQuery             *pQuery          = NULL;
-  SHashObj           *pVgroupHashmap  = NULL;
+static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
+  SVCreateTbBatchReq req = {0};
+  SDecoder           coder = {0};
+  int32_t            code = TSDB_CODE_SUCCESS;
+  SRequestObj*       pRequest = NULL;
+  SQuery*            pQuery = NULL;
+  SHashObj*          pVgroupHashmap = NULL;
 
-  code = buildRequest(*(int64_t*) taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -2455,8 +2454,8 @@ static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
 
   STscObj* pTscObj = pRequest->pTscObj;
 
-  SVCreateTbReq *pCreateReq = NULL;
-  SCatalog* pCatalog = NULL;
+  SVCreateTbReq* pCreateReq = NULL;
+  SCatalog*      pCatalog = NULL;
   code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
@@ -2540,13 +2539,13 @@ static void destroyDropTbReqBatch(void* data) {
   taosArrayDestroy(pTbBatch->req.pArray);
 }
 
-static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
-  SVDropTbBatchReq    req             = {0};
-  SDecoder            coder           = {0};
-  int32_t             code            = TSDB_CODE_SUCCESS;
-  SRequestObj        *pRequest        = NULL;
-  SQuery             *pQuery          = NULL;
-  SHashObj           *pVgroupHashmap  = NULL;
+static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
+  SVDropTbBatchReq req = {0};
+  SDecoder         coder = {0};
+  int32_t          code = TSDB_CODE_SUCCESS;
+  SRequestObj*     pRequest = NULL;
+  SQuery*          pQuery = NULL;
+  SHashObj*        pVgroupHashmap = NULL;
 
   code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
   if (code != TSDB_CODE_SUCCESS) {
@@ -2568,8 +2567,8 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
 
   STscObj* pTscObj = pRequest->pTscObj;
 
-  SVDropTbReq     *pDropReq = NULL;
-  SCatalog        *pCatalog = NULL;
+  SVDropTbReq* pDropReq = NULL;
+  SCatalog*    pCatalog = NULL;
   code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
@@ -2640,17 +2639,16 @@ end:
   return code;
 }
 
-static int32_t taosAlterTable(TAOS *taos, void *meta, int32_t metaLen){
-  SVAlterTbReq        req             = {0};
-  SDecoder            coder           = {0};
-  int32_t             code            = TSDB_CODE_SUCCESS;
-  SRequestObj        *pRequest        = NULL;
-  SQuery             *pQuery          = NULL;
-  SArray             *pArray          = NULL;
-  SVgDataBlocks      *pVgData         = NULL;
+static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
+  SVAlterTbReq   req = {0};
+  SDecoder       coder = {0};
+  int32_t        code = TSDB_CODE_SUCCESS;
+  SRequestObj*   pRequest = NULL;
+  SQuery*        pQuery = NULL;
+  SArray*        pArray = NULL;
+  SVgDataBlocks* pVgData = NULL;
 
-
-  code = buildRequest(*(int64_t*) taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c
index 38f46b9b11..9b65e08d29 100644
--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@@ -320,7 +320,9 @@ int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* p
     memcpy(pColumnInfoData->pData, pSource->pData, pSource->varmeta.length);
   } else {
     memcpy(pColumnInfoData->nullbitmap, pSource->nullbitmap, BitmapLen(numOfRows));
-    memcpy(pColumnInfoData->pData, pSource->pData, pSource->info.bytes * numOfRows);
+    if (pSource->pData) {
+      memcpy(pColumnInfoData->pData, pSource->pData, pSource->info.bytes * numOfRows);
+    }
   }
 
   pColumnInfoData->hasNull = pSource->hasNull;
@@ -1736,56 +1738,57 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
   int32_t colNum = taosArrayGetSize(pDataBlock->pDataBlock);
   int32_t rows = pDataBlock->info.rows;
   int32_t len = 0;
-  len += snprintf(dumpBuf + len, size - len, "\n%s |block type %d |child id %d|group id:%" PRIu64 "|\n", flag,
-                  (int32_t)pDataBlock->info.type, pDataBlock->info.childId, pDataBlock->info.groupId);
+  len += snprintf(dumpBuf + len, size - len, "\n%s |block type %d |child id %d|group id:%" PRIu64 "| uid:%ld\n", flag,
+                  (int32_t)pDataBlock->info.type, pDataBlock->info.childId, pDataBlock->info.groupId,
+                  pDataBlock->info.uid);
   if (len >= size - 1) return dumpBuf;
 
   for (int32_t j = 0; j < rows; j++) {
     len += snprintf(dumpBuf + len, size - len, "%s |", flag);
-    if (len >= size -1) return dumpBuf;
+    if (len >= size - 1) return dumpBuf;
 
     for (int32_t k = 0; k < colNum; k++) {
       SColumnInfoData* pColInfoData = taosArrayGet(pDataBlock->pDataBlock, k);
       void*            var = POINTER_SHIFT(pColInfoData->pData, j * pColInfoData->info.bytes);
       if (colDataIsNull(pColInfoData, rows, j, NULL) || !pColInfoData->pData) {
         len += snprintf(dumpBuf + len, size - len, " %15s |", "NULL");
-        if (len >= size -1) return dumpBuf;
+        if (len >= size - 1) return dumpBuf;
         continue;
       }
       switch (pColInfoData->info.type) {
         case TSDB_DATA_TYPE_TIMESTAMP:
           formatTimestamp(pBuf, *(uint64_t*)var, TSDB_TIME_PRECISION_MILLI);
           len += snprintf(dumpBuf + len, size - len, " %25s |", pBuf);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
         case TSDB_DATA_TYPE_INT:
           len += snprintf(dumpBuf + len, size - len, " %15d |", *(int32_t*)var);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
         case TSDB_DATA_TYPE_UINT:
           len += snprintf(dumpBuf + len, size - len, " %15u |", *(uint32_t*)var);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
         case TSDB_DATA_TYPE_BIGINT:
           len += snprintf(dumpBuf + len, size - len, " %15ld |", *(int64_t*)var);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
         case TSDB_DATA_TYPE_UBIGINT:
           len += snprintf(dumpBuf + len, size - len, " %15lu |", *(uint64_t*)var);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
         case TSDB_DATA_TYPE_FLOAT:
           len += snprintf(dumpBuf + len, size - len, " %15f |", *(float*)var);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
         case TSDB_DATA_TYPE_DOUBLE:
           len += snprintf(dumpBuf + len, size - len, " %15lf |", *(double*)var);
-          if (len >= size -1) return dumpBuf;
+          if (len >= size - 1) return dumpBuf;
           break;
       }
     }
     len += snprintf(dumpBuf + len, size - len, "\n");
-    if (len >= size -1) return dumpBuf;
+    if (len >= size - 1) return dumpBuf;
   }
   len += snprintf(dumpBuf + len, size - len, "%s |end\n", flag);
   return dumpBuf;
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index f19d17d034..357f258951 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -114,7 +114,7 @@ int32_t tsMinSlidingTime = 10;
 // the maxinum number of distict query result
 int32_t tsMaxNumOfDistinctResults = 1000 * 10000;
 
-// 1 us for interval time range, changed accordingly
+// 1 database precision unit for interval time range, changed accordingly
 int32_t tsMinIntervalTime = 1;
 
 // 20sec, the maximum value of stream computing delay, changed accordingly
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index adfa5b0f1e..eca8d49b6a 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -4962,7 +4962,7 @@ int tDecodeSVCreateTbReq(SDecoder *pCoder, SVCreateTbReq *pReq) {
     if (tDecodeI64(pCoder, &pReq->ctb.suid) < 0) return -1;
     if (tDecodeTag(pCoder, (STag **)&pReq->ctb.pTag) < 0) return -1;
   } else if (pReq->type == TSDB_NORMAL_TABLE) {
-    if (tDecodeSSchemaWrapper(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
+    if (tDecodeSSchemaWrapperEx(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
   } else {
     ASSERT(0);
   }
@@ -5526,6 +5526,11 @@ bool tOffsetEqual(const STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
       ASSERT(0);
       // TODO
       return pLeft->uid == pRight->uid && pLeft->ts == pRight->ts;
+    } else {
+      ASSERT(0);
+      /*ASSERT(pLeft->type == TMQ_OFFSET__RESET_NONE || pLeft->type == TMQ_OFFSET__RESET_EARLIEAST ||*/
+      /*pLeft->type == TMQ_OFFSET__RESET_LATEST);*/
+      /*return true;*/
     }
   }
   return false;
diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c
index d77b39003a..bcf926e5ee 100644
--- a/source/dnode/mnode/impl/src/mndSync.c
+++ b/source/dnode/mnode/impl/src/mndSync.c
@@ -199,6 +199,7 @@ int32_t mndInitSync(SMnode *pMnode) {
   }
 
   // decrease election timer
+  setPingTimerMS(pMgmt->sync, 5000);
   setElectTimerMS(pMgmt->sync, 600);
   setHeartbeatTimerMS(pMgmt->sync, 300);
 
diff --git a/source/dnode/vnode/src/inc/tq.h b/source/dnode/vnode/src/inc/tq.h
index 8abaac6dff..c62b7e95bf 100644
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@@ -89,8 +89,6 @@ typedef struct {
     STqExecTb  execTb;
     STqExecDb  execDb;
   };
-  // TODO remove it
-  int64_t tsdbEndVer;
 
 } STqExecHandle;
 
@@ -101,6 +99,8 @@ typedef struct {
   int32_t epoch;
   int8_t  fetchMeta;
 
+  int64_t snapshotVer;
+
   // TODO remove
   SWalReader* pWalReader;
 
@@ -131,7 +131,7 @@ typedef struct {
 static STqMgmt tqMgmt = {0};
 
 // tqRead
-int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal* offset);
+int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* offset);
 int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHead** pHeadWithCkSum);
 
 // tqExec
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index fbb972fafe..18091f0a4f 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -284,7 +284,8 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       fetchOffsetNew = pOffset->val;
       char formatBuf[80];
       tFormatOffset(formatBuf, 80, &fetchOffsetNew);
-      tqDebug("tmq poll: consumer %" PRId64 ", subkey %s, offset reset to %s", consumerId, pHandle->subKey, formatBuf);
+      tqDebug("tmq poll: consumer %" PRId64 ", subkey %s, vg %d, offset reset to %s", consumerId, pHandle->subKey,
+              TD_VID(pTq->pVnode), formatBuf);
     } else {
       if (reqOffset.type == TMQ_OFFSET__RESET_EARLIEAST) {
         if (pReq->useSnapshot && pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
@@ -299,8 +300,8 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
         }
       } else if (reqOffset.type == TMQ_OFFSET__RESET_LATEST) {
         tqOffsetResetToLog(&dataRsp.rspOffset, walGetLastVer(pTq->pVnode->pWal));
-        tqDebug("tmq poll: consumer %ld, subkey %s, offset reset to %ld", consumerId, pHandle->subKey,
-                dataRsp.rspOffset.version);
+        tqDebug("tmq poll: consumer %ld, subkey %s, vg %d, offset reset to %ld", consumerId, pHandle->subKey,
+                TD_VID(pTq->pVnode), dataRsp.rspOffset.version);
         if (tqSendDataRsp(pTq, pMsg, pReq, &dataRsp) < 0) {
           code = -1;
         }
@@ -318,10 +319,10 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
   // 3.query
   if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-    if (fetchOffsetNew.type == TMQ_OFFSET__LOG) {
-      fetchOffsetNew.version++;
-    }
-    if (tqScan(pTq, &pHandle->execHandle, &dataRsp, &fetchOffsetNew) < 0) {
+    /*if (fetchOffsetNew.type == TMQ_OFFSET__LOG) {*/
+    /*fetchOffsetNew.version++;*/
+    /*}*/
+    if (tqScan(pTq, pHandle, &dataRsp, &fetchOffsetNew) < 0) {
       ASSERT(0);
       code = -1;
       goto OVER;
@@ -480,30 +481,28 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
     pHandle->fetchMeta = req.withMeta;
 
     pHandle->pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-    /*for (int32_t i = 0; i < 5; i++) {*/
-    /*pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);*/
-    /*}*/
+
+    // TODO version should be assigned in preprocess
     int64_t ver = walGetCommittedVer(pTq->pVnode->pWal);
     if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
       pHandle->execHandle.execCol.qmsg = req.qmsg;
+      pHandle->snapshotVer = ver;
       req.qmsg = NULL;
       for (int32_t i = 0; i < 5; i++) {
         SReadHandle handle = {
-            .tqReader = pHandle->execHandle.pExecReader[i],
             .meta = pTq->pVnode->pMeta,
             .vnode = pTq->pVnode,
             .initTableReader = true,
             .initTqReader = true,
             .version = ver,
         };
-        pHandle->execHandle.execCol.task[i] = qCreateStreamExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle);
+        pHandle->execHandle.execCol.task[i] = qCreateQueueExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle);
         ASSERT(pHandle->execHandle.execCol.task[i]);
         void* scanner = NULL;
         qExtractStreamScanner(pHandle->execHandle.execCol.task[i], &scanner);
         ASSERT(scanner);
         pHandle->execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
         ASSERT(pHandle->execHandle.pExecReader[i]);
-        pHandle->execHandle.tsdbEndVer = ver;
       }
     } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__DB) {
       for (int32_t i = 0; i < 5; i++) {
diff --git a/source/dnode/vnode/src/tq/tqExec.c b/source/dnode/vnode/src/tq/tqExec.c
index 54e46e7b9a..0bdbe82b77 100644
--- a/source/dnode/vnode/src/tq/tqExec.c
+++ b/source/dnode/vnode/src/tq/tqExec.c
@@ -59,13 +59,13 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp) {
   return 0;
 }
 
-int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
-  qTaskInfo_t task = pExec->execCol.task[0];
+int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
+  const STqExecHandle* pExec = &pHandle->execHandle;
+  qTaskInfo_t          task = pExec->execCol.task[0];
 
   if (qStreamPrepareScan(task, pOffset) < 0) {
     ASSERT(pOffset->type == TMQ_OFFSET__LOG);
     pRsp->rspOffset = *pOffset;
-    pRsp->rspOffset.version--;
     return 0;
   }
 
@@ -73,9 +73,11 @@ int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffset
   while (1) {
     SSDataBlock* pDataBlock = NULL;
     uint64_t     ts = 0;
+    tqDebug("task start to execute");
     if (qExecTask(task, &pDataBlock, &ts) < 0) {
       ASSERT(0);
     }
+    tqDebug("task execute end, get %p", pDataBlock);
 
     if (pDataBlock != NULL) {
       tqAddBlockDataToRsp(pDataBlock, pRsp);
@@ -97,7 +99,7 @@ int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffset
     }
 
     if (pRsp->blockNum == 0 && pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
-      tqOffsetResetToLog(pOffset, pExec->tsdbEndVer + 1);
+      tqOffsetResetToLog(pOffset, pHandle->snapshotVer + 1);
       qStreamPrepareScan(task, pOffset);
       continue;
     }
@@ -116,7 +118,7 @@ int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffset
     if (pRsp->reqOffset.type == TMQ_OFFSET__LOG) {
       ASSERT(pRsp->rspOffset.version + 1 >= pRsp->reqOffset.version);
     }
-
+    tqDebug("task exec exited");
     break;
   }
 
diff --git a/source/dnode/vnode/src/tq/tqMeta.c b/source/dnode/vnode/src/tq/tqMeta.c
index 67fa4ed166..e6df58696d 100644
--- a/source/dnode/vnode/src/tq/tqMeta.c
+++ b/source/dnode/vnode/src/tq/tqMeta.c
@@ -19,6 +19,7 @@ static int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
   if (tStartEncode(pEncoder) < 0) return -1;
   if (tEncodeCStr(pEncoder, pHandle->subKey) < 0) return -1;
   if (tEncodeI64(pEncoder, pHandle->consumerId) < 0) return -1;
+  if (tEncodeI64(pEncoder, pHandle->snapshotVer) < 0) return -1;
   if (tEncodeI32(pEncoder, pHandle->epoch) < 0) return -1;
   if (tEncodeI8(pEncoder, pHandle->execHandle.subType) < 0) return -1;
   if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
@@ -32,6 +33,7 @@ static int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
   if (tStartDecode(pDecoder) < 0) return -1;
   if (tDecodeCStrTo(pDecoder, pHandle->subKey) < 0) return -1;
   if (tDecodeI64(pDecoder, &pHandle->consumerId) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pHandle->snapshotVer) < 0) return -1;
   if (tDecodeI32(pDecoder, &pHandle->epoch) < 0) return -1;
   if (tDecodeI8(pDecoder, &pHandle->execHandle.subType) < 0) return -1;
   if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
@@ -78,19 +80,25 @@ int32_t tqMetaOpen(STQ* pTq) {
     tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
     tDecodeSTqHandle(&decoder, &handle);
     handle.pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-    for (int32_t i = 0; i < 5; i++) {
-      handle.execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
-    }
+    /*for (int32_t i = 0; i < 5; i++) {*/
+    /*handle.execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);*/
+    /*}*/
     if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
       for (int32_t i = 0; i < 5; i++) {
         SReadHandle reader = {
-            .tqReader = handle.execHandle.pExecReader[i],
             .meta = pTq->pVnode->pMeta,
-            .pMsgCb = &pTq->pVnode->msgCb,
             .vnode = pTq->pVnode,
+            .initTableReader = true,
+            .initTqReader = true,
+            .version = handle.snapshotVer,
         };
-        handle.execHandle.execCol.task[i] = qCreateStreamExecTaskInfo(handle.execHandle.execCol.qmsg, &reader);
+        handle.execHandle.execCol.task[i] = qCreateQueueExecTaskInfo(handle.execHandle.execCol.qmsg, &reader);
         ASSERT(handle.execHandle.execCol.task[i]);
+        void* scanner = NULL;
+        qExtractStreamScanner(handle.execHandle.execCol.task[i], &scanner);
+        ASSERT(scanner);
+        handle.execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
+        ASSERT(handle.execHandle.pExecReader[i]);
       }
     } else {
       handle.execHandle.execDb.pFilterOutTbUid =
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 6e68d30a08..dc7c54fdc9 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -63,15 +63,15 @@ typedef struct SBlockLoadSuppInfo {
 } SBlockLoadSuppInfo;
 
 typedef struct SFilesetIter {
-  int32_t          numOfFiles;  // number of total files
-  int32_t          index;       // current accessed index in the list
-  SArray*          pFileList;   // data file list
-  int32_t          order;
+  int32_t numOfFiles;  // number of total files
+  int32_t index;       // current accessed index in the list
+  SArray* pFileList;   // data file list
+  int32_t order;
 } SFilesetIter;
 
 typedef struct SFileDataBlockInfo {
   int32_t
-           tbBlockIdx;  // index position in STableBlockScanInfo in order to check whether neighbor block overlaps with it
+      tbBlockIdx;  // index position in STableBlockScanInfo in order to check whether neighbor block overlaps with it
   uint64_t uid;
 } SFileDataBlockInfo;
 
@@ -119,10 +119,10 @@ struct STsdbReader {
   int32_t            type;   // query type: 1. retrieve all data blocks, 2. retrieve direct prev|next rows
   SBlockLoadSuppInfo suppInfo;
 
-  SIOCostSummary     cost;
-  STSchema*          pSchema;
-  SDataFReader*      pFileReader;
-  SVersionRange      verRange;
+  SIOCostSummary cost;
+  STSchema*      pSchema;
+  SDataFReader*  pFileReader;
+  SVersionRange  verRange;
 };
 
 static SFileDataBlockInfo* getCurrentBlockInfo(SDataBlockIter* pBlockIter);
@@ -287,9 +287,7 @@ static int32_t initFilesetIterator(SFilesetIter* pIter, const STsdbFSState* pFSt
   return TSDB_CODE_SUCCESS;
 }
 
-static void cleanupFilesetIterator(SFilesetIter* pIter) {
-  taosArrayDestroy(pIter->pFileList);
-}
+static void cleanupFilesetIterator(SFilesetIter* pIter) { taosArrayDestroy(pIter->pFileList); }
 
 static bool filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader) {
   bool    asc = ASCENDING_TRAVERSE(pIter->order);
@@ -304,6 +302,7 @@ static bool filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader) {
   STimeWindow win = {0};
 
   while (1) {
+    /*if (pReader->pFileReader != NULL) tsdbDataFReaderClose(&pReader->pFileReader);*/
     pReader->status.pCurrentFileset = (SDFileSet*)taosArrayGet(pIter->pFileList, pIter->index);
 
     int32_t code = tsdbDataFReaderOpen(&pReader->pFileReader, pReader->pTsdb, pReader->status.pCurrentFileset);
@@ -349,9 +348,7 @@ static void resetDataBlockIterator(SDataBlockIter* pIter, int32_t order) {
   }
 }
 
-static void cleanupDataBlockIterator(SDataBlockIter* pIter) {
-  taosArrayDestroy(pIter->blockList);
-}
+static void cleanupDataBlockIterator(SDataBlockIter* pIter) { taosArrayDestroy(pIter->blockList); }
 
 static void initReaderStatus(SReaderStatus* pStatus) {
   pStatus->pTableIter = NULL;
@@ -392,8 +389,7 @@ static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, STsd
 
   initReaderStatus(&pReader->status);
 
-  pReader->pTsdb =
-      getTsdbByRetentions(pVnode, pCond->twindows.skey, pVnode->config.tsdbCfg.retentions, idstr, &level);
+  pReader->pTsdb = getTsdbByRetentions(pVnode, pCond->twindows.skey, pVnode->config.tsdbCfg.retentions, idstr, &level);
   pReader->suid = pCond->suid;
   pReader->order = pCond->order;
   pReader->capacity = 4096;
@@ -833,7 +829,7 @@ static int32_t doLoadFileBlockData(STsdbReader* pReader, SDataBlockIter* pBlockI
 
   uint8_t *pb = NULL, *pb1 = NULL;
   int32_t  code = tsdbReadColData(pReader->pFileReader, &pBlockScanInfo->blockIdx, pBlock, pSupInfo->colIds, numOfCols,
-                                 pBlockData, &pb, &pb1);
+                                  pBlockData, &pb, &pb1);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }
@@ -1459,18 +1455,18 @@ static bool overlapWithDelSkyline(STableBlockScanInfo* pBlockScanInfo, const SBl
   }
 
   TSDBKEY* pFirst = taosArrayGet(pBlockScanInfo->delSkyline, 0);
-  TSDBKEY* pLast  = taosArrayGetLast(pBlockScanInfo->delSkyline);
+  TSDBKEY* pLast = taosArrayGetLast(pBlockScanInfo->delSkyline);
 
   // ts is not overlap
   if (pBlock->minKey.ts > pLast->ts || pBlock->maxKey.ts < pFirst->ts) {
     return false;
   }
 
-  int32_t step = ASCENDING_TRAVERSE(order)? 1:-1;
+  int32_t step = ASCENDING_TRAVERSE(order) ? 1 : -1;
 
   // version is not overlap
   size_t num = taosArrayGetSize(pBlockScanInfo->delSkyline);
-  for(int32_t i = pBlockScanInfo->fileDelIndex; i < num; i += step) {
+  for (int32_t i = pBlockScanInfo->fileDelIndex; i < num; i += step) {
     TSDBKEY* p = taosArrayGet(pBlockScanInfo->delSkyline, i);
     if (p->ts >= pBlock->minKey.ts && p->ts <= pBlock->maxKey.ts) {
       if (p->version >= pBlock->minVersion) {
@@ -1502,8 +1498,8 @@ static bool fileBlockShouldLoad(STsdbReader* pReader, SFileDataBlockInfo* pFBloc
   }
 
   // has duplicated ts of different version in this block
-  bool hasDup = (pBlock->nSubBlock == 1)? pBlock->hasDup:true;
-  bool overlapWithDel= overlapWithDelSkyline(pScanInfo, pBlock, pReader->order);
+  bool hasDup = (pBlock->nSubBlock == 1) ? pBlock->hasDup : true;
+  bool overlapWithDel = overlapWithDelSkyline(pScanInfo, pBlock, pReader->order);
 
   return (overlapWithNeighbor || hasDup || dataBlockPartiallyRequired(&pReader->window, &pReader->verRange, pBlock) ||
           keyOverlapFileBlock(key, pBlock, &pReader->verRange) || (pBlock->nRow > pReader->capacity) || overlapWithDel);
@@ -2220,17 +2216,18 @@ static STsdb* getTsdbByRetentions(SVnode* pVnode, TSKEY winSKey, SRetention* ret
 }
 
 SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond, int8_t level) {
-  int64_t startVer = (pCond->startVersion == -1)? 0:pCond->startVersion;
+  int64_t startVer = (pCond->startVersion == -1) ? 0 : pCond->startVersion;
 
   if (VND_IS_RSMA(pVnode)) {
     return (SVersionRange){.minVer = startVer, .maxVer = tdRSmaGetMaxSubmitVer(pVnode->pSma, level)};
   }
 
   int64_t endVer = 0;
-  if (pCond->endVersion == -1) {  // user not specified end version, set current maximum version of vnode as the endVersion
+  if (pCond->endVersion ==
+      -1) {  // user not specified end version, set current maximum version of vnode as the endVersion
     endVer = pVnode->state.applied;
   } else {
-    endVer = (pCond->endVersion > pVnode->state.applied)? pVnode->state.applied:pCond->endVersion;
+    endVer = (pCond->endVersion > pVnode->state.applied) ? pVnode->state.applied : pCond->endVersion;
   }
 
   return (SVersionRange){.minVer = startVer, .maxVer = endVer};
@@ -2274,9 +2271,9 @@ bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32
   if (pDelList == NULL) {
     return false;
   }
-  size_t num = taosArrayGetSize(pDelList);
-  bool asc = ASCENDING_TRAVERSE(order);
-  int32_t step = asc? 1:-1;
+  size_t  num = taosArrayGetSize(pDelList);
+  bool    asc = ASCENDING_TRAVERSE(order);
+  int32_t step = asc ? 1 : -1;
 
   if (asc) {
     if (*index >= num - 1) {
@@ -2823,7 +2820,7 @@ void tsdbReaderClose(STsdbReader* pReader) {
   taosMemoryFree(pSupInfo->colIds);
 
   taosArrayDestroy(pSupInfo->pColAgg);
-  for(int32_t i = 0; i < blockDataGetNumOfCols(pReader->pResBlock); ++i) {
+  for (int32_t i = 0; i < blockDataGetNumOfCols(pReader->pResBlock); ++i) {
     if (pSupInfo->buildBuf[i] != NULL) {
       taosMemoryFreeClear(pSupInfo->buildBuf[i]);
     }
@@ -2835,7 +2832,7 @@ void tsdbReaderClose(STsdbReader* pReader) {
   destroyBlockScanInfo(pReader->status.pTableMap);
   blockDataDestroy(pReader->pResBlock);
 
-
+  if (pReader->pFileReader != NULL) tsdbDataFReaderClose(&pReader->pFileReader);
 #if 0
 //   if (pReader->status.pTableScanInfo != NULL) {
 //     pReader->status.pTableScanInfo = destroyTableCheckInfo(pReader->status.pTableScanInfo);
@@ -3011,8 +3008,8 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond) {
     return TSDB_CODE_SUCCESS;
   }
 
-  pReader->order               = pCond->order;
-  pReader->type                = BLOCK_LOAD_OFFSET_ORDER;
+  pReader->order = pCond->order;
+  pReader->type = BLOCK_LOAD_OFFSET_ORDER;
   pReader->status.loadFromFile = true;
   pReader->status.pTableIter = NULL;
 
@@ -3028,6 +3025,8 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond) {
   int32_t         numOfTables = 1;
   SDataBlockIter* pBlockIter = &pReader->status.blockIter;
 
+  tsdbDataFReaderClose(&pReader->pFileReader);
+
   STsdbFSState* pFState = pReader->pTsdb->fs->cState;
   initFilesetIterator(&pReader->status.fileIter, pFState, pReader->order, pReader->idStr);
   resetDataBlockIterator(&pReader->status.blockIter, pReader->order);
@@ -3114,13 +3113,12 @@ int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTa
       pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;
     }
 
-/*
-    hasNext = blockIteratorNext(&pStatus->blockIter);
-*/
+    /*
+        hasNext = blockIteratorNext(&pStatus->blockIter);
+    */
 
-
-//         tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %s", pReader, numOfBlocks, numOfTables,
-//                   pReader->pFileGroup->fid, pReader->idStr);
+    //         tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %s", pReader, numOfBlocks, numOfTables,
+    //                   pReader->pFileGroup->fid, pReader->idStr);
   }
 
   return code;
@@ -3158,7 +3156,7 @@ int64_t tsdbGetNumOfRowsInMemTable(STsdbReader* pReader) {
   return rows;
 }
 
-int32_t tsdbGetTableSchema(SVnode* pVnode, int64_t uid, STSchema** pSchema, int64_t *suid) {
+int32_t tsdbGetTableSchema(SVnode* pVnode, int64_t uid, STSchema** pSchema, int64_t* suid) {
   int32_t sversion = 1;
 
   SMetaReader mr = {0};
@@ -3171,7 +3169,7 @@ int32_t tsdbGetTableSchema(SVnode* pVnode, int64_t uid, STSchema** pSchema, int6
   }
 
   *suid = 0;
-  
+
   if (mr.me.type == TSDB_CHILD_TABLE) {
     *suid = mr.me.ctbEntry.suid;
     code = metaGetTableEntryByUid(&mr, *suid);
@@ -3188,8 +3186,7 @@ int32_t tsdbGetTableSchema(SVnode* pVnode, int64_t uid, STSchema** pSchema, int6
 
   metaReaderClear(&mr);
   *pSchema = metaGetTbTSchema(pVnode->pMeta, uid, sversion);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-
diff --git a/source/dnode/vnode/src/vnd/vnodeSync.c b/source/dnode/vnode/src/vnd/vnodeSync.c
index 97ce8eaab7..bdcfe208d6 100644
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@@ -569,7 +569,7 @@ int32_t vnodeSyncOpen(SVnode *pVnode, char *path) {
     return -1;
   }
 
-  setPingTimerMS(pVnode->sync, 3000);
+  setPingTimerMS(pVnode->sync, 5000);
   setElectTimerMS(pVnode->sync, 500);
   setHeartbeatTimerMS(pVnode->sync, 100);
   return 0;
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index 69ba88916a..aab2f51421 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -389,6 +389,7 @@ typedef struct SStreamScanInfo {
   SSDataBlock*           pPullDataRes;    // pull data SSDataBlock
   SSDataBlock*           pDeleteDataRes;  // delete data SSDataBlock
   int32_t                deleteDataIndex;
+  STimeWindow            updateWin;
 
   // status for tmq
   // SSchemaWrapper schema;
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 2da8811e5e..2469062d09 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -191,6 +191,7 @@ SSDataBlock* createResDataBlock(SDataBlockDescNode* pNode) {
 
   pBlock->info.blockId = pNode->dataBlockId;
   pBlock->info.type = STREAM_INVALID;
+  pBlock->info.calWin = (STimeWindow){.skey = INT64_MIN, .ekey = INT64_MAX};
 
   for (int32_t i = 0; i < numOfCols; ++i) {
     SSlotDescNode* pDescNode = (SSlotDescNode*)nodesListGetNode(pNode->pSlots, i);
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 9f6b12c13a..6e4f02527f 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -106,6 +106,30 @@ int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numO
   return code;
 }
 
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers) {
+  if (msg == NULL) {
+    // TODO create raw scan
+    return NULL;
+  }
+
+  struct SSubplan* plan = NULL;
+  int32_t          code = qStringToSubplan(msg, &plan);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = code;
+    return NULL;
+  }
+
+  qTaskInfo_t pTaskInfo = NULL;
+  code = qCreateExecTask(readers, 0, 0, plan, &pTaskInfo, NULL, NULL, OPTR_EXEC_MODEL_QUEUE);
+  if (code != TSDB_CODE_SUCCESS) {
+    // TODO: destroy SSubplan & pTaskInfo
+    terrno = code;
+    return NULL;
+  }
+
+  return pTaskInfo;
+}
+
 qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers) {
   if (msg == NULL) {
     return NULL;
@@ -186,7 +210,7 @@ int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, const SArray* tableIdList, bo
 }
 
 int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
-                                      int32_t* tversion) {
+                                    int32_t* tversion) {
   ASSERT(tinfo != NULL && dbName != NULL && tableName != NULL);
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
 
diff --git a/source/libs/executor/src/executorMain.c b/source/libs/executor/src/executorMain.c
index b30800680b..5d9fea523c 100644
--- a/source/libs/executor/src/executorMain.c
+++ b/source/libs/executor/src/executorMain.c
@@ -269,13 +269,13 @@ const STqOffset* qExtractStatusFromStreamScanner(void* scanner) {
 
 void* qStreamExtractMetaMsg(qTaskInfo_t tinfo) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
-  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM);
+  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE);
   return pTaskInfo->streamInfo.metaBlk;
 }
 
 int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
-  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM);
+  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE);
   memcpy(pOffset, &pTaskInfo->streamInfo.lastStatus, sizeof(STqOffsetVal));
   return 0;
 }
@@ -283,35 +283,41 @@ int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset) {
 int32_t qStreamPrepareScan(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
   SOperatorInfo* pOperator = pTaskInfo->pRoot;
-  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM);
+  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE);
   pTaskInfo->streamInfo.prepareStatus = *pOffset;
-  // TODO: optimize
-  /*if (pTaskInfo->streamInfo.lastStatus.type != pOffset->type ||*/
-  /*pTaskInfo->streamInfo.prepareStatus.version != pTaskInfo->streamInfo.lastStatus.version) {*/
-  while (1) {
-    uint8_t type = pOperator->operatorType;
-    pOperator->status = OP_OPENED;
-    if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
-      SStreamScanInfo* pInfo = pOperator->info;
-      if (pOffset->type == TMQ_OFFSET__LOG) {
-        if (tqSeekVer(pInfo->tqReader, pOffset->version) < 0) {
-          return -1;
-        }
-        ASSERT(pInfo->tqReader->pWalReader->curVersion == pOffset->version);
-      } else if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
-        /*pInfo->blockType = STREAM_INPUT__TABLE_SCAN;*/
-        int64_t uid = pOffset->uid;
-        int64_t ts = pOffset->ts;
-
-        if (uid == 0) {
-          if (taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList) != 0) {
-            STableKeyInfo* pTableInfo = taosArrayGet(pTaskInfo->tableqinfoList.pTableList, 0);
-            uid = pTableInfo->uid;
-            ts = INT64_MIN;
+  if (!tOffsetEqual(pOffset, &pTaskInfo->streamInfo.lastStatus)) {
+    while (1) {
+      uint8_t type = pOperator->operatorType;
+      pOperator->status = OP_OPENED;
+      if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
+        SStreamScanInfo* pInfo = pOperator->info;
+        if (pOffset->type == TMQ_OFFSET__LOG) {
+#if 0
+          if (tOffsetEqual(pOffset, &pTaskInfo->streamInfo.lastStatus) &&
+              pInfo->tqReader->pWalReader->curVersion != pOffset->version) {
+            qError("prepare scan ver %ld actual ver %ld, last %ld", pOffset->version,
+                   pInfo->tqReader->pWalReader->curVersion, pTaskInfo->streamInfo.lastStatus.version);
+            ASSERT(0);
           }
-        }
-        if (pTaskInfo->streamInfo.lastStatus.type != TMQ_OFFSET__SNAPSHOT_DATA ||
-            pTaskInfo->streamInfo.lastStatus.uid != uid || pTaskInfo->streamInfo.lastStatus.ts != ts) {
+#endif
+          if (tqSeekVer(pInfo->tqReader, pOffset->version + 1) < 0) {
+            return -1;
+          }
+          ASSERT(pInfo->tqReader->pWalReader->curVersion == pOffset->version + 1);
+        } else if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
+          /*pInfo->blockType = STREAM_INPUT__TABLE_SCAN;*/
+          int64_t uid = pOffset->uid;
+          int64_t ts = pOffset->ts;
+
+          if (uid == 0) {
+            if (taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList) != 0) {
+              STableKeyInfo* pTableInfo = taosArrayGet(pTaskInfo->tableqinfoList.pTableList, 0);
+              uid = pTableInfo->uid;
+              ts = INT64_MIN;
+            }
+          }
+          /*if (pTaskInfo->streamInfo.lastStatus.type != TMQ_OFFSET__SNAPSHOT_DATA ||*/
+          /*pTaskInfo->streamInfo.lastStatus.uid != uid || pTaskInfo->streamInfo.lastStatus.ts != ts) {*/
           STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;
           int32_t         tableSz = taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList);
           bool            found = false;
@@ -320,6 +326,7 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
             if (pTableInfo->uid == uid) {
               found = true;
               pTableScanInfo->currentTable = i;
+              break;
             }
           }
 
@@ -335,18 +342,18 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
 
           qDebug("tsdb reader offset seek to uid %ld ts %ld, table cur set to %d , all table num %d", uid, ts,
                  pTableScanInfo->currentTable, tableSz);
-        }
+          /*}*/
 
+        } else {
+          ASSERT(0);
+        }
+        return 0;
       } else {
-        ASSERT(0);
+        ASSERT(pOperator->numOfDownstream == 1);
+        pOperator = pOperator->pDownstream[0];
       }
-      return 0;
-    } else {
-      ASSERT(pOperator->numOfDownstream == 1);
-      pOperator = pOperator->pDownstream[0];
     }
   }
-  /*}*/
   return 0;
 }
 
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index e9a244b573..4169ace2ab 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -538,7 +538,7 @@ static int32_t doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCt
   return code;
 }
 
-static int32_t doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SqlFunctionCtx* pCtx) {
+static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
   for (int32_t k = 0; k < pOperator->exprSupp.numOfExprs; ++k) {
     if (functionNeedToExecute(&pCtx[k])) {
       // todo add a dummy funtion to avoid process check
@@ -2969,25 +2969,10 @@ static int32_t doOpenAggregateOptr(SOperatorInfo* pOperator) {
     // the pDataBlock are always the same one, no need to call this again
     setExecutionContext(pOperator, pOperator->exprSupp.numOfExprs, pBlock->info.groupId, pAggInfo);
     setInputDataBlock(pOperator, pSup->pCtx, pBlock, order, scanFlag, true);
-    code = doAggregateImpl(pOperator, 0, pSup->pCtx);
+    code = doAggregateImpl(pOperator, pSup->pCtx);
     if (code != 0) {
       longjmp(pTaskInfo->env, code);
     }
-
-#if 0  // test for encode/decode result info
-    if(pOperator->fpSet.encodeResultRow){
-      char *result = NULL;
-      int32_t length = 0;
-      pOperator->fpSet.encodeResultRow(pOperator, &result, &length);
-      SAggSupporter* pSup = &pAggInfo->aggSup;
-      taosHashClear(pSup->pResultRowHashTable);
-      pInfo->resultRowInfo.size = 0;
-      pOperator->fpSet.decodeResultRow(pOperator, result);
-      if(result){
-        taosMemoryFree(result);
-      }
-    }
-#endif
   }
 
   closeAllResultRows(&pAggInfo->binfo.resultRowInfo);
@@ -3250,6 +3235,10 @@ static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
 
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   if (pOperator->status == OP_EXEC_DONE) {
+    if (pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE) {
+      pOperator->status = OP_OPENED;
+      return NULL;
+    }
     return NULL;
   }
 
@@ -3283,11 +3272,15 @@ static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
 
   while (1) {
     // The downstream exec may change the value of the newgroup, so use a local variable instead.
+    qDebug("projection call next");
     SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
     if (pBlock == NULL) {
-      // TODO optimize
-      /*if (pTaskInfo->execModel != OPTR_EXEC_MODEL_STREAM) {*/
+      qDebug("projection get null");
+
+      /*if (pTaskInfo->execModel == OPTR_EXEC_MODEL_BATCH) {*/
       doSetOperatorCompleted(pOperator);
+      /*} else if (pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE) {*/
+      /*pOperator->status = OP_RES_TO_RETURN;*/
       /*}*/
       break;
     }
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index 6ab3effc85..64c740decf 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -884,6 +884,28 @@ static bool prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_
   return true;
 }
 
+static STimeWindow getSlidingWindow(TSKEY* tsCol, SInterval* pInterval, SDataBlockInfo* pDataBlockInfo, int32_t* pRowIndex) {
+  SResultRowInfo   dumyInfo;
+  dumyInfo.cur.pageId = -1;
+  STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[*pRowIndex], pInterval,
+      TSDB_ORDER_ASC);
+  STimeWindow endWin = win;
+  STimeWindow preWin = win;
+  while (1) {
+    (*pRowIndex) += getNumOfRowsInTimeWindow(pDataBlockInfo, tsCol, *pRowIndex, endWin.ekey,
+        binarySearchForKey, NULL, TSDB_ORDER_ASC);
+    do {
+      preWin = endWin;
+      getNextTimeWindow(pInterval, &endWin, TSDB_ORDER_ASC);
+    } while (tsCol[(*pRowIndex) - 1] >= endWin.skey);
+    endWin = preWin;
+    if (win.ekey == endWin.ekey || (*pRowIndex) == pDataBlockInfo->rows ) {
+      win.ekey = endWin.ekey;
+      return win;
+    }
+    win.ekey = endWin.ekey;
+  }
+}
 static bool prepareDataScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t tsColIndex, int32_t* pRowIndex) {
   STimeWindow win = {
       .skey = INT64_MIN,
@@ -905,10 +927,13 @@ static bool prepareDataScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t t
       setGroupId(pInfo, pSDB, GROUPID_COLUMN_INDEX, *pRowIndex);
       (*pRowIndex) += updateSessionWindowInfo(pCurWin, tsCols, NULL, pSDB->info.rows, *pRowIndex, gap, NULL);
     } else {
-      win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[*pRowIndex], &pInfo->interval, TSDB_ORDER_ASC);
       setGroupId(pInfo, pSDB, GROUPID_COLUMN_INDEX, *pRowIndex);
-      (*pRowIndex) +=
-          getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
+      pInfo->updateWin.skey = tsCols[*pRowIndex];
+      win = getSlidingWindow(tsCols, &pInfo->interval, &pSDB->info, pRowIndex);
+      pInfo->updateWin.ekey = tsCols[*pRowIndex - 1];
+      // win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[*pRowIndex], &pInfo->interval, TSDB_ORDER_ASC);
+      // (*pRowIndex) +=
+      //     getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
     }
     needRead = true;
   } else if (isStateWindow(pInfo)) {
@@ -974,10 +999,12 @@ static SSDataBlock* doDataScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_
       }
     }
     if (!pResult) {
+      pInfo->updateWin = (STimeWindow){.skey = INT64_MIN, .ekey = INT64_MAX};
       return NULL;
     }
 
     if (pResult->info.groupId == pInfo->groupId) {
+      pResult->info.calWin = pInfo->updateWin;
       return pResult;
     }
   }
@@ -1209,6 +1236,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
   /*return NULL;*/
   /*}*/
 
+  qDebug("stream scan called");
   if (pTaskInfo->streamInfo.prepareStatus.type == TMQ_OFFSET__LOG) {
     while (1) {
       SFetchRet ret = {0};
@@ -1220,6 +1248,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
         }
         // TODO clean data block
         if (pInfo->pRes->info.rows > 0) {
+          qDebug("stream scan log return %d rows", pInfo->pRes->info.rows);
           return pInfo->pRes;
         }
       } else if (ret.fetchType == FETCH_TYPE__META) {
@@ -1230,6 +1259,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
       } else if (ret.fetchType == FETCH_TYPE__NONE) {
         pTaskInfo->streamInfo.lastStatus = ret.offset;
         ASSERT(pTaskInfo->streamInfo.lastStatus.version + 1 >= pTaskInfo->streamInfo.prepareStatus.version);
+        qDebug("stream scan log return null");
         return NULL;
       } else {
         ASSERT(0);
@@ -1237,7 +1267,12 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
     }
   } else if (pTaskInfo->streamInfo.prepareStatus.type == TMQ_OFFSET__SNAPSHOT_DATA) {
     SSDataBlock* pResult = doTableScan(pInfo->pTableScanOp);
-    return pResult && pResult->info.rows > 0 ? pResult : NULL;
+    if (pResult && pResult->info.rows > 0) {
+      qDebug("stream scan tsdb return %d rows", pResult->info.rows);
+      return pResult;
+    }
+    qDebug("stream scan tsdb return null");
+    return NULL;
   } else if (pTaskInfo->streamInfo.prepareStatus.type == TMQ_OFFSET__SNAPSHOT_META) {
     // TODO scan meta
     ASSERT(0);
@@ -1256,8 +1291,13 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
     int32_t      current = pInfo->validBlockIndex++;
     SSDataBlock* pBlock = taosArrayGetP(pInfo->pBlockLists, current);
     // TODO move into scan
+    pBlock->info.calWin.skey = INT64_MIN;
+    pBlock->info.calWin.ekey = INT64_MAX;
     blockDataUpdateTsWindow(pBlock, 0);
     switch (pBlock->info.type) {
+      case STREAM_NORMAL:
+      case STREAM_GET_ALL:
+        return pBlock;
       case STREAM_RETRIEVE: {
         pInfo->blockType = STREAM_INPUT__DATA_SUBMIT;
         pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RETRIEVE;
@@ -1287,6 +1327,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
     }
     return pBlock;
   } else if (pInfo->blockType == STREAM_INPUT__DATA_SUBMIT) {
+    qDebug("scan mode %d", pInfo->scanMode);
     if (pInfo->scanMode == STREAM_SCAN_FROM_RES) {
       blockDataDestroy(pInfo->pUpdateRes);
       pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;
@@ -1381,7 +1422,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
         }
       }
     }
-
+    qDebug("scan rows: %d", pBlockInfo->rows);
     return (pBlockInfo->rows == 0) ? NULL : pInfo->pRes;
 
 #if 0
@@ -1533,6 +1574,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
   pInfo->pStreamScanOp = pOperator;
   pInfo->deleteDataIndex = 0;
   pInfo->pDeleteDataRes = createPullDataBlock();
+  pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};
 
   pOperator->name = "StreamScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN;
@@ -2860,101 +2902,3 @@ _error:
   return NULL;
 }
 
-static SSDataBlock* doScanLastrow(SOperatorInfo* pOperator) {
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-
-  SLastrowScanInfo* pInfo = pOperator->info;
-  SExecTaskInfo*    pTaskInfo = pOperator->pTaskInfo;
-
-  int32_t size = taosArrayGetSize(pInfo->pTableList);
-  if (size == 0) {
-    setTaskStatus(pTaskInfo, TASK_COMPLETED);
-    return NULL;
-  }
-
-  // check if it is a group by tbname
-  if (size == taosArrayGetSize(pInfo->pTableList)) {
-    blockDataCleanup(pInfo->pRes);
-    tsdbRetrieveLastRow(pInfo->pLastrowReader, pInfo->pRes, pInfo->pSlotIds);
-    return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
-  } else {
-    // todo fetch the result for each group
-  }
-
-  return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
-}
-
-static void destroyLastrowScanOperator(void* param, int32_t numOfOutput) {
-  SLastrowScanInfo* pInfo = (SLastrowScanInfo*)param;
-  blockDataDestroy(pInfo->pRes);
-  tsdbLastrowReaderClose(pInfo->pLastrowReader);
-
-  taosMemoryFreeClear(param);
-}
-
-SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, SArray* pTableList,
-                                         SExecTaskInfo* pTaskInfo) {
-  SLastrowScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SLastrowScanInfo));
-  SOperatorInfo*    pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    goto _error;
-  }
-
-  pInfo->pTableList = pTableList;
-  pInfo->readHandle = *readHandle;
-  pInfo->pRes = createResDataBlock(pScanNode->node.pOutputDataBlockDesc);
-
-  int32_t numOfCols = 0;
-  pInfo->pColMatchInfo = extractColMatchInfo(pScanNode->pScanCols, pScanNode->node.pOutputDataBlockDesc, &numOfCols,
-                                             COL_MATCH_FROM_COL_ID);
-  int32_t* pCols = taosMemoryMalloc(numOfCols * sizeof(int32_t));
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    SColMatchInfo* pColMatch = taosArrayGet(pInfo->pColMatchInfo, i);
-    pCols[i] = pColMatch->colId;
-  }
-
-  pInfo->pSlotIds = taosMemoryMalloc(numOfCols * sizeof(pInfo->pSlotIds[0]));
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    SColMatchInfo* pColMatch = taosArrayGet(pInfo->pColMatchInfo, i);
-    for (int32_t j = 0; j < pTaskInfo->schemaVer.sw->nCols; ++j) {
-      if (pColMatch->colId == pTaskInfo->schemaVer.sw->pSchema[j].colId &&
-          pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
-        pInfo->pSlotIds[pColMatch->targetSlotId] = -1;
-        break;
-      }
-
-      if (pColMatch->colId == pTaskInfo->schemaVer.sw->pSchema[j].colId) {
-        pInfo->pSlotIds[pColMatch->targetSlotId] = j;
-        break;
-      }
-    }
-  }
-
-  tsdbLastRowReaderOpen(readHandle->vnode, LASTROW_RETRIEVE_TYPE_ALL, pTableList, pCols, numOfCols,
-                        &pInfo->pLastrowReader);
-  taosMemoryFree(pCols);
-
-  pOperator->name = "LastrowScanOperator";
-  pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN;
-  pOperator->blocking = false;
-  pOperator->status = OP_NOT_OPENED;
-  pOperator->info = pInfo;
-  pOperator->pTaskInfo = pTaskInfo;
-  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
-
-  initResultSizeInfo(pOperator, 1024);
-  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
-
-  pOperator->fpSet =
-      createOperatorFpSet(operatorDummyOpenFn, doScanLastrow, NULL, NULL, destroyLastrowScanOperator, NULL, NULL, NULL);
-  pOperator->cost.openCost = 0;
-  return pOperator;
-
-_error:
-  pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;
-  taosMemoryFree(pInfo);
-  taosMemoryFree(pOperator);
-  return NULL;
-}
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index 78775073a4..792f322f79 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -419,6 +419,14 @@ static bool setTimeWindowInterpolationEndTs(SIntervalAggOperatorInfo* pInfo, SEx
   return true;
 }
 
+bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo) {
+  if (pInterval->interval != pInterval->sliding && (pWin->ekey < pBlockInfo->calWin.skey ||
+      pWin->skey > pBlockInfo->calWin.ekey) ) {
+    return false;
+  }
+  return true;
+}
+
 static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
                                       TSKEY* primaryKeys, int32_t prevPosition, int32_t order) {
   bool ascQuery = (order == TSDB_ORDER_ASC);
@@ -432,6 +440,10 @@ static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext,
     return -1;
   }
 
+  if (!inSlidingWindow(pInterval, pNext, pDataBlockInfo) && order == TSDB_ORDER_ASC) {
+    return -1;
+  }
+
   TSKEY   skey = ascQuery ? pNext->skey : pNext->ekey;
   int32_t startPos = 0;
 
@@ -801,7 +813,7 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
 
   STimeWindow win = getActiveTimeWindow(pInfo->aggSup.pResultBuf, pResultRowInfo, ts, &pInfo->interval, pInfo->order);
   int32_t     ret = TSDB_CODE_SUCCESS;
-  if (!pInfo->ignoreExpiredData || !isCloseWindow(&win, &pInfo->twAggSup)) {
+  if ((!pInfo->ignoreExpiredData || !isCloseWindow(&win, &pInfo->twAggSup)) && inSlidingWindow(&pInfo->interval, &win, &pBlock->info)) {
     ret = setTimeWindowOutputBuf(pResultRowInfo, &win, (scanFlag == MAIN_SCAN), &pResult, tableGroupId, pSup->pCtx,
                                  numOfOutput, pSup->rowEntryInfoOffset, &pInfo->aggSup, pTaskInfo);
     if (ret != TSDB_CODE_SUCCESS || pResult == NULL) {
@@ -834,7 +846,7 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
     doWindowBorderInterpolation(pInfo, pBlock, pResult, &win, startPos, forwardRows, pSup);
   }
 
-  if (!pInfo->ignoreExpiredData || !isCloseWindow(&win, &pInfo->twAggSup)) {
+  if ((!pInfo->ignoreExpiredData || !isCloseWindow(&win, &pInfo->twAggSup)) && inSlidingWindow(&pInfo->interval, &win, &pBlock->info)) {
     updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &win, true);
     doApplyFunctions(pTaskInfo, pSup->pCtx, &win, &pInfo->twAggSup.timeWindowData, startPos, forwardRows, tsCols,
                      pBlock->info.rows, numOfOutput, pInfo->order);
@@ -916,7 +928,7 @@ int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo
     tsCols = (int64_t*)pColDataInfo->pData;
 
     if (tsCols != NULL) {
-      blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
+       blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
     }
   }
 
@@ -1279,17 +1291,23 @@ static void doClearWindows(SAggSupporter* pAggSup, SExprSupp* pSup1, SInterval*
     pGpDatas = (uint64_t*)pGpCol->pData;
   }
   int32_t step = 0;
-  for (int32_t i = 0; i < pBlock->info.rows; i += step) {
-    SResultRowInfo dumyInfo;
-    dumyInfo.cur.pageId = -1;
-    STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[i], pInterval, TSDB_ORDER_ASC);
-    step = getNumOfRowsInTimeWindow(&pBlock->info, tsCols, i, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
-    uint64_t winGpId = pGpDatas ? pGpDatas[i] : pBlock->info.groupId;
+  int32_t startPos = 0;
+  SResultRowInfo dumyInfo;
+  dumyInfo.cur.pageId = -1;
+  STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[0], pInterval, TSDB_ORDER_ASC);
+  while (1) {
+    step = getNumOfRowsInTimeWindow(&pBlock->info, tsCols, startPos, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
+    uint64_t winGpId = pGpDatas ? pGpDatas[startPos] : pBlock->info.groupId;
     bool     res = doClearWindow(pAggSup, pSup1, (char*)&win.skey, sizeof(TKEY), winGpId, numOfOutput);
     if (pUpWins && res) {
       SWinRes winRes = {.ts = win.skey, .groupId = winGpId};
       taosArrayPush(pUpWins, &winRes);
     }
+    int32_t prevEndPos = step - 1 + startPos;
+    startPos = getNextQualifiedWindow(pInterval, &win, &pBlock->info, tsCols, prevEndPos, TSDB_ORDER_ASC);
+    if (startPos < 0) {
+      break;
+    }
   }
 }
 
@@ -1332,13 +1350,13 @@ static int32_t closeIntervalWindow(SHashObj* pHashMap, STimeWindowAggSupp* pSup,
       if (chIds && pPullDataMap) {
         SArray* chAy = *(SArray**)chIds;
         int32_t size = taosArrayGetSize(chAy);
-        qInfo("window %" PRId64 " wait child size:%d", win.skey, size);
+        qDebug("window %" PRId64 " wait child size:%d", win.skey, size);
         for (int32_t i = 0; i < size; i++) {
-          qInfo("window %" PRId64 " wait chid id:%d", win.skey, *(int32_t*)taosArrayGet(chAy, i));
+          qDebug("window %" PRId64 " wait chid id:%d", win.skey, *(int32_t*)taosArrayGet(chAy, i));
         }
         continue;
       } else if (pPullDataMap) {
-        qInfo("close window %" PRId64, win.skey);
+        qDebug("close window %" PRId64, win.skey);
       }
       SResultRowPosition* pPos = (SResultRowPosition*)pIte;
       if (pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
@@ -2434,7 +2452,7 @@ static void doHashInterval(SOperatorInfo* pOperatorInfo, SSDataBlock* pSDataBloc
   }
   while (1) {
     bool isClosed = isCloseWindow(&nextWin, &pInfo->twAggSup);
-    if (pInfo->ignoreExpiredData && isClosed) {
+    if ((pInfo->ignoreExpiredData && isClosed) || !inSlidingWindow(&pInfo->interval, &nextWin, &pSDataBlock->info)) {
       startPos = getNexWindowPos(&pInfo->interval, &pSDataBlock->info, tsCols, startPos, nextWin.ekey, &nextWin);
       if (startPos < 0) {
         break;
@@ -2491,8 +2509,8 @@ static void doHashInterval(SOperatorInfo* pOperatorInfo, SSDataBlock* pSDataBloc
     if (IS_FINAL_OP(pInfo)) {
       forwardRows = 1;
     } else {
-      forwardRows = getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, nextWin.ekey, binarySearchForKey, NULL,
-                                           TSDB_ORDER_ASC);
+      forwardRows = getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, nextWin.ekey, binarySearchForKey,
+                                             NULL, TSDB_ORDER_ASC);
     }
     if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pUpdated) {
       saveResultRow(pResult, tableGroupId, pUpdated);
@@ -2609,6 +2627,8 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
 
   SExprSupp* pSup = &pOperator->exprSupp;
 
+  qDebug("interval status %d %s", pOperator->status, IS_FINAL_OP(pInfo) ? "interval Final" : "interval  Semi");
+
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   } else if (pOperator->status == OP_RES_TO_RETURN) {
@@ -2659,7 +2679,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       clearSpecialDataBlock(pInfo->pUpdateRes);
       removeDeleteResults(pUpdated, pInfo->pDelWins);
       pOperator->status = OP_RES_TO_RETURN;
-      qInfo("%s return data", IS_FINAL_OP(pInfo) ? "interval Final" : "interval  Semi");
+      qDebug("%s return data", IS_FINAL_OP(pInfo) ? "interval Final" : "interval  Semi");
       break;
     }
     printDataBlock(pBlock, IS_FINAL_OP(pInfo) ? "interval Final recv" : "interval  Semi recv");
@@ -3101,12 +3121,7 @@ int64_t getSessionWindowEndkey(void* data, int32_t index) {
 }
 
 bool isInTimeWindow(STimeWindow* pWin, TSKEY ts, int64_t gap) {
-  int64_t sGap = ts - pWin->skey + gap;
-  int64_t eGap = pWin->ekey - ts + gap;
-  // if ((sGap < 0 && sGap >= -gap) || (eGap < 0 && eGap >= -gap) || (sGap >= 0 && eGap >= 0)) {
-  //   return true;
-  // }
-  if (sGap >= 0 && eGap >= 0) {
+  if (ts + gap >= pWin->skey && ts - gap <= pWin->ekey) {
     return true;
   }
   return false;
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index e5e0e51d26..949aad768f 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -2774,7 +2774,6 @@ int32_t firstFunction(SqlFunctionCtx* pCtx) {
           }
         }
         pInfo->hasResult = true;
-        // DO_UPDATE_TAG_COLUMNS(pCtx, ts);
         pResInfo->numOfRes = 1;
         break;
       }
@@ -2871,7 +2870,6 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
         }
         pInfo->hasResult = true;
         pResInfo->numOfRes = 1;
-        // DO_UPDATE_TAG_COLUMNS(pCtx, ts);
       }
       break;
     }
@@ -6014,6 +6012,15 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
 
       pInfo->hasResult = true;
       pResInfo->numOfRes = 1;
+
+      if (pCtx->subsidiaries.num > 0) {
+        STuplePos* pTuplePos = (STuplePos*)(pInfo->buf + bytes + sizeof(TSKEY));
+        if (!pInfo->hasResult) {
+          saveTupleData(pCtx, i, pCtx->pSrcBlock, pTuplePos);
+        } else {
+          copyTupleData(pCtx, i, pCtx->pSrcBlock, pTuplePos);
+        }
+      }
     }
   }
 
diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c
index 294488a38d..3c285cc7f1 100644
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@@ -2481,7 +2481,6 @@ static int32_t jsonToSubplan(const SJson* pJson, void* pObj) {
   int32_t code = tjsonToObject(pJson, jkSubplanId, jsonToSubplanId, &pNode->id);
   if (TSDB_CODE_SUCCESS == code) {
     tjsonGetNumberValue(pJson, jkSubplanType, pNode->subplanType, code);
-    ;
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonGetIntValue(pJson, jkSubplanMsgType, &pNode->msgType);
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 897b575e10..4abb8f5c2c 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -956,7 +956,8 @@ void nodesDestroyNode(SNode* pNode) {
     }
     case QUERY_NODE_PHYSICAL_SUBPLAN: {
       SSubplan* pSubplan = (SSubplan*)pNode;
-      nodesDestroyList(pSubplan->pChildren);
+      // nodesDestroyList(pSubplan->pChildren);
+      nodesClearList(pSubplan->pChildren);
       nodesDestroyNode((SNode*)pSubplan->pNode);
       nodesDestroyNode((SNode*)pSubplan->pDataSink);
       nodesDestroyNode((SNode*)pSubplan->pTagCond);
@@ -972,7 +973,7 @@ void nodesDestroyNode(SNode* pNode) {
         SNode* pElement = NULL;
         FOREACH(pElement, pPlan->pSubplans) {
           if (first) {
-            first = false;
+            // first = false;
             nodesDestroyNode(pElement);
           } else {
             nodesClearList(((SNodeListNode*)pElement)->pNodeList);
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index cd0b5c1d6c..606d35a65b 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -556,6 +556,7 @@ signed_literal(A) ::= TIMESTAMP NK_STRING(B).
 signed_literal(A) ::= duration_literal(B).                                        { A = releaseRawExprNode(pCxt, B); }
 signed_literal(A) ::= NULL(B).                                                    { A = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &B); }
 signed_literal(A) ::= literal_func(B).                                            { A = releaseRawExprNode(pCxt, B); }
+signed_literal(A) ::= NK_QUESTION(B).                                             { A = createPlaceholderValueNode(pCxt, &B); }
 
 %type literal_list                                                                { SNodeList* }
 %destructor literal_list                                                          { nodesDestroyList($$); }
diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c
index 2494c5a8a7..f986d24a7e 100644
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
@@ -133,7 +133,10 @@ static int32_t createSName(SName* pName, SToken* pTableName, int32_t acctId, con
     assert(*p == TS_PATH_DELIMITER[0]);
 
     int32_t dbLen = p - pTableName->z;
-    char    name[TSDB_DB_FNAME_LEN] = {0};
+    if (dbLen <= 0) {
+      return buildInvalidOperationMsg(pMsgBuf, msg2);
+    }
+    char name[TSDB_DB_FNAME_LEN] = {0};
     strncpy(name, pTableName->z, dbLen);
     dbLen = strdequote(name);
 
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index f417f0e084..da393bb883 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -2173,14 +2173,28 @@ static int64_t getMonthsFromTimeVal(int64_t val, int32_t fromPrecision, char uni
   return -1;
 }
 
+static const char* getPrecisionStr(uint8_t precision) {
+  switch (precision) {
+    case TSDB_TIME_PRECISION_MILLI:
+      return TSDB_TIME_PRECISION_MILLI_STR;
+    case TSDB_TIME_PRECISION_MICRO:
+      return TSDB_TIME_PRECISION_MICRO_STR;
+    case TSDB_TIME_PRECISION_NANO:
+      return TSDB_TIME_PRECISION_NANO_STR;
+    default:
+      break;
+  }
+  return "unknown";
+}
+
 static int32_t checkIntervalWindow(STranslateContext* pCxt, SIntervalWindowNode* pInterval) {
   uint8_t precision = ((SColumnNode*)pInterval->pCol)->node.resType.precision;
 
   SValueNode* pInter = (SValueNode*)pInterval->pInterval;
   bool        valInter = TIME_IS_VAR_DURATION(pInter->unit);
-  if (pInter->datum.i <= 0 ||
-      (!valInter && convertTimePrecision(pInter->datum.i, precision, TSDB_TIME_PRECISION_MICRO) < tsMinIntervalTime)) {
-    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL, tsMinIntervalTime);
+  if (pInter->datum.i <= 0 || (!valInter && pInter->datum.i < tsMinIntervalTime)) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL, tsMinIntervalTime,
+                                getPrecisionStr(precision));
   }
 
   if (NULL != pInterval->pOffset) {
@@ -2754,6 +2768,11 @@ static int32_t translateInsertProject(STranslateContext* pCxt, SInsertStmt* pIns
     }
   }
 
+  if (NULL == pPrimaryKeyExpr) {
+    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_COLUMNS_NUM,
+                                   "Primary timestamp column can not be null");
+  }
+
   return addOrderByPrimaryKeyToQuery(pCxt, pPrimaryKeyExpr, pInsert->pQuery);
 }
 
@@ -2998,8 +3017,7 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, const char* pDbName
   int32_t code =
       checkRangeOption(pCxt, "buffer", pOptions->buffer, TSDB_MIN_BUFFER_PER_VNODE, TSDB_MAX_BUFFER_PER_VNODE);
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkRangeOption(pCxt, "cacheLast", pOptions->cacheLast, TSDB_MIN_DB_CACHE_LAST,
-                            TSDB_MAX_DB_CACHE_LAST);
+    code = checkRangeOption(pCxt, "cacheLast", pOptions->cacheLast, TSDB_MIN_DB_CACHE_LAST, TSDB_MAX_DB_CACHE_LAST);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkRangeOption(pCxt, "cacheLastSize", pOptions->cacheLastSize, TSDB_MIN_DB_CACHE_LAST_SIZE,
diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c
index 7a23338035..dedd9cabfc 100644
--- a/source/libs/parser/src/parUtil.c
+++ b/source/libs/parser/src/parUtil.c
@@ -60,7 +60,7 @@ static char* getSyntaxErrFormat(int32_t errCode) {
     case TSDB_CODE_PAR_EXPRIE_STATEMENT:
       return "This statement is no longer supported";
     case TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL:
-      return "Interval cannot be less than %d us";
+      return "Interval cannot be less than %d %s";
     case TSDB_CODE_PAR_DB_NOT_SPECIFIED:
       return "Database not specified";
     case TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME:
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index cb09860758..d01050ceeb 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -140,16 +140,16 @@ typedef union {
 #define ParseCTX_STORE
 #define YYFALLBACK 1
 #define YYNSTATE             666
-#define YYNRULE              488
+#define YYNRULE              489
 #define YYNTOKEN             255
 #define YY_MAX_SHIFT         665
-#define YY_MIN_SHIFTREDUCE   969
-#define YY_MAX_SHIFTREDUCE   1456
-#define YY_ERROR_ACTION      1457
-#define YY_ACCEPT_ACTION     1458
-#define YY_NO_ACTION         1459
-#define YY_MIN_REDUCE        1460
-#define YY_MAX_REDUCE        1947
+#define YY_MIN_SHIFTREDUCE   970
+#define YY_MAX_SHIFTREDUCE   1458
+#define YY_ERROR_ACTION      1459
+#define YY_ACCEPT_ACTION     1460
+#define YY_NO_ACTION         1461
+#define YY_MIN_REDUCE        1462
+#define YY_MAX_REDUCE        1950
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -216,260 +216,240 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (2520)
+#define YY_ACTTAB_COUNT (2318)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   529, 1698,  433,  552,  434, 1495,  441, 1587,  434, 1495,
- /*    10 */  1769,  113,   39,   37,  386,   62,  517, 1583,  471,  380,
- /*    20 */   338, 1766, 1258, 1002,  324,   79, 1782, 1695, 1598,   30,
- /*    30 */   260,  122,  143, 1333,  103, 1256, 1554,  102,  101,  100,
- /*    40 */    99,   98,   97,   96,   95,   94, 1591, 1762, 1768,  327,
- /*    50 */    71,  302,  557, 1925, 1800,  555, 1328, 1512, 1283,  574,
- /*    60 */  1925,   14,  581, 1006, 1007,  500, 1924, 1752, 1264,  580,
- /*    70 */  1922,  120, 1594,  159,   39,   37, 1396, 1922,  498,  487,
- /*    80 */   496,  529,  338,  557, 1258,    1,  250, 1867,  551, 1019,
- /*    90 */   550, 1018,  164, 1925, 1813, 1333,   61, 1256,   89, 1783,
- /*   100 */   583, 1785, 1786,  579,  469,  574,  161,  662, 1859, 1598,
- /*   110 */  1922,  343,  305, 1855, 1643, 1645,   71,   61, 1328, 1020,
- /*   120 */    43, 1335, 1336,   14, 1925, 1461, 1925,   33,   32,  117,
- /*   130 */  1264,   40,   38,   36,   35,   34,  475,  161, 1593,  160,
- /*   140 */   142, 1922, 1472, 1922, 1483, 1782,  103,    2,  214,  102,
- /*   150 */   101,  100,   99,   98,   97,   96,   95,   94,  474, 1155,
- /*   160 */  1156,  486,  485,  484,  170, 1925, 1259,  483, 1257,  662,
- /*   170 */   118,  480,  325, 1800,  479,  478,  477, 1458, 1923,   74,
- /*   180 */   140,  556, 1922, 1335, 1336, 1752, 1752,  555,  580, 1600,
- /*   190 */  1644, 1645,   69, 1262, 1263,   68, 1311, 1312, 1314, 1315,
- /*   200 */  1316, 1317, 1318,  576,  572, 1326, 1327, 1329, 1330, 1331,
- /*   210 */  1332, 1334, 1337, 1813,   36,   35,   34,   90, 1783,  583,
- /*   220 */  1785, 1786,  579,  529,  574,  162,  371, 1859, 1259,  555,
- /*   230 */  1257,  329, 1855,  154,  113,  419,  162,  350, 1482,   33,
+ /*     0 */   529, 1700,  433,  552,  434, 1497,  441, 1589,  434, 1497,
+ /*    10 */  1772,  113,   39,   37,  386,   62,  517, 1585,  471,  380,
+ /*    20 */   338, 1768, 1259, 1003,  324,   79, 1785, 1697, 1600,   30,
+ /*    30 */   260,  122,  143, 1335,  103, 1257, 1556,  102,  101,  100,
+ /*    40 */    99,   98,   97,   96,   95,   94, 1593, 1764, 1770,  327,
+ /*    50 */    71,  302,  557, 1928, 1803,  555, 1330, 1514, 1285,  574,
+ /*    60 */  1928,   14,  581, 1007, 1008,  500, 1927, 1754, 1265,  580,
+ /*    70 */  1925,  120, 1596,  159,   39,   37, 1398, 1925,  498,  487,
+ /*    80 */   496,  529,  338,  557, 1259,    1,  250, 1870,  551, 1020,
+ /*    90 */   550, 1019,  164, 1928, 1816, 1335,   61, 1257,   89, 1786,
+ /*   100 */   583, 1788, 1789,  579,  469,  574,  161,  662, 1862, 1600,
+ /*   110 */  1925,  343,  305, 1858, 1645, 1647,   71,   61, 1330, 1021,
+ /*   120 */    43, 1337, 1338,   14, 1928, 1463, 1928,   33,   32,  117,
+ /*   130 */  1265,   40,   38,   36,   35,   34,  475,  161, 1595,  160,
+ /*   140 */   142, 1925, 1474, 1925, 1485, 1785,  103,    2,  214,  102,
+ /*   150 */   101,  100,   99,   98,   97,   96,   95,   94,  474, 1156,
+ /*   160 */  1157,  486,  485,  484,  170, 1928, 1260,  483, 1258,  662,
+ /*   170 */   118,  480,  325, 1803,  479,  478,  477, 1460, 1926,   74,
+ /*   180 */   140,  556, 1925, 1337, 1338, 1754, 1754,  555,  580, 1602,
+ /*   190 */  1646, 1647,   69, 1263, 1264,   68, 1313, 1314, 1316, 1317,
+ /*   200 */  1318, 1319, 1320,  576,  572, 1328, 1329, 1331, 1332, 1333,
+ /*   210 */  1334, 1336, 1339, 1816,   36,   35,   34,   90, 1786,  583,
+ /*   220 */  1788, 1789,  579,  529,  574,  162,  371, 1862, 1260,  555,
+ /*   230 */  1258,  329, 1858,  154,  113,  419,  162,  350, 1484,   33,
  /*   240 */    32,  476,  450,   40,   38,   36,   35,   34,  373,  369,
- /*   250 */  1283, 1598,  552, 1886, 1393, 1262, 1263,  162, 1311, 1312,
- /*   260 */  1314, 1315, 1316, 1317, 1318,  576,  572, 1326, 1327, 1329,
- /*   270 */  1330, 1331, 1332, 1334, 1337,   39,   37, 1453, 1925, 1752,
- /*   280 */   122,  174,  173,  338,  220, 1258,   40,   38,   36,   35,
- /*   290 */    34,  159,  306,   61,   42, 1922, 1333, 1739, 1256, 1113,
- /*   300 */   605,  604,  603, 1117,  602, 1119, 1120,  601, 1122,  598,
- /*   310 */  1800, 1128,  595, 1130, 1131,  592,  589, 1296,  545, 1328,
- /*   320 */   120, 1782,   33,   32,   14, 1355,   40,   38,   36,   35,
- /*   330 */    34, 1264,   39,   37,  554,  155, 1867, 1868,   86, 1872,
- /*   340 */   338,  552, 1258, 1769,  359, 1650, 1238, 1239,    2, 1800,
- /*   350 */   341,  119,  326, 1333, 1766, 1256,  544,  581,  140, 1590,
- /*   360 */   344, 1648, 1752,  529,  580, 1400, 1452, 1600,  140,  122,
- /*   370 */   662, 1282, 1282,  379,  165,  378, 1328, 1600,  557, 1356,
- /*   380 */  1762, 1768,  333, 1576, 1335, 1336, 1460,  432, 1264, 1813,
- /*   390 */   436, 1598,  574,   89, 1783,  583, 1785, 1786,  579, 1481,
- /*   400 */   574,  440, 1361, 1859,  436,    8,  215,  305, 1855,  120,
- /*   410 */   112,  111,  110,  109,  108,  107,  106,  105,  104, 1925,
- /*   420 */   482,  481,  632,  630,  156, 1867, 1868,  662, 1872, 1259,
- /*   430 */   208, 1257,  159,  162,  162,   61, 1922,   75,  516, 1480,
- /*   440 */  1752, 1335, 1336,  450,   29,  336, 1350, 1351, 1352, 1353,
- /*   450 */  1354, 1358, 1359, 1360, 1479,  315, 1262, 1263,  546, 1311,
- /*   460 */  1312, 1314, 1315, 1316, 1317, 1318,  576,  572, 1326, 1327,
- /*   470 */  1329, 1330, 1331, 1332, 1334, 1337, 1392,   33,   32, 1925,
- /*   480 */  1752,   40,   38,   36,   35,   34, 1259, 1357, 1257,   73,
- /*   490 */   304, 1650,  159,  519,  541, 1752, 1922,   33,   32,  348,
- /*   500 */  1284,   40,   38,   36,   35,   34,  316, 1649,  314,  313,
- /*   510 */  1362,  473,  616, 1262, 1263,  475, 1311, 1312, 1314, 1315,
- /*   520 */  1316, 1317, 1318,  576,  572, 1326, 1327, 1329, 1330, 1331,
- /*   530 */  1332, 1334, 1337,   39,   37, 1338,  438,  474, 1006, 1007,
- /*   540 */  1925,  338, 1280, 1258, 1782,  162, 1874, 1478, 1313, 1019,
- /*   550 */   306, 1018,   27,  159, 1333, 1427, 1256, 1922, 1589,   33,
- /*   560 */    32,  221,  222,   40,   38,   36,   35,   34, 1285, 1766,
- /*   570 */  1871,  552, 1800,  547,  542,  162, 1574, 1328, 1281, 1020,
- /*   580 */   556,  529,  529, 1355,  153, 1752, 1477,  580, 1752, 1264,
- /*   590 */    39,   37,  384,  385,   22, 1762, 1768, 1637,  338,  122,
- /*   600 */  1258, 1522, 1075,   11,   10,  140,    9,  574, 1650, 1598,
- /*   610 */  1598, 1333, 1813, 1256, 1601,  342,   90, 1783,  583, 1785,
- /*   620 */  1786,  579,  304,  574, 1648,  519, 1859, 1752,  662,  529,
- /*   630 */   329, 1855,  154,  252, 1328, 1077,  616, 1356, 1874,  120,
- /*   640 */   389, 1473, 1335, 1336,  158, 1343, 1264, 1694, 1688,  299,
- /*   650 */   517, 1282, 1885, 1264,  157, 1867, 1868, 1598, 1872,  172,
- /*   660 */  1361, 1696, 1870,    9,  639,  638,  637,  636,  346,  561,
+ /*   250 */  1285, 1600,  552, 1889, 1395, 1263, 1264,  162, 1313, 1314,
+ /*   260 */  1316, 1317, 1318, 1319, 1320,  576,  572, 1328, 1329, 1331,
+ /*   270 */  1332, 1333, 1334, 1336, 1339,   39,   37, 1455, 1928, 1754,
+ /*   280 */   122,  174,  173,  338,  220, 1259,   40,   38,   36,   35,
+ /*   290 */    34,  159,  306,   61,   42, 1925, 1335, 1741, 1257, 1114,
+ /*   300 */   605,  604,  603, 1118,  602, 1120, 1121,  601, 1123,  598,
+ /*   310 */  1803, 1129,  595, 1131, 1132,  592,  589, 1298,  545, 1330,
+ /*   320 */   120, 1785,   33,   32,   14, 1357,   40,   38,   36,   35,
+ /*   330 */    34, 1265,   39,   37,  554,  155, 1870, 1871,   86, 1875,
+ /*   340 */   338,  552, 1259, 1772,  359, 1652, 1239, 1240,    2, 1803,
+ /*   350 */   341,  119,  326, 1335, 1768, 1257,  544,  581,  140, 1592,
+ /*   360 */   344, 1650, 1754,  529,  580, 1402, 1454, 1602,  140,  122,
+ /*   370 */   662, 1284, 1284,  379,  165,  378, 1330, 1602,  557, 1358,
+ /*   380 */  1764, 1770,  333, 1578, 1337, 1338, 1462,  432, 1265, 1816,
+ /*   390 */   436, 1600,  574,   89, 1786,  583, 1788, 1789,  579, 1483,
+ /*   400 */   574,  440, 1363, 1862,  436,    8,  215,  305, 1858,  120,
+ /*   410 */   112,  111,  110,  109,  108,  107,  106,  105,  104, 1928,
+ /*   420 */   482,  481,  632,  630,  156, 1870, 1871,  662, 1875, 1260,
+ /*   430 */   208, 1258,  159,  162,  162,   61, 1925,   75,  516, 1482,
+ /*   440 */  1754, 1337, 1338,  450,   29,  336, 1352, 1353, 1354, 1355,
+ /*   450 */  1356, 1360, 1361, 1362, 1481,  315, 1263, 1264,  546, 1313,
+ /*   460 */  1314, 1316, 1317, 1318, 1319, 1320,  576,  572, 1328, 1329,
+ /*   470 */  1331, 1332, 1333, 1334, 1336, 1339, 1394,   33,   32, 1928,
+ /*   480 */  1754,   40,   38,   36,   35,   34, 1260, 1359, 1258,   73,
+ /*   490 */   304, 1652,  159,  519,  541, 1754, 1925,   33,   32,  348,
+ /*   500 */  1286,   40,   38,   36,   35,   34,  316, 1651,  314,  313,
+ /*   510 */  1364,  473,  616, 1263, 1264,  475, 1313, 1314, 1316, 1317,
+ /*   520 */  1318, 1319, 1320,  576,  572, 1328, 1329, 1331, 1332, 1333,
+ /*   530 */  1334, 1336, 1339,   39,   37, 1340,  438,  474, 1007, 1008,
+ /*   540 */  1928,  338, 1282, 1259, 1785,  162, 1877, 1480, 1315, 1020,
+ /*   550 */   306, 1019,   27,  159, 1335, 1429, 1257, 1925, 1591,   33,
+ /*   560 */    32,  221,  222,   40,   38,   36,   35,   34, 1287, 1768,
+ /*   570 */  1874,  552, 1803,  547,  542,  162, 1576, 1330, 1283, 1021,
+ /*   580 */   556,  529,  529, 1357,  153, 1754, 1479,  580, 1754, 1265,
+ /*   590 */    39,   37,  384,  385,   22, 1764, 1770, 1639,  338,  122,
+ /*   600 */  1259, 1524, 1076,   11,   10,  140,    9,  574, 1652, 1600,
+ /*   610 */  1600, 1335, 1816, 1257, 1603,  342,   90, 1786,  583, 1788,
+ /*   620 */  1789,  579,  304,  574, 1650,  519, 1862, 1754,  662,  529,
+ /*   630 */   329, 1858,  154,  252, 1330, 1078,  616, 1358, 1877,  120,
+ /*   640 */   389, 1557, 1337, 1338,  158, 1345, 1265, 1696, 1690,  299,
+ /*   650 */   517, 1284, 1888, 1265,  157, 1870, 1871, 1600, 1875,  172,
+ /*   660 */  1363, 1698, 1873,    9,  639,  638,  637,  636,  346, 1587,
  /*   670 */   635,  634,  633,  123,  628,  627,  626,  625,  624,  623,
- /*   680 */   622,  621,  133,  617, 1525,  662, 1282, 1259, 1369, 1257,
- /*   690 */    33,   32, 1874, 1476,   40,   38,   36,   35,   34, 1335,
- /*   700 */  1336,  232,   29,  336, 1350, 1351, 1352, 1353, 1354, 1358,
- /*   710 */  1359, 1360,    7, 1475, 1262, 1263, 1869, 1311, 1312, 1314,
- /*   720 */  1315, 1316, 1317, 1318,  576,  572, 1326, 1327, 1329, 1330,
- /*   730 */  1331, 1332, 1334, 1337, 1752,   33,   32, 1879, 1389,   40,
- /*   740 */    38,   36,   35,   34, 1259,  608, 1257,  486,  485,  484,
- /*   750 */    44,    4, 1258,  483, 1752,  272,  118,  480, 1628,  619,
- /*   760 */   479,  478,  477, 1474, 1585, 1256, 1417, 1693, 1407,  299,
- /*   770 */   612, 1262, 1263, 1641, 1311, 1312, 1314, 1315, 1316, 1317,
- /*   780 */  1318,  576,  572, 1326, 1327, 1329, 1330, 1331, 1332, 1334,
- /*   790 */  1337,   39,   37,  301,  613, 1280,  614, 1641, 1264,  338,
- /*   800 */  1581, 1258,  412, 1782, 1752,  424,  211,  538, 1415, 1416,
- /*   810 */  1418, 1419, 1333, 1296, 1256,  131,  130,  611,  610,  609,
- /*   820 */    11,   10,  397, 1575,  425,  575,  399,   59, 1313,  529,
- /*   830 */   529, 1800,  529, 1471,  620, 1328, 1570,  662, 1573,  581,
- /*   840 */   404,  405,   26,  449, 1752,  509,  580, 1264,   33,   32,
- /*   850 */  1507, 1505,   40,   38,   36,   35,   34, 1598, 1598,  390,
- /*   860 */  1598,   33,   32, 1313,    2,   40,   38,   36,   35,   34,
- /*   870 */   562, 1813,  489,  492, 1752,   91, 1783,  583, 1785, 1786,
- /*   880 */   579,   28,  574,  607,  631, 1859,  662,   33,   32, 1858,
- /*   890 */  1855,   40,   38,   36,   35,   34, 1259, 1389, 1257,  423,
- /*   900 */  1335, 1336,  418,  417,  416,  415,  414,  411,  410,  409,
+ /*   680 */   622,  621,  133,  617, 1527,  662, 1284, 1260, 1371, 1258,
+ /*   690 */    33,   32, 1877, 1478,   40,   38,   36,   35,   34, 1337,
+ /*   700 */  1338,  232,   29,  336, 1352, 1353, 1354, 1355, 1356, 1360,
+ /*   710 */  1361, 1362,    7, 1477, 1263, 1264, 1872, 1313, 1314, 1316,
+ /*   720 */  1317, 1318, 1319, 1320,  576,  572, 1328, 1329, 1331, 1332,
+ /*   730 */  1333, 1334, 1336, 1339, 1754,   33,   32, 1882, 1391,   40,
+ /*   740 */    38,   36,   35,   34, 1260,  561, 1258,  486,  485,  484,
+ /*   750 */    44,    4, 1259,  483, 1754,  272,  118,  480, 1630,  608,
+ /*   760 */   479,  478,  477, 1476,  619, 1257, 1419, 1695, 1409,  299,
+ /*   770 */   612, 1263, 1264, 1643, 1313, 1314, 1316, 1317, 1318, 1319,
+ /*   780 */  1320,  576,  572, 1328, 1329, 1331, 1332, 1333, 1334, 1336,
+ /*   790 */  1339,   39,   37,  301,  613, 1282,  614, 1643, 1265,  338,
+ /*   800 */  1583, 1259,  412, 1785, 1754,  424, 1268,  538, 1417, 1418,
+ /*   810 */  1420, 1421, 1335, 1298, 1257,  131,  130,  611,  610,  609,
+ /*   820 */    11,   10,  397,  529,  425,  211,  399,  631, 1315,  529,
+ /*   830 */   529, 1803,  529, 1473,  404, 1330,  620,  662, 1572,  581,
+ /*   840 */   405,  449,   26, 1597, 1754,   59,  580, 1265,   33,   32,
+ /*   850 */  1509, 1600,   40,   38,   36,   35,   34, 1600, 1600,  390,
+ /*   860 */  1600,   33,   32, 1315,    2,   40,   38,   36,   35,   34,
+ /*   870 */   374, 1816,  489,  570, 1754,   91, 1786,  583, 1788, 1789,
+ /*   880 */   579,   28,  574, 1457, 1458, 1862,  662,   33,   32, 1861,
+ /*   890 */  1858,   40,   38,   36,   35,   34, 1260, 1391, 1258,  423,
+ /*   900 */  1337, 1338,  418,  417,  416,  415,  414,  411,  410,  409,
  /*   910 */   408,  407,  403,  402,  401,  400,  394,  393,  392,  391,
- /*   920 */   614,  388,  387, 1262, 1263,  529, 1470,  374,  199,  141,
- /*   930 */  1555,  197,  564,  529,  278,  614, 1595,   52,  513,  131,
- /*   940 */   130,  611,  610,  609, 1727, 1259,  255, 1257,  276,   58,
- /*   950 */    41,  219,   57, 1598,  131,  130,  611,  610,  609, 1267,
- /*   960 */  1770, 1598,  502, 1469, 1782, 1455, 1456, 1752,  177,  429,
- /*   970 */   427, 1766, 1262, 1263, 1468, 1311, 1312, 1314, 1315, 1316,
- /*   980 */  1317, 1318,  576,  572, 1326, 1327, 1329, 1330, 1331, 1332,
- /*   990 */  1334, 1337, 1800, 1206,  223,  539,   61, 1762, 1768,  529,
- /*  1000 */   581,  468,  529, 1925, 1752, 1752,  139,  580, 1467,  574,
- /*  1010 */   510, 1266, 1466,  514,  529, 1752,  159, 1772,  201, 1465,
- /*  1020 */  1922,  200, 1464,  203, 1463,  527,  202, 1598,  570,  503,
- /*  1030 */  1598, 1801, 1813,  244,   88,  125,   90, 1783,  583, 1785,
- /*  1040 */  1786,  579, 1598,  574,  529, 1782, 1859,  529,  529, 1752,
- /*  1050 */   329, 1855, 1938, 1752,  205,  528, 1774,  204,  261,  345,
- /*  1060 */  1752, 1893,  552, 1752, 1046, 1752,  559,  128, 1501,   66,
- /*  1070 */    65,  383, 1598, 1800,  169, 1598, 1598,  347,  522,   85,
- /*  1080 */   377,  581,  129,   50,  335,  334, 1752, 1496,  580,   82,
- /*  1090 */   122,  236, 1270,  300, 1272, 1638,  367, 1047,  365,  361,
- /*  1100 */   357,  166,  352,  349,  249, 1333, 1889, 1265,  254,  553,
- /*  1110 */   229,  557,  257, 1813,   50,    3,  657,   90, 1783,  583,
- /*  1120 */  1785, 1786,  579, 1782,  574, 1106, 1414, 1859, 1328,   41,
- /*  1130 */   120,  329, 1855, 1938,  239,  565,  162,   41,  491,  259,
- /*  1140 */  1264,   80, 1916,  587, 1269,  250, 1867,  551,   53,  550,
- /*  1150 */     5, 1800, 1925,  501,  351, 1280,  354, 1363,  128,  581,
- /*  1160 */  1347,  358, 1222,  129, 1752,  159,  580,  207,  311, 1922,
- /*  1170 */   114,  128, 1319, 1075,  312,  406, 1782,  268, 1690,  569,
- /*  1180 */   271,  494,  171,  413,  421,  488, 1134,  420,  422, 1286,
- /*  1190 */   206, 1813,  426,  428,  430,   90, 1783,  583, 1785, 1786,
- /*  1200 */   579, 1138,  574,  431, 1800, 1859, 1145,  439, 1289,  329,
- /*  1210 */  1855, 1938,  581, 1143,  132,  442,  180, 1752,   56,  580,
- /*  1220 */  1878,   55,  443,  182, 1288, 1290,  445,  444, 1782,  185,
- /*  1230 */   447,  187, 1287,  557,  189,  451,   70,  448, 1273,  470,
- /*  1240 */  1268,  472,  192, 1588, 1813,  303,  196, 1732,  285, 1783,
- /*  1250 */   583, 1785, 1786,  579, 1584,  574, 1800,   93,  269,  198,
- /*  1260 */   134,  135,  504, 1586,  581, 1276, 1582,  136,  137, 1752,
- /*  1270 */   209,  580,  505,  212, 1925,  511,  572, 1326, 1327, 1329,
- /*  1280 */  1330, 1331, 1332,  515,  508,  557,  216,  161,  518,  537,
- /*  1290 */   227, 1922,  321, 1782,  126, 1731, 1813,  127, 1700,  520,
- /*  1300 */   285, 1783,  583, 1785, 1786,  579,  323,  574,  523, 1782,
- /*  1310 */   225,  524,  270,  525,   78, 1599, 1285, 1890,  533,  535,
- /*  1320 */   540, 1800,  234,  238, 1900,  536, 1925,  328,    6,  581,
- /*  1330 */   543,  549,  534,  532, 1752,  531,  580, 1800,  248,  159,
- /*  1340 */  1389,  121, 1284, 1922,  566,  578,  563,   48, 1899,  330,
- /*  1350 */  1752, 1875,  580, 1840,  585, 1881,  245,  243, 1642,  148,
- /*  1360 */   247, 1813,  273,  264, 1782,   91, 1783,  583, 1785, 1786,
- /*  1370 */   579,  246,  574, 1571,  658, 1859, 1782, 1813,  659,  568,
- /*  1380 */  1855,  293, 1783,  583, 1785, 1786,  579,  577,  574,  571,
- /*  1390 */  1831,  661, 1800,   51,  147,  275, 1746, 1921,  253,  286,
- /*  1400 */   581,  296,  295,  277, 1800, 1752,  560,  580,  256, 1941,
- /*  1410 */   567,   63,  581,  258, 1745, 1744,   64, 1752, 1743,  580,
- /*  1420 */   353, 1740,  355,  356, 1250, 1251,  167,  360, 1738,  362,
- /*  1430 */   363,  364, 1813, 1737,  366, 1736,  144, 1783,  583, 1785,
- /*  1440 */  1786,  579,  368,  574, 1813, 1735,  370, 1734,   91, 1783,
- /*  1450 */   583, 1785, 1786,  579, 1782,  574, 1717,  372, 1859,  375,
- /*  1460 */   168,  376, 1225, 1856, 1224, 1711, 1710,  381, 1782,  382,
- /*  1470 */  1709, 1708, 1194, 1683, 1682, 1681,   67, 1680, 1782, 1679,
- /*  1480 */   558, 1939, 1800, 1678, 1677, 1676,  395,  322,  396, 1675,
- /*  1490 */   581,  398, 1674, 1673, 1672, 1752, 1800,  580, 1671, 1670,
- /*  1500 */  1669,  530, 1668, 1667,  581, 1666, 1800, 1665, 1664, 1752,
- /*  1510 */  1663,  580, 1662, 1661,  581, 1660, 1659, 1658,  124, 1752,
- /*  1520 */  1657,  580, 1813, 1656, 1655, 1654,  294, 1783,  583, 1785,
- /*  1530 */  1786,  579, 1653,  574, 1652, 1782, 1813, 1651, 1527, 1526,
- /*  1540 */   294, 1783,  583, 1785, 1786,  579, 1813,  574, 1524, 1196,
- /*  1550 */   289, 1783,  583, 1785, 1786,  579, 1492,  574, 1491, 1782,
- /*  1560 */   175,  178,  176, 1800,  152,  115, 1009, 1008,  435,  179,
- /*  1570 */   116,  581, 1725, 1719,  437, 1707, 1752,  186,  580,  184,
- /*  1580 */  1706, 1692, 1577, 1523, 1521, 1782,  452, 1800,  548,  453,
- /*  1590 */  1519, 1517, 1039,  454,  456,  578,  457,  460, 1515,  458,
- /*  1600 */  1752, 1504,  580, 1813,  461,  462,  464,  144, 1783,  583,
- /*  1610 */  1785, 1786,  579, 1800,  574,  465,  466, 1503,  337, 1488,
- /*  1620 */  1579,  581, 1149, 1578, 1148,  195, 1752, 1813,  580,   49,
- /*  1630 */  1074,  293, 1783,  583, 1785, 1786,  579,  629,  574, 1782,
- /*  1640 */  1832, 1073, 1072,  631, 1071, 1068, 1067, 1066, 1065, 1513,
- /*  1650 */   317, 1508, 1940, 1813,  318,  665, 1506,  294, 1783,  583,
- /*  1660 */  1785, 1786,  579,  490,  574,  319,  493, 1800, 1487,  267,
- /*  1670 */   495, 1486,  339,  497, 1485,  581,  499,   92, 1724, 1232,
- /*  1680 */  1752, 1718,  580,  151,  506, 1705,  138, 1703,  655,  651,
- /*  1690 */   647,  643,  265, 1704,   54,  213,  507, 1702, 1701,  320,
- /*  1700 */    15, 1699,  512, 1691,  218,  226,  224, 1813,   41,   76,
- /*  1710 */    77,  294, 1783,  583, 1785, 1786,  579,  194,  574,  231,
- /*  1720 */    87,  521, 1782,  230,   82,  228,   16,   23,  242,   47,
- /*  1730 */   233,  146, 1429,  235, 1411,  237,  467,  463,  459,  455,
- /*  1740 */   193, 1413, 1242,  145,  240,   24, 1782, 1406,  241,   81,
- /*  1750 */  1800,   10, 1772,   25, 1441, 1386,  526,  251,  581,   45,
- /*  1760 */    46, 1385, 1771, 1752,  149,  580, 1446,   18,   72, 1435,
- /*  1770 */  1440,  191,  331, 1445, 1800, 1444,  332, 1274, 1348,   17,
- /*  1780 */  1816,  573,  581, 1304,   13,   19, 1323, 1752,  217,  580,
- /*  1790 */  1813,  150,  163, 1321,  279, 1783,  583, 1785, 1786,  579,
- /*  1800 */    31,  574, 1782,  586, 1112,  584, 1320,   12,   20, 1230,
- /*  1810 */    21,  210, 1135,  340, 1813,  588,  590,  582,  280, 1783,
- /*  1820 */   583, 1785, 1786,  579,  591,  574,  593,  596,  599, 1132,
- /*  1830 */  1800,  606,  594,  190,  183,  597,  188, 1129,  581, 1123,
- /*  1840 */   446, 1127, 1121, 1752, 1782,  580, 1144,  600,   83,   84,
- /*  1850 */    60,  262, 1140, 1126, 1782, 1062, 1037, 1125,  615,  181,
- /*  1860 */   618, 1124,  263, 1081, 1060, 1055, 1782, 1059, 1058, 1057,
- /*  1870 */  1813, 1056, 1800, 1054,  281, 1783,  583, 1785, 1786,  579,
- /*  1880 */   581,  574, 1800, 1053, 1078, 1752, 1076,  580, 1050, 1049,
- /*  1890 */   581, 1048, 1045, 1044, 1800, 1752, 1043,  580, 1042, 1520,
- /*  1900 */   640,  642,  581, 1518,  644,  646,  641, 1752, 1516,  580,
- /*  1910 */   648,  645, 1813,  650,  649, 1514,  288, 1783,  583, 1785,
- /*  1920 */  1786,  579, 1813,  574,  652,  653,  290, 1783,  583, 1785,
- /*  1930 */  1786,  579,  654,  574, 1813,  656,  999, 1484,  282, 1783,
- /*  1940 */   583, 1785, 1786,  579, 1502,  574,  266, 1782,  660, 1459,
- /*  1950 */  1260,  274,  663,  664, 1459, 1459, 1459, 1459, 1459, 1459,
- /*  1960 */  1459, 1459, 1459, 1459, 1459, 1459, 1782, 1459, 1459, 1459,
- /*  1970 */  1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459,
- /*  1980 */  1459, 1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,
- /*  1990 */   580, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, 1459,
- /*  2000 */  1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,  580,
- /*  2010 */  1459, 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459,  291,
- /*  2020 */  1783,  583, 1785, 1786,  579, 1459,  574, 1782, 1459, 1459,
- /*  2030 */  1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459,  283, 1783,
- /*  2040 */   583, 1785, 1786,  579, 1459,  574, 1782, 1459, 1459, 1459,
- /*  2050 */  1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459,
- /*  2060 */  1459, 1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,
- /*  2070 */   580, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, 1459,
- /*  2080 */  1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,  580,
- /*  2090 */  1459, 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459,  292,
- /*  2100 */  1783,  583, 1785, 1786,  579, 1459,  574, 1459, 1459, 1459,
- /*  2110 */  1459, 1459, 1459, 1782, 1813, 1459, 1459, 1459,  284, 1783,
- /*  2120 */   583, 1785, 1786,  579, 1459,  574, 1459, 1459, 1459, 1782,
- /*  2130 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1782,
- /*  2140 */  1459, 1800, 1459, 1459, 1459, 1459, 1459, 1459, 1459,  581,
- /*  2150 */  1459, 1459, 1459, 1459, 1752, 1459,  580, 1800, 1459, 1459,
- /*  2160 */  1459, 1459, 1459, 1459, 1459,  581, 1459, 1800, 1459, 1459,
- /*  2170 */  1752, 1459,  580, 1459, 1459,  581, 1459, 1459, 1459, 1459,
- /*  2180 */  1752, 1813,  580, 1459, 1459,  297, 1783,  583, 1785, 1786,
- /*  2190 */   579, 1459,  574, 1782, 1459, 1459, 1459, 1813, 1459, 1459,
- /*  2200 */  1459,  298, 1783,  583, 1785, 1786,  579, 1813,  574, 1459,
- /*  2210 */  1459, 1794, 1783,  583, 1785, 1786,  579, 1459,  574, 1459,
- /*  2220 */  1459, 1800, 1459, 1459, 1459, 1459, 1459, 1459, 1459,  581,
- /*  2230 */  1459, 1459, 1459, 1459, 1752, 1459,  580, 1459, 1459, 1459,
- /*  2240 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1782, 1459, 1459,
- /*  2250 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
- /*  2260 */  1459, 1813, 1459, 1459, 1459, 1793, 1783,  583, 1785, 1786,
- /*  2270 */   579, 1459,  574, 1459, 1459, 1800, 1459, 1459, 1459, 1459,
- /*  2280 */  1459, 1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,
- /*  2290 */   580, 1459, 1459, 1459, 1459, 1459, 1459, 1782, 1459, 1459,
- /*  2300 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
- /*  2310 */  1459, 1459, 1459, 1459, 1782, 1813, 1459, 1459, 1459, 1792,
- /*  2320 */  1783,  583, 1785, 1786,  579, 1800,  574, 1459, 1459, 1459,
- /*  2330 */  1459, 1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,
- /*  2340 */   580, 1459, 1800, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
- /*  2350 */   581, 1459, 1459, 1459, 1459, 1752, 1459,  580, 1459, 1459,
- /*  2360 */  1459, 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459,  309,
- /*  2370 */  1783,  583, 1785, 1786,  579, 1459,  574, 1782, 1459, 1459,
- /*  2380 */  1459, 1459, 1813, 1459, 1459, 1459,  308, 1783,  583, 1785,
- /*  2390 */  1786,  579, 1459,  574, 1459, 1459, 1459, 1459, 1782, 1459,
- /*  2400 */  1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459,
- /*  2410 */  1459, 1459, 1459,  581, 1459, 1459, 1459, 1459, 1752, 1459,
- /*  2420 */   580, 1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459,
- /*  2430 */  1459, 1459, 1459, 1459,  581, 1459, 1459, 1459, 1459, 1752,
- /*  2440 */  1782,  580, 1459, 1459, 1459, 1813, 1459, 1459, 1459,  310,
- /*  2450 */  1783,  583, 1785, 1786,  579, 1459,  574, 1459, 1459, 1459,
- /*  2460 */  1459, 1459, 1459, 1459, 1459, 1459, 1813, 1459, 1800, 1459,
- /*  2470 */   307, 1783,  583, 1785, 1786,  579,  581,  574, 1459, 1459,
- /*  2480 */  1459, 1752, 1459,  580, 1459, 1459, 1459, 1459, 1459, 1459,
- /*  2490 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
- /*  2500 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1813, 1459,
- /*  2510 */  1459, 1459,  287, 1783,  583, 1785, 1786,  579, 1459,  574,
+ /*   920 */   575,  388,  387, 1263, 1264,  529,  564,  529, 1507,  141,
+ /*   930 */  1472,  529,  199,  529,  278,  197, 1729,  201,  510, 1271,
+ /*   940 */   200, 1047,  514,  194,  527, 1260,  562, 1258,  276,   58,
+ /*   950 */   492,  203,   57, 1600,  202, 1600,  607,  146,  502, 1600,
+ /*   960 */   509, 1600,  467,  463,  459,  455,  193, 1785,  177,  429,
+ /*   970 */   427, 1754, 1263, 1264, 1048, 1313, 1314, 1316, 1317, 1318,
+ /*   980 */  1319, 1320,  576,  572, 1328, 1329, 1331, 1332, 1333, 1334,
+ /*   990 */  1336, 1339,  335,  334,   72, 1803,   61,  191,  529, 1928,
+ /*  1000 */   529,  205, 1273,  581,  204, 1349,  139, 1475, 1754,  528,
+ /*  1010 */   580,  261,  159, 1335, 1773, 1266, 1925,   52,  513,  529,
+ /*  1020 */   255,  539,   85,  468, 1471, 1768, 1600, 1470, 1600, 1267,
+ /*  1030 */   345, 1469,   82,   41,   88, 1816, 1330, 1577, 1468,   90,
+ /*  1040 */  1786,  583, 1788, 1789,  579, 1785,  574, 1600, 1265, 1862,
+ /*  1050 */  1467, 1764, 1770,  329, 1858, 1941, 1503,  503,  244,  190,
+ /*  1060 */   183, 1575,  188,  574, 1896, 1754,  446, 1466, 1754,   66,
+ /*  1070 */    65,  383, 1754, 1803,  169, 1465, 1207, 1804,  347, 1754,
+ /*  1080 */   377,  581,  219,  125,  559,  181, 1754,  569,  580, 1775,
+ /*  1090 */  1498, 1754, 1640,  300,  128,  129,  367,   50,  365,  361,
+ /*  1100 */   357,  166,  352,  349,  657, 1892,  236,   50, 1754,   41,
+ /*  1110 */   249,  553,  254, 1816,  257,  259, 1754,   90, 1786,  583,
+ /*  1120 */  1788, 1789,  579, 1785,  574,  223,  522, 1862, 1777,  565,
+ /*  1130 */    80,  329, 1858, 1941,  614,    3,  162,  229, 1107,   41,
+ /*  1140 */  1416,   53, 1919,    5,  351, 1282, 1274,  354, 1269,  239,
+ /*  1150 */  1365, 1803, 1321,  131,  130,  611,  610,  609,  614,  581,
+ /*  1160 */   587,  128, 1270,  358, 1754, 1785,  580,  311, 1076,  129,
+ /*  1170 */   114,  128,  312, 1277, 1279, 1223,  268,  131,  130,  611,
+ /*  1180 */   610,  609,  271,  406,  572, 1328, 1329, 1331, 1332, 1333,
+ /*  1190 */  1334, 1816, 1692, 1803,  171,   90, 1786,  583, 1788, 1789,
+ /*  1200 */   579,  581,  574, 1135, 1139, 1862, 1754,  413,  580,  329,
+ /*  1210 */  1858, 1941, 1146, 1144,  132,  421,  426,  420,  422,  428,
+ /*  1220 */  1881,  430,  557, 1288,  431,  439, 1785,  180, 1291,  442,
+ /*  1230 */   443,  182, 1290, 1816,  444, 1292, 1785,  285, 1786,  583,
+ /*  1240 */  1788, 1789,  579,  445,  574,  491,  185,  447, 1289,  187,
+ /*  1250 */   448,  189,   70,  451, 1803,  192,  470,  472, 1590,  196,
+ /*  1260 */   501, 1586,  581, 1928, 1803,  303, 1734, 1754,   93,  580,
+ /*  1270 */   198,  209,  581,  269,  207,  134,  161, 1754,  135,  580,
+ /*  1280 */  1925, 1588,  504,  557, 1584,  136,  137,  508,  494,  505,
+ /*  1290 */   212,  511,  488, 1785, 1816,  515,  216,  206,  285, 1786,
+ /*  1300 */   583, 1788, 1789,  579, 1816,  574,  537, 1785,   91, 1786,
+ /*  1310 */   583, 1788, 1789,  579,  126,  574,  518, 1733, 1862, 1702,
+ /*  1320 */   321, 1803,  568, 1858, 1928,   56,  520,  523,   55,  578,
+ /*  1330 */   323,  127,  524,  525, 1754, 1803,  580,  159,  225,  227,
+ /*  1340 */   270, 1925, 1601,  581,   78, 1287,  533,  540, 1754,  535,
+ /*  1350 */   580,  234, 1893, 1903,  536, 1902,  238, 1785,  328,  543,
+ /*  1360 */     6, 1816, 1884,  549,  534,  293, 1786,  583, 1788, 1789,
+ /*  1370 */   579,  577,  574,  571, 1834, 1816,  243, 1785,  148,  144,
+ /*  1380 */  1786,  583, 1788, 1789,  579, 1803,  574,  532,  531,  248,
+ /*  1390 */  1391,  245,  246,  581,  121,  247, 1286, 1878, 1754,  566,
+ /*  1400 */   580,  563,   48,  330,  253, 1803, 1924, 1573, 1644,  273,
+ /*  1410 */   322,  658,  585,  581,  560, 1944, 1843,  264, 1754,  661,
+ /*  1420 */   580,   51,  659,  558, 1942, 1816,  147,  277,  256,   91,
+ /*  1430 */  1786,  583, 1788, 1789,  579, 1748,  574,  286,  275, 1862,
+ /*  1440 */   567,  258,  296, 1785, 1859, 1816,   63,  295, 1747,  294,
+ /*  1450 */  1786,  583, 1788, 1789,  579, 1785,  574, 1746,   64, 1745,
+ /*  1460 */   353, 1742,  355, 1251,  356, 1785, 1252,  167,  360, 1740,
+ /*  1470 */   364, 1803,  362,  363, 1739,  366,  530, 1738,  368,  581,
+ /*  1480 */  1737, 1736,  370, 1803, 1754, 1719,  580,  372,  168,  375,
+ /*  1490 */   376,  581, 1226, 1803, 1225, 1713, 1754, 1712,  580,  381,
+ /*  1500 */   382,  581, 1711, 1710, 1195, 1685, 1754, 1684,  580, 1683,
+ /*  1510 */    67, 1816, 1682, 1681, 1680,  294, 1786,  583, 1788, 1789,
+ /*  1520 */   579, 1785,  574, 1816, 1679, 1678,  396,  289, 1786,  583,
+ /*  1530 */  1788, 1789,  579, 1816,  574, 1785,  395,  144, 1786,  583,
+ /*  1540 */  1788, 1789,  579, 1677,  574,  398, 1676, 1675, 1674, 1803,
+ /*  1550 */   124, 1662, 1661, 1660, 1659, 1658, 1657,  578, 1673, 1672,
+ /*  1560 */  1671, 1670, 1754, 1803,  580,  548, 1669, 1668,  337, 1667,
+ /*  1570 */  1666,  581, 1665, 1664, 1663, 1656, 1754, 1655,  580, 1197,
+ /*  1580 */  1654, 1653, 1943, 1529,  175, 1528,  176, 1526, 1785, 1816,
+ /*  1590 */  1494,  178, 1010,  293, 1786,  583, 1788, 1789,  579, 1493,
+ /*  1600 */   574,  115, 1835, 1816,  179, 1009,  152,  294, 1786,  583,
+ /*  1610 */  1788, 1789,  579,  665,  574,  453, 1803,  435,  116, 1727,
+ /*  1620 */  1721,  339,  437, 1709,  581,  184, 1708,  267,  186, 1754,
+ /*  1630 */  1785,  580, 1694, 1579, 1525, 1523,  452,  454, 1521,  456,
+ /*  1640 */   457,  151, 1519,  460, 1785,  458,  655,  651,  647,  643,
+ /*  1650 */   265, 1040,  461,  462, 1517,  466, 1816,  464, 1803,  465,
+ /*  1660 */   294, 1786,  583, 1788, 1789,  579,  581,  574, 1506, 1505,
+ /*  1670 */  1490, 1754, 1803,  580, 1581, 1150,   49, 1149,   87, 1580,
+ /*  1680 */   581,  230, 1075, 1074,  195, 1754, 1073,  580, 1072,  629,
+ /*  1690 */  1515, 1069,  631, 1068, 1067, 1066, 1510,  317, 1816,  318,
+ /*  1700 */  1508,  490,  279, 1786,  583, 1788, 1789,  579, 1785,  574,
+ /*  1710 */   319,  493, 1816, 1489,  526,  495,  280, 1786,  583, 1788,
+ /*  1720 */  1789,  579, 1488,  574,  497, 1487,  499,   92, 1726, 1233,
+ /*  1730 */  1785, 1720,  506, 1707, 1705, 1706, 1803,   54, 1704, 1703,
+ /*  1740 */  1701, 1693,  226,  231,  581,   82,  217,  213,  507, 1754,
+ /*  1750 */  1785,  580,  218,  320,   41,   16,   15,  512, 1803, 1431,
+ /*  1760 */   138,  521,  228,  224,   47,  242,  581, 1231,   76,  210,
+ /*  1770 */    77, 1754,   23,  580,   17,  241, 1816, 1243, 1803,  235,
+ /*  1780 */   281, 1786,  583, 1788, 1789,  579,  581,  574, 1413, 1775,
+ /*  1790 */   233, 1754, 1785,  580,  237,   25,  251,  145, 1816,   46,
+ /*  1800 */  1415,  240,  288, 1786,  583, 1788, 1789,  579, 1785,  574,
+ /*  1810 */  1408,   24,   81, 1774,  149, 1388, 1387,   18, 1816, 1443,
+ /*  1820 */  1803, 1442,  290, 1786,  583, 1788, 1789,  579,  581,  574,
+ /*  1830 */    45, 1448, 1437, 1754,  331,  580, 1803, 1447,   13, 1446,
+ /*  1840 */   332,   10, 1275,   19,  581, 1819, 1306, 1325,  573, 1754,
+ /*  1850 */  1323,  580, 1322,  150, 1350,   31,   12,   20,  163,  582,
+ /*  1860 */  1816, 1785,   21,  586,  282, 1786,  583, 1788, 1789,  579,
+ /*  1870 */   340,  574,  584, 1785, 1136,  588, 1816, 1133,  590,  591,
+ /*  1880 */   291, 1786,  583, 1788, 1789,  579,  593,  574,  594, 1803,
+ /*  1890 */   596,  599, 1130, 1113, 1124,  597,  600,  581, 1128, 1122,
+ /*  1900 */    83, 1803, 1754,   84,  580, 1127, 1126, 1125, 1145,  581,
+ /*  1910 */   262,  606,   60, 1141, 1754, 1785,  580, 1063, 1082, 1038,
+ /*  1920 */   615,  618,  263, 1061, 1060, 1785, 1056, 1059, 1058, 1816,
+ /*  1930 */  1057, 1055, 1054,  283, 1786,  583, 1788, 1789,  579, 1785,
+ /*  1940 */   574, 1816, 1079, 1803, 1077,  292, 1786,  583, 1788, 1789,
+ /*  1950 */   579,  581,  574, 1803, 1051, 1050, 1754, 1049,  580, 1046,
+ /*  1960 */  1045,  581, 1044, 1043, 1522,  640, 1754, 1803,  580, 1520,
+ /*  1970 */   641,  642,  644,  645,  646,  581, 1518,  648,  649, 1516,
+ /*  1980 */  1754,  652,  580, 1816,  650,  653,  654,  284, 1786,  583,
+ /*  1990 */  1788, 1789,  579, 1816,  574, 1785, 1504,  297, 1786,  583,
+ /*  2000 */  1788, 1789,  579,  656,  574, 1785, 1000, 1816, 1486,  266,
+ /*  2010 */   660,  298, 1786,  583, 1788, 1789,  579, 1785,  574, 1261,
+ /*  2020 */   274,  663,  664, 1803, 1461, 1461, 1461, 1461, 1461, 1461,
+ /*  2030 */  1461,  581, 1461, 1803, 1461, 1461, 1754, 1461,  580, 1461,
+ /*  2040 */  1461,  581, 1461, 1461, 1461, 1803, 1754, 1461,  580, 1461,
+ /*  2050 */  1461, 1461, 1461,  581, 1461, 1461, 1461, 1461, 1754, 1461,
+ /*  2060 */   580, 1461, 1461, 1816, 1461, 1461, 1461, 1797, 1786,  583,
+ /*  2070 */  1788, 1789,  579, 1816,  574, 1461, 1461, 1796, 1786,  583,
+ /*  2080 */  1788, 1789,  579, 1785,  574, 1816, 1461, 1461, 1461, 1795,
+ /*  2090 */  1786,  583, 1788, 1789,  579, 1785,  574, 1461, 1461, 1461,
+ /*  2100 */  1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /*  2110 */  1461, 1803, 1461, 1461, 1461, 1461, 1461, 1461, 1461,  581,
+ /*  2120 */  1461, 1461, 1461, 1803, 1754, 1461,  580, 1461, 1461, 1461,
+ /*  2130 */  1461,  581, 1461, 1461, 1461, 1461, 1754, 1461,  580, 1461,
+ /*  2140 */  1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1785, 1461,
+ /*  2150 */  1461, 1816, 1461, 1461, 1461,  309, 1786,  583, 1788, 1789,
+ /*  2160 */   579, 1461,  574, 1816, 1461, 1461, 1461,  308, 1786,  583,
+ /*  2170 */  1788, 1789,  579, 1461,  574, 1461, 1803, 1461, 1461, 1461,
+ /*  2180 */  1461, 1461, 1461, 1461,  581, 1461, 1461, 1461, 1461, 1754,
+ /*  2190 */  1461,  580, 1461, 1461, 1461, 1461, 1461, 1461, 1785, 1461,
+ /*  2200 */  1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1785, 1461,
+ /*  2210 */   552, 1461, 1461, 1461, 1461, 1461, 1816, 1461, 1461, 1461,
+ /*  2220 */   310, 1786,  583, 1788, 1789,  579, 1803,  574, 1461, 1461,
+ /*  2230 */  1461, 1461, 1461, 1461,  581, 1461, 1803, 1461,  122, 1754,
+ /*  2240 */  1461,  580, 1461, 1461,  581, 1461, 1461, 1461, 1461, 1754,
+ /*  2250 */  1461,  580, 1461, 1461, 1461, 1461, 1461, 1461, 1461,  557,
+ /*  2260 */  1461, 1461, 1461, 1461, 1461, 1461, 1816, 1461, 1461, 1461,
+ /*  2270 */   307, 1786,  583, 1788, 1789,  579, 1816,  574,  120, 1461,
+ /*  2280 */   287, 1786,  583, 1788, 1789,  579, 1461,  574, 1461, 1461,
+ /*  2290 */  1461, 1461, 1461,  250, 1870,  551, 1461,  550, 1461, 1461,
+ /*  2300 */  1928, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461,
+ /*  2310 */  1461, 1461, 1461,  159, 1461, 1461, 1461, 1925,
 };
 static const YYCODETYPE yy_lookahead[] = {
  /*     0 */   266,    0,  262,  266,  264,  265,  262,  287,  264,  265,
@@ -536,9 +516,9 @@ static const YYCODETYPE yy_lookahead[] = {
  /*   610 */   294,   33,  326,   35,  295,  293,  330,  331,  332,  333,
  /*   620 */   334,  335,  177,  337,  302,  180,  340,  299,  107,  266,
  /*   630 */   344,  345,  346,  153,   56,   68,   60,  148,  328,  334,
- /*   640 */   277,  259,  121,  122,  358,   14,   68,  311,  294,  313,
+ /*   640 */   277,  275,  121,  122,  358,   14,   68,  311,  294,  313,
  /*   650 */   301,   20,  366,   68,  349,  350,  351,  294,  353,  305,
- /*   660 */   171,  312,  352,   85,   63,   64,   65,   66,   67,   43,
+ /*   660 */   171,  312,  352,   85,   63,   64,   65,   66,   67,  287,
  /*   670 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
  /*   680 */    79,   80,   81,   82,    0,  107,   20,  166,   86,  168,
  /*   690 */     8,    9,  328,  258,   12,   13,   14,   15,   16,  121,
@@ -546,195 +526,175 @@ static const YYCODETYPE yy_lookahead[] = {
  /*   710 */   221,  222,   39,  258,  193,  194,  352,  196,  197,  198,
  /*   720 */   199,  200,  201,  202,  203,  204,  205,  206,  207,  208,
  /*   730 */   209,  210,  211,  212,  299,    8,    9,  223,  224,   12,
- /*   740 */    13,   14,   15,   16,  166,   96,  168,   63,   64,   65,
- /*   750 */    42,   43,   22,   69,  299,  279,   72,   73,  282,   68,
- /*   760 */    76,   77,   78,  258,  287,   35,  193,  311,   86,  313,
+ /*   740 */    13,   14,   15,   16,  166,   43,  168,   63,   64,   65,
+ /*   750 */    42,   43,   22,   69,  299,  279,   72,   73,  282,   96,
+ /*   760 */    76,   77,   78,  258,   68,   35,  193,  311,   86,  313,
  /*   770 */   296,  193,  194,  299,  196,  197,  198,  199,  200,  201,
  /*   780 */   202,  203,  204,  205,  206,  207,  208,  209,  210,  211,
  /*   790 */   212,   12,   13,   18,  296,   20,   97,  299,   68,   20,
- /*   800 */   287,   22,   27,  258,  299,   30,  287,  234,  235,  236,
+ /*   800 */   287,   22,   27,  258,  299,   30,   35,  234,  235,  236,
  /*   810 */   237,  238,   33,   86,   35,  116,  117,  118,  119,  120,
- /*   820 */     1,    2,   47,    0,   49,  287,   51,    3,  197,  266,
- /*   830 */   266,  286,  266,  258,  274,   56,  276,  107,    0,  294,
- /*   840 */   277,  277,    2,  277,  299,  319,  301,   68,    8,    9,
- /*   850 */     0,    0,   12,   13,   14,   15,   16,  294,  294,   84,
+ /*   820 */     1,    2,   47,  266,   49,  287,   51,   43,  197,  266,
+ /*   830 */   266,  286,  266,  258,  277,   56,  274,  107,  276,  294,
+ /*   840 */   277,  277,    2,  277,  299,    3,  301,   68,    8,    9,
+ /*   850 */     0,  294,   12,   13,   14,   15,   16,  294,  294,   84,
  /*   860 */   294,    8,    9,  197,   85,   12,   13,   14,   15,   16,
- /*   870 */   244,  326,   22,   22,  299,  330,  331,  332,  333,  334,
- /*   880 */   335,    2,  337,  287,   43,  340,  107,    8,    9,  344,
+ /*   870 */    86,  326,   22,   61,  299,  330,  331,  332,  333,  334,
+ /*   880 */   335,    2,  337,  121,  122,  340,  107,    8,    9,  344,
  /*   890 */   345,   12,   13,   14,   15,   16,  166,  224,  168,  124,
  /*   900 */   121,  122,  127,  128,  129,  130,  131,  132,  133,  134,
  /*   910 */   135,  136,  137,  138,  139,  140,  141,  142,  143,  144,
- /*   920 */    97,  146,  147,  193,  194,  266,  258,   86,   89,   18,
- /*   930 */   275,   92,   43,  266,   23,   97,  277,  153,  154,  116,
- /*   940 */   117,  118,  119,  120,  277,  166,  376,  168,   37,   38,
- /*   950 */    43,   43,   41,  294,  116,  117,  118,  119,  120,   35,
- /*   960 */   288,  294,  315,  258,  258,  121,  122,  299,   57,   58,
- /*   970 */    59,  299,  193,  194,  258,  196,  197,  198,  199,  200,
+ /*   920 */   287,  146,  147,  193,  194,  266,   43,  266,    0,   18,
+ /*   930 */   258,  266,   89,  266,   23,   92,  277,   89,  277,  168,
+ /*   940 */    92,   35,  277,   33,  277,  166,  244,  168,   37,   38,
+ /*   950 */    22,   89,   41,  294,   92,  294,  287,   47,  315,  294,
+ /*   960 */   319,  294,   52,   53,   54,   55,   56,  258,   57,   58,
+ /*   970 */    59,  299,  193,  194,   68,  196,  197,  198,  199,  200,
  /*   980 */   201,  202,  203,  204,  205,  206,  207,  208,  209,  210,
- /*   990 */   211,  212,  286,   86,   86,  367,   85,  325,  326,  266,
- /*  1000 */   294,  267,  266,  356,  299,  299,  153,  301,  258,  337,
- /*  1010 */   277,   35,  258,  277,  266,  299,  369,   46,   89,  258,
- /*  1020 */   373,   92,  258,   89,  258,  277,   92,  294,   61,  322,
- /*  1030 */   294,  286,  326,  363,  123,   43,  330,  331,  332,  333,
- /*  1040 */   334,  335,  294,  337,  266,  258,  340,  266,  266,  299,
- /*  1050 */   344,  345,  346,  299,   89,  277,   85,   92,  277,  277,
- /*  1060 */   299,  355,  266,  299,   35,  299,  242,   43,    0,  158,
- /*  1070 */   159,  160,  294,  286,  163,  294,  294,  267,   86,   85,
- /*  1080 */   169,  294,   43,   43,   12,   13,  299,  265,  301,   95,
- /*  1090 */   294,   43,  168,  182,   22,  298,  185,   68,  187,  188,
- /*  1100 */   189,  190,  191,  192,  347,   33,  329,   35,  370,  354,
- /*  1110 */    86,  315,  370,  326,   43,  357,   48,  330,  331,  332,
- /*  1120 */   333,  334,  335,  258,  337,   86,   86,  340,   56,   43,
- /*  1130 */   334,  344,  345,  346,   86,  246,  225,   43,    4,  370,
- /*  1140 */    68,   85,  355,   43,  168,  349,  350,  351,  290,  353,
- /*  1150 */   227,  286,  356,   19,  324,   20,  266,   86,   43,  294,
- /*  1160 */   193,   47,  164,   43,  299,  369,  301,   33,  323,  373,
- /*  1170 */    43,   43,   86,   35,  272,  266,  258,  317,  266,  107,
- /*  1180 */    86,   47,   42,  306,  148,   51,   86,  304,  304,   20,
- /*  1190 */    56,  326,  266,  266,  266,  330,  331,  332,  333,  334,
- /*  1200 */   335,   86,  337,  260,  286,  340,   86,  260,   20,  344,
- /*  1210 */   345,  346,  294,   86,   86,  321,  270,  299,   84,  301,
- /*  1220 */   355,   87,  301,  270,   20,   20,  316,  314,  258,  270,
- /*  1230 */   314,  270,   20,  315,  270,  266,  270,  307,  166,  260,
- /*  1240 */   168,  286,  270,  286,  326,  260,  286,  299,  330,  331,
- /*  1250 */   332,  333,  334,  335,  286,  337,  286,  266,  321,  286,
- /*  1260 */   286,  286,  174,  286,  294,  193,  286,  286,  286,  299,
- /*  1270 */   268,  301,  320,  268,  356,  266,  204,  205,  206,  207,
- /*  1280 */   208,  209,  210,  266,  301,  315,  268,  369,  299,  232,
- /*  1290 */   268,  373,  314,  258,  310,  299,  326,  310,  299,  299,
- /*  1300 */   330,  331,  332,  333,  334,  335,  299,  337,  150,  258,
- /*  1310 */   294,  308,  282,  307,  268,  294,   20,  329,  299,  299,
- /*  1320 */   233,  286,  310,  310,  362,  299,  356,  299,  239,  294,
- /*  1330 */   299,  157,  241,  240,  299,  228,  301,  286,  324,  369,
- /*  1340 */   224,  294,   20,  373,  245,  294,  243,   85,  362,  248,
- /*  1350 */   299,  328,  301,  343,  290,  365,  361,  364,  299,  362,
- /*  1360 */   359,  326,  266,  268,  258,  330,  331,  332,  333,  334,
- /*  1370 */   335,  360,  337,  276,   36,  340,  258,  326,  261,  344,
- /*  1380 */   345,  330,  331,  332,  333,  334,  335,  336,  337,  338,
- /*  1390 */   339,  260,  286,  318,  313,  269,    0,  372,  371,  280,
- /*  1400 */   294,  280,  280,  256,  286,  299,  372,  301,  371,  377,
- /*  1410 */   372,  176,  294,  371,    0,    0,   42,  299,    0,  301,
- /*  1420 */    76,    0,   35,  186,   35,   35,   35,  186,    0,   35,
- /*  1430 */    35,  186,  326,    0,  186,    0,  330,  331,  332,  333,
- /*  1440 */   334,  335,   35,  337,  326,    0,   22,    0,  330,  331,
- /*  1450 */   332,  333,  334,  335,  258,  337,    0,   35,  340,  171,
- /*  1460 */    85,  170,  168,  345,  166,    0,    0,  162,  258,  161,
- /*  1470 */     0,    0,   46,    0,    0,    0,  145,    0,  258,    0,
- /*  1480 */   374,  375,  286,    0,    0,    0,  140,  291,   35,    0,
- /*  1490 */   294,  140,    0,    0,    0,  299,  286,  301,    0,    0,
- /*  1500 */     0,  291,    0,    0,  294,    0,  286,    0,    0,  299,
- /*  1510 */     0,  301,    0,    0,  294,    0,    0,    0,   42,  299,
- /*  1520 */     0,  301,  326,    0,    0,    0,  330,  331,  332,  333,
- /*  1530 */   334,  335,    0,  337,    0,  258,  326,    0,    0,    0,
- /*  1540 */   330,  331,  332,  333,  334,  335,  326,  337,    0,   22,
- /*  1550 */   330,  331,  332,  333,  334,  335,    0,  337,    0,  258,
- /*  1560 */    56,   42,   56,  286,   43,   39,   14,   14,   46,   40,
- /*  1570 */    39,  294,    0,    0,   46,    0,  299,  157,  301,   39,
- /*  1580 */     0,    0,    0,    0,    0,  258,   35,  286,  368,   47,
- /*  1590 */     0,    0,   62,   39,   35,  294,   47,   35,    0,   39,
- /*  1600 */   299,    0,  301,  326,   47,   39,   35,  330,  331,  332,
- /*  1610 */   333,  334,  335,  286,  337,   47,   39,    0,  291,    0,
- /*  1620 */     0,  294,   35,    0,   22,   92,  299,  326,  301,   94,
- /*  1630 */    35,  330,  331,  332,  333,  334,  335,   43,  337,  258,
- /*  1640 */   339,   35,   35,   43,   35,   35,   35,   35,   35,    0,
- /*  1650 */    22,    0,  375,  326,   22,   19,    0,  330,  331,  332,
- /*  1660 */   333,  334,  335,   49,  337,   22,   35,  286,    0,   33,
- /*  1670 */    35,    0,  291,   35,    0,  294,   22,   20,    0,   35,
- /*  1680 */   299,    0,  301,   47,   22,    0,  172,    0,   52,   53,
- /*  1690 */    54,   55,   56,    0,  153,  150,  153,    0,    0,  153,
- /*  1700 */    85,    0,  155,    0,   86,   39,   85,  326,   43,   85,
- /*  1710 */    85,  330,  331,  332,  333,  334,  335,   33,  337,   46,
- /*  1720 */    84,  151,  258,   87,   95,  149,  229,   85,   46,   43,
- /*  1730 */    85,   47,   86,   86,   86,   85,   52,   53,   54,   55,
- /*  1740 */    56,   86,  181,   85,   85,   85,  258,   86,   43,   85,
- /*  1750 */   286,    2,   46,   43,   35,   86,  120,   46,  294,  223,
- /*  1760 */    43,   86,   46,  299,   46,  301,   86,   43,   84,   86,
- /*  1770 */    35,   87,   35,   35,  286,   35,   35,   22,  193,  229,
- /*  1780 */    85,   85,  294,   22,  229,   43,   86,  299,  152,  301,
- /*  1790 */   326,   46,   46,   86,  330,  331,  332,  333,  334,  335,
- /*  1800 */    85,  337,  258,   35,   22,   96,   86,   85,   85,  173,
- /*  1810 */    85,  175,   86,   35,  326,   85,   35,  195,  330,  331,
- /*  1820 */   332,  333,  334,  335,   85,  337,   35,   35,   35,   86,
- /*  1830 */   286,   97,   85,  149,  150,   85,  152,   86,  294,   86,
- /*  1840 */   156,  109,   86,  299,  258,  301,   35,   85,   85,   85,
- /*  1850 */    85,   43,   22,  109,  258,   35,   62,  109,   61,  175,
- /*  1860 */    83,  109,   43,   68,   35,   22,  258,   35,   35,   35,
- /*  1870 */   326,   35,  286,   35,  330,  331,  332,  333,  334,  335,
- /*  1880 */   294,  337,  286,   35,   68,  299,   35,  301,   35,   35,
- /*  1890 */   294,   35,   35,   35,  286,  299,   35,  301,   35,    0,
- /*  1900 */    35,   39,  294,    0,   35,   39,   47,  299,    0,  301,
- /*  1910 */    35,   47,  326,   39,   47,    0,  330,  331,  332,  333,
- /*  1920 */   334,  335,  326,  337,   35,   47,  330,  331,  332,  333,
- /*  1930 */   334,  335,   39,  337,  326,   35,   35,    0,  330,  331,
- /*  1940 */   332,  333,  334,  335,    0,  337,   22,  258,   21,  378,
- /*  1950 */    22,   22,   21,   20,  378,  378,  378,  378,  378,  378,
- /*  1960 */   378,  378,  378,  378,  378,  378,  258,  378,  378,  378,
- /*  1970 */   378,  378,  378,  378,  378,  286,  378,  378,  378,  378,
- /*  1980 */   378,  378,  378,  294,  378,  378,  378,  378,  299,  378,
- /*  1990 */   301,  378,  378,  378,  286,  378,  378,  378,  378,  378,
- /*  2000 */   378,  378,  294,  378,  378,  378,  378,  299,  378,  301,
- /*  2010 */   378,  378,  378,  378,  378,  326,  378,  378,  378,  330,
- /*  2020 */   331,  332,  333,  334,  335,  378,  337,  258,  378,  378,
- /*  2030 */   378,  378,  378,  378,  326,  378,  378,  378,  330,  331,
- /*  2040 */   332,  333,  334,  335,  378,  337,  258,  378,  378,  378,
- /*  2050 */   378,  378,  378,  378,  378,  286,  378,  378,  378,  378,
- /*  2060 */   378,  378,  378,  294,  378,  378,  378,  378,  299,  378,
- /*  2070 */   301,  378,  378,  378,  286,  378,  378,  378,  378,  378,
- /*  2080 */   378,  378,  294,  378,  378,  378,  378,  299,  378,  301,
- /*  2090 */   378,  378,  378,  378,  378,  326,  378,  378,  378,  330,
- /*  2100 */   331,  332,  333,  334,  335,  378,  337,  378,  378,  378,
- /*  2110 */   378,  378,  378,  258,  326,  378,  378,  378,  330,  331,
- /*  2120 */   332,  333,  334,  335,  378,  337,  378,  378,  378,  258,
- /*  2130 */   378,  378,  378,  378,  378,  378,  378,  378,  378,  258,
- /*  2140 */   378,  286,  378,  378,  378,  378,  378,  378,  378,  294,
- /*  2150 */   378,  378,  378,  378,  299,  378,  301,  286,  378,  378,
- /*  2160 */   378,  378,  378,  378,  378,  294,  378,  286,  378,  378,
- /*  2170 */   299,  378,  301,  378,  378,  294,  378,  378,  378,  378,
- /*  2180 */   299,  326,  301,  378,  378,  330,  331,  332,  333,  334,
- /*  2190 */   335,  378,  337,  258,  378,  378,  378,  326,  378,  378,
- /*  2200 */   378,  330,  331,  332,  333,  334,  335,  326,  337,  378,
- /*  2210 */   378,  330,  331,  332,  333,  334,  335,  378,  337,  378,
- /*  2220 */   378,  286,  378,  378,  378,  378,  378,  378,  378,  294,
- /*  2230 */   378,  378,  378,  378,  299,  378,  301,  378,  378,  378,
- /*  2240 */   378,  378,  378,  378,  378,  378,  378,  258,  378,  378,
- /*  2250 */   378,  378,  378,  378,  378,  378,  378,  378,  378,  378,
- /*  2260 */   378,  326,  378,  378,  378,  330,  331,  332,  333,  334,
- /*  2270 */   335,  378,  337,  378,  378,  286,  378,  378,  378,  378,
- /*  2280 */   378,  378,  378,  294,  378,  378,  378,  378,  299,  378,
- /*  2290 */   301,  378,  378,  378,  378,  378,  378,  258,  378,  378,
- /*  2300 */   378,  378,  378,  378,  378,  378,  378,  378,  378,  378,
- /*  2310 */   378,  378,  378,  378,  258,  326,  378,  378,  378,  330,
- /*  2320 */   331,  332,  333,  334,  335,  286,  337,  378,  378,  378,
- /*  2330 */   378,  378,  378,  294,  378,  378,  378,  378,  299,  378,
- /*  2340 */   301,  378,  286,  378,  378,  378,  378,  378,  378,  378,
- /*  2350 */   294,  378,  378,  378,  378,  299,  378,  301,  378,  378,
- /*  2360 */   378,  378,  378,  378,  378,  326,  378,  378,  378,  330,
- /*  2370 */   331,  332,  333,  334,  335,  378,  337,  258,  378,  378,
- /*  2380 */   378,  378,  326,  378,  378,  378,  330,  331,  332,  333,
- /*  2390 */   334,  335,  378,  337,  378,  378,  378,  378,  258,  378,
- /*  2400 */   378,  378,  378,  378,  378,  286,  378,  378,  378,  378,
- /*  2410 */   378,  378,  378,  294,  378,  378,  378,  378,  299,  378,
- /*  2420 */   301,  378,  378,  378,  378,  378,  286,  378,  378,  378,
- /*  2430 */   378,  378,  378,  378,  294,  378,  378,  378,  378,  299,
- /*  2440 */   258,  301,  378,  378,  378,  326,  378,  378,  378,  330,
- /*  2450 */   331,  332,  333,  334,  335,  378,  337,  378,  378,  378,
- /*  2460 */   378,  378,  378,  378,  378,  378,  326,  378,  286,  378,
- /*  2470 */   330,  331,  332,  333,  334,  335,  294,  337,  378,  378,
- /*  2480 */   378,  299,  378,  301,  378,  378,  378,  378,  378,  378,
- /*  2490 */   378,  378,  378,  378,  378,  378,  378,  378,  378,  378,
- /*  2500 */   378,  378,  378,  378,  378,  378,  378,  378,  326,  378,
- /*  2510 */   378,  378,  330,  331,  332,  333,  334,  335,  378,  337,
+ /*   990 */   211,  212,   12,   13,   84,  286,   85,   87,  266,  356,
+ /*  1000 */   266,   89,   22,  294,   92,  193,  153,  259,  299,  277,
+ /*  1010 */   301,  277,  369,   33,  288,   35,  373,  153,  154,  266,
+ /*  1020 */   376,  367,   85,  267,  258,  299,  294,  258,  294,   35,
+ /*  1030 */   277,  258,   95,   43,  123,  326,   56,    0,  258,  330,
+ /*  1040 */   331,  332,  333,  334,  335,  258,  337,  294,   68,  340,
+ /*  1050 */   258,  325,  326,  344,  345,  346,    0,  322,  363,  149,
+ /*  1060 */   150,    0,  152,  337,  355,  299,  156,  258,  299,  158,
+ /*  1070 */   159,  160,  299,  286,  163,  258,   86,  286,  267,  299,
+ /*  1080 */   169,  294,   43,   43,  242,  175,  299,  107,  301,   46,
+ /*  1090 */   265,  299,  298,  182,   43,   43,  185,   43,  187,  188,
+ /*  1100 */   189,  190,  191,  192,   48,  329,   43,   43,  299,   43,
+ /*  1110 */   347,  354,  370,  326,  370,  370,  299,  330,  331,  332,
+ /*  1120 */   333,  334,  335,  258,  337,   86,   86,  340,   85,  246,
+ /*  1130 */    85,  344,  345,  346,   97,  357,  225,   86,   86,   43,
+ /*  1140 */    86,  290,  355,  227,  324,   20,  166,  266,  168,   86,
+ /*  1150 */    86,  286,   86,  116,  117,  118,  119,  120,   97,  294,
+ /*  1160 */    43,   43,  168,   47,  299,  258,  301,  323,   35,   43,
+ /*  1170 */    43,   43,  272,  193,  194,  164,  317,  116,  117,  118,
+ /*  1180 */   119,  120,   86,  266,  204,  205,  206,  207,  208,  209,
+ /*  1190 */   210,  326,  266,  286,   42,  330,  331,  332,  333,  334,
+ /*  1200 */   335,  294,  337,   86,   86,  340,  299,  306,  301,  344,
+ /*  1210 */   345,  346,   86,   86,   86,  148,  266,  304,  304,  266,
+ /*  1220 */   355,  266,  315,   20,  260,  260,  258,  270,   20,  321,
+ /*  1230 */   301,  270,   20,  326,  314,   20,  258,  330,  331,  332,
+ /*  1240 */   333,  334,  335,  316,  337,    4,  270,  314,   20,  270,
+ /*  1250 */   307,  270,  270,  266,  286,  270,  260,  286,  286,  286,
+ /*  1260 */    19,  286,  294,  356,  286,  260,  299,  299,  266,  301,
+ /*  1270 */   286,  268,  294,  321,   33,  286,  369,  299,  286,  301,
+ /*  1280 */   373,  286,  174,  315,  286,  286,  286,  301,   47,  320,
+ /*  1290 */   268,  266,   51,  258,  326,  266,  268,   56,  330,  331,
+ /*  1300 */   332,  333,  334,  335,  326,  337,  232,  258,  330,  331,
+ /*  1310 */   332,  333,  334,  335,  310,  337,  299,  299,  340,  299,
+ /*  1320 */   314,  286,  344,  345,  356,   84,  299,  150,   87,  294,
+ /*  1330 */   299,  310,  308,  307,  299,  286,  301,  369,  294,  268,
+ /*  1340 */   282,  373,  294,  294,  268,   20,  299,  233,  299,  299,
+ /*  1350 */   301,  310,  329,  362,  299,  362,  310,  258,  299,  299,
+ /*  1360 */   239,  326,  365,  157,  241,  330,  331,  332,  333,  334,
+ /*  1370 */   335,  336,  337,  338,  339,  326,  364,  258,  362,  330,
+ /*  1380 */   331,  332,  333,  334,  335,  286,  337,  240,  228,  324,
+ /*  1390 */   224,  361,  360,  294,  294,  359,   20,  328,  299,  245,
+ /*  1400 */   301,  243,   85,  248,  371,  286,  372,  276,  299,  266,
+ /*  1410 */   291,   36,  290,  294,  372,  377,  343,  268,  299,  260,
+ /*  1420 */   301,  318,  261,  374,  375,  326,  313,  256,  371,  330,
+ /*  1430 */   331,  332,  333,  334,  335,    0,  337,  280,  269,  340,
+ /*  1440 */   372,  371,  280,  258,  345,  326,  176,  280,    0,  330,
+ /*  1450 */   331,  332,  333,  334,  335,  258,  337,    0,   42,    0,
+ /*  1460 */    76,    0,   35,   35,  186,  258,   35,   35,  186,    0,
+ /*  1470 */   186,  286,   35,   35,    0,  186,  291,    0,   35,  294,
+ /*  1480 */     0,    0,   22,  286,  299,    0,  301,   35,   85,  171,
+ /*  1490 */   170,  294,  168,  286,  166,    0,  299,    0,  301,  162,
+ /*  1500 */   161,  294,    0,    0,   46,    0,  299,    0,  301,    0,
+ /*  1510 */   145,  326,    0,    0,    0,  330,  331,  332,  333,  334,
+ /*  1520 */   335,  258,  337,  326,    0,    0,   35,  330,  331,  332,
+ /*  1530 */   333,  334,  335,  326,  337,  258,  140,  330,  331,  332,
+ /*  1540 */   333,  334,  335,    0,  337,  140,    0,    0,    0,  286,
+ /*  1550 */    42,    0,    0,    0,    0,    0,    0,  294,    0,    0,
+ /*  1560 */     0,    0,  299,  286,  301,  368,    0,    0,  291,    0,
+ /*  1570 */     0,  294,    0,    0,    0,    0,  299,    0,  301,   22,
+ /*  1580 */     0,    0,  375,    0,   56,    0,   56,    0,  258,  326,
+ /*  1590 */     0,   42,   14,  330,  331,  332,  333,  334,  335,    0,
+ /*  1600 */   337,   39,  339,  326,   40,   14,   43,  330,  331,  332,
+ /*  1610 */   333,  334,  335,   19,  337,   47,  286,   46,   39,    0,
+ /*  1620 */     0,  291,   46,    0,  294,   39,    0,   33,  157,  299,
+ /*  1630 */   258,  301,    0,    0,    0,    0,   35,   39,    0,   35,
+ /*  1640 */    47,   47,    0,   35,  258,   39,   52,   53,   54,   55,
+ /*  1650 */    56,   62,   47,   39,    0,   39,  326,   35,  286,   47,
+ /*  1660 */   330,  331,  332,  333,  334,  335,  294,  337,    0,    0,
+ /*  1670 */     0,  299,  286,  301,    0,   35,   94,   22,   84,    0,
+ /*  1680 */   294,   87,   35,   35,   92,  299,   35,  301,   35,   43,
+ /*  1690 */     0,   35,   43,   35,   35,   35,    0,   22,  326,   22,
+ /*  1700 */     0,   49,  330,  331,  332,  333,  334,  335,  258,  337,
+ /*  1710 */    22,   35,  326,    0,  120,   35,  330,  331,  332,  333,
+ /*  1720 */   334,  335,    0,  337,   35,    0,   22,   20,    0,   35,
+ /*  1730 */   258,    0,   22,    0,    0,    0,  286,  153,    0,    0,
+ /*  1740 */     0,    0,   39,   46,  294,   95,  152,  150,  153,  299,
+ /*  1750 */   258,  301,   86,  153,   43,  229,   85,  155,  286,   86,
+ /*  1760 */   172,  151,  149,   85,   43,   46,  294,  173,   85,  175,
+ /*  1770 */    85,  299,   85,  301,  229,   43,  326,  181,  286,   86,
+ /*  1780 */   330,  331,  332,  333,  334,  335,  294,  337,   86,   46,
+ /*  1790 */    85,  299,  258,  301,   85,   43,   46,   85,  326,   43,
+ /*  1800 */    86,   85,  330,  331,  332,  333,  334,  335,  258,  337,
+ /*  1810 */    86,   85,   85,   46,   46,   86,   86,   43,  326,   35,
+ /*  1820 */   286,   35,  330,  331,  332,  333,  334,  335,  294,  337,
+ /*  1830 */   223,   86,   86,  299,   35,  301,  286,   35,  229,   35,
+ /*  1840 */    35,    2,   22,   43,  294,   85,   22,   86,   85,  299,
+ /*  1850 */    86,  301,   86,   46,  193,   85,   85,   85,   46,  195,
+ /*  1860 */   326,  258,   85,   35,  330,  331,  332,  333,  334,  335,
+ /*  1870 */    35,  337,   96,  258,   86,   85,  326,   86,   35,   85,
+ /*  1880 */   330,  331,  332,  333,  334,  335,   35,  337,   85,  286,
+ /*  1890 */    35,   35,   86,   22,   86,   85,   85,  294,  109,   86,
+ /*  1900 */    85,  286,  299,   85,  301,  109,  109,  109,   35,  294,
+ /*  1910 */    43,   97,   85,   22,  299,  258,  301,   35,   68,   62,
+ /*  1920 */    61,   83,   43,   35,   35,  258,   22,   35,   35,  326,
+ /*  1930 */    35,   35,   35,  330,  331,  332,  333,  334,  335,  258,
+ /*  1940 */   337,  326,   68,  286,   35,  330,  331,  332,  333,  334,
+ /*  1950 */   335,  294,  337,  286,   35,   35,  299,   35,  301,   35,
+ /*  1960 */    35,  294,   35,   35,    0,   35,  299,  286,  301,    0,
+ /*  1970 */    47,   39,   35,   47,   39,  294,    0,   35,   47,    0,
+ /*  1980 */   299,   35,  301,  326,   39,   47,   39,  330,  331,  332,
+ /*  1990 */   333,  334,  335,  326,  337,  258,    0,  330,  331,  332,
+ /*  2000 */   333,  334,  335,   35,  337,  258,   35,  326,    0,   22,
+ /*  2010 */    21,  330,  331,  332,  333,  334,  335,  258,  337,   22,
+ /*  2020 */    22,   21,   20,  286,  378,  378,  378,  378,  378,  378,
+ /*  2030 */   378,  294,  378,  286,  378,  378,  299,  378,  301,  378,
+ /*  2040 */   378,  294,  378,  378,  378,  286,  299,  378,  301,  378,
+ /*  2050 */   378,  378,  378,  294,  378,  378,  378,  378,  299,  378,
+ /*  2060 */   301,  378,  378,  326,  378,  378,  378,  330,  331,  332,
+ /*  2070 */   333,  334,  335,  326,  337,  378,  378,  330,  331,  332,
+ /*  2080 */   333,  334,  335,  258,  337,  326,  378,  378,  378,  330,
+ /*  2090 */   331,  332,  333,  334,  335,  258,  337,  378,  378,  378,
+ /*  2100 */   378,  378,  378,  378,  378,  378,  378,  378,  378,  378,
+ /*  2110 */   378,  286,  378,  378,  378,  378,  378,  378,  378,  294,
+ /*  2120 */   378,  378,  378,  286,  299,  378,  301,  378,  378,  378,
+ /*  2130 */   378,  294,  378,  378,  378,  378,  299,  378,  301,  378,
+ /*  2140 */   378,  378,  378,  378,  378,  378,  378,  378,  258,  378,
+ /*  2150 */   378,  326,  378,  378,  378,  330,  331,  332,  333,  334,
+ /*  2160 */   335,  378,  337,  326,  378,  378,  378,  330,  331,  332,
+ /*  2170 */   333,  334,  335,  378,  337,  378,  286,  378,  378,  378,
+ /*  2180 */   378,  378,  378,  378,  294,  378,  378,  378,  378,  299,
+ /*  2190 */   378,  301,  378,  378,  378,  378,  378,  378,  258,  378,
+ /*  2200 */   378,  378,  378,  378,  378,  378,  378,  378,  258,  378,
+ /*  2210 */   266,  378,  378,  378,  378,  378,  326,  378,  378,  378,
+ /*  2220 */   330,  331,  332,  333,  334,  335,  286,  337,  378,  378,
+ /*  2230 */   378,  378,  378,  378,  294,  378,  286,  378,  294,  299,
+ /*  2240 */   378,  301,  378,  378,  294,  378,  378,  378,  378,  299,
+ /*  2250 */   378,  301,  378,  378,  378,  378,  378,  378,  378,  315,
+ /*  2260 */   378,  378,  378,  378,  378,  378,  326,  378,  378,  378,
+ /*  2270 */   330,  331,  332,  333,  334,  335,  326,  337,  334,  378,
+ /*  2280 */   330,  331,  332,  333,  334,  335,  378,  337,  378,  378,
+ /*  2290 */   378,  378,  378,  349,  350,  351,  378,  353,  378,  378,
+ /*  2300 */   356,  378,  378,  378,  378,  378,  378,  378,  378,  378,
+ /*  2310 */   378,  378,  378,  369,  378,  378,  378,  373,
 };
 #define YY_SHIFT_COUNT    (665)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (1944)
+#define YY_SHIFT_MAX      (2008)
 static const unsigned short int yy_shift_ofst[] = {
  /*     0 */   911,    0,    0,   62,   62,  263,  263,  263,  320,  320,
  /*    10 */   263,  263,  521,  578,  779,  578,  578,  578,  578,  578,
  /*    20 */   578,  578,  578,  578,  578,  578,  578,  578,  578,  578,
  /*    30 */   578,  578,  578,  578,  578,  578,  578,  578,  578,  578,
- /*    40 */   578,  578,  209,  209,   35,   35,   35, 1072, 1072, 1072,
- /*    50 */  1072,  208,  350,   32,   32,  167,  167,   19,   19,   11,
+ /*    40 */   578,  578,  209,  209,   35,   35,   35,  980,  980,  980,
+ /*    50 */   980,  208,  350,   32,   32,  167,  167,   19,   19,   11,
  /*    60 */    38,   32,   32,  167,  167,  167,  167,  167,  167,  167,
  /*    70 */   167,  167,  182,  167,  167,  167,  230,  352,  167,  167,
  /*    80 */   352,  438,  167,  352,  352,  352,  167,  452,  775,  231,
@@ -742,162 +702,162 @@ static const unsigned short int yy_shift_ofst[] = {
  /*   100 */   730,  730,  730,  730,  730,  730,  730,  730,  730,  730,
  /*   110 */   730,  730,  730,  418,   38,  522,  522,  383,  567,  576,
  /*   120 */   480,  480,  480,  567,  558,  230,    1,    1,  352,  352,
- /*   130 */   585,  585,  649,  691,  201,  201,  201,  201,  201,  201,
- /*   140 */   201, 1636,  125,  684,  119,  573,   69,  313,  343,  351,
- /*   150 */   631,  529,  494,   39,  548,  514,  673,  514,  708,  824,
- /*   160 */   824,  824,  250,  666, 1056,  923, 1135, 1114, 1138,  998,
- /*   170 */  1135, 1135, 1140, 1036, 1036, 1135, 1135, 1135, 1169, 1169,
- /*   180 */  1188,  182,  230,  182, 1204, 1205,  182, 1204,  182, 1212,
- /*   190 */   182,  182, 1135,  182, 1169,  352,  352,  352,  352,  352,
- /*   200 */   352,  352,  352,  352,  352,  352, 1135, 1169,  585, 1188,
- /*   210 */   452, 1088,  230,  452, 1135, 1135, 1204,  452, 1057,  585,
- /*   220 */   585,  585,  585, 1057,  585, 1158,  558, 1212,  452,  649,
- /*   230 */   452,  558, 1296,  585, 1087, 1057,  585,  585, 1087, 1057,
- /*   240 */   585,  585,  352, 1089, 1174, 1087, 1091, 1093, 1107,  923,
- /*   250 */  1116,  558, 1322, 1099, 1103, 1101, 1099, 1103, 1099, 1103,
- /*   260 */  1262, 1056,  585,  691, 1135,  452, 1338, 1169, 2520, 2520,
- /*   270 */  2520, 2520, 2520, 2520, 2520,  601, 1684,  386, 1134,  469,
- /*   280 */   551,  682,  840,  879,  853,  727,  823,  314,  314,  314,
- /*   290 */   314,  314,  314,  314,  314,  838,  699,  274,  274,  445,
+ /*   130 */   585,  585,  663,  696,  201,  201,  201,  201,  201,  201,
+ /*   140 */   201, 1594,  125,  684,  119,  573,   69,  313,  343,  351,
+ /*   150 */   631,  529,  494,   39,  548,  514,  673,  514,  708,  842,
+ /*   160 */   842,  842,  250,  666, 1045,  916, 1125, 1116, 1133, 1011,
+ /*   170 */  1125, 1125, 1152, 1067, 1067, 1125, 1125, 1125, 1203, 1203,
+ /*   180 */  1208,  182,  230,  182, 1212, 1215,  182, 1212,  182, 1228,
+ /*   190 */   182,  182, 1125,  182, 1203,  352,  352,  352,  352,  352,
+ /*   200 */   352,  352,  352,  352,  352,  352, 1125, 1203,  585, 1208,
+ /*   210 */   452, 1108,  230,  452, 1125, 1125, 1212,  452, 1074,  585,
+ /*   220 */   585,  585,  585, 1074,  585, 1177,  558, 1228,  452,  663,
+ /*   230 */   452,  558, 1325,  585, 1114, 1074,  585,  585, 1114, 1074,
+ /*   240 */   585,  585,  352, 1121, 1206, 1114, 1123, 1147, 1160,  916,
+ /*   250 */  1166,  558, 1376, 1154, 1158, 1155, 1154, 1158, 1154, 1158,
+ /*   260 */  1317, 1045,  585,  696, 1125,  452, 1375, 1203, 2318, 2318,
+ /*   270 */  2318, 2318, 2318, 2318, 2318,  601,  910,  386, 1241,  469,
+ /*   280 */   551,  682,  840,  879,  853,  727, 1037,  314,  314,  314,
+ /*   290 */   314,  314,  314,  314,  314, 1061,  699,  274,  274,  445,
  /*   300 */    65,  108,  156,   44,  168,  602,  339,  200,  200,  200,
- /*   310 */   200,  297,  841,  839,  929,  934,  965,   57,  850,  851,
- /*   320 */    92,  784,  907,  908,  992, 1024, 1039, 1040, 1048,  819,
- /*   330 */   844,  626,  889, 1071,  924,  976,  967, 1086,  971, 1094,
- /*   340 */  1100, 1115, 1120, 1127, 1128,  994, 1029, 1068, 1396, 1235,
- /*   350 */  1414, 1415, 1374, 1418, 1344, 1421, 1387, 1237, 1389, 1390,
- /*   360 */  1391, 1241, 1428, 1394, 1395, 1245, 1433, 1248, 1435, 1407,
- /*   370 */  1445, 1424, 1447, 1422, 1456, 1375, 1288, 1291, 1294, 1298,
- /*   380 */  1465, 1466, 1305, 1308, 1470, 1471, 1426, 1473, 1474, 1475,
- /*   390 */  1331, 1477, 1479, 1483, 1484, 1485, 1346, 1453, 1489, 1351,
- /*   400 */  1492, 1493, 1494, 1498, 1499, 1500, 1502, 1503, 1505, 1507,
- /*   410 */  1508, 1510, 1512, 1513, 1476, 1515, 1516, 1517, 1520, 1523,
- /*   420 */  1524, 1527, 1525, 1532, 1534, 1537, 1538, 1504, 1539, 1506,
- /*   430 */  1548, 1556, 1519, 1526, 1521, 1552, 1522, 1553, 1528, 1558,
- /*   440 */  1529, 1531, 1572, 1573, 1575, 1540, 1420, 1580, 1581, 1582,
- /*   450 */  1530, 1583, 1584, 1551, 1542, 1554, 1590, 1559, 1549, 1560,
- /*   460 */  1591, 1562, 1557, 1566, 1598, 1571, 1568, 1577, 1601, 1617,
- /*   470 */  1619, 1620, 1535, 1533, 1587, 1602, 1623, 1595, 1606, 1607,
- /*   480 */  1609, 1594, 1600, 1610, 1611, 1612, 1613, 1649, 1628, 1651,
- /*   490 */  1632, 1614, 1656, 1643, 1631, 1668, 1635, 1671, 1638, 1674,
- /*   500 */  1654, 1657, 1678, 1541, 1644, 1681, 1514, 1662, 1543, 1545,
- /*   510 */  1685, 1687, 1546, 1547, 1693, 1697, 1698, 1615, 1618, 1561,
- /*   520 */  1701, 1621, 1570, 1624, 1703, 1666, 1576, 1625, 1629, 1673,
- /*   530 */  1665, 1497, 1642, 1646, 1645, 1647, 1648, 1650, 1686, 1655,
- /*   540 */  1658, 1659, 1660, 1661, 1705, 1682, 1706, 1664, 1710, 1550,
- /*   550 */  1669, 1675, 1711, 1536, 1717, 1716, 1718, 1680, 1724, 1555,
- /*   560 */  1683, 1719, 1735, 1737, 1738, 1740, 1741, 1683, 1749, 1755,
- /*   570 */  1585, 1742, 1695, 1700, 1696, 1707, 1715, 1720, 1745, 1722,
- /*   580 */  1723, 1746, 1761, 1622, 1725, 1709, 1726, 1768, 1778, 1730,
- /*   590 */  1743, 1781, 1739, 1751, 1791, 1747, 1753, 1792, 1750, 1756,
- /*   600 */  1793, 1762, 1732, 1744, 1748, 1752, 1782, 1734, 1763, 1764,
- /*   610 */  1811, 1765, 1808, 1808, 1830, 1794, 1797, 1820, 1795, 1777,
- /*   620 */  1819, 1829, 1832, 1833, 1834, 1836, 1843, 1838, 1848, 1816,
- /*   630 */  1594, 1851, 1600, 1853, 1854, 1856, 1857, 1858, 1861, 1863,
- /*   640 */  1899, 1865, 1859, 1862, 1903, 1869, 1864, 1866, 1908, 1875,
- /*   650 */  1867, 1874, 1915, 1889, 1878, 1893, 1944, 1900, 1901, 1937,
- /*   660 */  1924, 1927, 1928, 1929, 1931, 1933,
+ /*   310 */   200,  297,  784,  843,  848,  862,  912,   57,  850,  928,
+ /*   320 */    92,  864,  990, 1039, 1040, 1051, 1052, 1054, 1063,  819,
+ /*   330 */   762,  702,  883, 1064,  771,  994,  812, 1066, 1043, 1096,
+ /*   340 */  1117, 1118, 1126, 1127, 1128,  937,  906, 1056, 1435, 1270,
+ /*   350 */  1448, 1457, 1416, 1459, 1384, 1461, 1427, 1278, 1428, 1431,
+ /*   360 */  1432, 1282, 1469, 1437, 1438, 1284, 1474, 1289, 1477, 1443,
+ /*   370 */  1480, 1460, 1481, 1452, 1485, 1403, 1318, 1320, 1324, 1328,
+ /*   380 */  1495, 1497, 1337, 1339, 1502, 1503, 1458, 1505, 1507, 1509,
+ /*   390 */  1365, 1512, 1513, 1514, 1524, 1525, 1396, 1491, 1543, 1405,
+ /*   400 */  1546, 1547, 1548, 1558, 1559, 1560, 1561, 1566, 1567, 1569,
+ /*   410 */  1570, 1572, 1573, 1574, 1508, 1551, 1552, 1553, 1554, 1555,
+ /*   420 */  1556, 1557, 1575, 1577, 1580, 1581, 1583, 1528, 1585, 1530,
+ /*   430 */  1587, 1590, 1549, 1562, 1563, 1578, 1571, 1591, 1576, 1599,
+ /*   440 */  1564, 1579, 1619, 1620, 1623, 1586, 1471, 1626, 1632, 1633,
+ /*   450 */  1589, 1634, 1635, 1601, 1568, 1598, 1638, 1604, 1593, 1606,
+ /*   460 */  1642, 1608, 1605, 1614, 1654, 1622, 1612, 1616, 1668, 1669,
+ /*   470 */  1670, 1674, 1582, 1592, 1640, 1655, 1679, 1647, 1648, 1651,
+ /*   480 */  1653, 1646, 1649, 1656, 1658, 1659, 1660, 1690, 1675, 1696,
+ /*   490 */  1677, 1652, 1700, 1688, 1676, 1713, 1680, 1722, 1689, 1725,
+ /*   500 */  1704, 1707, 1728, 1584, 1694, 1731, 1588, 1710, 1595, 1597,
+ /*   510 */  1733, 1734, 1600, 1602, 1735, 1738, 1739, 1671, 1666, 1596,
+ /*   520 */  1740, 1678, 1610, 1683, 1741, 1703, 1613, 1685, 1650, 1697,
+ /*   530 */  1711, 1526, 1687, 1673, 1705, 1693, 1702, 1709, 1721, 1714,
+ /*   540 */  1712, 1716, 1726, 1724, 1732, 1719, 1743, 1727, 1752, 1545,
+ /*   550 */  1729, 1730, 1750, 1607, 1756, 1767, 1768, 1745, 1774, 1609,
+ /*   560 */  1746, 1784, 1786, 1799, 1802, 1804, 1805, 1746, 1839, 1820,
+ /*   570 */  1661, 1800, 1760, 1761, 1763, 1764, 1770, 1766, 1807, 1771,
+ /*   580 */  1772, 1812, 1824, 1664, 1777, 1776, 1788, 1828, 1835, 1790,
+ /*   590 */  1791, 1843, 1794, 1806, 1851, 1803, 1808, 1855, 1810, 1813,
+ /*   600 */  1856, 1811, 1789, 1796, 1797, 1798, 1871, 1814, 1815, 1818,
+ /*   610 */  1873, 1827, 1867, 1867, 1891, 1857, 1859, 1882, 1850, 1838,
+ /*   620 */  1879, 1888, 1889, 1892, 1893, 1895, 1904, 1896, 1897, 1874,
+ /*   630 */  1646, 1909, 1649, 1919, 1920, 1922, 1924, 1925, 1927, 1928,
+ /*   640 */  1964, 1930, 1923, 1932, 1969, 1937, 1926, 1935, 1976, 1942,
+ /*   650 */  1931, 1945, 1979, 1946, 1938, 1947, 1996, 1968, 1971, 2008,
+ /*   660 */  1987, 1989, 1997, 1998, 2000, 2002,
 };
 #define YY_REDUCE_COUNT (274)
 #define YY_REDUCE_MIN   (-312)
-#define YY_REDUCE_MAX   (2182)
+#define YY_REDUCE_MAX   (1950)
 static const short yy_reduce_ofst[] = {
- /*     0 */   -78, -232,   63,  286, -113,  706,  787,  865,  918,  970,
- /*    10 */   545, 1035, 1051, 1106, 1118, 1196, 1210, 1220, 1277, 1301,
- /*    20 */  1327, 1381, 1464, 1488, 1544, 1586, 1596, 1608, 1689, 1708,
- /*    30 */  1769, 1788, 1855, 1871, 1881, 1935, 1989, 2039, 2056, 2119,
- /*    40 */  2140, 2182, -263,  796,  -14,   75,  305, -278,   55,  270,
- /*    50 */   672, -296,  123,  184,  647, -266,  -43, -260, -256, -303,
- /*    60 */  -186, -230, -191, -185,   97,  315,  316,  363,  563,  564,
- /*    70 */   566,  659, -154,  667,  733,  736, -285, -106,  748,  778,
- /*    80 */    59,   24,  781,   72,  322,   82,  782,   70, -252, -312,
+ /*     0 */   -78, -232,   63,  286, -113,  709,  787,  865,  907,  968,
+ /*    10 */   545,  978, 1035, 1049, 1099, 1119, 1185, 1197, 1207, 1263,
+ /*    20 */  1277, 1330, 1372, 1386, 1450, 1472, 1492, 1534, 1550, 1603,
+ /*    30 */  1615, 1657, 1667, 1681, 1737, 1747, 1759, 1825, 1837, 1890,
+ /*    40 */  1940, 1950, -263, 1944,  -14,   75,  305, -278,   55,  270,
+ /*    50 */   726, -296,  123,  184,  643, -266,  -43, -260, -256, -303,
+ /*    60 */  -186, -230, -191, -185,   97,  315,  316,  363,  557,  563,
+ /*    70 */   564,  566, -154,  659,  661,  665, -285, -106,  667,  732,
+ /*    80 */    59,   24,  734,   72,  322,   82,  753,   70, -252, -312,
  /*    90 */  -312, -312, -117, -239, -114,  -20,  141,  181,  196,  289,
- /*   100 */   328,  435,  455,  505,  575,  668,  705,  716,  750,  754,
- /*   110 */   761,  764,  766,  299, -110,  124,  138, -220,  148, -243,
+ /*   100 */   328,  435,  455,  505,  575,  672,  766,  769,  773,  780,
+ /*   110 */   792,  809,  817,  299, -110,  124,  138, -220,  148, -243,
  /*   120 */   218,  310,  364,  150,  354,  349,  336,  456,  319,  205,
- /*   130 */   474,  498,  476,  560, -280, -270,  477,  513,  519,  538,
- /*   140 */   596,  526,  382,  655,  570,  628,  734,  707,  670,  745,
- /*   150 */   745,  810,  822,  797,  777,  755,  755,  755,  757,  738,
- /*   160 */   742,  769,  758,  745,  858,  830,  890,  845,  902,  860,
- /*   170 */   909,  912,  877,  883,  884,  926,  927,  928,  943,  947,
- /*   180 */   894,  946,  921,  953,  913,  910,  959,  916,  961,  930,
- /*   190 */   964,  966,  969,  972,  979,  955,  957,  960,  968,  973,
- /*   200 */   974,  975,  977,  980,  981,  982,  991,  985,  948,  937,
- /*   210 */  1002,  952,  983, 1005, 1009, 1017,  978, 1018,  984,  989,
- /*   220 */   996,  999, 1000,  987, 1007, 1003, 1016, 1006, 1022, 1030,
- /*   230 */  1046, 1021,  988, 1019,  962, 1012, 1020, 1026,  986, 1013,
- /*   240 */  1028, 1031,  745,  990,  993,  997,  995, 1011, 1001, 1014,
- /*   250 */   755, 1047, 1023, 1025, 1027, 1032, 1034, 1037, 1038, 1042,
- /*   260 */  1010, 1064, 1059, 1097, 1096, 1095, 1117, 1131, 1075, 1081,
- /*   270 */  1119, 1121, 1122, 1126, 1147,
+ /*   130 */   474,  498,  476,  562, -280, -270,  382,  513,  538,  633,
+ /*   140 */   669,  641,  748,  366,  644,  654,  756,  735,  695,  791,
+ /*   150 */   791,  811,  825,  794,  776,  757,  757,  757,  763,  742,
+ /*   160 */   744,  745,  778,  791,  851,  820,  881,  844,  900,  859,
+ /*   170 */   917,  926,  901,  913,  914,  950,  953,  955,  964,  965,
+ /*   180 */   908,  957,  929,  961,  920,  927,  976,  933,  979,  943,
+ /*   190 */   981,  982,  987,  985,  996,  971,  972,  973,  975,  984,
+ /*   200 */   989,  992,  995,  998,  999, 1000, 1002, 1005,  967,  952,
+ /*   210 */  1003,  969,  986, 1022, 1025, 1029, 1006, 1028, 1004, 1017,
+ /*   220 */  1018, 1020, 1027, 1021, 1031, 1024, 1044, 1026, 1071, 1058,
+ /*   230 */  1076, 1048, 1023, 1047,  991, 1041, 1050, 1055,  993, 1046,
+ /*   240 */  1059, 1060,  791,  997, 1012, 1016, 1030, 1032, 1036, 1065,
+ /*   250 */   757, 1100, 1069, 1034, 1033, 1038, 1042, 1057, 1068, 1070,
+ /*   260 */  1073, 1122, 1109, 1131, 1143, 1149, 1161, 1159, 1103, 1113,
+ /*   270 */  1157, 1162, 1167, 1169, 1171,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    10 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    20 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    30 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    40 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    50 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    60 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    70 */  1457, 1457, 1531, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*    80 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1529, 1684, 1457,
- /*    90 */  1861, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   100 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   110 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1531, 1457, 1529,
- /*   120 */  1873, 1873, 1873, 1457, 1457, 1457, 1728, 1728, 1457, 1457,
- /*   130 */  1457, 1457, 1627, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   140 */  1457, 1720, 1457, 1457, 1942, 1457, 1457, 1726, 1896, 1457,
- /*   150 */  1457, 1457, 1457, 1580, 1888, 1865, 1879, 1866, 1863, 1927,
- /*   160 */  1927, 1927, 1882, 1457, 1596, 1892, 1457, 1457, 1457, 1712,
- /*   170 */  1457, 1457, 1689, 1686, 1686, 1457, 1457, 1457, 1457, 1457,
- /*   180 */  1457, 1531, 1457, 1531, 1457, 1457, 1531, 1457, 1531, 1457,
- /*   190 */  1531, 1531, 1457, 1531, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   200 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   210 */  1529, 1722, 1457, 1529, 1457, 1457, 1457, 1529, 1901, 1457,
- /*   220 */  1457, 1457, 1457, 1901, 1457, 1457, 1457, 1457, 1529, 1457,
- /*   230 */  1529, 1457, 1457, 1457, 1903, 1901, 1457, 1457, 1903, 1901,
- /*   240 */  1457, 1457, 1457, 1915, 1911, 1903, 1919, 1917, 1894, 1892,
- /*   250 */  1879, 1457, 1457, 1933, 1929, 1945, 1933, 1929, 1933, 1929,
- /*   260 */  1457, 1596, 1457, 1457, 1457, 1529, 1489, 1457, 1714, 1728,
- /*   270 */  1630, 1630, 1630, 1532, 1462, 1457, 1457, 1457, 1457, 1457,
- /*   280 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1799, 1914, 1913,
- /*   290 */  1837, 1836, 1835, 1833, 1798, 1457, 1592, 1797, 1796, 1457,
- /*   300 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1790, 1791, 1789,
- /*   310 */  1788, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   320 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1862,
- /*   330 */  1457, 1930, 1934, 1457, 1457, 1457, 1457, 1457, 1773, 1457,
- /*   340 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   350 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   360 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   370 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   380 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   390 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   400 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   410 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   420 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   430 */  1457, 1457, 1457, 1457, 1494, 1457, 1457, 1457, 1457, 1457,
- /*   440 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   450 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   460 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   470 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   480 */  1457, 1561, 1560, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   490 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   500 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   510 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   520 */  1732, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   530 */  1895, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   540 */  1457, 1457, 1457, 1457, 1457, 1457, 1773, 1457, 1912, 1457,
- /*   550 */  1872, 1868, 1457, 1457, 1864, 1772, 1457, 1457, 1928, 1457,
- /*   560 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1857, 1457,
- /*   570 */  1457, 1830, 1815, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   580 */  1457, 1457, 1457, 1784, 1457, 1457, 1457, 1457, 1457, 1624,
- /*   590 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   600 */  1457, 1457, 1609, 1607, 1606, 1605, 1457, 1602, 1457, 1457,
- /*   610 */  1457, 1457, 1633, 1632, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   620 */  1552, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   630 */  1543, 1457, 1542, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   640 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   650 */  1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457,
- /*   660 */  1457, 1457, 1457, 1457, 1457, 1457,
+ /*     0 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    10 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    20 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    30 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    40 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    50 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    60 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    70 */  1459, 1459, 1533, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*    80 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1531, 1686, 1459,
+ /*    90 */  1864, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   100 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   110 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1533, 1459, 1531,
+ /*   120 */  1876, 1876, 1876, 1459, 1459, 1459, 1730, 1730, 1459, 1459,
+ /*   130 */  1459, 1459, 1629, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   140 */  1459, 1722, 1459, 1459, 1945, 1459, 1459, 1728, 1899, 1459,
+ /*   150 */  1459, 1459, 1459, 1582, 1891, 1868, 1882, 1869, 1866, 1930,
+ /*   160 */  1930, 1930, 1885, 1459, 1598, 1895, 1459, 1459, 1459, 1714,
+ /*   170 */  1459, 1459, 1691, 1688, 1688, 1459, 1459, 1459, 1459, 1459,
+ /*   180 */  1459, 1533, 1459, 1533, 1459, 1459, 1533, 1459, 1533, 1459,
+ /*   190 */  1533, 1533, 1459, 1533, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   200 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   210 */  1531, 1724, 1459, 1531, 1459, 1459, 1459, 1531, 1904, 1459,
+ /*   220 */  1459, 1459, 1459, 1904, 1459, 1459, 1459, 1459, 1531, 1459,
+ /*   230 */  1531, 1459, 1459, 1459, 1906, 1904, 1459, 1459, 1906, 1904,
+ /*   240 */  1459, 1459, 1459, 1918, 1914, 1906, 1922, 1920, 1897, 1895,
+ /*   250 */  1882, 1459, 1459, 1936, 1932, 1948, 1936, 1932, 1936, 1932,
+ /*   260 */  1459, 1598, 1459, 1459, 1459, 1531, 1491, 1459, 1716, 1730,
+ /*   270 */  1632, 1632, 1632, 1534, 1464, 1459, 1459, 1459, 1459, 1459,
+ /*   280 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1802, 1917, 1916,
+ /*   290 */  1840, 1839, 1838, 1836, 1801, 1459, 1594, 1800, 1799, 1459,
+ /*   300 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1793, 1794, 1792,
+ /*   310 */  1791, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   320 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1865,
+ /*   330 */  1459, 1933, 1937, 1459, 1459, 1459, 1459, 1459, 1776, 1459,
+ /*   340 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   350 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   360 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   370 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   380 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   390 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   400 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   410 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   420 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   430 */  1459, 1459, 1459, 1459, 1496, 1459, 1459, 1459, 1459, 1459,
+ /*   440 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   450 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   460 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   470 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   480 */  1459, 1563, 1562, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   490 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   500 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   510 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   520 */  1734, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   530 */  1898, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   540 */  1459, 1459, 1459, 1459, 1459, 1459, 1776, 1459, 1915, 1459,
+ /*   550 */  1875, 1871, 1459, 1459, 1867, 1775, 1459, 1459, 1931, 1459,
+ /*   560 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1860, 1459,
+ /*   570 */  1459, 1833, 1818, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   580 */  1459, 1459, 1459, 1787, 1459, 1459, 1459, 1459, 1459, 1626,
+ /*   590 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   600 */  1459, 1459, 1611, 1609, 1608, 1607, 1459, 1604, 1459, 1459,
+ /*   610 */  1459, 1459, 1635, 1634, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   620 */  1554, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   630 */  1545, 1459, 1544, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   640 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   650 */  1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459,
+ /*   660 */  1459, 1459, 1459, 1459, 1459, 1459,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1953,185 +1913,186 @@ static const char *const yyRuleName[] = {
  /* 306 */ "signed_literal ::= duration_literal",
  /* 307 */ "signed_literal ::= NULL",
  /* 308 */ "signed_literal ::= literal_func",
- /* 309 */ "literal_list ::= signed_literal",
- /* 310 */ "literal_list ::= literal_list NK_COMMA signed_literal",
- /* 311 */ "db_name ::= NK_ID",
- /* 312 */ "table_name ::= NK_ID",
- /* 313 */ "column_name ::= NK_ID",
- /* 314 */ "function_name ::= NK_ID",
- /* 315 */ "table_alias ::= NK_ID",
- /* 316 */ "column_alias ::= NK_ID",
- /* 317 */ "user_name ::= NK_ID",
- /* 318 */ "index_name ::= NK_ID",
- /* 319 */ "topic_name ::= NK_ID",
- /* 320 */ "stream_name ::= NK_ID",
- /* 321 */ "cgroup_name ::= NK_ID",
- /* 322 */ "expression ::= literal",
- /* 323 */ "expression ::= pseudo_column",
- /* 324 */ "expression ::= column_reference",
- /* 325 */ "expression ::= function_expression",
- /* 326 */ "expression ::= subquery",
- /* 327 */ "expression ::= NK_LP expression NK_RP",
- /* 328 */ "expression ::= NK_PLUS expression",
- /* 329 */ "expression ::= NK_MINUS expression",
- /* 330 */ "expression ::= expression NK_PLUS expression",
- /* 331 */ "expression ::= expression NK_MINUS expression",
- /* 332 */ "expression ::= expression NK_STAR expression",
- /* 333 */ "expression ::= expression NK_SLASH expression",
- /* 334 */ "expression ::= expression NK_REM expression",
- /* 335 */ "expression ::= column_reference NK_ARROW NK_STRING",
- /* 336 */ "expression ::= expression NK_BITAND expression",
- /* 337 */ "expression ::= expression NK_BITOR expression",
- /* 338 */ "expression_list ::= expression",
- /* 339 */ "expression_list ::= expression_list NK_COMMA expression",
- /* 340 */ "column_reference ::= column_name",
- /* 341 */ "column_reference ::= table_name NK_DOT column_name",
- /* 342 */ "pseudo_column ::= ROWTS",
- /* 343 */ "pseudo_column ::= TBNAME",
- /* 344 */ "pseudo_column ::= table_name NK_DOT TBNAME",
- /* 345 */ "pseudo_column ::= QSTARTTS",
- /* 346 */ "pseudo_column ::= QENDTS",
- /* 347 */ "pseudo_column ::= WSTARTTS",
- /* 348 */ "pseudo_column ::= WENDTS",
- /* 349 */ "pseudo_column ::= WDURATION",
- /* 350 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
- /* 351 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
- /* 352 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP",
- /* 353 */ "function_expression ::= literal_func",
- /* 354 */ "literal_func ::= noarg_func NK_LP NK_RP",
- /* 355 */ "literal_func ::= NOW",
- /* 356 */ "noarg_func ::= NOW",
- /* 357 */ "noarg_func ::= TODAY",
- /* 358 */ "noarg_func ::= TIMEZONE",
- /* 359 */ "noarg_func ::= DATABASE",
- /* 360 */ "noarg_func ::= CLIENT_VERSION",
- /* 361 */ "noarg_func ::= SERVER_VERSION",
- /* 362 */ "noarg_func ::= SERVER_STATUS",
- /* 363 */ "noarg_func ::= CURRENT_USER",
- /* 364 */ "noarg_func ::= USER",
- /* 365 */ "star_func ::= COUNT",
- /* 366 */ "star_func ::= FIRST",
- /* 367 */ "star_func ::= LAST",
- /* 368 */ "star_func ::= LAST_ROW",
- /* 369 */ "star_func_para_list ::= NK_STAR",
- /* 370 */ "star_func_para_list ::= other_para_list",
- /* 371 */ "other_para_list ::= star_func_para",
- /* 372 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
- /* 373 */ "star_func_para ::= expression",
- /* 374 */ "star_func_para ::= table_name NK_DOT NK_STAR",
- /* 375 */ "predicate ::= expression compare_op expression",
- /* 376 */ "predicate ::= expression BETWEEN expression AND expression",
- /* 377 */ "predicate ::= expression NOT BETWEEN expression AND expression",
- /* 378 */ "predicate ::= expression IS NULL",
- /* 379 */ "predicate ::= expression IS NOT NULL",
- /* 380 */ "predicate ::= expression in_op in_predicate_value",
- /* 381 */ "compare_op ::= NK_LT",
- /* 382 */ "compare_op ::= NK_GT",
- /* 383 */ "compare_op ::= NK_LE",
- /* 384 */ "compare_op ::= NK_GE",
- /* 385 */ "compare_op ::= NK_NE",
- /* 386 */ "compare_op ::= NK_EQ",
- /* 387 */ "compare_op ::= LIKE",
- /* 388 */ "compare_op ::= NOT LIKE",
- /* 389 */ "compare_op ::= MATCH",
- /* 390 */ "compare_op ::= NMATCH",
- /* 391 */ "compare_op ::= CONTAINS",
- /* 392 */ "in_op ::= IN",
- /* 393 */ "in_op ::= NOT IN",
- /* 394 */ "in_predicate_value ::= NK_LP literal_list NK_RP",
- /* 395 */ "boolean_value_expression ::= boolean_primary",
- /* 396 */ "boolean_value_expression ::= NOT boolean_primary",
- /* 397 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
- /* 398 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
- /* 399 */ "boolean_primary ::= predicate",
- /* 400 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
- /* 401 */ "common_expression ::= expression",
- /* 402 */ "common_expression ::= boolean_value_expression",
- /* 403 */ "from_clause_opt ::=",
- /* 404 */ "from_clause_opt ::= FROM table_reference_list",
- /* 405 */ "table_reference_list ::= table_reference",
- /* 406 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
- /* 407 */ "table_reference ::= table_primary",
- /* 408 */ "table_reference ::= joined_table",
- /* 409 */ "table_primary ::= table_name alias_opt",
- /* 410 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
- /* 411 */ "table_primary ::= subquery alias_opt",
- /* 412 */ "table_primary ::= parenthesized_joined_table",
- /* 413 */ "alias_opt ::=",
- /* 414 */ "alias_opt ::= table_alias",
- /* 415 */ "alias_opt ::= AS table_alias",
- /* 416 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
- /* 417 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
- /* 418 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
- /* 419 */ "join_type ::=",
- /* 420 */ "join_type ::= INNER",
- /* 421 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
- /* 422 */ "set_quantifier_opt ::=",
- /* 423 */ "set_quantifier_opt ::= DISTINCT",
- /* 424 */ "set_quantifier_opt ::= ALL",
- /* 425 */ "select_list ::= select_item",
- /* 426 */ "select_list ::= select_list NK_COMMA select_item",
- /* 427 */ "select_item ::= NK_STAR",
- /* 428 */ "select_item ::= common_expression",
- /* 429 */ "select_item ::= common_expression column_alias",
- /* 430 */ "select_item ::= common_expression AS column_alias",
- /* 431 */ "select_item ::= table_name NK_DOT NK_STAR",
- /* 432 */ "where_clause_opt ::=",
- /* 433 */ "where_clause_opt ::= WHERE search_condition",
- /* 434 */ "partition_by_clause_opt ::=",
- /* 435 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
- /* 436 */ "twindow_clause_opt ::=",
- /* 437 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
- /* 438 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
- /* 439 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
- /* 440 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
- /* 441 */ "sliding_opt ::=",
- /* 442 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
- /* 443 */ "fill_opt ::=",
- /* 444 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
- /* 445 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
- /* 446 */ "fill_mode ::= NONE",
- /* 447 */ "fill_mode ::= PREV",
- /* 448 */ "fill_mode ::= NULL",
- /* 449 */ "fill_mode ::= LINEAR",
- /* 450 */ "fill_mode ::= NEXT",
- /* 451 */ "group_by_clause_opt ::=",
- /* 452 */ "group_by_clause_opt ::= GROUP BY group_by_list",
- /* 453 */ "group_by_list ::= expression",
- /* 454 */ "group_by_list ::= group_by_list NK_COMMA expression",
- /* 455 */ "having_clause_opt ::=",
- /* 456 */ "having_clause_opt ::= HAVING search_condition",
- /* 457 */ "range_opt ::=",
- /* 458 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP",
- /* 459 */ "every_opt ::=",
- /* 460 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
- /* 461 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
- /* 462 */ "query_expression_body ::= query_primary",
- /* 463 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
- /* 464 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
- /* 465 */ "query_primary ::= query_specification",
- /* 466 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP",
- /* 467 */ "order_by_clause_opt ::=",
- /* 468 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
- /* 469 */ "slimit_clause_opt ::=",
- /* 470 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
- /* 471 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
- /* 472 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 473 */ "limit_clause_opt ::=",
- /* 474 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
- /* 475 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
- /* 476 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 477 */ "subquery ::= NK_LP query_expression NK_RP",
- /* 478 */ "search_condition ::= common_expression",
- /* 479 */ "sort_specification_list ::= sort_specification",
- /* 480 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
- /* 481 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
- /* 482 */ "ordering_specification_opt ::=",
- /* 483 */ "ordering_specification_opt ::= ASC",
- /* 484 */ "ordering_specification_opt ::= DESC",
- /* 485 */ "null_ordering_opt ::=",
- /* 486 */ "null_ordering_opt ::= NULLS FIRST",
- /* 487 */ "null_ordering_opt ::= NULLS LAST",
+ /* 309 */ "signed_literal ::= NK_QUESTION",
+ /* 310 */ "literal_list ::= signed_literal",
+ /* 311 */ "literal_list ::= literal_list NK_COMMA signed_literal",
+ /* 312 */ "db_name ::= NK_ID",
+ /* 313 */ "table_name ::= NK_ID",
+ /* 314 */ "column_name ::= NK_ID",
+ /* 315 */ "function_name ::= NK_ID",
+ /* 316 */ "table_alias ::= NK_ID",
+ /* 317 */ "column_alias ::= NK_ID",
+ /* 318 */ "user_name ::= NK_ID",
+ /* 319 */ "index_name ::= NK_ID",
+ /* 320 */ "topic_name ::= NK_ID",
+ /* 321 */ "stream_name ::= NK_ID",
+ /* 322 */ "cgroup_name ::= NK_ID",
+ /* 323 */ "expression ::= literal",
+ /* 324 */ "expression ::= pseudo_column",
+ /* 325 */ "expression ::= column_reference",
+ /* 326 */ "expression ::= function_expression",
+ /* 327 */ "expression ::= subquery",
+ /* 328 */ "expression ::= NK_LP expression NK_RP",
+ /* 329 */ "expression ::= NK_PLUS expression",
+ /* 330 */ "expression ::= NK_MINUS expression",
+ /* 331 */ "expression ::= expression NK_PLUS expression",
+ /* 332 */ "expression ::= expression NK_MINUS expression",
+ /* 333 */ "expression ::= expression NK_STAR expression",
+ /* 334 */ "expression ::= expression NK_SLASH expression",
+ /* 335 */ "expression ::= expression NK_REM expression",
+ /* 336 */ "expression ::= column_reference NK_ARROW NK_STRING",
+ /* 337 */ "expression ::= expression NK_BITAND expression",
+ /* 338 */ "expression ::= expression NK_BITOR expression",
+ /* 339 */ "expression_list ::= expression",
+ /* 340 */ "expression_list ::= expression_list NK_COMMA expression",
+ /* 341 */ "column_reference ::= column_name",
+ /* 342 */ "column_reference ::= table_name NK_DOT column_name",
+ /* 343 */ "pseudo_column ::= ROWTS",
+ /* 344 */ "pseudo_column ::= TBNAME",
+ /* 345 */ "pseudo_column ::= table_name NK_DOT TBNAME",
+ /* 346 */ "pseudo_column ::= QSTARTTS",
+ /* 347 */ "pseudo_column ::= QENDTS",
+ /* 348 */ "pseudo_column ::= WSTARTTS",
+ /* 349 */ "pseudo_column ::= WENDTS",
+ /* 350 */ "pseudo_column ::= WDURATION",
+ /* 351 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
+ /* 352 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
+ /* 353 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP",
+ /* 354 */ "function_expression ::= literal_func",
+ /* 355 */ "literal_func ::= noarg_func NK_LP NK_RP",
+ /* 356 */ "literal_func ::= NOW",
+ /* 357 */ "noarg_func ::= NOW",
+ /* 358 */ "noarg_func ::= TODAY",
+ /* 359 */ "noarg_func ::= TIMEZONE",
+ /* 360 */ "noarg_func ::= DATABASE",
+ /* 361 */ "noarg_func ::= CLIENT_VERSION",
+ /* 362 */ "noarg_func ::= SERVER_VERSION",
+ /* 363 */ "noarg_func ::= SERVER_STATUS",
+ /* 364 */ "noarg_func ::= CURRENT_USER",
+ /* 365 */ "noarg_func ::= USER",
+ /* 366 */ "star_func ::= COUNT",
+ /* 367 */ "star_func ::= FIRST",
+ /* 368 */ "star_func ::= LAST",
+ /* 369 */ "star_func ::= LAST_ROW",
+ /* 370 */ "star_func_para_list ::= NK_STAR",
+ /* 371 */ "star_func_para_list ::= other_para_list",
+ /* 372 */ "other_para_list ::= star_func_para",
+ /* 373 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
+ /* 374 */ "star_func_para ::= expression",
+ /* 375 */ "star_func_para ::= table_name NK_DOT NK_STAR",
+ /* 376 */ "predicate ::= expression compare_op expression",
+ /* 377 */ "predicate ::= expression BETWEEN expression AND expression",
+ /* 378 */ "predicate ::= expression NOT BETWEEN expression AND expression",
+ /* 379 */ "predicate ::= expression IS NULL",
+ /* 380 */ "predicate ::= expression IS NOT NULL",
+ /* 381 */ "predicate ::= expression in_op in_predicate_value",
+ /* 382 */ "compare_op ::= NK_LT",
+ /* 383 */ "compare_op ::= NK_GT",
+ /* 384 */ "compare_op ::= NK_LE",
+ /* 385 */ "compare_op ::= NK_GE",
+ /* 386 */ "compare_op ::= NK_NE",
+ /* 387 */ "compare_op ::= NK_EQ",
+ /* 388 */ "compare_op ::= LIKE",
+ /* 389 */ "compare_op ::= NOT LIKE",
+ /* 390 */ "compare_op ::= MATCH",
+ /* 391 */ "compare_op ::= NMATCH",
+ /* 392 */ "compare_op ::= CONTAINS",
+ /* 393 */ "in_op ::= IN",
+ /* 394 */ "in_op ::= NOT IN",
+ /* 395 */ "in_predicate_value ::= NK_LP literal_list NK_RP",
+ /* 396 */ "boolean_value_expression ::= boolean_primary",
+ /* 397 */ "boolean_value_expression ::= NOT boolean_primary",
+ /* 398 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
+ /* 399 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
+ /* 400 */ "boolean_primary ::= predicate",
+ /* 401 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
+ /* 402 */ "common_expression ::= expression",
+ /* 403 */ "common_expression ::= boolean_value_expression",
+ /* 404 */ "from_clause_opt ::=",
+ /* 405 */ "from_clause_opt ::= FROM table_reference_list",
+ /* 406 */ "table_reference_list ::= table_reference",
+ /* 407 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
+ /* 408 */ "table_reference ::= table_primary",
+ /* 409 */ "table_reference ::= joined_table",
+ /* 410 */ "table_primary ::= table_name alias_opt",
+ /* 411 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
+ /* 412 */ "table_primary ::= subquery alias_opt",
+ /* 413 */ "table_primary ::= parenthesized_joined_table",
+ /* 414 */ "alias_opt ::=",
+ /* 415 */ "alias_opt ::= table_alias",
+ /* 416 */ "alias_opt ::= AS table_alias",
+ /* 417 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
+ /* 418 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
+ /* 419 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
+ /* 420 */ "join_type ::=",
+ /* 421 */ "join_type ::= INNER",
+ /* 422 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
+ /* 423 */ "set_quantifier_opt ::=",
+ /* 424 */ "set_quantifier_opt ::= DISTINCT",
+ /* 425 */ "set_quantifier_opt ::= ALL",
+ /* 426 */ "select_list ::= select_item",
+ /* 427 */ "select_list ::= select_list NK_COMMA select_item",
+ /* 428 */ "select_item ::= NK_STAR",
+ /* 429 */ "select_item ::= common_expression",
+ /* 430 */ "select_item ::= common_expression column_alias",
+ /* 431 */ "select_item ::= common_expression AS column_alias",
+ /* 432 */ "select_item ::= table_name NK_DOT NK_STAR",
+ /* 433 */ "where_clause_opt ::=",
+ /* 434 */ "where_clause_opt ::= WHERE search_condition",
+ /* 435 */ "partition_by_clause_opt ::=",
+ /* 436 */ "partition_by_clause_opt ::= PARTITION BY expression_list",
+ /* 437 */ "twindow_clause_opt ::=",
+ /* 438 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
+ /* 439 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP",
+ /* 440 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
+ /* 441 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
+ /* 442 */ "sliding_opt ::=",
+ /* 443 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
+ /* 444 */ "fill_opt ::=",
+ /* 445 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
+ /* 446 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP",
+ /* 447 */ "fill_mode ::= NONE",
+ /* 448 */ "fill_mode ::= PREV",
+ /* 449 */ "fill_mode ::= NULL",
+ /* 450 */ "fill_mode ::= LINEAR",
+ /* 451 */ "fill_mode ::= NEXT",
+ /* 452 */ "group_by_clause_opt ::=",
+ /* 453 */ "group_by_clause_opt ::= GROUP BY group_by_list",
+ /* 454 */ "group_by_list ::= expression",
+ /* 455 */ "group_by_list ::= group_by_list NK_COMMA expression",
+ /* 456 */ "having_clause_opt ::=",
+ /* 457 */ "having_clause_opt ::= HAVING search_condition",
+ /* 458 */ "range_opt ::=",
+ /* 459 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP",
+ /* 460 */ "every_opt ::=",
+ /* 461 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
+ /* 462 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
+ /* 463 */ "query_expression_body ::= query_primary",
+ /* 464 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
+ /* 465 */ "query_expression_body ::= query_expression_body UNION query_expression_body",
+ /* 466 */ "query_primary ::= query_specification",
+ /* 467 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP",
+ /* 468 */ "order_by_clause_opt ::=",
+ /* 469 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /* 470 */ "slimit_clause_opt ::=",
+ /* 471 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
+ /* 472 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /* 473 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 474 */ "limit_clause_opt ::=",
+ /* 475 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
+ /* 476 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /* 477 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 478 */ "subquery ::= NK_LP query_expression NK_RP",
+ /* 479 */ "search_condition ::= common_expression",
+ /* 480 */ "sort_specification_list ::= sort_specification",
+ /* 481 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /* 482 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt",
+ /* 483 */ "ordering_specification_opt ::=",
+ /* 484 */ "ordering_specification_opt ::= ASC",
+ /* 485 */ "ordering_specification_opt ::= DESC",
+ /* 486 */ "null_ordering_opt ::=",
+ /* 487 */ "null_ordering_opt ::= NULLS FIRST",
+ /* 488 */ "null_ordering_opt ::= NULLS LAST",
 };
 #endif /* NDEBUG */
 
@@ -3040,185 +3001,186 @@ static const struct {
   {  288,   -1 }, /* (306) signed_literal ::= duration_literal */
   {  288,   -1 }, /* (307) signed_literal ::= NULL */
   {  288,   -1 }, /* (308) signed_literal ::= literal_func */
-  {  327,   -1 }, /* (309) literal_list ::= signed_literal */
-  {  327,   -3 }, /* (310) literal_list ::= literal_list NK_COMMA signed_literal */
-  {  266,   -1 }, /* (311) db_name ::= NK_ID */
-  {  294,   -1 }, /* (312) table_name ::= NK_ID */
-  {  286,   -1 }, /* (313) column_name ::= NK_ID */
-  {  301,   -1 }, /* (314) function_name ::= NK_ID */
-  {  328,   -1 }, /* (315) table_alias ::= NK_ID */
-  {  329,   -1 }, /* (316) column_alias ::= NK_ID */
-  {  260,   -1 }, /* (317) user_name ::= NK_ID */
-  {  307,   -1 }, /* (318) index_name ::= NK_ID */
-  {  314,   -1 }, /* (319) topic_name ::= NK_ID */
-  {  321,   -1 }, /* (320) stream_name ::= NK_ID */
-  {  316,   -1 }, /* (321) cgroup_name ::= NK_ID */
-  {  330,   -1 }, /* (322) expression ::= literal */
-  {  330,   -1 }, /* (323) expression ::= pseudo_column */
-  {  330,   -1 }, /* (324) expression ::= column_reference */
-  {  330,   -1 }, /* (325) expression ::= function_expression */
-  {  330,   -1 }, /* (326) expression ::= subquery */
-  {  330,   -3 }, /* (327) expression ::= NK_LP expression NK_RP */
-  {  330,   -2 }, /* (328) expression ::= NK_PLUS expression */
-  {  330,   -2 }, /* (329) expression ::= NK_MINUS expression */
-  {  330,   -3 }, /* (330) expression ::= expression NK_PLUS expression */
-  {  330,   -3 }, /* (331) expression ::= expression NK_MINUS expression */
-  {  330,   -3 }, /* (332) expression ::= expression NK_STAR expression */
-  {  330,   -3 }, /* (333) expression ::= expression NK_SLASH expression */
-  {  330,   -3 }, /* (334) expression ::= expression NK_REM expression */
-  {  330,   -3 }, /* (335) expression ::= column_reference NK_ARROW NK_STRING */
-  {  330,   -3 }, /* (336) expression ::= expression NK_BITAND expression */
-  {  330,   -3 }, /* (337) expression ::= expression NK_BITOR expression */
-  {  291,   -1 }, /* (338) expression_list ::= expression */
-  {  291,   -3 }, /* (339) expression_list ::= expression_list NK_COMMA expression */
-  {  332,   -1 }, /* (340) column_reference ::= column_name */
-  {  332,   -3 }, /* (341) column_reference ::= table_name NK_DOT column_name */
-  {  331,   -1 }, /* (342) pseudo_column ::= ROWTS */
-  {  331,   -1 }, /* (343) pseudo_column ::= TBNAME */
-  {  331,   -3 }, /* (344) pseudo_column ::= table_name NK_DOT TBNAME */
-  {  331,   -1 }, /* (345) pseudo_column ::= QSTARTTS */
-  {  331,   -1 }, /* (346) pseudo_column ::= QENDTS */
-  {  331,   -1 }, /* (347) pseudo_column ::= WSTARTTS */
-  {  331,   -1 }, /* (348) pseudo_column ::= WENDTS */
-  {  331,   -1 }, /* (349) pseudo_column ::= WDURATION */
-  {  333,   -4 }, /* (350) function_expression ::= function_name NK_LP expression_list NK_RP */
-  {  333,   -4 }, /* (351) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
-  {  333,   -6 }, /* (352) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
-  {  333,   -1 }, /* (353) function_expression ::= literal_func */
-  {  326,   -3 }, /* (354) literal_func ::= noarg_func NK_LP NK_RP */
-  {  326,   -1 }, /* (355) literal_func ::= NOW */
-  {  337,   -1 }, /* (356) noarg_func ::= NOW */
-  {  337,   -1 }, /* (357) noarg_func ::= TODAY */
-  {  337,   -1 }, /* (358) noarg_func ::= TIMEZONE */
-  {  337,   -1 }, /* (359) noarg_func ::= DATABASE */
-  {  337,   -1 }, /* (360) noarg_func ::= CLIENT_VERSION */
-  {  337,   -1 }, /* (361) noarg_func ::= SERVER_VERSION */
-  {  337,   -1 }, /* (362) noarg_func ::= SERVER_STATUS */
-  {  337,   -1 }, /* (363) noarg_func ::= CURRENT_USER */
-  {  337,   -1 }, /* (364) noarg_func ::= USER */
-  {  335,   -1 }, /* (365) star_func ::= COUNT */
-  {  335,   -1 }, /* (366) star_func ::= FIRST */
-  {  335,   -1 }, /* (367) star_func ::= LAST */
-  {  335,   -1 }, /* (368) star_func ::= LAST_ROW */
-  {  336,   -1 }, /* (369) star_func_para_list ::= NK_STAR */
-  {  336,   -1 }, /* (370) star_func_para_list ::= other_para_list */
-  {  338,   -1 }, /* (371) other_para_list ::= star_func_para */
-  {  338,   -3 }, /* (372) other_para_list ::= other_para_list NK_COMMA star_func_para */
-  {  339,   -1 }, /* (373) star_func_para ::= expression */
-  {  339,   -3 }, /* (374) star_func_para ::= table_name NK_DOT NK_STAR */
-  {  340,   -3 }, /* (375) predicate ::= expression compare_op expression */
-  {  340,   -5 }, /* (376) predicate ::= expression BETWEEN expression AND expression */
-  {  340,   -6 }, /* (377) predicate ::= expression NOT BETWEEN expression AND expression */
-  {  340,   -3 }, /* (378) predicate ::= expression IS NULL */
-  {  340,   -4 }, /* (379) predicate ::= expression IS NOT NULL */
-  {  340,   -3 }, /* (380) predicate ::= expression in_op in_predicate_value */
-  {  341,   -1 }, /* (381) compare_op ::= NK_LT */
-  {  341,   -1 }, /* (382) compare_op ::= NK_GT */
-  {  341,   -1 }, /* (383) compare_op ::= NK_LE */
-  {  341,   -1 }, /* (384) compare_op ::= NK_GE */
-  {  341,   -1 }, /* (385) compare_op ::= NK_NE */
-  {  341,   -1 }, /* (386) compare_op ::= NK_EQ */
-  {  341,   -1 }, /* (387) compare_op ::= LIKE */
-  {  341,   -2 }, /* (388) compare_op ::= NOT LIKE */
-  {  341,   -1 }, /* (389) compare_op ::= MATCH */
-  {  341,   -1 }, /* (390) compare_op ::= NMATCH */
-  {  341,   -1 }, /* (391) compare_op ::= CONTAINS */
-  {  342,   -1 }, /* (392) in_op ::= IN */
-  {  342,   -2 }, /* (393) in_op ::= NOT IN */
-  {  343,   -3 }, /* (394) in_predicate_value ::= NK_LP literal_list NK_RP */
-  {  344,   -1 }, /* (395) boolean_value_expression ::= boolean_primary */
-  {  344,   -2 }, /* (396) boolean_value_expression ::= NOT boolean_primary */
-  {  344,   -3 }, /* (397) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-  {  344,   -3 }, /* (398) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-  {  345,   -1 }, /* (399) boolean_primary ::= predicate */
-  {  345,   -3 }, /* (400) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-  {  346,   -1 }, /* (401) common_expression ::= expression */
-  {  346,   -1 }, /* (402) common_expression ::= boolean_value_expression */
-  {  347,    0 }, /* (403) from_clause_opt ::= */
-  {  347,   -2 }, /* (404) from_clause_opt ::= FROM table_reference_list */
-  {  348,   -1 }, /* (405) table_reference_list ::= table_reference */
-  {  348,   -3 }, /* (406) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-  {  349,   -1 }, /* (407) table_reference ::= table_primary */
-  {  349,   -1 }, /* (408) table_reference ::= joined_table */
-  {  350,   -2 }, /* (409) table_primary ::= table_name alias_opt */
-  {  350,   -4 }, /* (410) table_primary ::= db_name NK_DOT table_name alias_opt */
-  {  350,   -2 }, /* (411) table_primary ::= subquery alias_opt */
-  {  350,   -1 }, /* (412) table_primary ::= parenthesized_joined_table */
-  {  352,    0 }, /* (413) alias_opt ::= */
-  {  352,   -1 }, /* (414) alias_opt ::= table_alias */
-  {  352,   -2 }, /* (415) alias_opt ::= AS table_alias */
-  {  353,   -3 }, /* (416) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-  {  353,   -3 }, /* (417) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-  {  351,   -6 }, /* (418) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-  {  354,    0 }, /* (419) join_type ::= */
-  {  354,   -1 }, /* (420) join_type ::= INNER */
-  {  356,  -12 }, /* (421) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-  {  357,    0 }, /* (422) set_quantifier_opt ::= */
-  {  357,   -1 }, /* (423) set_quantifier_opt ::= DISTINCT */
-  {  357,   -1 }, /* (424) set_quantifier_opt ::= ALL */
-  {  358,   -1 }, /* (425) select_list ::= select_item */
-  {  358,   -3 }, /* (426) select_list ::= select_list NK_COMMA select_item */
-  {  366,   -1 }, /* (427) select_item ::= NK_STAR */
-  {  366,   -1 }, /* (428) select_item ::= common_expression */
-  {  366,   -2 }, /* (429) select_item ::= common_expression column_alias */
-  {  366,   -3 }, /* (430) select_item ::= common_expression AS column_alias */
-  {  366,   -3 }, /* (431) select_item ::= table_name NK_DOT NK_STAR */
-  {  324,    0 }, /* (432) where_clause_opt ::= */
-  {  324,   -2 }, /* (433) where_clause_opt ::= WHERE search_condition */
-  {  359,    0 }, /* (434) partition_by_clause_opt ::= */
-  {  359,   -3 }, /* (435) partition_by_clause_opt ::= PARTITION BY expression_list */
-  {  363,    0 }, /* (436) twindow_clause_opt ::= */
-  {  363,   -6 }, /* (437) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-  {  363,   -4 }, /* (438) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-  {  363,   -6 }, /* (439) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-  {  363,   -8 }, /* (440) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-  {  310,    0 }, /* (441) sliding_opt ::= */
-  {  310,   -4 }, /* (442) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-  {  362,    0 }, /* (443) fill_opt ::= */
-  {  362,   -4 }, /* (444) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-  {  362,   -6 }, /* (445) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-  {  367,   -1 }, /* (446) fill_mode ::= NONE */
-  {  367,   -1 }, /* (447) fill_mode ::= PREV */
-  {  367,   -1 }, /* (448) fill_mode ::= NULL */
-  {  367,   -1 }, /* (449) fill_mode ::= LINEAR */
-  {  367,   -1 }, /* (450) fill_mode ::= NEXT */
-  {  364,    0 }, /* (451) group_by_clause_opt ::= */
-  {  364,   -3 }, /* (452) group_by_clause_opt ::= GROUP BY group_by_list */
-  {  368,   -1 }, /* (453) group_by_list ::= expression */
-  {  368,   -3 }, /* (454) group_by_list ::= group_by_list NK_COMMA expression */
-  {  365,    0 }, /* (455) having_clause_opt ::= */
-  {  365,   -2 }, /* (456) having_clause_opt ::= HAVING search_condition */
-  {  360,    0 }, /* (457) range_opt ::= */
-  {  360,   -6 }, /* (458) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
-  {  361,    0 }, /* (459) every_opt ::= */
-  {  361,   -4 }, /* (460) every_opt ::= EVERY NK_LP duration_literal NK_RP */
-  {  315,   -4 }, /* (461) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
-  {  369,   -1 }, /* (462) query_expression_body ::= query_primary */
-  {  369,   -4 }, /* (463) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-  {  369,   -3 }, /* (464) query_expression_body ::= query_expression_body UNION query_expression_body */
-  {  373,   -1 }, /* (465) query_primary ::= query_specification */
-  {  373,   -6 }, /* (466) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
-  {  370,    0 }, /* (467) order_by_clause_opt ::= */
-  {  370,   -3 }, /* (468) order_by_clause_opt ::= ORDER BY sort_specification_list */
-  {  371,    0 }, /* (469) slimit_clause_opt ::= */
-  {  371,   -2 }, /* (470) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-  {  371,   -4 }, /* (471) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-  {  371,   -4 }, /* (472) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  372,    0 }, /* (473) limit_clause_opt ::= */
-  {  372,   -2 }, /* (474) limit_clause_opt ::= LIMIT NK_INTEGER */
-  {  372,   -4 }, /* (475) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-  {  372,   -4 }, /* (476) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  334,   -3 }, /* (477) subquery ::= NK_LP query_expression NK_RP */
-  {  355,   -1 }, /* (478) search_condition ::= common_expression */
-  {  374,   -1 }, /* (479) sort_specification_list ::= sort_specification */
-  {  374,   -3 }, /* (480) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-  {  375,   -3 }, /* (481) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-  {  376,    0 }, /* (482) ordering_specification_opt ::= */
-  {  376,   -1 }, /* (483) ordering_specification_opt ::= ASC */
-  {  376,   -1 }, /* (484) ordering_specification_opt ::= DESC */
-  {  377,    0 }, /* (485) null_ordering_opt ::= */
-  {  377,   -2 }, /* (486) null_ordering_opt ::= NULLS FIRST */
-  {  377,   -2 }, /* (487) null_ordering_opt ::= NULLS LAST */
+  {  288,   -1 }, /* (309) signed_literal ::= NK_QUESTION */
+  {  327,   -1 }, /* (310) literal_list ::= signed_literal */
+  {  327,   -3 }, /* (311) literal_list ::= literal_list NK_COMMA signed_literal */
+  {  266,   -1 }, /* (312) db_name ::= NK_ID */
+  {  294,   -1 }, /* (313) table_name ::= NK_ID */
+  {  286,   -1 }, /* (314) column_name ::= NK_ID */
+  {  301,   -1 }, /* (315) function_name ::= NK_ID */
+  {  328,   -1 }, /* (316) table_alias ::= NK_ID */
+  {  329,   -1 }, /* (317) column_alias ::= NK_ID */
+  {  260,   -1 }, /* (318) user_name ::= NK_ID */
+  {  307,   -1 }, /* (319) index_name ::= NK_ID */
+  {  314,   -1 }, /* (320) topic_name ::= NK_ID */
+  {  321,   -1 }, /* (321) stream_name ::= NK_ID */
+  {  316,   -1 }, /* (322) cgroup_name ::= NK_ID */
+  {  330,   -1 }, /* (323) expression ::= literal */
+  {  330,   -1 }, /* (324) expression ::= pseudo_column */
+  {  330,   -1 }, /* (325) expression ::= column_reference */
+  {  330,   -1 }, /* (326) expression ::= function_expression */
+  {  330,   -1 }, /* (327) expression ::= subquery */
+  {  330,   -3 }, /* (328) expression ::= NK_LP expression NK_RP */
+  {  330,   -2 }, /* (329) expression ::= NK_PLUS expression */
+  {  330,   -2 }, /* (330) expression ::= NK_MINUS expression */
+  {  330,   -3 }, /* (331) expression ::= expression NK_PLUS expression */
+  {  330,   -3 }, /* (332) expression ::= expression NK_MINUS expression */
+  {  330,   -3 }, /* (333) expression ::= expression NK_STAR expression */
+  {  330,   -3 }, /* (334) expression ::= expression NK_SLASH expression */
+  {  330,   -3 }, /* (335) expression ::= expression NK_REM expression */
+  {  330,   -3 }, /* (336) expression ::= column_reference NK_ARROW NK_STRING */
+  {  330,   -3 }, /* (337) expression ::= expression NK_BITAND expression */
+  {  330,   -3 }, /* (338) expression ::= expression NK_BITOR expression */
+  {  291,   -1 }, /* (339) expression_list ::= expression */
+  {  291,   -3 }, /* (340) expression_list ::= expression_list NK_COMMA expression */
+  {  332,   -1 }, /* (341) column_reference ::= column_name */
+  {  332,   -3 }, /* (342) column_reference ::= table_name NK_DOT column_name */
+  {  331,   -1 }, /* (343) pseudo_column ::= ROWTS */
+  {  331,   -1 }, /* (344) pseudo_column ::= TBNAME */
+  {  331,   -3 }, /* (345) pseudo_column ::= table_name NK_DOT TBNAME */
+  {  331,   -1 }, /* (346) pseudo_column ::= QSTARTTS */
+  {  331,   -1 }, /* (347) pseudo_column ::= QENDTS */
+  {  331,   -1 }, /* (348) pseudo_column ::= WSTARTTS */
+  {  331,   -1 }, /* (349) pseudo_column ::= WENDTS */
+  {  331,   -1 }, /* (350) pseudo_column ::= WDURATION */
+  {  333,   -4 }, /* (351) function_expression ::= function_name NK_LP expression_list NK_RP */
+  {  333,   -4 }, /* (352) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+  {  333,   -6 }, /* (353) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+  {  333,   -1 }, /* (354) function_expression ::= literal_func */
+  {  326,   -3 }, /* (355) literal_func ::= noarg_func NK_LP NK_RP */
+  {  326,   -1 }, /* (356) literal_func ::= NOW */
+  {  337,   -1 }, /* (357) noarg_func ::= NOW */
+  {  337,   -1 }, /* (358) noarg_func ::= TODAY */
+  {  337,   -1 }, /* (359) noarg_func ::= TIMEZONE */
+  {  337,   -1 }, /* (360) noarg_func ::= DATABASE */
+  {  337,   -1 }, /* (361) noarg_func ::= CLIENT_VERSION */
+  {  337,   -1 }, /* (362) noarg_func ::= SERVER_VERSION */
+  {  337,   -1 }, /* (363) noarg_func ::= SERVER_STATUS */
+  {  337,   -1 }, /* (364) noarg_func ::= CURRENT_USER */
+  {  337,   -1 }, /* (365) noarg_func ::= USER */
+  {  335,   -1 }, /* (366) star_func ::= COUNT */
+  {  335,   -1 }, /* (367) star_func ::= FIRST */
+  {  335,   -1 }, /* (368) star_func ::= LAST */
+  {  335,   -1 }, /* (369) star_func ::= LAST_ROW */
+  {  336,   -1 }, /* (370) star_func_para_list ::= NK_STAR */
+  {  336,   -1 }, /* (371) star_func_para_list ::= other_para_list */
+  {  338,   -1 }, /* (372) other_para_list ::= star_func_para */
+  {  338,   -3 }, /* (373) other_para_list ::= other_para_list NK_COMMA star_func_para */
+  {  339,   -1 }, /* (374) star_func_para ::= expression */
+  {  339,   -3 }, /* (375) star_func_para ::= table_name NK_DOT NK_STAR */
+  {  340,   -3 }, /* (376) predicate ::= expression compare_op expression */
+  {  340,   -5 }, /* (377) predicate ::= expression BETWEEN expression AND expression */
+  {  340,   -6 }, /* (378) predicate ::= expression NOT BETWEEN expression AND expression */
+  {  340,   -3 }, /* (379) predicate ::= expression IS NULL */
+  {  340,   -4 }, /* (380) predicate ::= expression IS NOT NULL */
+  {  340,   -3 }, /* (381) predicate ::= expression in_op in_predicate_value */
+  {  341,   -1 }, /* (382) compare_op ::= NK_LT */
+  {  341,   -1 }, /* (383) compare_op ::= NK_GT */
+  {  341,   -1 }, /* (384) compare_op ::= NK_LE */
+  {  341,   -1 }, /* (385) compare_op ::= NK_GE */
+  {  341,   -1 }, /* (386) compare_op ::= NK_NE */
+  {  341,   -1 }, /* (387) compare_op ::= NK_EQ */
+  {  341,   -1 }, /* (388) compare_op ::= LIKE */
+  {  341,   -2 }, /* (389) compare_op ::= NOT LIKE */
+  {  341,   -1 }, /* (390) compare_op ::= MATCH */
+  {  341,   -1 }, /* (391) compare_op ::= NMATCH */
+  {  341,   -1 }, /* (392) compare_op ::= CONTAINS */
+  {  342,   -1 }, /* (393) in_op ::= IN */
+  {  342,   -2 }, /* (394) in_op ::= NOT IN */
+  {  343,   -3 }, /* (395) in_predicate_value ::= NK_LP literal_list NK_RP */
+  {  344,   -1 }, /* (396) boolean_value_expression ::= boolean_primary */
+  {  344,   -2 }, /* (397) boolean_value_expression ::= NOT boolean_primary */
+  {  344,   -3 }, /* (398) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+  {  344,   -3 }, /* (399) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+  {  345,   -1 }, /* (400) boolean_primary ::= predicate */
+  {  345,   -3 }, /* (401) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+  {  346,   -1 }, /* (402) common_expression ::= expression */
+  {  346,   -1 }, /* (403) common_expression ::= boolean_value_expression */
+  {  347,    0 }, /* (404) from_clause_opt ::= */
+  {  347,   -2 }, /* (405) from_clause_opt ::= FROM table_reference_list */
+  {  348,   -1 }, /* (406) table_reference_list ::= table_reference */
+  {  348,   -3 }, /* (407) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+  {  349,   -1 }, /* (408) table_reference ::= table_primary */
+  {  349,   -1 }, /* (409) table_reference ::= joined_table */
+  {  350,   -2 }, /* (410) table_primary ::= table_name alias_opt */
+  {  350,   -4 }, /* (411) table_primary ::= db_name NK_DOT table_name alias_opt */
+  {  350,   -2 }, /* (412) table_primary ::= subquery alias_opt */
+  {  350,   -1 }, /* (413) table_primary ::= parenthesized_joined_table */
+  {  352,    0 }, /* (414) alias_opt ::= */
+  {  352,   -1 }, /* (415) alias_opt ::= table_alias */
+  {  352,   -2 }, /* (416) alias_opt ::= AS table_alias */
+  {  353,   -3 }, /* (417) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+  {  353,   -3 }, /* (418) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+  {  351,   -6 }, /* (419) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+  {  354,    0 }, /* (420) join_type ::= */
+  {  354,   -1 }, /* (421) join_type ::= INNER */
+  {  356,  -12 }, /* (422) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+  {  357,    0 }, /* (423) set_quantifier_opt ::= */
+  {  357,   -1 }, /* (424) set_quantifier_opt ::= DISTINCT */
+  {  357,   -1 }, /* (425) set_quantifier_opt ::= ALL */
+  {  358,   -1 }, /* (426) select_list ::= select_item */
+  {  358,   -3 }, /* (427) select_list ::= select_list NK_COMMA select_item */
+  {  366,   -1 }, /* (428) select_item ::= NK_STAR */
+  {  366,   -1 }, /* (429) select_item ::= common_expression */
+  {  366,   -2 }, /* (430) select_item ::= common_expression column_alias */
+  {  366,   -3 }, /* (431) select_item ::= common_expression AS column_alias */
+  {  366,   -3 }, /* (432) select_item ::= table_name NK_DOT NK_STAR */
+  {  324,    0 }, /* (433) where_clause_opt ::= */
+  {  324,   -2 }, /* (434) where_clause_opt ::= WHERE search_condition */
+  {  359,    0 }, /* (435) partition_by_clause_opt ::= */
+  {  359,   -3 }, /* (436) partition_by_clause_opt ::= PARTITION BY expression_list */
+  {  363,    0 }, /* (437) twindow_clause_opt ::= */
+  {  363,   -6 }, /* (438) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+  {  363,   -4 }, /* (439) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+  {  363,   -6 }, /* (440) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+  {  363,   -8 }, /* (441) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+  {  310,    0 }, /* (442) sliding_opt ::= */
+  {  310,   -4 }, /* (443) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+  {  362,    0 }, /* (444) fill_opt ::= */
+  {  362,   -4 }, /* (445) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+  {  362,   -6 }, /* (446) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+  {  367,   -1 }, /* (447) fill_mode ::= NONE */
+  {  367,   -1 }, /* (448) fill_mode ::= PREV */
+  {  367,   -1 }, /* (449) fill_mode ::= NULL */
+  {  367,   -1 }, /* (450) fill_mode ::= LINEAR */
+  {  367,   -1 }, /* (451) fill_mode ::= NEXT */
+  {  364,    0 }, /* (452) group_by_clause_opt ::= */
+  {  364,   -3 }, /* (453) group_by_clause_opt ::= GROUP BY group_by_list */
+  {  368,   -1 }, /* (454) group_by_list ::= expression */
+  {  368,   -3 }, /* (455) group_by_list ::= group_by_list NK_COMMA expression */
+  {  365,    0 }, /* (456) having_clause_opt ::= */
+  {  365,   -2 }, /* (457) having_clause_opt ::= HAVING search_condition */
+  {  360,    0 }, /* (458) range_opt ::= */
+  {  360,   -6 }, /* (459) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
+  {  361,    0 }, /* (460) every_opt ::= */
+  {  361,   -4 }, /* (461) every_opt ::= EVERY NK_LP duration_literal NK_RP */
+  {  315,   -4 }, /* (462) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+  {  369,   -1 }, /* (463) query_expression_body ::= query_primary */
+  {  369,   -4 }, /* (464) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+  {  369,   -3 }, /* (465) query_expression_body ::= query_expression_body UNION query_expression_body */
+  {  373,   -1 }, /* (466) query_primary ::= query_specification */
+  {  373,   -6 }, /* (467) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+  {  370,    0 }, /* (468) order_by_clause_opt ::= */
+  {  370,   -3 }, /* (469) order_by_clause_opt ::= ORDER BY sort_specification_list */
+  {  371,    0 }, /* (470) slimit_clause_opt ::= */
+  {  371,   -2 }, /* (471) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+  {  371,   -4 }, /* (472) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+  {  371,   -4 }, /* (473) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {  372,    0 }, /* (474) limit_clause_opt ::= */
+  {  372,   -2 }, /* (475) limit_clause_opt ::= LIMIT NK_INTEGER */
+  {  372,   -4 }, /* (476) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+  {  372,   -4 }, /* (477) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {  334,   -3 }, /* (478) subquery ::= NK_LP query_expression NK_RP */
+  {  355,   -1 }, /* (479) search_condition ::= common_expression */
+  {  374,   -1 }, /* (480) sort_specification_list ::= sort_specification */
+  {  374,   -3 }, /* (481) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+  {  375,   -3 }, /* (482) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+  {  376,    0 }, /* (483) ordering_specification_opt ::= */
+  {  376,   -1 }, /* (484) ordering_specification_opt ::= ASC */
+  {  376,   -1 }, /* (485) ordering_specification_opt ::= DESC */
+  {  377,    0 }, /* (486) null_ordering_opt ::= */
+  {  377,   -2 }, /* (487) null_ordering_opt ::= NULLS FIRST */
+  {  377,   -2 }, /* (488) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -3434,30 +3396,30 @@ static YYACTIONTYPE yy_reduce(
       case 49: /* dnode_endpoint ::= NK_STRING */
       case 50: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==50);
       case 51: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==51);
-      case 311: /* db_name ::= NK_ID */ yytestcase(yyruleno==311);
-      case 312: /* table_name ::= NK_ID */ yytestcase(yyruleno==312);
-      case 313: /* column_name ::= NK_ID */ yytestcase(yyruleno==313);
-      case 314: /* function_name ::= NK_ID */ yytestcase(yyruleno==314);
-      case 315: /* table_alias ::= NK_ID */ yytestcase(yyruleno==315);
-      case 316: /* column_alias ::= NK_ID */ yytestcase(yyruleno==316);
-      case 317: /* user_name ::= NK_ID */ yytestcase(yyruleno==317);
-      case 318: /* index_name ::= NK_ID */ yytestcase(yyruleno==318);
-      case 319: /* topic_name ::= NK_ID */ yytestcase(yyruleno==319);
-      case 320: /* stream_name ::= NK_ID */ yytestcase(yyruleno==320);
-      case 321: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==321);
-      case 356: /* noarg_func ::= NOW */ yytestcase(yyruleno==356);
-      case 357: /* noarg_func ::= TODAY */ yytestcase(yyruleno==357);
-      case 358: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==358);
-      case 359: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==359);
-      case 360: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==360);
-      case 361: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==361);
-      case 362: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==362);
-      case 363: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==363);
-      case 364: /* noarg_func ::= USER */ yytestcase(yyruleno==364);
-      case 365: /* star_func ::= COUNT */ yytestcase(yyruleno==365);
-      case 366: /* star_func ::= FIRST */ yytestcase(yyruleno==366);
-      case 367: /* star_func ::= LAST */ yytestcase(yyruleno==367);
-      case 368: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==368);
+      case 312: /* db_name ::= NK_ID */ yytestcase(yyruleno==312);
+      case 313: /* table_name ::= NK_ID */ yytestcase(yyruleno==313);
+      case 314: /* column_name ::= NK_ID */ yytestcase(yyruleno==314);
+      case 315: /* function_name ::= NK_ID */ yytestcase(yyruleno==315);
+      case 316: /* table_alias ::= NK_ID */ yytestcase(yyruleno==316);
+      case 317: /* column_alias ::= NK_ID */ yytestcase(yyruleno==317);
+      case 318: /* user_name ::= NK_ID */ yytestcase(yyruleno==318);
+      case 319: /* index_name ::= NK_ID */ yytestcase(yyruleno==319);
+      case 320: /* topic_name ::= NK_ID */ yytestcase(yyruleno==320);
+      case 321: /* stream_name ::= NK_ID */ yytestcase(yyruleno==321);
+      case 322: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==322);
+      case 357: /* noarg_func ::= NOW */ yytestcase(yyruleno==357);
+      case 358: /* noarg_func ::= TODAY */ yytestcase(yyruleno==358);
+      case 359: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==359);
+      case 360: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==360);
+      case 361: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==361);
+      case 362: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==362);
+      case 363: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==363);
+      case 364: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==364);
+      case 365: /* noarg_func ::= USER */ yytestcase(yyruleno==365);
+      case 366: /* star_func ::= COUNT */ yytestcase(yyruleno==366);
+      case 367: /* star_func ::= FIRST */ yytestcase(yyruleno==367);
+      case 368: /* star_func ::= LAST */ yytestcase(yyruleno==368);
+      case 369: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==369);
 { yylhsminor.yy533 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy533 = yylhsminor.yy533;
         break;
@@ -3516,7 +3478,7 @@ static YYACTIONTYPE yy_reduce(
       case 71: /* exists_opt ::= */ yytestcase(yyruleno==71);
       case 252: /* analyze_opt ::= */ yytestcase(yyruleno==252);
       case 260: /* agg_func_opt ::= */ yytestcase(yyruleno==260);
-      case 422: /* set_quantifier_opt ::= */ yytestcase(yyruleno==422);
+      case 423: /* set_quantifier_opt ::= */ yytestcase(yyruleno==423);
 { yymsp[1].minor.yy173 = false; }
         break;
       case 70: /* exists_opt ::= IF EXISTS */
@@ -3663,10 +3625,10 @@ static YYACTIONTYPE yy_reduce(
       case 183: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==183);
       case 188: /* col_name_list ::= col_name */ yytestcase(yyruleno==188);
       case 235: /* func_list ::= func */ yytestcase(yyruleno==235);
-      case 309: /* literal_list ::= signed_literal */ yytestcase(yyruleno==309);
-      case 371: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==371);
-      case 425: /* select_list ::= select_item */ yytestcase(yyruleno==425);
-      case 479: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==479);
+      case 310: /* literal_list ::= signed_literal */ yytestcase(yyruleno==310);
+      case 372: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==372);
+      case 426: /* select_list ::= select_item */ yytestcase(yyruleno==426);
+      case 480: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==480);
 { yylhsminor.yy712 = createNodeList(pCxt, yymsp[0].minor.yy560); }
   yymsp[0].minor.yy712 = yylhsminor.yy712;
         break;
@@ -3675,10 +3637,10 @@ static YYACTIONTYPE yy_reduce(
       case 184: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==184);
       case 189: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==189);
       case 236: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==236);
-      case 310: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==310);
-      case 372: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==372);
-      case 426: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==426);
-      case 480: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==480);
+      case 311: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==311);
+      case 373: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==373);
+      case 427: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==427);
+      case 481: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==481);
 { yylhsminor.yy712 = addNodeToList(pCxt, yymsp[-2].minor.yy712, yymsp[0].minor.yy560); }
   yymsp[-2].minor.yy712 = yylhsminor.yy712;
         break;
@@ -3761,9 +3723,9 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 136: /* specific_cols_opt ::= */
       case 167: /* tags_def_opt ::= */ yytestcase(yyruleno==167);
-      case 434: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==434);
-      case 451: /* group_by_clause_opt ::= */ yytestcase(yyruleno==451);
-      case 467: /* order_by_clause_opt ::= */ yytestcase(yyruleno==467);
+      case 435: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==435);
+      case 452: /* group_by_clause_opt ::= */ yytestcase(yyruleno==452);
+      case 468: /* order_by_clause_opt ::= */ yytestcase(yyruleno==468);
 { yymsp[1].minor.yy712 = NULL; }
         break;
       case 137: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */
@@ -3853,7 +3815,7 @@ static YYACTIONTYPE yy_reduce(
 { yymsp[-5].minor.yy196 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
         break;
       case 168: /* tags_def_opt ::= tags_def */
-      case 370: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==370);
+      case 371: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==371);
 { yylhsminor.yy712 = yymsp[0].minor.yy712; }
   yymsp[0].minor.yy712 = yylhsminor.yy712;
         break;
@@ -3902,12 +3864,12 @@ static YYACTIONTYPE yy_reduce(
 { yymsp[-1].minor.yy389.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy389.val = yymsp[0].minor.yy0; }
         break;
       case 181: /* duration_list ::= duration_literal */
-      case 338: /* expression_list ::= expression */ yytestcase(yyruleno==338);
+      case 339: /* expression_list ::= expression */ yytestcase(yyruleno==339);
 { yylhsminor.yy712 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy560)); }
   yymsp[0].minor.yy712 = yylhsminor.yy712;
         break;
       case 182: /* duration_list ::= duration_list NK_COMMA duration_literal */
-      case 339: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==339);
+      case 340: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==340);
 { yylhsminor.yy712 = addNodeToList(pCxt, yymsp[-2].minor.yy712, releaseRawExprNode(pCxt, yymsp[0].minor.yy560)); }
   yymsp[-2].minor.yy712 = yylhsminor.yy712;
         break;
@@ -4031,16 +3993,16 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 226: /* like_pattern_opt ::= */
       case 266: /* into_opt ::= */ yytestcase(yyruleno==266);
-      case 403: /* from_clause_opt ::= */ yytestcase(yyruleno==403);
-      case 432: /* where_clause_opt ::= */ yytestcase(yyruleno==432);
-      case 436: /* twindow_clause_opt ::= */ yytestcase(yyruleno==436);
-      case 441: /* sliding_opt ::= */ yytestcase(yyruleno==441);
-      case 443: /* fill_opt ::= */ yytestcase(yyruleno==443);
-      case 455: /* having_clause_opt ::= */ yytestcase(yyruleno==455);
-      case 457: /* range_opt ::= */ yytestcase(yyruleno==457);
-      case 459: /* every_opt ::= */ yytestcase(yyruleno==459);
-      case 469: /* slimit_clause_opt ::= */ yytestcase(yyruleno==469);
-      case 473: /* limit_clause_opt ::= */ yytestcase(yyruleno==473);
+      case 404: /* from_clause_opt ::= */ yytestcase(yyruleno==404);
+      case 433: /* where_clause_opt ::= */ yytestcase(yyruleno==433);
+      case 437: /* twindow_clause_opt ::= */ yytestcase(yyruleno==437);
+      case 442: /* sliding_opt ::= */ yytestcase(yyruleno==442);
+      case 444: /* fill_opt ::= */ yytestcase(yyruleno==444);
+      case 456: /* having_clause_opt ::= */ yytestcase(yyruleno==456);
+      case 458: /* range_opt ::= */ yytestcase(yyruleno==458);
+      case 460: /* every_opt ::= */ yytestcase(yyruleno==460);
+      case 470: /* slimit_clause_opt ::= */ yytestcase(yyruleno==470);
+      case 474: /* limit_clause_opt ::= */ yytestcase(yyruleno==474);
 { yymsp[1].minor.yy560 = NULL; }
         break;
       case 227: /* like_pattern_opt ::= LIKE NK_STRING */
@@ -4115,7 +4077,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 253: /* analyze_opt ::= ANALYZE */
       case 261: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==261);
-      case 423: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==423);
+      case 424: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==424);
 { yymsp[0].minor.yy173 = true; }
         break;
       case 254: /* explain_options ::= */
@@ -4151,9 +4113,9 @@ static YYACTIONTYPE yy_reduce(
 { pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy173, &yymsp[0].minor.yy533); }
         break;
       case 267: /* into_opt ::= INTO full_table_name */
-      case 404: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==404);
-      case 433: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==433);
-      case 456: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==456);
+      case 405: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==405);
+      case 434: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==434);
+      case 457: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==457);
 { yymsp[-1].minor.yy560 = yymsp[0].minor.yy560; }
         break;
       case 269: /* stream_options ::= stream_options TRIGGER AT_ONCE */
@@ -4227,22 +4189,22 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 292: /* literal ::= duration_literal */
       case 302: /* signed_literal ::= signed */ yytestcase(yyruleno==302);
-      case 322: /* expression ::= literal */ yytestcase(yyruleno==322);
-      case 323: /* expression ::= pseudo_column */ yytestcase(yyruleno==323);
-      case 324: /* expression ::= column_reference */ yytestcase(yyruleno==324);
-      case 325: /* expression ::= function_expression */ yytestcase(yyruleno==325);
-      case 326: /* expression ::= subquery */ yytestcase(yyruleno==326);
-      case 353: /* function_expression ::= literal_func */ yytestcase(yyruleno==353);
-      case 395: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==395);
-      case 399: /* boolean_primary ::= predicate */ yytestcase(yyruleno==399);
-      case 401: /* common_expression ::= expression */ yytestcase(yyruleno==401);
-      case 402: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==402);
-      case 405: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==405);
-      case 407: /* table_reference ::= table_primary */ yytestcase(yyruleno==407);
-      case 408: /* table_reference ::= joined_table */ yytestcase(yyruleno==408);
-      case 412: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==412);
-      case 462: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==462);
-      case 465: /* query_primary ::= query_specification */ yytestcase(yyruleno==465);
+      case 323: /* expression ::= literal */ yytestcase(yyruleno==323);
+      case 324: /* expression ::= pseudo_column */ yytestcase(yyruleno==324);
+      case 325: /* expression ::= column_reference */ yytestcase(yyruleno==325);
+      case 326: /* expression ::= function_expression */ yytestcase(yyruleno==326);
+      case 327: /* expression ::= subquery */ yytestcase(yyruleno==327);
+      case 354: /* function_expression ::= literal_func */ yytestcase(yyruleno==354);
+      case 396: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==396);
+      case 400: /* boolean_primary ::= predicate */ yytestcase(yyruleno==400);
+      case 402: /* common_expression ::= expression */ yytestcase(yyruleno==402);
+      case 403: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==403);
+      case 406: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==406);
+      case 408: /* table_reference ::= table_primary */ yytestcase(yyruleno==408);
+      case 409: /* table_reference ::= joined_table */ yytestcase(yyruleno==409);
+      case 413: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==413);
+      case 463: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==463);
+      case 466: /* query_primary ::= query_specification */ yytestcase(yyruleno==466);
 { yylhsminor.yy560 = yymsp[0].minor.yy560; }
   yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
@@ -4301,9 +4263,9 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 306: /* signed_literal ::= duration_literal */
       case 308: /* signed_literal ::= literal_func */ yytestcase(yyruleno==308);
-      case 373: /* star_func_para ::= expression */ yytestcase(yyruleno==373);
-      case 428: /* select_item ::= common_expression */ yytestcase(yyruleno==428);
-      case 478: /* search_condition ::= common_expression */ yytestcase(yyruleno==478);
+      case 374: /* star_func_para ::= expression */ yytestcase(yyruleno==374);
+      case 429: /* select_item ::= common_expression */ yytestcase(yyruleno==429);
+      case 479: /* search_condition ::= common_expression */ yytestcase(yyruleno==479);
 { yylhsminor.yy560 = releaseRawExprNode(pCxt, yymsp[0].minor.yy560); }
   yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
@@ -4311,26 +4273,30 @@ static YYACTIONTYPE yy_reduce(
 { yylhsminor.yy560 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
-      case 327: /* expression ::= NK_LP expression NK_RP */
-      case 400: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==400);
+      case 309: /* signed_literal ::= NK_QUESTION */
+{ yylhsminor.yy560 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy560 = yylhsminor.yy560;
+        break;
+      case 328: /* expression ::= NK_LP expression NK_RP */
+      case 401: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==401);
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 328: /* expression ::= NK_PLUS expression */
+      case 329: /* expression ::= NK_PLUS expression */
 {
                                                                                     SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
                                                                                     yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy560));
                                                                                   }
   yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
-      case 329: /* expression ::= NK_MINUS expression */
+      case 330: /* expression ::= NK_MINUS expression */
 {
                                                                                     SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
                                                                                     yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy560), NULL));
                                                                                   }
   yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
-      case 330: /* expression ::= expression NK_PLUS expression */
+      case 331: /* expression ::= expression NK_PLUS expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4338,7 +4304,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 331: /* expression ::= expression NK_MINUS expression */
+      case 332: /* expression ::= expression NK_MINUS expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4346,7 +4312,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 332: /* expression ::= expression NK_STAR expression */
+      case 333: /* expression ::= expression NK_STAR expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4354,7 +4320,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 333: /* expression ::= expression NK_SLASH expression */
+      case 334: /* expression ::= expression NK_SLASH expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4362,7 +4328,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 334: /* expression ::= expression NK_REM expression */
+      case 335: /* expression ::= expression NK_REM expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4370,14 +4336,14 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 335: /* expression ::= column_reference NK_ARROW NK_STRING */
+      case 336: /* expression ::= column_reference NK_ARROW NK_STRING */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     yylhsminor.yy560 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); 
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 336: /* expression ::= expression NK_BITAND expression */
+      case 337: /* expression ::= expression NK_BITAND expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4385,7 +4351,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 337: /* expression ::= expression NK_BITOR expression */
+      case 338: /* expression ::= expression NK_BITOR expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4393,53 +4359,53 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 340: /* column_reference ::= column_name */
+      case 341: /* column_reference ::= column_name */
 { yylhsminor.yy560 = createRawExprNode(pCxt, &yymsp[0].minor.yy533, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy533)); }
   yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
-      case 341: /* column_reference ::= table_name NK_DOT column_name */
+      case 342: /* column_reference ::= table_name NK_DOT column_name */
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy533, createColumnNode(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy533)); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 342: /* pseudo_column ::= ROWTS */
-      case 343: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==343);
-      case 345: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==345);
-      case 346: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==346);
-      case 347: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==347);
-      case 348: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==348);
-      case 349: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==349);
-      case 355: /* literal_func ::= NOW */ yytestcase(yyruleno==355);
+      case 343: /* pseudo_column ::= ROWTS */
+      case 344: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==344);
+      case 346: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==346);
+      case 347: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==347);
+      case 348: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==348);
+      case 349: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==349);
+      case 350: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==350);
+      case 356: /* literal_func ::= NOW */ yytestcase(yyruleno==356);
 { yylhsminor.yy560 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
   yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
-      case 344: /* pseudo_column ::= table_name NK_DOT TBNAME */
+      case 345: /* pseudo_column ::= table_name NK_DOT TBNAME */
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy533)))); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 350: /* function_expression ::= function_name NK_LP expression_list NK_RP */
-      case 351: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==351);
+      case 351: /* function_expression ::= function_name NK_LP expression_list NK_RP */
+      case 352: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==352);
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy533, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy533, yymsp[-1].minor.yy712)); }
   yymsp[-3].minor.yy560 = yylhsminor.yy560;
         break;
-      case 352: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+      case 353: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), yymsp[-1].minor.yy196)); }
   yymsp[-5].minor.yy560 = yylhsminor.yy560;
         break;
-      case 354: /* literal_func ::= noarg_func NK_LP NK_RP */
+      case 355: /* literal_func ::= noarg_func NK_LP NK_RP */
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy533, NULL)); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 369: /* star_func_para_list ::= NK_STAR */
+      case 370: /* star_func_para_list ::= NK_STAR */
 { yylhsminor.yy712 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); }
   yymsp[0].minor.yy712 = yylhsminor.yy712;
         break;
-      case 374: /* star_func_para ::= table_name NK_DOT NK_STAR */
-      case 431: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==431);
+      case 375: /* star_func_para ::= table_name NK_DOT NK_STAR */
+      case 432: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==432);
 { yylhsminor.yy560 = createColumnNode(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy0); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 375: /* predicate ::= expression compare_op expression */
-      case 380: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==380);
+      case 376: /* predicate ::= expression compare_op expression */
+      case 381: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==381);
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4447,7 +4413,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 376: /* predicate ::= expression BETWEEN expression AND expression */
+      case 377: /* predicate ::= expression BETWEEN expression AND expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4455,7 +4421,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-4].minor.yy560 = yylhsminor.yy560;
         break;
-      case 377: /* predicate ::= expression NOT BETWEEN expression AND expression */
+      case 378: /* predicate ::= expression NOT BETWEEN expression AND expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4463,71 +4429,71 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-5].minor.yy560 = yylhsminor.yy560;
         break;
-      case 378: /* predicate ::= expression IS NULL */
+      case 379: /* predicate ::= expression IS NULL */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     yylhsminor.yy560 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), NULL));
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 379: /* predicate ::= expression IS NOT NULL */
+      case 380: /* predicate ::= expression IS NOT NULL */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy560);
                                                                                     yylhsminor.yy560 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), NULL));
                                                                                   }
   yymsp[-3].minor.yy560 = yylhsminor.yy560;
         break;
-      case 381: /* compare_op ::= NK_LT */
+      case 382: /* compare_op ::= NK_LT */
 { yymsp[0].minor.yy128 = OP_TYPE_LOWER_THAN; }
         break;
-      case 382: /* compare_op ::= NK_GT */
+      case 383: /* compare_op ::= NK_GT */
 { yymsp[0].minor.yy128 = OP_TYPE_GREATER_THAN; }
         break;
-      case 383: /* compare_op ::= NK_LE */
+      case 384: /* compare_op ::= NK_LE */
 { yymsp[0].minor.yy128 = OP_TYPE_LOWER_EQUAL; }
         break;
-      case 384: /* compare_op ::= NK_GE */
+      case 385: /* compare_op ::= NK_GE */
 { yymsp[0].minor.yy128 = OP_TYPE_GREATER_EQUAL; }
         break;
-      case 385: /* compare_op ::= NK_NE */
+      case 386: /* compare_op ::= NK_NE */
 { yymsp[0].minor.yy128 = OP_TYPE_NOT_EQUAL; }
         break;
-      case 386: /* compare_op ::= NK_EQ */
+      case 387: /* compare_op ::= NK_EQ */
 { yymsp[0].minor.yy128 = OP_TYPE_EQUAL; }
         break;
-      case 387: /* compare_op ::= LIKE */
+      case 388: /* compare_op ::= LIKE */
 { yymsp[0].minor.yy128 = OP_TYPE_LIKE; }
         break;
-      case 388: /* compare_op ::= NOT LIKE */
+      case 389: /* compare_op ::= NOT LIKE */
 { yymsp[-1].minor.yy128 = OP_TYPE_NOT_LIKE; }
         break;
-      case 389: /* compare_op ::= MATCH */
+      case 390: /* compare_op ::= MATCH */
 { yymsp[0].minor.yy128 = OP_TYPE_MATCH; }
         break;
-      case 390: /* compare_op ::= NMATCH */
+      case 391: /* compare_op ::= NMATCH */
 { yymsp[0].minor.yy128 = OP_TYPE_NMATCH; }
         break;
-      case 391: /* compare_op ::= CONTAINS */
+      case 392: /* compare_op ::= CONTAINS */
 { yymsp[0].minor.yy128 = OP_TYPE_JSON_CONTAINS; }
         break;
-      case 392: /* in_op ::= IN */
+      case 393: /* in_op ::= IN */
 { yymsp[0].minor.yy128 = OP_TYPE_IN; }
         break;
-      case 393: /* in_op ::= NOT IN */
+      case 394: /* in_op ::= NOT IN */
 { yymsp[-1].minor.yy128 = OP_TYPE_NOT_IN; }
         break;
-      case 394: /* in_predicate_value ::= NK_LP literal_list NK_RP */
+      case 395: /* in_predicate_value ::= NK_LP literal_list NK_RP */
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy712)); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 396: /* boolean_value_expression ::= NOT boolean_primary */
+      case 397: /* boolean_value_expression ::= NOT boolean_primary */
 {
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
                                                                                     yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy560), NULL));
                                                                                   }
   yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
-      case 397: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+      case 398: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4535,7 +4501,7 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 398: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+      case 399: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560);
@@ -4543,47 +4509,47 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 406: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
+      case 407: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
 { yylhsminor.yy560 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy560, yymsp[0].minor.yy560, NULL); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 409: /* table_primary ::= table_name alias_opt */
+      case 410: /* table_primary ::= table_name alias_opt */
 { yylhsminor.yy560 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy533, &yymsp[0].minor.yy533); }
   yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
-      case 410: /* table_primary ::= db_name NK_DOT table_name alias_opt */
+      case 411: /* table_primary ::= db_name NK_DOT table_name alias_opt */
 { yylhsminor.yy560 = createRealTableNode(pCxt, &yymsp[-3].minor.yy533, &yymsp[-1].minor.yy533, &yymsp[0].minor.yy533); }
   yymsp[-3].minor.yy560 = yylhsminor.yy560;
         break;
-      case 411: /* table_primary ::= subquery alias_opt */
+      case 412: /* table_primary ::= subquery alias_opt */
 { yylhsminor.yy560 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560), &yymsp[0].minor.yy533); }
   yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
-      case 413: /* alias_opt ::= */
+      case 414: /* alias_opt ::= */
 { yymsp[1].minor.yy533 = nil_token;  }
         break;
-      case 414: /* alias_opt ::= table_alias */
+      case 415: /* alias_opt ::= table_alias */
 { yylhsminor.yy533 = yymsp[0].minor.yy533; }
   yymsp[0].minor.yy533 = yylhsminor.yy533;
         break;
-      case 415: /* alias_opt ::= AS table_alias */
+      case 416: /* alias_opt ::= AS table_alias */
 { yymsp[-1].minor.yy533 = yymsp[0].minor.yy533; }
         break;
-      case 416: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-      case 417: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==417);
+      case 417: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+      case 418: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==418);
 { yymsp[-2].minor.yy560 = yymsp[-1].minor.yy560; }
         break;
-      case 418: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+      case 419: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
 { yylhsminor.yy560 = createJoinTableNode(pCxt, yymsp[-4].minor.yy36, yymsp[-5].minor.yy560, yymsp[-2].minor.yy560, yymsp[0].minor.yy560); }
   yymsp[-5].minor.yy560 = yylhsminor.yy560;
         break;
-      case 419: /* join_type ::= */
+      case 420: /* join_type ::= */
 { yymsp[1].minor.yy36 = JOIN_TYPE_INNER; }
         break;
-      case 420: /* join_type ::= INNER */
+      case 421: /* join_type ::= INNER */
 { yymsp[0].minor.yy36 = JOIN_TYPE_INNER; }
         break;
-      case 421: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+      case 422: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
 { 
                                                                                     yymsp[-11].minor.yy560 = createSelectStmt(pCxt, yymsp[-10].minor.yy173, yymsp[-9].minor.yy712, yymsp[-8].minor.yy560);
                                                                                     yymsp[-11].minor.yy560 = addWhereClause(pCxt, yymsp[-11].minor.yy560, yymsp[-7].minor.yy560);
@@ -4596,75 +4562,75 @@ static YYACTIONTYPE yy_reduce(
                                                                                     yymsp[-11].minor.yy560 = addFillClause(pCxt, yymsp[-11].minor.yy560, yymsp[-3].minor.yy560);
                                                                                   }
         break;
-      case 424: /* set_quantifier_opt ::= ALL */
+      case 425: /* set_quantifier_opt ::= ALL */
 { yymsp[0].minor.yy173 = false; }
         break;
-      case 427: /* select_item ::= NK_STAR */
+      case 428: /* select_item ::= NK_STAR */
 { yylhsminor.yy560 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
-      case 429: /* select_item ::= common_expression column_alias */
+      case 430: /* select_item ::= common_expression column_alias */
 { yylhsminor.yy560 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560), &yymsp[0].minor.yy533); }
   yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
-      case 430: /* select_item ::= common_expression AS column_alias */
+      case 431: /* select_item ::= common_expression AS column_alias */
 { yylhsminor.yy560 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), &yymsp[0].minor.yy533); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 435: /* partition_by_clause_opt ::= PARTITION BY expression_list */
-      case 452: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==452);
-      case 468: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==468);
+      case 436: /* partition_by_clause_opt ::= PARTITION BY expression_list */
+      case 453: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==453);
+      case 469: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==469);
 { yymsp[-2].minor.yy712 = yymsp[0].minor.yy712; }
         break;
-      case 437: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+      case 438: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
 { yymsp[-5].minor.yy560 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); }
         break;
-      case 438: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+      case 439: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
 { yymsp[-3].minor.yy560 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); }
         break;
-      case 439: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+      case 440: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
 { yymsp[-5].minor.yy560 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), NULL, yymsp[-1].minor.yy560, yymsp[0].minor.yy560); }
         break;
-      case 440: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+      case 441: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
 { yymsp[-7].minor.yy560 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy560), releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), yymsp[-1].minor.yy560, yymsp[0].minor.yy560); }
         break;
-      case 442: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-      case 460: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==460);
+      case 443: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+      case 461: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==461);
 { yymsp[-3].minor.yy560 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy560); }
         break;
-      case 444: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
+      case 445: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
 { yymsp[-3].minor.yy560 = createFillNode(pCxt, yymsp[-1].minor.yy18, NULL); }
         break;
-      case 445: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+      case 446: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
 { yymsp[-5].minor.yy560 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy712)); }
         break;
-      case 446: /* fill_mode ::= NONE */
+      case 447: /* fill_mode ::= NONE */
 { yymsp[0].minor.yy18 = FILL_MODE_NONE; }
         break;
-      case 447: /* fill_mode ::= PREV */
+      case 448: /* fill_mode ::= PREV */
 { yymsp[0].minor.yy18 = FILL_MODE_PREV; }
         break;
-      case 448: /* fill_mode ::= NULL */
+      case 449: /* fill_mode ::= NULL */
 { yymsp[0].minor.yy18 = FILL_MODE_NULL; }
         break;
-      case 449: /* fill_mode ::= LINEAR */
+      case 450: /* fill_mode ::= LINEAR */
 { yymsp[0].minor.yy18 = FILL_MODE_LINEAR; }
         break;
-      case 450: /* fill_mode ::= NEXT */
+      case 451: /* fill_mode ::= NEXT */
 { yymsp[0].minor.yy18 = FILL_MODE_NEXT; }
         break;
-      case 453: /* group_by_list ::= expression */
+      case 454: /* group_by_list ::= expression */
 { yylhsminor.yy712 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy560))); }
   yymsp[0].minor.yy712 = yylhsminor.yy712;
         break;
-      case 454: /* group_by_list ::= group_by_list NK_COMMA expression */
+      case 455: /* group_by_list ::= group_by_list NK_COMMA expression */
 { yylhsminor.yy712 = addNodeToList(pCxt, yymsp[-2].minor.yy712, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy560))); }
   yymsp[-2].minor.yy712 = yylhsminor.yy712;
         break;
-      case 458: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
+      case 459: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */
 { yymsp[-5].minor.yy560 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); }
         break;
-      case 461: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+      case 462: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
 { 
                                                                                     yylhsminor.yy560 = addOrderByClause(pCxt, yymsp[-3].minor.yy560, yymsp[-2].minor.yy712);
                                                                                     yylhsminor.yy560 = addSlimitClause(pCxt, yylhsminor.yy560, yymsp[-1].minor.yy560);
@@ -4672,57 +4638,57 @@ static YYACTIONTYPE yy_reduce(
                                                                                   }
   yymsp[-3].minor.yy560 = yylhsminor.yy560;
         break;
-      case 463: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+      case 464: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
 { yylhsminor.yy560 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy560, yymsp[0].minor.yy560); }
   yymsp[-3].minor.yy560 = yylhsminor.yy560;
         break;
-      case 464: /* query_expression_body ::= query_expression_body UNION query_expression_body */
+      case 465: /* query_expression_body ::= query_expression_body UNION query_expression_body */
 { yylhsminor.yy560 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy560, yymsp[0].minor.yy560); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 466: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+      case 467: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
 { 
                                                                                     yymsp[-5].minor.yy560 = addOrderByClause(pCxt, yymsp[-4].minor.yy560, yymsp[-3].minor.yy712);
                                                                                     yymsp[-5].minor.yy560 = addSlimitClause(pCxt, yymsp[-5].minor.yy560, yymsp[-2].minor.yy560);
                                                                                     yymsp[-5].minor.yy560 = addLimitClause(pCxt, yymsp[-5].minor.yy560, yymsp[-1].minor.yy560);
                                                                                   }
         break;
-      case 470: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
-      case 474: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==474);
+      case 471: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
+      case 475: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==475);
 { yymsp[-1].minor.yy560 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
         break;
-      case 471: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-      case 475: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==475);
+      case 472: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+      case 476: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==476);
 { yymsp[-3].minor.yy560 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
         break;
-      case 472: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-      case 476: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==476);
+      case 473: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+      case 477: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==477);
 { yymsp[-3].minor.yy560 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
         break;
-      case 477: /* subquery ::= NK_LP query_expression NK_RP */
+      case 478: /* subquery ::= NK_LP query_expression NK_RP */
 { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy560); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 481: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+      case 482: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */
 { yylhsminor.yy560 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), yymsp[-1].minor.yy218, yymsp[0].minor.yy109); }
   yymsp[-2].minor.yy560 = yylhsminor.yy560;
         break;
-      case 482: /* ordering_specification_opt ::= */
+      case 483: /* ordering_specification_opt ::= */
 { yymsp[1].minor.yy218 = ORDER_ASC; }
         break;
-      case 483: /* ordering_specification_opt ::= ASC */
+      case 484: /* ordering_specification_opt ::= ASC */
 { yymsp[0].minor.yy218 = ORDER_ASC; }
         break;
-      case 484: /* ordering_specification_opt ::= DESC */
+      case 485: /* ordering_specification_opt ::= DESC */
 { yymsp[0].minor.yy218 = ORDER_DESC; }
         break;
-      case 485: /* null_ordering_opt ::= */
+      case 486: /* null_ordering_opt ::= */
 { yymsp[1].minor.yy109 = NULL_ORDER_DEFAULT; }
         break;
-      case 486: /* null_ordering_opt ::= NULLS FIRST */
+      case 487: /* null_ordering_opt ::= NULLS FIRST */
 { yymsp[-1].minor.yy109 = NULL_ORDER_FIRST; }
         break;
-      case 487: /* null_ordering_opt ::= NULLS LAST */
+      case 488: /* null_ordering_opt ::= NULLS LAST */
 { yymsp[-1].minor.yy109 = NULL_ORDER_LAST; }
         break;
       default:
diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c
index dd55894266..e610fcb62e 100644
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
@@ -729,6 +729,7 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
 
   if (colDataIsNull_s(output.columnData, 0)) {
     res->node.resType.type = TSDB_DATA_TYPE_NULL;
+    res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;    
   } else {
     res->node.resType.type = output.columnData->info.type;
     res->node.resType.bytes = output.columnData->info.bytes;
@@ -819,6 +820,7 @@ EDealRes sclRewriteOperator(SNode** pNode, SScalarCtx *ctx) {
   if (colDataIsNull_s(output.columnData, 0)) {
     if(node->node.resType.type != TSDB_DATA_TYPE_JSON){
       res->node.resType.type = TSDB_DATA_TYPE_NULL;
+      res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
     }else{
       res->node.resType = node->node.resType;
       res->isNull = true;
diff --git a/source/libs/stream/src/stream.c b/source/libs/stream/src/stream.c
index 29e0f7ded0..becfac0cac 100644
--- a/source/libs/stream/src/stream.c
+++ b/source/libs/stream/src/stream.c
@@ -173,7 +173,8 @@ int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pReq,
 }
 
 int32_t streamProcessDispatchReq(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pRsp) {
-  qInfo("task %d receive dispatch req from node %d task %d", pTask->taskId, pReq->upstreamNodeId, pReq->upstreamTaskId);
+  qDebug("task %d receive dispatch req from node %d task %d", pTask->taskId, pReq->upstreamNodeId,
+         pReq->upstreamTaskId);
 
   // 1. handle input
   streamTaskEnqueue(pTask, pReq, pRsp);
diff --git a/source/libs/stream/src/streamExec.c b/source/libs/stream/src/streamExec.c
index d178c19615..36885e73c0 100644
--- a/source/libs/stream/src/streamExec.c
+++ b/source/libs/stream/src/streamExec.c
@@ -26,10 +26,12 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, void* data, SArray* pRes)
   } else if (pItem->type == STREAM_INPUT__DATA_SUBMIT) {
     ASSERT(pTask->isDataScan);
     SStreamDataSubmit* pSubmit = (SStreamDataSubmit*)data;
+    qDebug("task %d %p set submit input %p %p %d", pTask->taskId, pTask, pSubmit, pSubmit->data, *pSubmit->dataRef);
     qSetStreamInput(exec, pSubmit->data, STREAM_INPUT__DATA_SUBMIT, false);
   } else if (pItem->type == STREAM_INPUT__DATA_BLOCK || pItem->type == STREAM_INPUT__DATA_RETRIEVE) {
     SStreamDataBlock* pBlock = (SStreamDataBlock*)data;
     SArray*           blocks = pBlock->blocks;
+    qDebug("task %d %p set ssdata input", pTask->taskId, pTask);
     qSetMultiStreamInput(exec, blocks->pData, blocks->size, STREAM_INPUT__DATA_BLOCK, false);
   } else if (pItem->type == STREAM_INPUT__DROP) {
     // TODO exec drop
diff --git a/source/libs/sync/inc/syncEnv.h b/source/libs/sync/inc/syncEnv.h
index beddec64c5..dd032f1481 100644
--- a/source/libs/sync/inc/syncEnv.h
+++ b/source/libs/sync/inc/syncEnv.h
@@ -30,7 +30,7 @@ extern "C" {
 
 #define TIMER_MAX_MS 0x7FFFFFFF
 #define ENV_TICK_TIMER_MS 1000
-#define PING_TIMER_MS 1000
+#define PING_TIMER_MS 5000
 #define ELECT_TIMER_MS_MIN 1300
 #define ELECT_TIMER_MS_MAX (ELECT_TIMER_MS_MIN * 2)
 #define ELECT_TIMER_MS_RANGE (ELECT_TIMER_MS_MAX - ELECT_TIMER_MS_MIN)
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index e1c3d4bb33..abc0f53611 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -273,16 +273,8 @@ int32_t syncLeaderTransfer(int64_t rid) {
   }
   ASSERT(rid == pSyncNode->rid);
 
-  if (pSyncNode->peersNum == 0) {
-    taosReleaseRef(tsNodeRefId, pSyncNode->rid);
-    terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
-    return -1;
-  }
-
-  SNodeInfo newLeader = (pSyncNode->peersNodeInfo)[0];
+  int32_t ret = syncNodeLeaderTransfer(pSyncNode);
   taosReleaseRef(tsNodeRefId, pSyncNode->rid);
-
-  int32_t ret = syncLeaderTransferTo(rid, newLeader);
   return ret;
 }
 
@@ -293,25 +285,8 @@ int32_t syncLeaderTransferTo(int64_t rid, SNodeInfo newLeader) {
     return -1;
   }
   ASSERT(rid == pSyncNode->rid);
-  int32_t ret = 0;
 
-  if (pSyncNode->replicaNum == 1) {
-    sError("only one replica, cannot drop leader");
-    taosReleaseRef(tsNodeRefId, pSyncNode->rid);
-    terrno = TSDB_CODE_SYN_ONE_REPLICA;
-    return -1;
-  }
-
-  SyncLeaderTransfer* pMsg = syncLeaderTransferBuild(pSyncNode->vgId);
-  pMsg->newLeaderId.addr = syncUtilAddr2U64(newLeader.nodeFqdn, newLeader.nodePort);
-  pMsg->newLeaderId.vgId = pSyncNode->vgId;
-  pMsg->newNodeInfo = newLeader;
-  ASSERT(pMsg != NULL);
-  SRpcMsg rpcMsg = {0};
-  syncLeaderTransfer2RpcMsg(pMsg, &rpcMsg);
-  syncLeaderTransferDestroy(pMsg);
-
-  ret = syncNodePropose(pSyncNode, &rpcMsg, false);
+  int32_t ret = syncNodeLeaderTransferTo(pSyncNode, newLeader);
   taosReleaseRef(tsNodeRefId, pSyncNode->rid);
   return ret;
 }
@@ -337,6 +312,12 @@ int32_t syncNodeLeaderTransferTo(SSyncNode* pSyncNode, SNodeInfo newLeader) {
     return -1;
   }
 
+  do {
+    char logBuf[128];
+    snprintf(logBuf, sizeof(logBuf), "begin leader transfer to %s:%u", newLeader.nodeFqdn, newLeader.nodePort);
+    syncNodeEventLog(pSyncNode, logBuf);
+  } while (0);
+
   SyncLeaderTransfer* pMsg = syncLeaderTransferBuild(pSyncNode->vgId);
   pMsg->newLeaderId.addr = syncUtilAddr2U64(newLeader.nodeFqdn, newLeader.nodePort);
   pMsg->newLeaderId.vgId = pSyncNode->vgId;
@@ -1118,19 +1099,13 @@ void syncNodeStart(SSyncNode* pSyncNode) {
     // Raft 3.6.2 Committing entries from previous terms
     syncNodeAppendNoop(pSyncNode);
     syncMaybeAdvanceCommitIndex(pSyncNode);
-
-    return;
+  } else {
+    syncNodeBecomeFollower(pSyncNode, "first start");
   }
 
-  syncNodeBecomeFollower(pSyncNode, "first start");
-
-  // int32_t ret = 0;
-  // ret = syncNodeStartPingTimer(pSyncNode);
-  // ASSERT(ret == 0);
-
-  if (gRaftDetailLog) {
-    syncNodeLog2("==state change become leader immediately==", pSyncNode);
-  }
+  int32_t ret = 0;
+  ret = syncNodeStartPingTimer(pSyncNode);
+  ASSERT(ret == 0);
 }
 
 void syncNodeStartStandBy(SSyncNode* pSyncNode) {
@@ -1147,8 +1122,6 @@ void syncNodeStartStandBy(SSyncNode* pSyncNode) {
 void syncNodeClose(SSyncNode* pSyncNode) {
   syncNodeEventLog(pSyncNode, "sync close");
 
-  // leader transfer
-
   int32_t ret;
   ASSERT(pSyncNode != NULL);
 
@@ -1183,14 +1156,6 @@ void syncNodeClose(SSyncNode* pSyncNode) {
     pSyncNode->pNewNodeReceiver = NULL;
   }
 
-  /*
-  if (pSyncNode->pSnapshot != NULL) {
-    taosMemoryFree(pSyncNode->pSnapshot);
-  }
-  */
-
-  // tsem_destroy(&pSyncNode->restoreSem);
-
   // free memory in syncFreeNode
   // taosMemoryFree(pSyncNode);
 }
@@ -1255,7 +1220,7 @@ int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) {
                  &pSyncNode->pPingTimer);
     atomic_store_64(&pSyncNode->pingTimerLogicClock, pSyncNode->pingTimerLogicClockUser);
   } else {
-    sError("sync env is stop, syncNodeStartPingTimer");
+    sError("vgId:%d, start ping timer error, sync env is stop", pSyncNode->vgId);
   }
   return ret;
 }
@@ -1276,7 +1241,7 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) {
                  &pSyncNode->pElectTimer);
     atomic_store_64(&pSyncNode->electTimerLogicClock, pSyncNode->electTimerLogicClockUser);
   } else {
-    sError("sync env is stop, syncNodeStartElectTimer");
+    sError("vgId:%d, start elect timer error, sync env is stop", pSyncNode->vgId);
   }
   return ret;
 }
@@ -1316,7 +1281,7 @@ int32_t syncNodeStartHeartbeatTimer(SSyncNode* pSyncNode) {
                  &pSyncNode->pHeartbeatTimer);
     atomic_store_64(&pSyncNode->heartbeatTimerLogicClock, pSyncNode->heartbeatTimerLogicClockUser);
   } else {
-    sError("sync env is stop, syncNodeStartHeartbeatTimer");
+    sError("vgId:%d, start heartbeat timer error, sync env is stop", pSyncNode->vgId);
   }
   return ret;
 }
@@ -2643,7 +2608,7 @@ const char* syncStr(ESyncState state) {
 static int32_t syncDoLeaderTransfer(SSyncNode* ths, SRpcMsg* pRpcMsg, SSyncRaftEntry* pEntry) {
   SyncLeaderTransfer* pSyncLeaderTransfer = syncLeaderTransferFromRpcMsg2(pRpcMsg);
 
-  syncNodeEventLog(ths, "begin leader transfer");
+  syncNodeEventLog(ths, "do leader transfer");
 
   bool sameId = syncUtilSameId(&(pSyncLeaderTransfer->newLeaderId), &(ths->myRaftId));
   bool sameNodeInfo = strcmp(pSyncLeaderTransfer->newNodeInfo.nodeFqdn, ths->myNodeInfo.nodeFqdn) == 0 &&
diff --git a/source/libs/sync/src/syncTimeout.c b/source/libs/sync/src/syncTimeout.c
index 0d3a3c3cc5..52181a3da8 100644
--- a/source/libs/sync/src/syncTimeout.c
+++ b/source/libs/sync/src/syncTimeout.c
@@ -17,6 +17,11 @@
 #include "syncElection.h"
 #include "syncReplication.h"
 
+int32_t syncNodeTimerRoutine(SSyncNode* ths) {
+  syncNodeEventLog(ths, "timer routines ... ");
+  return 0;
+}
+
 int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) {
   int32_t ret = 0;
   syncTimeoutLog2("==syncNodeOnTimeoutCb==", pMsg);
@@ -24,8 +29,11 @@ int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) {
   if (pMsg->timeoutType == SYNC_TIMEOUT_PING) {
     if (atomic_load_64(&ths->pingTimerLogicClockUser) <= pMsg->logicClock) {
       ++(ths->pingTimerCounter);
+
       // syncNodePingAll(ths);
-      syncNodePingPeers(ths);
+      // syncNodePingPeers(ths);
+
+      syncNodeTimerRoutine(ths);
     }
 
   } else if (pMsg->timeoutType == SYNC_TIMEOUT_ELECTION) {
@@ -40,7 +48,7 @@ int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) {
       syncNodeReplicate(ths);
     }
   } else {
-    sTrace("unknown timeoutType:%d", pMsg->timeoutType);
+    sError("vgId:%d, unknown timeout-type:%d", ths->vgId, pMsg->timeoutType);
   }
 
   return ret;
diff --git a/source/libs/wal/src/walRead.c b/source/libs/wal/src/walRead.c
index eb0c7f56bd..908523f2a6 100644
--- a/source/libs/wal/src/walRead.c
+++ b/source/libs/wal/src/walRead.c
@@ -66,6 +66,7 @@ void walCloseReader(SWalReader *pRead) {
 }
 
 int32_t walNextValidMsg(SWalReader *pRead) {
+  wDebug("vgId:%d wal start to fetch", pRead->pWal->cfg.vgId);
   int64_t fetchVer = pRead->curVersion;
   int64_t endVer = pRead->cond.scanUncommited ? walGetLastVer(pRead->pWal) : walGetCommittedVer(pRead->pWal);
   while (fetchVer <= endVer) {
@@ -176,7 +177,7 @@ int32_t walReadSeekVerImpl(SWalReader *pRead, int64_t ver) {
     return -1;
   }
 
-  wDebug("wal version reset from %ld to %ld", pRead->curVersion, ver);
+  wDebug("wal version reset from %ld(invalid: %d) to %ld", pRead->curVersion, pRead->curInvalid, ver);
 
   pRead->curVersion = ver;
   return 0;
@@ -242,6 +243,7 @@ static int32_t walFetchHeadNew(SWalReader *pRead, int64_t fetchVer) {
       return -1;
     }
   }
+  pRead->curInvalid = 0;
   return 0;
 }
 
@@ -301,6 +303,7 @@ static int32_t walSkipFetchBodyNew(SWalReader *pRead) {
   int64_t code;
 
   ASSERT(pRead->curVersion == pRead->pHead->head.version);
+  ASSERT(pRead->curInvalid == 0);
 
   code = taosLSeekFile(pRead->pLogFile, pRead->pHead->head.bodyLen, SEEK_CUR);
   if (code < 0) {
@@ -404,6 +407,7 @@ int32_t walFetchBody(SWalReader *pRead, SWalCkHead **ppHead) {
 }
 
 int32_t walReadVer(SWalReader *pRead, int64_t ver) {
+  wDebug("vgId:%d wal start to read ver %ld", pRead->pWal->cfg.vgId, ver);
   int64_t contLen;
   bool    seeked = false;
 
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 6826258151..465677de80 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -96,11 +96,11 @@
 ./test.sh -f tsim/stream/basic2.sim
 ./test.sh -f tsim/stream/drop_stream.sim
 ./test.sh -f tsim/stream/distributeInterval0.sim
-# ./test.sh -f tsim/stream/distributeIntervalRetrive0.sim
+./test.sh -f tsim/stream/distributeIntervalRetrive0.sim
 # ./test.sh -f tsim/stream/distributesession0.sim
 ./test.sh -f tsim/stream/session0.sim
 ./test.sh -f tsim/stream/session1.sim
-# ./test.sh -f tsim/stream/state0.sim
+./test.sh -f tsim/stream/state0.sim
 ./test.sh -f tsim/stream/triggerInterval0.sim
 # ./test.sh -f tsim/stream/triggerSession0.sim
 ./test.sh -f tsim/stream/partitionby.sim
diff --git a/tests/script/tsim/query/scalarNull.sim b/tests/script/tsim/query/scalarNull.sim
index 07bd5e57cd..ae4b2a9624 100644
--- a/tests/script/tsim/query/scalarNull.sim
+++ b/tests/script/tsim/query/scalarNull.sim
@@ -89,5 +89,10 @@ endi
 #TODO: MOVE IT TO NORMAL CASE
 sql_error select * from tb1 where not (null);
 
+sql select sum(1/0) from tb1;
+if $rows != 1 then
+  return -1
+endi
+
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/tsim/stream/distributeIntervalRetrive0.sim b/tests/script/tsim/stream/distributeIntervalRetrive0.sim
index cde5c7058f..32170e3c41 100644
--- a/tests/script/tsim/stream/distributeIntervalRetrive0.sim
+++ b/tests/script/tsim/stream/distributeIntervalRetrive0.sim
@@ -76,7 +76,7 @@ if $data01 != 5 then
   goto loop1
 endi
 
-if $data02 != 14 then
+if $data02 != 38 then
   print =====data02=$data02
   goto loop1
 endi
@@ -134,7 +134,7 @@ if $data01 != 6 then
   goto loop2
 endi
 
-if $data02 != 18 then
+if $data02 != 42 then
   print =====data02=$data02
   goto loop2
 endi
@@ -192,7 +192,7 @@ if $data01 != 7 then
   goto loop3
 endi
 
-if $data02 != 22 then
+if $data02 != 46 then
   print =====data02=$data02
   goto loop3
 endi
@@ -232,60 +232,4 @@ endi
 
 print loop3 over
 
-$loop_count = 0
-loop4:
-sleep 1000
-sql select * from streamtST1;
-
-$loop_count = $loop_count + 1
-if $loop_count == 10 then
-  return -1
-endi
-
-# row 0
-if $data01 != 7 then
-  print =====data01=$data01
-  goto loop4
-endi
-
-if $data02 != 22 then
-  print =====data02=$data02
-  goto loop4
-endi
-
-# row 1
-if $data11 != 3 then
-  print =====data11=$data11
-  goto loop4
-endi
-
-if $data12 != 10 then
-  print =====data12=$data12
-  goto loop4
-endi
-
-#row2
-if $data21 != 3 then
-  print =====data21=$data21
-  goto loop4
-endi
-
-if $data22 != 11 then
-  print =====data22=$data22
-  goto loop4
-endi
-
-#row 3
-if $data31 != 5 then
-  print =====data31=$data31
-  goto loop4
-endi
-
-if $data32 != 60 then
-  print =====data32=$data32
-  goto loop4
-endi
-
-print loop4 over
-
 system sh/stop_dnodes.sh
diff --git a/tests/script/tsim/sync/electTest.sim b/tests/script/tsim/sync/electTest.sim
new file mode 100644
index 0000000000..5433434014
--- /dev/null
+++ b/tests/script/tsim/sync/electTest.sim
@@ -0,0 +1,193 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/deploy.sh -n dnode2 -i 2
+system sh/deploy.sh -n dnode3 -i 3
+system sh/deploy.sh -n dnode4 -i 4
+
+system sh/cfg.sh -n dnode1 -c supportVnodes -v 0
+
+system sh/exec.sh -n dnode1 -s start
+system sh/exec.sh -n dnode2 -s start
+system sh/exec.sh -n dnode3 -s start
+system sh/exec.sh -n dnode4 -s start
+
+$loop_cnt = 0
+check_dnode_ready:
+	$loop_cnt = $loop_cnt + 1
+	sleep 200
+	if $loop_cnt == 10 then
+	  print ====> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ===> $rows $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
+print ===> $rows $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] $data[1][5] $data[1][6]
+print ===> $rows $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6]
+print ===> $rows $data[3][0] $data[3][1] $data[3][2] $data[3][3] $data[3][4] $data[3][5] $data[3][6]
+if $data[0][0] != 1 then
+  return -1
+endi
+if $data[0][4] != ready then
+  goto check_dnode_ready
+endi
+
+sql connect
+sql create dnode $hostname port 7200
+sql create dnode $hostname port 7300
+sql create dnode $hostname port 7400
+
+$loop_cnt = 0
+check_dnode_ready_1:
+$loop_cnt = $loop_cnt + 1
+sleep 200
+if $loop_cnt == 10 then
+  print ====> dnodes not ready!
+	return -1
+endi
+sql show dnodes
+print ===> $rows $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6]
+print ===> $rows $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] $data[1][5] $data[1][6]
+print ===> $rows $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6]
+print ===> $rows $data[3][0] $data[3][1] $data[3][2] $data[3][3] $data[3][4] $data[3][5] $data[3][6]
+if $data[0][4] != ready then
+  goto check_dnode_ready_1
+endi
+if $data[1][4] != ready then
+  goto check_dnode_ready_1
+endi
+if $data[2][4] != ready then
+  goto check_dnode_ready_1
+endi
+if $data[3][4] != ready then
+  goto check_dnode_ready_1
+endi
+
+$replica = 3
+$vgroups = 1
+
+print ============= create database
+sql create database db replica $replica vgroups $vgroups
+
+$loop_cnt = 0
+check_db_ready:
+$loop_cnt = $loop_cnt + 1
+sleep 200
+if $loop_cnt == 100 then
+  print ====> db not ready!
+	return -1
+endi
+sql show databases
+print ===> rows: $rows
+print $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6] $data[2][7] $data[2][8] $data[2][9] $data[2][6] $data[2][11] $data[2][12]  $data[2][13]  $data[2][14]  $data[2][15]  $data[2][16]  $data[2][17]  $data[2][18]  $data[2][19]
+if $rows != 3 then
+  return -1
+endi
+if $data[2][19] != ready then
+  goto check_db_ready
+endi
+
+sql use db
+
+$loop_cnt = 0
+check_vg_ready:
+$loop_cnt = $loop_cnt + 1
+sleep 200
+if $loop_cnt == 300 then
+  print ====> vgroups not ready!
+	return -1
+endi
+
+sql show vgroups
+print ===> rows: $rows
+print $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6] $data[0][7] $data[0][8] $data[0][9] $data[0][10] $data[0][11]
+
+if $rows != $vgroups then
+  return -1
+endi
+
+if $data[0][4] == leader then
+   if $data[0][6] == follower then
+      if $data[0][8] == follower then
+         print ---- vgroup $data[0][0] leader locate on dnode $data[0][3] 
+      endi
+   endi
+elif $data[0][6] == leader then
+   if $data[0][4] == follower then
+      if $data[0][8] == follower then
+         print ---- vgroup $data[0][0] leader locate on dnode $data[0][5] 
+      endi
+   endi
+elif $data[0][8] == leader then
+   if $data[0][4] == follower then
+      if $data[0][6] == follower then
+         print ---- vgroup $data[0][0] leader locate on dnode $data[0][7] 
+      endi
+   endi
+else
+   goto check_vg_ready
+endi
+
+
+vg_ready:
+print ====>  create stable/child table
+sql create table stb (ts timestamp, c1 int, c2 float, c3 double) tags (t1 int)
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+sql create table ct1 using stb tags(1000)
+
+
+print ===> write 100 records
+$N = 100
+$count = 0
+while $count < $N
+	$ms = 1591200000000 + $count
+    sql insert into ct1 values( $ms , $count , 2.1, 3.1)
+    $count = $count + 1
+endw
+
+
+#sql flush database db;
+
+
+sleep 3000
+
+
+print ===> stop dnode1 dnode2 dnode3 dnode4
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode2 -s stop -x SIGINT
+system sh/exec.sh -n dnode3 -s stop -x SIGINT
+system sh/exec.sh -n dnode4 -s stop -x SIGINT
+
+
+
+########################################################
+print ===> start dnode1 dnode2 dnode3 dnode4
+system sh/exec.sh -n dnode1 -s start
+system sh/exec.sh -n dnode2 -s start
+system sh/exec.sh -n dnode3 -s start
+system sh/exec.sh -n dnode4 -s start
+
+sleep 3000
+
+print =============== query data 
+sql connect
+sql use db
+sql select * from ct1
+print rows: $rows
+print $data00 $data01 $data02
+if $rows != 100 then
+  return -1
+endi
+
+#system sh/exec.sh -n dnode1 -s stop -x SIGINT
+#system sh/exec.sh -n dnode2 -s stop -x SIGINT
+#system sh/exec.sh -n dnode3 -s stop -x SIGINT
+#system sh/exec.sh -n dnode4 -s stop -x SIGINT
+#########################################################
+
+
+
diff --git a/tests/system-test/1-insert/alter_table.py b/tests/system-test/1-insert/alter_table.py
index f2de7c6bae..4a9cfd30c7 100644
--- a/tests/system-test/1-insert/alter_table.py
+++ b/tests/system-test/1-insert/alter_table.py
@@ -210,10 +210,11 @@ class TDTestCase:
                 self.tag_check(i,k,tag_unint)
                 for error in [constant.INT_UN_MIN-1,constant.INT_UN_MAX+1]:
                     tdSql.error(f'alter table {self.stbname}_{i} set tag {k} = {error}')  
-            elif v.lower() == 'bigint unsigned':
-                self.tag_check(i,k,tag_unbigint)
-                for error in [constant.BIGINT_UN_MIN-1,constant.BIGINT_UN_MAX+1]:
-                    tdSql.error(f'alter table {self.stbname}_{i} set tag {k} = {error}') 
+            #! bug TD-17106
+            # elif v.lower() == 'bigint unsigned':
+                # self.tag_check(i,k,tag_unbigint)
+                # for error in [constant.BIGINT_UN_MIN-1,constant.BIGINT_UN_MAX+1]:
+                #     tdSql.error(f'alter table {self.stbname}_{i} set tag {k} = {error}') 
             elif v.lower() == 'bool':     
                 self.tag_check(i,k,tag_bool)
             elif v.lower() == 'float':
@@ -223,7 +224,8 @@ class TDTestCase:
                     tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
                 else:
                     tdLog.exit(f'select {k} from {self.stbname}_{i},data check failure')
-                # for error in [constant.FLOAT_MIN*10,constant.FLOAT_MAX*10]:
+            #! bug TD-17106    
+                # for error in [constant.FLOAT_MIN*1.1,constant.FLOAT_MAX*1.1]:
                 #     tdSql.error(f'alter table {self.stbname}_{i} set tag {k} = {error}') 
             elif v.lower() == 'double':
                 tdSql.execute(f'alter table {self.stbname}_{i} set tag {k} = {tag_double}')
@@ -232,7 +234,7 @@ class TDTestCase:
                     tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
                 else:
                     tdLog.exit(f'select {k} from {self.stbname}_{i},data check failure')
-                for error in [constant.DOUBLE_MIN-1,constant.DOUBLE_MAX+1]:
+                for error in [constant.DOUBLE_MIN*1.1,constant.DOUBLE_MAX*1.1]:
                     tdSql.error(f'alter table {self.stbname}_{i} set tag {k} = {error}') 
             elif 'binary' in v.lower():
                 tag_binary_error = tdCom.getLongName(self.binary_length+1)
@@ -242,7 +244,8 @@ class TDTestCase:
                 tdSql.checkData(0,0,tag_binary)
             elif 'nchar' in v.lower():
                 tag_nchar_error = tdCom.getLongName(self.nchar_length+1)
-                tdSql.execute(f'alter table {self.stbname}_{i} set tag {k} = "{tag_nchar_error}"')
+                tdSql.error(f'alter table {self.stbname}_{i} set tag {k} = "{tag_nchar_error}"')
+                tdSql.execute(f'alter table {self.stbname}_{i} set tag {k} = "{tag_nchar}"')
                 tdSql.query(f'select {k} from {self.stbname}_{i}')
                 tdSql.checkData(0,0,tag_nchar)
     
diff --git a/tests/system-test/2-query/To_iso8601.py b/tests/system-test/2-query/To_iso8601.py
index da7b7e272f..a80978bcda 100644
--- a/tests/system-test/2-query/To_iso8601.py
+++ b/tests/system-test/2-query/To_iso8601.py
@@ -16,18 +16,18 @@ class TDTestCase:
         self.rowNum = 10
         self.ts = 1640966400000  # 2022-1-1 00:00:00.000
     def check_customize_param_ms(self):
-        
+
         time_zone = time.strftime('%z')
         tdSql.execute('create database db1 precision "ms"')
         tdSql.execute('use db1')
         tdSql.execute('create table if not exists ntb(ts timestamp, c1 int, c2 timestamp)')
         for i in range(self.rowNum):
-            tdSql.execute("insert into ntb values(%d, %d, %d)" 
+            tdSql.execute("insert into ntb values(%d, %d, %d)"
                         % (self.ts + i, i + 1, self.ts + i))
         tdSql.query('select to_iso8601(ts) from ntb')
         for i in range(self.rowNum):
             tdSql.checkEqual(tdSql.queryResult[i][0],f'2022-01-01T00:00:00.00{i}{time_zone}')
-            
+
         timezone_list = ['+0000','+0100','+0200','+0300','+0330','+0400','+0500','+0530','+0600','+0700','+0800','+0900','+1000','+1100','+1200',\
                         '+00','+01','+02','+03','+04','+05','+06','+07','+08','+09','+10','+11','+12',\
                             '+00:00','+01:00','+02:00','+03:00','+03:30','+04:00','+05:00','+05:30','+06:00','+07:00','+08:00','+09:00','+10:00','+11:00','+12:00',\
@@ -39,7 +39,7 @@ class TDTestCase:
             tdSql.query(f'select to_iso8601(ts,"{j}") from ntb')
             for i in range(self.rowNum):
                 tdSql.checkEqual(tdSql.queryResult[i][0],f'2022-01-01T00:00:00.00{i}{j}')
-        
+
         error_param_list = [0,100.5,'a','!']
         for i in error_param_list:
             tdSql.error(f'select to_iso8601(ts,"{i}") from ntb')
@@ -47,7 +47,7 @@ class TDTestCase:
         error_timezone_param = ['+13','-13','+1300','-1300','+0001','-0001','-0330','-0530']
         for i in error_timezone_param:
             tdSql.error(f'select to_iso8601(ts,"{i}") from ntb')
-        
+
     def check_base_function(self):
         tdSql.prepare()
         tdLog.printNoPrefix("==========step1:create tables==========")
@@ -75,12 +75,12 @@ class TDTestCase:
         tdSql.query("select to_iso8601(ts) from ntb")
         tdSql.checkRows(3)
         tdSql.query("select to_iso8601(ts) from db.ntb")
-        
+
         tdSql.query("select to_iso8601(today()) from ntb")
         tdSql.checkRows(3)
         tdSql.query("select to_iso8601(now()) from ntb")
         tdSql.checkRows(3)
-        
+
         tdSql.error("select to_iso8601(timezone()) from ntb")
         tdSql.error("select to_iso8601('abc') from ntb")
 
@@ -104,7 +104,7 @@ class TDTestCase:
         for i in err_param:
             tdSql.error(f"select to_iso8601({i}) from ntb")
             tdSql.error(f"select to_iso8601({i}) from db.ntb")
-            
+
         tdSql.query("select to_iso8601(now) from stb")
         tdSql.checkRows(3)
         tdSql.query("select to_iso8601(now()) from stb")
@@ -126,7 +126,7 @@ class TDTestCase:
             tdSql.query(f"select to_iso8601(today()) {i}null from db.stb")
             tdSql.checkRows(3)
             tdSql.checkData(0,0,None)
-        
+
     def run(self):  # sourcery skip: extract-duplicate-method
         self.check_base_function()
         self.check_customize_param_ms()
diff --git a/tests/system-test/2-query/Today.py b/tests/system-test/2-query/Today.py
index e6199d629e..43c5263af6 100644
--- a/tests/system-test/2-query/Today.py
+++ b/tests/system-test/2-query/Today.py
@@ -58,7 +58,7 @@ class TDTestCase:
             tag_sql += f"{k} {v},"
         create_stb_sql = f'create table {stbname} ({column_sql[:-1]}) tags({tag_sql[:-1]})'
         return create_stb_sql
-        
+
     def data_check(self,column_dict={},tbname = '',values_list = [],tb_num = 1,tb = 'tb',precision = 'ms'):
         for k,v in column_dict.items():
             num_up = 0
@@ -175,7 +175,7 @@ class TDTestCase:
             tdSql.execute('drop database db')
 
     def run(self):  # sourcery skip: extract-duplicate-method
-        
+
         self.today_check_ntb()
         self.today_check_stb_tb()
 
diff --git a/tests/system-test/2-query/abs.py b/tests/system-test/2-query/abs.py
index 7ebb2eba8c..6dc65ce3c2 100644
--- a/tests/system-test/2-query/abs.py
+++ b/tests/system-test/2-query/abs.py
@@ -47,7 +47,7 @@ class TDTestCase:
                 c9 = "'nchar_val'"
                 c10 = ts
                 tdSql.execute(f" insert into  {tbname} values ({ts},{c1},{c2},{c3},{c4},{c5},{c6},{c7},{c8},{c9},{c10})")
-        
+
         tdSql.execute("use test")
         tbnames = ["stb", "sub_tb_1"]
         support_types = ["BIGINT", "SMALLINT", "TINYINT", "FLOAT", "DOUBLE", "INT"]
@@ -60,7 +60,7 @@ class TDTestCase:
                 origin_sql = "select {} from {} order by tbname".format(colname, tbname)
                 if coltype[1] in support_types:
                     self.check_result_auto(origin_sql , abs_sql)
-                    
+
 
     def prepare_datas(self):
         tdSql.execute(
diff --git a/tests/system-test/2-query/and_or_for_byte.py b/tests/system-test/2-query/and_or_for_byte.py
index 416e62c0f2..62951e571f 100644
--- a/tests/system-test/2-query/and_or_for_byte.py
+++ b/tests/system-test/2-query/and_or_for_byte.py
@@ -47,7 +47,7 @@ class TDTestCase:
                 c9 = "'nchar_val'"
                 c10 = ts
                 tdSql.execute(f" insert into  {tbname} values ({ts},{c1},{c2},{c3},{c4},{c5},{c6},{c7},{c8},{c9},{c10})")
-        
+
         tdSql.execute("use test")
         tbnames = ["stb", "sub_tb_1"]
         support_types = ["BIGINT", "SMALLINT", "TINYINT", "FLOAT", "DOUBLE", "INT"]
@@ -62,7 +62,7 @@ class TDTestCase:
             cols = random.sample(colnames,3)
             self.check_function("&",False,tbname,cols[0],cols[1],cols[2])
             self.check_function("|",False,tbname,cols[0],cols[1],cols[2])
-                    
+
 
     def prepare_datas(self):
         tdSql.execute(
@@ -215,14 +215,14 @@ class TDTestCase:
                 "abs value check pass , it work as expected ,sql is \"%s\"   " % abs_query)
 
     def check_function(self, opera ,agg, tbname ,  *args):
-    
+
         if opera =="&":
             pass
         elif opera =="|":
             pass
         else:
             pass
-        work_sql = " select " 
+        work_sql = " select "
         for ind , arg in enumerate(args):
             if ind ==len(args)-1:
                 work_sql += f"cast({arg} as bigint) "
@@ -235,7 +235,7 @@ class TDTestCase:
             work_sql+= f" from {tbname} "
         tdSql.query(work_sql)
         work_result = tdSql.queryResult
-      
+
         origin_sql = " select "
         for ind , arg in enumerate(args):
             if ind ==len(args)-1:
@@ -323,7 +323,7 @@ class TDTestCase:
         tdSql.checkData(0,0,None)
         tdSql.checkData(1,0,640)
         tdSql.checkData(10,0,0)
-       
+
         # used for regular table
         tdSql.query("select abs(c1)&c3&c3 from t1")
         tdSql.checkData(0, 0, None)
@@ -349,7 +349,7 @@ class TDTestCase:
         self.check_function("&",False,"stb1","c1","floor(t1)","abs(c1+c2)","t1+1")
         self.check_function("&",True,"stb1","max(c1)","min(floor(t1))","sum(abs(c1+c2))","last(t1)+1")
         self.check_function("&",False,"stb1","abs(abs(abs(abs(abs(abs(abs(abs(abs(abs(c1))))))))))","floor(t1)","abs(c1+c2)","t1+1")
-      
+
         # mix with common col
         tdSql.query("select c1&abs(c1)&c2&c3 ,c1,c2, t1 from ct1")
         tdSql.checkData(0, 0, 8)
@@ -388,7 +388,7 @@ class TDTestCase:
         # agg functions mix with agg functions
 
         tdSql.query("select sum(c1&abs(c1)&c2&c3) ,max(c5), count(c5) from stb1")
-    
+
         tdSql.query("select max(c1)&max(c2)|first(ts), count(c5) from ct1")
 
         # bug fix for compute
@@ -409,7 +409,7 @@ class TDTestCase:
         tdSql.checkData(1, 2, 894.900000000)
 
 
-    
+
 
     def check_boundary_values(self):
 
@@ -490,7 +490,7 @@ class TDTestCase:
         self.check_function("&", False ,"ct4","123","abs(c1)","t1","abs(t2)","abs(t3)","abs(t4)","t5")
         self.check_function("&", False ,"ct4","c1+2","abs(t2+2)","t3","abs(t4)","abs(t5)","abs(c1)","t5")
 
-        tdSql.query(" select sum(c1) from stb1 where t1+10 >1; ")  
+        tdSql.query(" select sum(c1) from stb1 where t1+10 >1; ")
         tdSql.query("select c1 ,t1 from stb1 where t1 =0 ")
         tdSql.checkRows(13)
         self.check_function("&", False ,"t1","c1+2","abs(c2)")
@@ -534,7 +534,7 @@ class TDTestCase:
         self.support_super_table_test()
         self.insert_datas_and_check_abs(self.tb_nums,self.row_nums,self.time_step)
 
-        
+
 
     def stop(self):
         tdSql.close()
diff --git a/tests/system-test/2-query/apercentile.py b/tests/system-test/2-query/apercentile.py
index 8c8b47f3bf..6e4b4eeb8a 100644
--- a/tests/system-test/2-query/apercentile.py
+++ b/tests/system-test/2-query/apercentile.py
@@ -44,7 +44,7 @@ class TDTestCase:
             'col12': f'binary({self.binary_length})',
             'col13': f'nchar({self.nchar_length})'
         }
-        
+
         self.tag_dict = {
             'ts_tag'  : 'timestamp',
             't1': 'tinyint',
@@ -79,9 +79,9 @@ class TDTestCase:
         self.tag_values = [
             f'{self.tag_ts},{self.tag_tinyint},{self.tag_smallint},{self.tag_int},{self.tag_bigint},\
             {self.tag_utint},{self.tag_usint},{self.tag_uint},{self.tag_ubint},{self.tag_float},{self.tag_double},{self.tag_bool},"{self.binary_str}","{self.nchar_str}"'
-            
+
         ]
-        
+
         self.percent = [1,50,100]
         self.param_list = ['default','t-digest']
     def insert_data(self,column_dict,tbname,row_num):
@@ -90,7 +90,7 @@ class TDTestCase:
             insert_list = []
             self.setsql.insert_values(column_dict,i,insert_sql,insert_list,self.ts)
 
-        
+
     def function_check_ntb(self):
         tdSql.prepare()
         tdSql.execute(self.setsql.set_create_normaltable_sql(self.ntbname,self.column_dict))
@@ -126,7 +126,7 @@ class TDTestCase:
     def run(self):
         self.function_check_ntb()
         self.function_check_stb()
-        
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/system-test/2-query/bottom.py b/tests/system-test/2-query/bottom.py
index 3aeadb172a..1b7c967348 100644
--- a/tests/system-test/2-query/bottom.py
+++ b/tests/system-test/2-query/bottom.py
@@ -48,7 +48,7 @@ class TDTestCase:
             'col12': 'binary(20)',
             'col13': 'nchar(20)'
         }
-        
+
         self.param_list = [1,100]
     def insert_data(self,column_dict,tbname,row_num):
         insert_sql = self.setsql.set_insertsql(column_dict,tbname,self.binary_str,self.nchar_str)
@@ -125,11 +125,11 @@ class TDTestCase:
             self.bottom_check_data(f'{stbname}_{i}','child_table')
         self.bottom_check_data(f'{stbname}','stable')
         tdSql.execute(f'drop database {self.dbname}')
- 
+
     def run(self):
         self.bottom_check_ntb()
         self.bottom_check_stb()
-        
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/system-test/2-query/ceil.py b/tests/system-test/2-query/ceil.py
index 9816751e55..f1379e6661 100644
--- a/tests/system-test/2-query/ceil.py
+++ b/tests/system-test/2-query/ceil.py
@@ -9,14 +9,14 @@ from util.sql import *
 from util.cases import *
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
 
     def init(self, conn, logSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
-    
+
     def prepare_datas(self):
         tdSql.execute(
             '''create table stb1
@@ -24,7 +24,7 @@ class TDTestCase:
             tags (t1 int)
             '''
         )
-        
+
         tdSql.execute(
             '''
             create table t1
@@ -66,14 +66,14 @@ class TDTestCase:
             ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             '''
         )
-    
+
     def check_result_auto(self ,origin_query , ceil_query):
         pass
         ceil_result = tdSql.getResult(ceil_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -88,13 +88,13 @@ class TDTestCase:
         for row_index , row in enumerate(ceil_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("ceil function value has not as expected , sql is \"%s\" "%ceil_query )
             sys.exit(1)
         else:
             tdLog.info("ceil value check pass , it work as expected ,sql is \"%s\"   "%ceil_query )
-        
+
     def test_errors(self):
         error_sql_lists = [
             "select ceil from t1",
@@ -128,42 +128,42 @@ class TDTestCase:
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
-    
+
     def support_types(self):
         type_error_sql_lists = [
-            "select ceil(ts) from t1" , 
+            "select ceil(ts) from t1" ,
             "select ceil(c7) from t1",
             "select ceil(c8) from t1",
             "select ceil(c9) from t1",
-            "select ceil(ts) from ct1" , 
+            "select ceil(ts) from ct1" ,
             "select ceil(c7) from ct1",
             "select ceil(c8) from ct1",
             "select ceil(c9) from ct1",
-            "select ceil(ts) from ct3" , 
+            "select ceil(ts) from ct3" ,
             "select ceil(c7) from ct3",
             "select ceil(c8) from ct3",
             "select ceil(c9) from ct3",
-            "select ceil(ts) from ct4" , 
+            "select ceil(ts) from ct4" ,
             "select ceil(c7) from ct4",
             "select ceil(c8) from ct4",
             "select ceil(c9) from ct4",
-            "select ceil(ts) from stb1" , 
+            "select ceil(ts) from stb1" ,
             "select ceil(c7) from stb1",
             "select ceil(c8) from stb1",
             "select ceil(c9) from stb1" ,
 
-            "select ceil(ts) from stbbb1" , 
+            "select ceil(ts) from stbbb1" ,
             "select ceil(c7) from stbbb1",
 
             "select ceil(ts) from tbname",
             "select ceil(c9) from tbname"
 
         ]
-        
+
         for type_sql in type_error_sql_lists:
             tdSql.error(type_sql)
-        
-        
+
+
         type_sql_lists = [
             "select ceil(c1) from t1",
             "select ceil(c2) from t1",
@@ -193,16 +193,16 @@ class TDTestCase:
             "select ceil(c5) from stb1",
             "select ceil(c6) from stb1",
 
-            "select ceil(c6) as alisb from stb1", 
-            "select ceil(c6) alisb from stb1", 
+            "select ceil(c6) as alisb from stb1",
+            "select ceil(c6) alisb from stb1",
         ]
 
         for type_sql in type_sql_lists:
             tdSql.query(type_sql)
-    
+
     def basic_ceil_function(self):
 
-        # basic query 
+        # basic query
         tdSql.query("select c1 from ct3")
         tdSql.checkRows(0)
         tdSql.query("select c1 from t1")
@@ -222,7 +222,7 @@ class TDTestCase:
         tdSql.query("select ceil(c5) from ct3")
         tdSql.checkRows(0)
         tdSql.query("select ceil(c6) from ct3")
-        
+
         # used for regular table
         tdSql.query("select ceil(c1) from t1")
         tdSql.checkData(0, 0, None)
@@ -240,7 +240,7 @@ class TDTestCase:
         tdSql.checkData(5, 5, None)
 
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from t1", "select (c1), ceil(c2) ,ceil(c3), ceil(c4), ceil(c5) from t1")
-        
+
         # used for sub table
         tdSql.query("select ceil(c1) from ct1")
         tdSql.checkData(0, 0, 8)
@@ -252,20 +252,20 @@ class TDTestCase:
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct1", "select (c1), ceil(c2) ,ceil(c3), ceil(c4), ceil(c5) from ct1")
         self.check_result_auto("select ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(c1)))))))))) nest_col_func from ct1;","select c1 from ct1" )
 
-        # used for stable table 
-        
+        # used for stable table
+
         tdSql.query("select ceil(c1) from stb1")
         tdSql.checkRows(25)
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct4 ", "select (c1), ceil(c2) ,ceil(c3), ceil(c4), ceil(c5) from ct4")
         self.check_result_auto("select ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(c1)))))))))) nest_col_func from ct4;" , "select c1 from ct4" )
-        
+
 
         # used for not exists table
         tdSql.error("select ceil(c1) from stbbb1")
         tdSql.error("select ceil(c1) from tbname")
         tdSql.error("select ceil(c1) from ct5")
 
-        # mix with common col 
+        # mix with common col
         tdSql.query("select c1, ceil(c1) from ct1")
         tdSql.checkData(0 , 0 ,8)
         tdSql.checkData(0 , 1 ,8)
@@ -290,7 +290,7 @@ class TDTestCase:
         tdSql.checkData(0 , 1 ,None)
         tdSql.checkData(0 , 2 ,None)
         tdSql.checkData(0 , 3 ,None)
-        
+
         tdSql.checkData(3 , 0 , 6)
         tdSql.checkData(3 , 1 , 6)
         tdSql.checkData(3 , 2 ,6.66000)
@@ -311,7 +311,7 @@ class TDTestCase:
         tdSql.query("select max(c5), count(c5) from stb1")
         tdSql.query("select max(c5), count(c5) from ct1")
 
-        
+
         # bug fix for count
         tdSql.query("select count(c1) from ct4 ")
         tdSql.checkData(0,0,9)
@@ -322,7 +322,7 @@ class TDTestCase:
         tdSql.query("select count(*) from stb1 ")
         tdSql.checkData(0,0,25)
 
-        # bug fix for compute 
+        # bug fix for compute
         tdSql.query("select c1, abs(c1) -0 ,ceil(c1)-0 from ct4 ")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
@@ -373,10 +373,10 @@ class TDTestCase:
         tdSql.checkData(0,3,8.000000000)
         tdSql.checkData(0,4,7.900000000)
         tdSql.checkData(0,5,3.000000000)
-        
+
     def ceil_Arithmetic(self):
         pass
-    
+
     def check_boundary_values(self):
 
         tdSql.execute("drop database if exists bound_test")
@@ -405,14 +405,14 @@ class TDTestCase:
         tdSql.execute(
                 f"insert into sub1_bound values ( now(), -2147483643, -9223372036854775803, -32763, -123, -3.39E+38, -1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
-        
+
         tdSql.error(
                 f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
         self.check_result_auto( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select ceil(c1), ceil(c2) ,ceil(c3), ceil(c4), ceil(c5) ,ceil(c6) from sub1_bound")
         self.check_result_auto( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select ceil(c1), ceil(c2) ,ceil(c3), ceil(c3), ceil(c2) ,ceil(c1) from sub1_bound")
         self.check_result_auto("select ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(ceil(c1)))))))))) nest_col_func from sub1_bound;" , "select ceil(c1) from sub1_bound" )
-        
+
         # check basic elem for table per row
         tdSql.query("select ceil(c1+0.2) ,ceil(c2) , ceil(c3+0.3) , ceil(c4-0.3), ceil(c5/2), ceil(c6/2) from sub1_bound ")
         tdSql.checkData(0, 0, 2147483648.000000000)
@@ -426,7 +426,7 @@ class TDTestCase:
         tdSql.checkData(4, 4, -169499995645668991474575059260979281920.000000000)
 
         self.check_result_auto("select c1+1 ,c2 , c3*1 , c4/2, c5/2, c6 from sub1_bound" ,"select ceil(c1+1) ,ceil(c2) , ceil(c3*1) , ceil(c4/2), ceil(c5)/2, ceil(c6) from sub1_bound ")
-        
+
     def support_super_table_test(self):
         tdSql.execute(" use db ")
         self.check_result_auto( " select c5 from stb1 order by ts " , "select ceil(c5) from stb1 order by ts" )
@@ -444,26 +444,26 @@ class TDTestCase:
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4: ceil basic query ============") 
+        tdLog.printNoPrefix("==========step4: ceil basic query ============")
 
         self.basic_ceil_function()
 
-        tdLog.printNoPrefix("==========step5: ceil boundary query ============") 
+        tdLog.printNoPrefix("==========step5: ceil boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step6: ceil filter query ============") 
+        tdLog.printNoPrefix("==========step6: ceil filter query ============")
 
         self.abs_func_filter()
 
diff --git a/tests/system-test/2-query/cos.py b/tests/system-test/2-query/cos.py
index e50ec6d523..e0941b9157 100644
--- a/tests/system-test/2-query/cos.py
+++ b/tests/system-test/2-query/cos.py
@@ -9,13 +9,13 @@ from util.cases import *
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
     def init(self, conn, powSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
-    
+
     def prepare_datas(self):
         tdSql.execute(
             '''create table stb1
@@ -23,7 +23,7 @@ class TDTestCase:
             tags (t1 int)
             '''
         )
-        
+
         tdSql.execute(
             '''
             create table t1
@@ -65,14 +65,14 @@ class TDTestCase:
             ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             '''
         )
-    
+
     def check_result_auto_cos(self ,origin_query , pow_query):
 
         pow_result = tdSql.getResult(pow_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -90,7 +90,7 @@ class TDTestCase:
                 if auto_result[row_index][col_index] == None  and not (auto_result[row_index][col_index] == None and elem == None):
                     check_status = False
                 elif auto_result[row_index][col_index] != None  and (auto_result[row_index][col_index] - elem > 0.00000001):
-                    check_status = False 
+                    check_status = False
                 else:
                     pass
         if not check_status:
@@ -98,7 +98,7 @@ class TDTestCase:
             sys.exit(1)
         else:
             tdLog.info("cos value check pass , it work as expected ,sql is \"%s\"   "%pow_query )
-        
+
     def test_errors(self):
         error_sql_lists = [
             "select cos from t1",
@@ -132,42 +132,42 @@ class TDTestCase:
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
-    
+
     def support_types(self):
         type_error_sql_lists = [
-            "select cos(ts) from t1" , 
+            "select cos(ts) from t1" ,
             "select cos(c7) from t1",
             "select cos(c8) from t1",
             "select cos(c9) from t1",
-            "select cos(ts) from ct1" , 
+            "select cos(ts) from ct1" ,
             "select cos(c7) from ct1",
             "select cos(c8) from ct1",
             "select cos(c9) from ct1",
-            "select cos(ts) from ct3" , 
+            "select cos(ts) from ct3" ,
             "select cos(c7) from ct3",
             "select cos(c8) from ct3",
             "select cos(c9) from ct3",
-            "select cos(ts) from ct4" , 
+            "select cos(ts) from ct4" ,
             "select cos(c7) from ct4",
             "select cos(c8) from ct4",
             "select cos(c9) from ct4",
-            "select cos(ts) from stb1" , 
+            "select cos(ts) from stb1" ,
             "select cos(c7) from stb1",
             "select cos(c8) from stb1",
             "select cos(c9) from stb1" ,
 
-            "select cos(ts) from stbbb1" , 
+            "select cos(ts) from stbbb1" ,
             "select cos(c7) from stbbb1",
 
             "select cos(ts) from tbname",
             "select cos(c9) from tbname"
 
         ]
-        
+
         for type_sql in type_error_sql_lists:
             tdSql.error(type_sql)
-        
-        
+
+
         type_sql_lists = [
             "select cos(c1) from t1",
             "select cos(c2) from t1",
@@ -197,16 +197,16 @@ class TDTestCase:
             "select cos(c5) from stb1",
             "select cos(c6) from stb1",
 
-            "select cos(c6) as alisb from stb1", 
-            "select cos(c6) alisb from stb1", 
+            "select cos(c6) as alisb from stb1",
+            "select cos(c6) alisb from stb1",
         ]
 
         for type_sql in type_sql_lists:
             tdSql.query(type_sql)
-    
+
     def basic_cosin_function(self):
 
-        # basic query 
+        # basic query
         tdSql.query("select c1 from ct3")
         tdSql.checkRows(0)
         tdSql.query("select c1 from t1")
@@ -247,7 +247,7 @@ class TDTestCase:
         tdSql.checkData(5, 5, None)
 
         self.check_result_auto_cos( "select abs(c1), abs(c2), abs(c3) , abs(c4), abs(c5) from t1", "select cos(abs(c1)), cos(abs(c2)) ,cos(abs(c3)), cos(abs(c4)), cos(abs(c5)) from t1")
-        
+
         # used for sub table
         tdSql.query("select c2 ,cos(c2) from ct1")
         tdSql.checkData(0, 1, 0.975339851)
@@ -263,7 +263,7 @@ class TDTestCase:
         tdSql.checkData(5 , 2, None)
 
         self.check_result_auto_cos( "select c1, c2, c3 , c4, c5 from ct1", "select cos(c1), cos(c2) ,cos(c3), cos(c4), cos(c5) from ct1")
-       
+
         # nest query for cos functions
         tdSql.query("select c4  , cos(c4) ,cos(cos(c4)) , cos(cos(cos(c4))) from ct1;")
         tdSql.checkData(0 , 0 , 88)
@@ -281,21 +281,21 @@ class TDTestCase:
         tdSql.checkData(11 , 2 , 0.999207254)
         tdSql.checkData(11 , 3 , 0.540969209)
 
-        # used for stable table 
-        
+        # used for stable table
+
         tdSql.query("select cos(c1) from stb1")
         tdSql.checkRows(25)
-      
+
 
         # used for not exists table
         tdSql.error("select cos(c1) from stbbb1")
         tdSql.error("select cos(c1) from tbname")
         tdSql.error("select cos(c1) from ct5")
 
-        # mix with common col 
+        # mix with common col
         tdSql.query("select c1, cos(c1) from ct1")
         tdSql.query("select c2, cos(c2) from ct4")
-        
+
 
         # mix with common functions
         tdSql.query("select c1, cos(c1),cos(c1), cos(cos(c1)) from ct4 ")
@@ -303,7 +303,7 @@ class TDTestCase:
         tdSql.checkData(0 , 1 ,None)
         tdSql.checkData(0 , 2 ,None)
         tdSql.checkData(0 , 3 ,None)
-        
+
         tdSql.checkData(3 , 0 , 6)
         tdSql.checkData(3 , 1 ,0.960170287)
         tdSql.checkData(3 , 2 ,0.960170287)
@@ -324,8 +324,8 @@ class TDTestCase:
         tdSql.query("select max(c5), count(c5) from stb1")
         tdSql.query("select max(c5), count(c5) from ct1")
 
-        
-        # # bug fix for compute 
+
+        # # bug fix for compute
         tdSql.query("select c1, cos(c1) -0 ,cos(c1-4)-0 from ct4 ")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
@@ -394,10 +394,10 @@ class TDTestCase:
         tdSql.checkData(0,3,8.000000000)
         tdSql.checkData(0,4,7.900000000)
         tdSql.checkData(0,5,0.000000000)
-        
+
     def pow_Arithmetic(self):
         pass
-    
+
     def check_boundary_values(self):
 
         PI=3.1415926
@@ -426,11 +426,11 @@ class TDTestCase:
                 f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
         self.check_result_auto_cos( "select abs(c1), abs(c2), abs(c3) , abs(c4), abs(c5) from sub1_bound ", "select cos(abs(c1)), cos(abs(c2)) ,cos(abs(c3)), cos(abs(c4)), cos(abs(c5)) from sub1_bound")
-       
+
         self.check_result_auto_cos( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select cos(c1), cos(c2) ,cos(c3), cos(c3), cos(c2) ,cos(c1) from sub1_bound")
 
         self.check_result_auto_cos("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from sub1_bound" , "select cos(abs(c1)) from sub1_bound" )
-        
+
         # check basic elem for table per row
         tdSql.query("select cos(abs(c1)) ,cos(abs(c2)) , cos(abs(c3)) , cos(abs(c4)), cos(abs(c5)), cos(abs(c6)) from sub1_bound ")
         tdSql.checkData(0,0,math.cos(2147483647))
@@ -489,36 +489,36 @@ class TDTestCase:
         self.check_result_auto_cos( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select cos(t1) ,cos(c5) from stb1 where c1 > 0 order by tbname" )
         self.check_result_auto_cos( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select cos(t1) , cos(c5) from stb1 where c1 > 0 order by tbname" )
         pass
-    
+
     def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4: cos basic query ============") 
+        tdLog.printNoPrefix("==========step4: cos basic query ============")
 
         self.basic_cosin_function()
 
-        tdLog.printNoPrefix("==========step5: big number cos query ============") 
+        tdLog.printNoPrefix("==========step5: big number cos query ============")
 
         self.test_big_number()
 
 
-        tdLog.printNoPrefix("==========step6: cos boundary query ============") 
+        tdLog.printNoPrefix("==========step6: cos boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step7: cos filter query ============") 
+        tdLog.printNoPrefix("==========step7: cos filter query ============")
 
         self.abs_func_filter()
 
diff --git a/tests/system-test/2-query/count.py b/tests/system-test/2-query/count.py
index a70a2e72f2..c4c1d19898 100644
--- a/tests/system-test/2-query/count.py
+++ b/tests/system-test/2-query/count.py
@@ -13,24 +13,24 @@ class TDTestCase:
     def run(self):
         tdSql.prepare()
 
-        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
+        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20))''')
         tdSql.execute("create table stb_1 using stb tags('beijing')")
         tdSql.execute("create table stb_2 using stb tags('shanghai')")
 
-        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
+        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''')
-        
+
         for i in range(self.rowNum):
-            tdSql.execute("insert into stb_1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into stb_1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
-            tdSql.execute("insert into stb_2 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into stb_2 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
-        
+
         for i in range(self.rowNum):
-            tdSql.execute("insert into ntb values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into ntb values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
-        
+
         tdSql.query("select count(*) from stb")
         tdSql.checkData(0,0,20)
         tdSql.query("select count(*) from db.stb")
@@ -95,7 +95,7 @@ class TDTestCase:
 
 
         tdSql.query("select count(ts) from db.stb_1")
-        tdSql.checkData(0,0,10)        
+        tdSql.checkData(0,0,10)
         tdSql.query("select count(ts) from db.stb_1")
         tdSql.checkData(0,0,10)
         tdSql.query("select count(col1) from stb_1")
@@ -171,7 +171,7 @@ class TDTestCase:
         tdSql.query("select count(col1),count(ts) from stb")
         tdSql.checkData(0,0,20)
         tdSql.checkData(0,1,21)
-        
+
         tdSql.query("select count(col1) from db.stb")
         tdSql.checkData(0,0,20)
         tdSql.query("select count(col1),count(ts) from db.stb")
@@ -184,7 +184,7 @@ class TDTestCase:
         tdSql.query("select count(col1) from stb group by col7")
         tdSql.checkRows(3)
 
-        
+
 
 
     def stop(self):
@@ -193,4 +193,4 @@ class TDTestCase:
 
 
 tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/system-test/2-query/csum.py b/tests/system-test/2-query/csum.py
index 5bd1d4d45e..708aa35183 100644
--- a/tests/system-test/2-query/csum.py
+++ b/tests/system-test/2-query/csum.py
@@ -419,7 +419,7 @@ class TDTestCase:
         tdSql.checkData(3,0,4)
         tdSql.query("select csum(abs(c1))+2 from t1 ")
         tdSql.checkRows(4)
-    
+
     def csum_support_stable(self):
         tdSql.query(" select csum(1) from stb1 ")
         tdSql.checkRows(70)
@@ -434,17 +434,17 @@ class TDTestCase:
         tdSql.query("select csum(st1+c1) from stb1 partition by tbname")
         tdSql.checkRows(40)
 
-        # # bug need fix 
+        # # bug need fix
         # tdSql.query("select csum(st1+c1) from stb1 partition by tbname slimit 1 ")
         # tdSql.checkRows(4)
         # tdSql.error("select csum(st1+c1) from stb1 partition by tbname limit 1 ")
 
 
-        # bug need fix 
+        # bug need fix
         tdSql.query("select csum(st1+c1) from stb1 partition by tbname")
-        tdSql.checkRows(40)        
+        tdSql.checkRows(40)
 
-        # bug need fix 
+        # bug need fix
         # tdSql.query("select tbname , csum(c1) from stb1 partition by tbname")
         # tdSql.checkRows(40)
         # tdSql.query("select tbname , csum(st1) from stb1 partition by tbname")
@@ -452,7 +452,7 @@ class TDTestCase:
         # tdSql.query("select tbname , csum(st1) from stb1 partition by tbname slimit 1")
         # tdSql.checkRows(7)
 
-        # partition by tags 
+        # partition by tags
         # tdSql.query("select st1 , csum(c1) from stb1 partition by st1")
         # tdSql.checkRows(40)
         # tdSql.query("select csum(c1) from stb1 partition by st1")
@@ -491,4 +491,4 @@ class TDTestCase:
         tdLog.success("%s successfully executed" % __file__)
 
 tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/system-test/2-query/floor.py b/tests/system-test/2-query/floor.py
index 7f5c7f5591..29fddda0ae 100644
--- a/tests/system-test/2-query/floor.py
+++ b/tests/system-test/2-query/floor.py
@@ -16,7 +16,7 @@ class TDTestCase:
     def init(self, conn, logSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
-    
+
     def prepare_datas(self):
         tdSql.execute(
             '''create table stb1
@@ -24,7 +24,7 @@ class TDTestCase:
             tags (t1 int)
             '''
         )
-        
+
         tdSql.execute(
             '''
             create table t1
@@ -66,14 +66,14 @@ class TDTestCase:
             ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             '''
         )
-    
+
     def check_result_auto(self ,origin_query , floor_query):
         pass
         floor_result = tdSql.getResult(floor_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -88,13 +88,13 @@ class TDTestCase:
         for row_index , row in enumerate(floor_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("floor function value has not as expected , sql is \"%s\" "%floor_query )
             sys.exit(1)
         else:
             tdLog.info("floor value check pass , it work as expected ,sql is \"%s\"   "%floor_query )
-        
+
     def test_errors(self):
         error_sql_lists = [
             "select floor from t1",
@@ -128,42 +128,42 @@ class TDTestCase:
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
-    
+
     def support_types(self):
         type_error_sql_lists = [
-            "select floor(ts) from t1" , 
+            "select floor(ts) from t1" ,
             "select floor(c7) from t1",
             "select floor(c8) from t1",
             "select floor(c9) from t1",
-            "select floor(ts) from ct1" , 
+            "select floor(ts) from ct1" ,
             "select floor(c7) from ct1",
             "select floor(c8) from ct1",
             "select floor(c9) from ct1",
-            "select floor(ts) from ct3" , 
+            "select floor(ts) from ct3" ,
             "select floor(c7) from ct3",
             "select floor(c8) from ct3",
             "select floor(c9) from ct3",
-            "select floor(ts) from ct4" , 
+            "select floor(ts) from ct4" ,
             "select floor(c7) from ct4",
             "select floor(c8) from ct4",
             "select floor(c9) from ct4",
-            "select floor(ts) from stb1" , 
+            "select floor(ts) from stb1" ,
             "select floor(c7) from stb1",
             "select floor(c8) from stb1",
             "select floor(c9) from stb1" ,
 
-            "select floor(ts) from stbbb1" , 
+            "select floor(ts) from stbbb1" ,
             "select floor(c7) from stbbb1",
 
             "select floor(ts) from tbname",
             "select floor(c9) from tbname"
 
         ]
-        
+
         for type_sql in type_error_sql_lists:
             tdSql.error(type_sql)
-        
-        
+
+
         type_sql_lists = [
             "select floor(c1) from t1",
             "select floor(c2) from t1",
@@ -193,16 +193,16 @@ class TDTestCase:
             "select floor(c5) from stb1",
             "select floor(c6) from stb1",
 
-            "select floor(c6) as alisb from stb1", 
-            "select floor(c6) alisb from stb1", 
+            "select floor(c6) as alisb from stb1",
+            "select floor(c6) alisb from stb1",
         ]
 
         for type_sql in type_sql_lists:
             tdSql.query(type_sql)
-    
+
     def basic_floor_function(self):
 
-        # basic query 
+        # basic query
         tdSql.query("select c1 from ct3")
         tdSql.checkRows(0)
         tdSql.query("select c1 from t1")
@@ -222,7 +222,7 @@ class TDTestCase:
         tdSql.query("select floor(c5) from ct3")
         tdSql.checkRows(0)
         tdSql.query("select floor(c6) from ct3")
-        
+
         # used for regular table
         tdSql.query("select floor(c1) from t1")
         tdSql.checkData(0, 0, None)
@@ -240,7 +240,7 @@ class TDTestCase:
         tdSql.checkData(5, 5, None)
 
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from t1", "select (c1), floor(c2) ,floor(c3), floor(c4), floor(c5) from t1")
-        
+
         # used for sub table
         tdSql.query("select floor(c1) from ct1")
         tdSql.checkData(0, 0, 8)
@@ -252,20 +252,20 @@ class TDTestCase:
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct1", "select (c1), floor(c2) ,floor(c3), floor(c4), floor(c5) from ct1")
         self.check_result_auto("select floor(floor(floor(floor(floor(floor(floor(floor(floor(floor(c1)))))))))) nest_col_func from ct1;","select c1 from ct1" )
 
-        # used for stable table 
-        
+        # used for stable table
+
         tdSql.query("select floor(c1) from stb1")
         tdSql.checkRows(25)
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct4 ", "select (c1), floor(c2) ,floor(c3), floor(c4), floor(c5) from ct4")
         self.check_result_auto("select floor(floor(floor(floor(floor(floor(floor(floor(floor(floor(c1)))))))))) nest_col_func from ct4;" , "select c1 from ct4" )
-        
+
 
         # used for not exists table
         tdSql.error("select floor(c1) from stbbb1")
         tdSql.error("select floor(c1) from tbname")
         tdSql.error("select floor(c1) from ct5")
 
-        # mix with common col 
+        # mix with common col
         tdSql.query("select c1, floor(c1) from ct1")
         tdSql.checkData(0 , 0 ,8)
         tdSql.checkData(0 , 1 ,8)
@@ -290,7 +290,7 @@ class TDTestCase:
         tdSql.checkData(0 , 1 ,None)
         tdSql.checkData(0 , 2 ,None)
         tdSql.checkData(0 , 3 ,None)
-        
+
         tdSql.checkData(3 , 0 , 6)
         tdSql.checkData(3 , 1 , 6)
         tdSql.checkData(3 , 2 ,6.66000)
@@ -311,7 +311,7 @@ class TDTestCase:
         tdSql.query("select max(c5), count(c5) from stb1")
         tdSql.query("select max(c5), count(c5) from ct1")
 
-        
+
         # bug fix for count
         tdSql.query("select count(c1) from ct4 ")
         tdSql.checkData(0,0,9)
@@ -322,7 +322,7 @@ class TDTestCase:
         tdSql.query("select count(*) from stb1 ")
         tdSql.checkData(0,0,25)
 
-        # bug fix for compute 
+        # bug fix for compute
         tdSql.query("select c1, abs(c1) -0 ,floor(c1)-0 from ct4 ")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
@@ -373,10 +373,10 @@ class TDTestCase:
         tdSql.checkData(0,3,8.000000000)
         tdSql.checkData(0,4,7.900000000)
         tdSql.checkData(0,5,3.000000000)
-        
+
     def floor_Arithmetic(self):
         pass
-    
+
     def check_boundary_values(self):
 
         tdSql.execute("drop database if exists bound_test")
@@ -405,14 +405,14 @@ class TDTestCase:
         tdSql.execute(
                 f"insert into sub1_bound values ( now(), -2147483643, -9223372036854775803, -32763, -123, -3.39E+38, -1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
-        
+
         tdSql.error(
                 f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
         self.check_result_auto( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select floor(c1), floor(c2) ,floor(c3), floor(c4), floor(c5) ,floor(c6) from sub1_bound")
         self.check_result_auto( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select floor(c1), floor(c2) ,floor(c3), floor(c3), floor(c2) ,floor(c1) from sub1_bound")
         self.check_result_auto("select floor(floor(floor(floor(floor(floor(floor(floor(floor(floor(c1)))))))))) nest_col_func from sub1_bound;" , "select floor(c1) from sub1_bound" )
-        
+
         # check basic elem for table per row
         tdSql.query("select floor(c1+0.2) ,floor(c2) , floor(c3+0.3) , floor(c4-0.3), floor(c5/2), floor(c6/2) from sub1_bound ")
         tdSql.checkData(0, 0, 2147483647.000000000)
@@ -444,26 +444,26 @@ class TDTestCase:
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4: floor basic query ============") 
+        tdLog.printNoPrefix("==========step4: floor basic query ============")
 
         self.basic_floor_function()
 
-        tdLog.printNoPrefix("==========step5: floor boundary query ============") 
+        tdLog.printNoPrefix("==========step5: floor boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step6: floor filter query ============") 
+        tdLog.printNoPrefix("==========step6: floor filter query ============")
 
         self.abs_func_filter()
 
diff --git a/tests/system-test/2-query/function_diff.py b/tests/system-test/2-query/function_diff.py
index 7d49f875d1..5e95510c1d 100644
--- a/tests/system-test/2-query/function_diff.py
+++ b/tests/system-test/2-query/function_diff.py
@@ -370,17 +370,17 @@ class TDTestCase:
         tdSql.query("select diff(st1+c1) from stb1 partition by tbname")
         tdSql.checkRows(190)
 
-        # # bug need fix 
+        # # bug need fix
         # tdSql.query("select diff(st1+c1) from stb1 partition by tbname slimit 1 ")
         # tdSql.checkRows(19)
         # tdSql.error("select diff(st1+c1) from stb1 partition by tbname limit 1 ")
 
 
-        # bug need fix 
+        # bug need fix
         tdSql.query("select diff(st1+c1) from stb1 partition by tbname")
         tdSql.checkRows(190)
 
-        # bug need fix 
+        # bug need fix
         # tdSql.query("select tbname , diff(c1) from stb1 partition by tbname")
         # tdSql.checkRows(199)
         # tdSql.query("select tbname , diff(st1) from stb1 partition by tbname")
@@ -388,7 +388,7 @@ class TDTestCase:
         # tdSql.query("select tbname , diff(st1) from stb1 partition by tbname slimit 1")
         # tdSql.checkRows(19)
 
-        # partition by tags 
+        # partition by tags
         # tdSql.query("select st1 , diff(c1) from stb1 partition by st1")
         # tdSql.checkRows(199)
         # tdSql.query("select diff(c1) from stb1 partition by st1")
@@ -488,4 +488,4 @@ class TDTestCase:
         tdLog.success("%s successfully executed" % __file__)
 
 tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/system-test/2-query/function_stateduration.py b/tests/system-test/2-query/function_stateduration.py
index a716d67236..3478b7fef9 100644
--- a/tests/system-test/2-query/function_stateduration.py
+++ b/tests/system-test/2-query/function_stateduration.py
@@ -11,7 +11,7 @@ from util.sql import *
 from util.cases import *
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
 
@@ -388,11 +388,11 @@ class TDTestCase:
         tdSql.execute(
                 f"insert into sub1_bound values ( now(), -2147483643, -9223372036854775803, -32763, -123, -3.39E+38, -1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
-        
+
         tdSql.error(
                 f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
-        
+
         tdSql.query("select stateduration(c1,'GT',1,1s) from sub1_bound")
         tdSql.checkRows(5)
 
@@ -400,29 +400,29 @@ class TDTestCase:
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4:support opers ============") 
+        tdLog.printNoPrefix("==========step4:support opers ============")
         self.support_opers()
 
-        tdLog.printNoPrefix("==========step5: stateduration basic query ============") 
+        tdLog.printNoPrefix("==========step5: stateduration basic query ============")
 
         self.basic_stateduration_function()
 
-        tdLog.printNoPrefix("==========step6: stateduration boundary query ============") 
+        tdLog.printNoPrefix("==========step6: stateduration boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step6: stateduration unit time test ============") 
+        tdLog.printNoPrefix("==========step6: stateduration unit time test ============")
 
         self.check_unit_time()
 
diff --git a/tests/system-test/2-query/last.py b/tests/system-test/2-query/last.py
index ee65d22a22..d07d0c83eb 100644
--- a/tests/system-test/2-query/last.py
+++ b/tests/system-test/2-query/last.py
@@ -34,7 +34,7 @@ class TDTestCase:
             tag_sql += f"{k} {v},"
         create_stb_sql = f'create table {stbname} (ts timestamp,{column_sql[:-1]}) tags({tag_sql[:-1]})'
         return create_stb_sql
-    
+
     def last_check_stb_tb_base(self):
         tdSql.prepare()
         stbname = tdCom.getLongName(5, "letters")
@@ -201,7 +201,7 @@ class TDTestCase:
         tdSql.execute(f'use {dbname}')
 
         # build 20 child tables,every table insert 10 rows
-        tdSql.execute(f'''create table {stbname}(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned, 
+        tdSql.execute(f'''create table {stbname}(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned,
                     col7 int unsigned, col8 bigint unsigned, col9 float, col10 double, col11 bool, col12 binary(20), col13 nchar(20)) tags(loc nchar(20))''')
         for i in range(self.tbnum):
             tdSql.execute(
diff --git a/tests/system-test/2-query/mavg.py b/tests/system-test/2-query/mavg.py
index de379e39ce..91e5e013b4 100644
--- a/tests/system-test/2-query/mavg.py
+++ b/tests/system-test/2-query/mavg.py
@@ -159,7 +159,7 @@ class TDTestCase:
             return tdSql.error(self.mavg_query_form(
                 sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
                 table_expr=table_expr, condition=condition
-            ))                
+            ))
 
         if all(["group" in condition.lower(), "tbname" not in condition.lower()]):
             print(f"case in {line}: ", end='')
@@ -295,7 +295,7 @@ class TDTestCase:
                 pre_result = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
                 if (platform.system().lower() == 'windows' and pre_result.dtype == 'int32'):
                     pre_result = np.array(pre_result, dtype = 'int64')
-            
+
                 pre_mavg = pre_mavg = np.convolve(pre_result, np.ones(k), "valid")[offset_val:]/k
                 tdSql.query(self.mavg_query_form(
                     sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
@@ -669,7 +669,7 @@ class TDTestCase:
         tdSql.checkData(0,0,1.000000000)
         tdSql.checkData(1,0,1.000000000)
         tdSql.checkData(5,0,1.000000000)
-        
+
         tdSql.query("select mavg(abs(c1),1) from t1")
         tdSql.checkRows(4)
 
@@ -688,17 +688,17 @@ class TDTestCase:
         tdSql.query("select mavg(st1+c1,3) from stb1 partition by tbname")
         tdSql.checkRows(20)
 
-        # # bug need fix 
+        # # bug need fix
         # tdSql.query("select mavg(st1+c1,3) from stb1 partition by tbname slimit 1 ")
         # tdSql.checkRows(2)
         # tdSql.error("select mavg(st1+c1,3) from stb1 partition by tbname limit 1 ")
 
 
-        # bug need fix 
+        # bug need fix
         tdSql.query("select mavg(st1+c1,3) from stb1 partition by tbname")
         tdSql.checkRows(20)
 
-        # bug need fix 
+        # bug need fix
         # tdSql.query("select tbname , mavg(c1,3) from stb1 partition by tbname")
         # tdSql.checkRows(38)
         # tdSql.query("select tbname , mavg(st1,3) from stb1 partition by tbname")
@@ -706,7 +706,7 @@ class TDTestCase:
         # tdSql.query("select tbname , mavg(st1,3) from stb1 partition by tbname slimit 1")
         # tdSql.checkRows(2)
 
-        # partition by tags 
+        # partition by tags
         # tdSql.query("select st1 , mavg(c1,3) from stb1 partition by st1")
         # tdSql.checkRows(38)
         # tdSql.query("select mavg(c1,3) from stb1 partition by st1")
@@ -743,4 +743,4 @@ class TDTestCase:
         tdLog.success("%s successfully executed" % __file__)
 
 tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/system-test/2-query/max.py b/tests/system-test/2-query/max.py
index 0ca3f8f71a..8a5dca3763 100644
--- a/tests/system-test/2-query/max.py
+++ b/tests/system-test/2-query/max.py
@@ -5,7 +5,7 @@ import numpy as np
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -19,15 +19,15 @@ class TDTestCase:
         self.nchar_str = '涛思数据'
     def max_check_stb_and_tb_base(self):
         tdSql.prepare()
-        intData = []        
+        intData = []
         floatData = []
-        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned, 
+        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned,
                     col7 int unsigned, col8 bigint unsigned, col9 float, col10 double, col11 bool, col12 binary(20), col13 nchar(20)) tags(loc nchar(20))''')
         tdSql.execute("create table stb_1 using stb tags('beijing')")
         for i in range(self.rowNum):
             tdSql.execute(f"insert into stb_1 values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')"
                           % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1))
-            intData.append(i + 1)            
+            intData.append(i + 1)
             floatData.append(i + 0.1)
         for i in ['ts','col11','col12','col13']:
             for j in ['db.stb','stb','db.stb_1','stb_1']:
@@ -45,17 +45,17 @@ class TDTestCase:
         tdSql.query("select max(col1) from stb where col2<=5")
         tdSql.checkData(0,0,5)
         tdSql.execute('drop database db')
-        
+
     def max_check_ntb_base(self):
         tdSql.prepare()
-        intData = []        
+        intData = []
         floatData = []
-        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned, 
+        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned,
                     col7 int unsigned, col8 bigint unsigned, col9 float, col10 double, col11 bool, col12 binary(20), col13 nchar(20))''')
         for i in range(self.rowNum):
             tdSql.execute(f"insert into ntb values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')"
                           % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1))
-            intData.append(i + 1)            
+            intData.append(i + 1)
             floatData.append(i + 0.1)
         for i in ['ts','col11','col12','col13']:
             for j in ['db.ntb','ntb']:
@@ -79,7 +79,7 @@ class TDTestCase:
         same_sql = f"select {col_name} from {tbname} order by {col_name} desc limit 1"
 
         tdSql.query(max_sql)
-        max_result = tdSql.queryResult 
+        max_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -91,7 +91,7 @@ class TDTestCase:
 
 
     def support_distributed_aggregate(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -161,17 +161,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
 
         count = 0
         for k ,v in vnode_tables.items():
@@ -180,8 +180,8 @@ class TDTestCase:
         if count < 2:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -190,23 +190,23 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_max_functions(tablename,colname)
 
-        # max function with basic filter 
+        # max function with basic filter
         print(vnode_tables)
 
 
-    def run(self):                 
+    def run(self):
 
-        # max verifacation 
+        # max verifacation
         self.max_check_stb_and_tb_base()
         self.max_check_ntb_base()
 
diff --git a/tests/system-test/2-query/min.py b/tests/system-test/2-query/min.py
index 60a8c105f1..c27e9926ff 100644
--- a/tests/system-test/2-query/min.py
+++ b/tests/system-test/2-query/min.py
@@ -12,30 +12,30 @@ class TDTestCase:
 
         self.rowNum = 10
         self.ts = 1537146000000
-        
+
     def run(self):
         tdSql.prepare()
 
-        intData = []        
+        intData = []
         floatData = []
 
-        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
+        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20))''')
         tdSql.execute("create table stb_1 using stb tags('beijing')")
-        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
+        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''')
         for i in range(self.rowNum):
-            tdSql.execute("insert into ntb values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into ntb values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
-            intData.append(i + 1)            
+            intData.append(i + 1)
             floatData.append(i + 0.1)
         for i in range(self.rowNum):
-            tdSql.execute("insert into stb_1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into stb_1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
-            intData.append(i + 1)            
-            floatData.append(i + 0.1)                        
+            intData.append(i + 1)
+            floatData.append(i + 0.1)
 
-        # max verifacation 
+        # max verifacation
         tdSql.error("select min(ts) from stb_1")
         tdSql.error("select min(ts) from db.stb_1")
         tdSql.error("select min(col7) from stb_1")
@@ -206,7 +206,7 @@ class TDTestCase:
         tdSql.query("select min(col1) from ntb where col2>=5")
         tdSql.checkData(0,0,5)
 
-        
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/system-test/2-query/nestedQuery.py b/tests/system-test/2-query/nestedQuery.py
index 9f2b8c4b56..757a75cf88 100755
--- a/tests/system-test/2-query/nestedQuery.py
+++ b/tests/system-test/2-query/nestedQuery.py
@@ -23,10 +23,10 @@ from util.dnodes import tdDnodes
 from util.dnodes import *
 
 class TDTestCase:
-    updatecfgDict = {'maxSQLLength':1048576,'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'maxSQLLength':1048576,'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
-    
+
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)
         tdSql.init(conn.cursor(), logSql)
@@ -34,28 +34,28 @@ class TDTestCase:
         testcasePath = os.path.split(__file__)[0]
         testcaseFilename = os.path.split(__file__)[-1]
         os.system("rm -rf %s/%s.sql" % (testcasePath,testcaseFilename))
-        
+
         now = time.time()
         self.ts = int(round(now * 1000))
         self.num = 10
         self.fornum = 5
 
     # def case_common(self):
-    #     db = "nested"         
-    #     self.dropandcreateDB("%s" % db, 1) 
+    #     db = "nested"
+    #     self.dropandcreateDB("%s" % db, 1)
 
     #     conn1 = taos.connect(host="127.0.0.1", user="root", password="taosdata", config="/etc/taos/")
-    #     cur1 = conn1.cursor()        
+    #     cur1 = conn1.cursor()
     #     cur1.execute('use "%s";' %self.db)
     #     sql = 'select * from stable_1 limit 5;'
     #     cur1.execute(sql)
 
-    #     return(conn1,cur1)  
-    
+    #     return(conn1,cur1)
+
     def data_matrix_equal(self, sql1,row1_s,row1_e,col1_s,col1_e, sql2,row2_s,row2_e,col2_s,col2_e):
         #  ----row1_start----col1_start----
-        #  - - - - 是一个矩阵内的数据相等- - - 
-        #  - - - - - - - - - - - - - - - - 
+        #  - - - - 是一个矩阵内的数据相等- - -
+        #  - - - - - - - - - - - - - - - -
         #  ----row1_end------col1_end------
         self.sql1 = sql1
         list1 =[]
@@ -67,9 +67,9 @@ class TDTestCase:
                 #print("data=%s" %(tdSql.getData(i1,j1)))
                 list1.append(tdSql.getData(i1,j1))
         print("=====list1-------list1---=%s" %set(list1))
-        
+
         tdSql.execute("reset query cache;")
-        self.sql2 = sql2  
+        self.sql2 = sql2
         list2 =[]
         tdSql.query(sql2)
         for i2 in range(row2_s-1,row2_e):
@@ -78,8 +78,8 @@ class TDTestCase:
                 #print("jjjj222=%d"%j2)
                 #print("data=%s" %(tdSql.getData(i2,j2)))
                 list2.append(tdSql.getData(i2,j2))
-        print("=====list2-------list2---=%s" %set(list2)) 
-       
+        print("=====list2-------list2---=%s" %set(list2))
+
         if  (list1 == list2) and len(list2)>0:
             # print(("=====matrix===sql1.list1:'%s',sql2.list2:'%s'") %(list1,list2))
             tdLog.info(("===matrix===sql1:'%s' matrix_result = sql2:'%s' matrix_result") %(sql1,sql2))
@@ -105,7 +105,7 @@ class TDTestCase:
             print(("=====matrix_error===sql1.list1:'%s',sql2.list2:'%s'") %(list1,list2))
             tdLog.info(("sql1:'%s' matrix_result != sql2:'%s' matrix_result") %(sql1,sql2))
             return tdSql.checkEqual(list1,list2)
-            
+
     def restartDnodes(self):
         pass
         # tdDnodes.stop(1)
@@ -125,7 +125,7 @@ class TDTestCase:
         tdSql.execute('''create stable stable_2 (ts timestamp , q_int int , q_bigint bigint , q_smallint smallint , q_tinyint tinyint , q_float float , q_double double , q_bool bool , q_binary binary(100) , q_nchar nchar(100) , q_ts timestamp , \
                 q_int_null int , q_bigint_null bigint , q_smallint_null smallint , q_tinyint_null tinyint, q_float_null float , q_double_null double , q_bool_null bool , q_binary_null binary(20) , q_nchar_null nchar(20) , q_ts_null timestamp) \
                 tags(loc nchar(100) , t_int int , t_bigint bigint , t_smallint smallint , t_tinyint tinyint, t_bool bool , t_binary binary(100) , t_nchar nchar(100) ,t_float float , t_double double , t_ts timestamp);''')
-        
+
         tdSql.execute('''create stable stable_null_data (ts timestamp , q_int int , q_bigint bigint , q_smallint smallint , q_tinyint tinyint , q_float float , q_double double , q_bool bool , q_binary binary(100) , q_nchar nchar(100) , q_ts timestamp , \
                 q_int_null int , q_bigint_null bigint , q_smallint_null smallint , q_tinyint_null tinyint, q_float_null float , q_double_null double , q_bool_null bool , q_binary_null binary(20) , q_nchar_null nchar(20) , q_ts_null timestamp) \
                 tags(loc nchar(100) , t_int int , t_bigint bigint , t_smallint smallint , t_tinyint tinyint, t_bool bool , t_binary binary(100) , t_nchar nchar(100) ,t_float float , t_double double , t_ts timestamp);''')
@@ -133,35 +133,35 @@ class TDTestCase:
         tdSql.execute('''create stable stable_null_childtable (ts timestamp , q_int int , q_bigint bigint , q_smallint smallint , q_tinyint tinyint , q_float float , q_double double , q_bool bool , q_binary binary(100) , q_nchar nchar(100) , q_ts timestamp , \
                 q_int_null int , q_bigint_null bigint , q_smallint_null smallint , q_tinyint_null tinyint, q_float_null float , q_double_null double , q_bool_null bool , q_binary_null binary(20) , q_nchar_null nchar(20) , q_ts_null timestamp) \
                 tags(loc nchar(100) , t_int int , t_bigint bigint , t_smallint smallint , t_tinyint tinyint, t_bool bool , t_binary binary(100) , t_nchar nchar(100) ,t_float float , t_double double , t_ts timestamp);''')
-        
+
         #tdSql.execute('''create table stable_1_1 using stable_1 tags('stable_1_1', '0' , '0' , '0' , '0' , 0 , 'binary1' , 'nchar1' , '0' , '0' ,'0') ;''')
-        tdSql.execute('''create table stable_1_1 using stable_1 tags('stable_1_1', '%d' , '%d', '%d' , '%d' , 0 , 'binary1.%s' , 'nchar1.%s' , '%f', '%f' ,'%d') ;''' 
-                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1), 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
-                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1)))  
+        tdSql.execute('''create table stable_1_1 using stable_1 tags('stable_1_1', '%d' , '%d', '%d' , '%d' , 0 , 'binary1.%s' , 'nchar1.%s' , '%f', '%f' ,'%d') ;'''
+                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1),
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
+                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1)))
         tdSql.execute('''create table stable_1_2 using stable_1 tags('stable_1_2', '2147483647' , '9223372036854775807' , '32767' , '127' , 1 , 'binary2' , 'nchar2' , '2' , '22' , \'1999-09-09 09:09:09.090\') ;''')
         tdSql.execute('''create table stable_1_3 using stable_1 tags('stable_1_3', '-2147483647' , '-9223372036854775807' , '-32767' , '-127' , false , 'binary3' , 'nchar3nchar3' , '-3.3' , '-33.33' , \'2099-09-09 09:09:09.090\') ;''')
         #tdSql.execute('''create table stable_1_4 using stable_1 tags('stable_1_4', '0' , '0' , '0' , '0' , 0 , '0' , '0' , '0' , '0' ,'0') ;''')
-        tdSql.execute('''create table stable_1_4 using stable_1 tags('stable_1_4', '%d' , '%d', '%d' , '%d' , 1 , 'binary1.%s' , 'nchar1.%s' , '%f', '%f' ,'%d') ;''' 
-                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1), 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
-                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1))) 
+        tdSql.execute('''create table stable_1_4 using stable_1 tags('stable_1_4', '%d' , '%d', '%d' , '%d' , 1 , 'binary1.%s' , 'nchar1.%s' , '%f', '%f' ,'%d') ;'''
+                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1),
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
+                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1)))
 
         # tdSql.execute('''create table stable_2_1 using stable_2 tags('stable_2_1' , '0' , '0' , '0' , '0' , 0 , 'binary21' , 'nchar21' , '0' , '0' ,'0') ;''')
         # tdSql.execute('''create table stable_2_2 using stable_2 tags('stable_2_2' , '0' , '0' , '0' , '0' , 0 , '0' , '0' , '0' , '0' ,'0') ;''')
 
         # tdSql.execute('''create table stable_null_data_1 using stable_null_data tags('stable_null_data_1', '0' , '0' , '0' , '0' , 0 , '0' , '0' , '0' , '0' ,'0') ;''')
-        
-        tdSql.execute('''create table stable_2_1 using stable_2 tags('stable_2_1' , '0' , '0' , '0' , '0' , 0 , 'binary21' , 'nchar21' , '0' , '0' ,\'2099-09-09 09:09:09.090\') ;''')
-        tdSql.execute('''create table stable_2_2 using stable_2 tags('stable_2_2' , '%d' , '%d', '%d' , '%d' , 0 , 'binary2.%s' , 'nchar2.%s' , '%f', '%f' ,'%d') ;''' 
-                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1), 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
-                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1))) 
 
-        tdSql.execute('''create table stable_null_data_1 using stable_null_data tags('stable_null_data_1', '%d' , '%d', '%d' , '%d' , 1 , 'binary1.%s' , 'nchar1.%s' , '%f', '%f' ,'%d') ;''' 
-                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1), 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
-                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1))) 
+        tdSql.execute('''create table stable_2_1 using stable_2 tags('stable_2_1' , '0' , '0' , '0' , '0' , 0 , 'binary21' , 'nchar21' , '0' , '0' ,\'2099-09-09 09:09:09.090\') ;''')
+        tdSql.execute('''create table stable_2_2 using stable_2 tags('stable_2_2' , '%d' , '%d', '%d' , '%d' , 0 , 'binary2.%s' , 'nchar2.%s' , '%f', '%f' ,'%d') ;'''
+                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1),
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
+                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1)))
+
+        tdSql.execute('''create table stable_null_data_1 using stable_null_data tags('stable_null_data_1', '%d' , '%d', '%d' , '%d' , 1 , 'binary1.%s' , 'nchar1.%s' , '%f', '%f' ,'%d') ;'''
+                      %(fake.random_int(min=-2147483647, max=2147483647, step=1), fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1),
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
+                        fake.pystr() ,fake.pystr() ,fake.pyfloat(),fake.pyfloat(),fake.random_int(min=-2147483647, max=2147483647, step=1)))
 
         #regular table
         tdSql.execute('''create table regular_table_1 \
@@ -179,50 +179,50 @@ class TDTestCase:
                     q_int_null int , q_bigint_null bigint , q_smallint_null smallint , q_tinyint_null tinyint, q_float_null float , q_double_null double , q_bool_null bool , q_binary_null binary(20) , q_nchar_null nchar(20) , q_ts_null timestamp) ;''')
 
 
-        for i in range(num_random*n):        
-            tdSql.execute('''insert into stable_1_1  (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double , q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 0, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000, fake.random_int(min=-2147483647, max=2147483647, step=1), 
-                        fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1), 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
+        for i in range(num_random*n):
+            tdSql.execute('''insert into stable_1_1  (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double , q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 0, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000, fake.random_int(min=-2147483647, max=2147483647, step=1),
+                        fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1),
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i))
-            tdSql.execute('''insert into  regular_table_1 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 0, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000, fake.random_int(min=-2147483647, max=2147483647, step=1) , 
-                        fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1) , 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
+            tdSql.execute('''insert into  regular_table_1 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 0, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000, fake.random_int(min=-2147483647, max=2147483647, step=1) ,
+                        fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1) ,
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i))
 
-            tdSql.execute('''insert into stable_1_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000, fake.random_int(min=0, max=2147483647, step=1), 
-                        fake.random_int(min=0, max=9223372036854775807, step=1), 
-                        fake.random_int(min=0, max=32767, step=1) , fake.random_int(min=0, max=127, step=1) , 
+            tdSql.execute('''insert into stable_1_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000, fake.random_int(min=0, max=2147483647, step=1),
+                        fake.random_int(min=0, max=9223372036854775807, step=1),
+                        fake.random_int(min=0, max=32767, step=1) , fake.random_int(min=0, max=127, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i))
-            tdSql.execute('''insert into regular_table_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000, fake.random_int(min=0, max=2147483647, step=1), 
-                        fake.random_int(min=0, max=9223372036854775807, step=1), 
-                        fake.random_int(min=0, max=32767, step=1) , fake.random_int(min=0, max=127, step=1) , 
+            tdSql.execute('''insert into regular_table_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000, fake.random_int(min=0, max=2147483647, step=1),
+                        fake.random_int(min=0, max=9223372036854775807, step=1),
+                        fake.random_int(min=0, max=32767, step=1) , fake.random_int(min=0, max=127, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i))
-            
-            tdSql.execute('''insert into stable_1_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000 +1, fake.random_int(min=-2147483647, max=0, step=1), 
-                        fake.random_int(min=-9223372036854775807, max=0, step=1), 
-                        fake.random_int(min=-32767, max=0, step=1) , fake.random_int(min=-127, max=0, step=1) , 
+
+            tdSql.execute('''insert into stable_1_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000 +1, fake.random_int(min=-2147483647, max=0, step=1),
+                        fake.random_int(min=-9223372036854775807, max=0, step=1),
+                        fake.random_int(min=-32767, max=0, step=1) , fake.random_int(min=-127, max=0, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i +1))
-            tdSql.execute('''insert into regular_table_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000 +1, fake.random_int(min=-2147483647, max=0, step=1), 
-                        fake.random_int(min=-9223372036854775807, max=0, step=1), 
-                        fake.random_int(min=-32767, max=0, step=1) , fake.random_int(min=-127, max=0, step=1) , 
+            tdSql.execute('''insert into regular_table_2 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000 +1, fake.random_int(min=-2147483647, max=0, step=1),
+                        fake.random_int(min=-9223372036854775807, max=0, step=1),
+                        fake.random_int(min=-32767, max=0, step=1) , fake.random_int(min=-127, max=0, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i +1))
 
-            tdSql.execute('''insert into stable_2_1 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 0, 'binary.%s', 'nchar.%s', %d) ;''' 
-                        % (ts + i*1000, fake.random_int(min=-2147483647, max=2147483647, step=1), 
-                        fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1), 
-                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) , 
+            tdSql.execute('''insert into stable_2_1 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 0, 'binary.%s', 'nchar.%s', %d) ;'''
+                        % (ts + i*1000, fake.random_int(min=-2147483647, max=2147483647, step=1),
+                        fake.random_int(min=-9223372036854775807, max=9223372036854775807, step=1),
+                        fake.random_int(min=-32767, max=32767, step=1) , fake.random_int(min=-127, max=127, step=1) ,
                         fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i))
 
-            # tdSql.execute('''insert into regular_table_3 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d)''' 
-            #             % (ts + i*1000, fake.random_int(min=-2147483647, max=0, step=1), 
-            #             fake.random_int(min=-9223372036854775807, max=0, step=1), 
-            #             fake.random_int(min=-32767, max=0, step=1) , fake.random_int(min=-127, max=0, step=1) , 
+            # tdSql.execute('''insert into regular_table_3 (ts , q_int , q_bigint , q_smallint , q_tinyint , q_float , q_double, q_bool , q_binary , q_nchar, q_ts) values(%d, %d, %d, %d, %d, %f, %f, 1, 'binary.%s', 'nchar.%s', %d)'''
+            #             % (ts + i*1000, fake.random_int(min=-2147483647, max=0, step=1),
+            #             fake.random_int(min=-9223372036854775807, max=0, step=1),
+            #             fake.random_int(min=-32767, max=0, step=1) , fake.random_int(min=-127, max=0, step=1) ,
             #             fake.pyfloat() , fake.pyfloat() , fake.pystr() , fake.address() , ts + i))
 
         tdSql.query("select count(*) from stable_1;")
@@ -234,9 +234,9 @@ class TDTestCase:
     def run(self):
         tdSql.prepare()
         os.system("rm -rf nestedQuery3.py.sql")
-        
-        startTime = time.time() 
-        
+
+        startTime = time.time()
+
         db = "nest"
         self.dropandcreateDB_random("%s" %db, 1)
 
@@ -252,11 +252,11 @@ class TDTestCase:
         qt_select=  q_select + t_select
 
         # distinct regular column select
-        dq_select= ['distinct q_int', 'distinct q_bigint' , 'distinct q_smallint' , 'distinct q_tinyint' , 
+        dq_select= ['distinct q_int', 'distinct q_bigint' , 'distinct q_smallint' , 'distinct q_tinyint' ,
                 'distinct q_bool' , 'distinct q_binary' , 'distinct q_nchar' ,'distinct q_float' , 'distinct q_double' ,'distinct q_ts ']
 
         # distinct tag column select
-        dt_select= ['distinct loc', 'distinct t_int', 'distinct t_bigint'  , 'distinct t_smallint' , 'distinct t_tinyint' , 
+        dt_select= ['distinct loc', 'distinct t_int', 'distinct t_bigint'  , 'distinct t_smallint' , 'distinct t_tinyint' ,
                 'distinct t_bool' , 'distinct t_binary' , 'distinct t_nchar' ,'distinct t_float' , 'distinct t_double' ,'distinct t_ts ']
 
         # distinct regular and tag column select
@@ -267,12 +267,12 @@ class TDTestCase:
         s_s_select= ['tbname' , '_rowts' , '_c0', '_C0' ]
         unionall_or_union= [ ' union ' , ' union all ' ]
 
-        # regular column where 
+        # regular column where
         q_where = ['ts < now +1s','q_bigint >= -9223372036854775807 and q_bigint <= 9223372036854775807', 'q_int <= 2147483647 and q_int >= -2147483647',
-        'q_smallint >= -32767 and q_smallint <= 32767','q_tinyint >= -127 and q_tinyint <= 127','q_float >= -1.7E308 and q_float <= 1.7E308', 
-        'q_double >= -1.7E308 and q_double <= 1.7E308', 'q_binary like \'binary%\'  or q_binary = \'0\' ' , 'q_nchar like \'nchar%\' or q_nchar = \'0\' ' , 
+        'q_smallint >= -32767 and q_smallint <= 32767','q_tinyint >= -127 and q_tinyint <= 127','q_float >= -1.7E308 and q_float <= 1.7E308',
+        'q_double >= -1.7E308 and q_double <= 1.7E308', 'q_binary like \'binary%\'  or q_binary = \'0\' ' , 'q_nchar like \'nchar%\' or q_nchar = \'0\' ' ,
         'q_bool = true or  q_bool = false' , 'q_bool in (0 , 1)' , 'q_bool in ( true , false)' , 'q_bool = 0 or q_bool = 1',
-        'q_bigint between  -9223372036854775807 and 9223372036854775807',' q_int between -2147483647 and 2147483647','q_smallint between -32767 and 32767', 
+        'q_bigint between  -9223372036854775807 and 9223372036854775807',' q_int between -2147483647 and 2147483647','q_smallint between -32767 and 32767',
         'q_tinyint between -127 and 127 ','q_float >= -3.4E38  ','q_float <= 3.4E38  ','q_double >= -1.7E308  ',
         'q_double <= 1.7E308  ','q_float between -3.4E38 and 3.4E38  ','q_double between -1.7E308 and 1.7E308  ' ,
         'q_float is not null  ' ,'q_double is not null  ' ,]
@@ -284,33 +284,33 @@ class TDTestCase:
         't1.q_smallint >= -32767 and t1.q_smallint <= 32767 and t2.q_smallint >= -32767 and t2.q_smallint <= 32767',
         't1.q_tinyint >= -127 and t1.q_tinyint <= 127 and t2.q_tinyint >= -127 and t2.q_tinyint <= 127',
         't1.q_float >= - 1.7E308 and t1.q_float <=  1.7E308 and t2.q_float >= - 1.7E308 and t2.q_float <=  1.7E308',
-        't1.q_double >= - 1.7E308 and t1.q_double <=  1.7E308 and t2.q_double >= - 1.7E308 and t2.q_double <=  1.7E308', 
-        't1.q_binary like \'binary%\'  and t2.q_binary like \'binary%\'  ' , 
-        't1.q_nchar like \'nchar%\' and t2.q_nchar like \'nchar%\' ' , 
-        't1.q_bool in (0 , 1) and t2.q_bool in (0 , 1)' , 't1.q_bool in ( true , false) and t2.q_bool in ( true , false)' , 
+        't1.q_double >= - 1.7E308 and t1.q_double <=  1.7E308 and t2.q_double >= - 1.7E308 and t2.q_double <=  1.7E308',
+        't1.q_binary like \'binary%\'  and t2.q_binary like \'binary%\'  ' ,
+        't1.q_nchar like \'nchar%\' and t2.q_nchar like \'nchar%\' ' ,
+        't1.q_bool in (0 , 1) and t2.q_bool in (0 , 1)' , 't1.q_bool in ( true , false) and t2.q_bool in ( true , false)' ,
         't1.q_bigint between  -9223372036854775807 and 9223372036854775807 and t2.q_bigint between  -9223372036854775807 and 9223372036854775807',
         't1.q_int between -2147483647 and 2147483647 and t2.q_int between -2147483647 and 2147483647',
-        't1.q_smallint between -32767 and 32767 and t2.q_smallint between -32767 and 32767', 
+        't1.q_smallint between -32767 and 32767 and t2.q_smallint between -32767 and 32767',
         't1.q_tinyint between -127 and 127 and t2.q_tinyint between -127 and 127 ','t1.q_float between -1.7E308 and  1.7E308 and t2.q_float between -1.7E308 and  1.7E308',
         't1.q_double between -1.7E308 and  1.7E308 and t2.q_double between -1.7E308 and  1.7E308']
         #TD-6201 ,'t1.q_bool between 0 and 1 or t2.q_bool between 0 and 1']
         #'t1.q_bool = true and  t1.q_bool = false and t2.q_bool = true and  t2.q_bool = false' , 't1.q_bool = 0 and t1.q_bool = 1 and t2.q_bool = 0 and t2.q_bool = 1' ,
 
-        q_u_or_where = ['(t1.q_binary like \'binary%\'  or t1.q_binary = \'0\'  or t2.q_binary like \'binary%\'  or t2.q_binary = \'0\' )' , 
-        '(t1.q_nchar like \'nchar%\' or t1.q_nchar = \'0\' or t2.q_nchar like \'nchar%\' or t2.q_nchar = \'0\' )' , '(t1.q_bool = true or  t1.q_bool = false or t2.q_bool = true or  t2.q_bool = false)' , 
+        q_u_or_where = ['(t1.q_binary like \'binary%\'  or t1.q_binary = \'0\'  or t2.q_binary like \'binary%\'  or t2.q_binary = \'0\' )' ,
+        '(t1.q_nchar like \'nchar%\' or t1.q_nchar = \'0\' or t2.q_nchar like \'nchar%\' or t2.q_nchar = \'0\' )' , '(t1.q_bool = true or  t1.q_bool = false or t2.q_bool = true or  t2.q_bool = false)' ,
         '(t1.q_bool in (0 , 1) or t2.q_bool in (0 , 1))' , '(t1.q_bool in ( true , false) or t2.q_bool in ( true , false))' , '(t1.q_bool = 0 or t1.q_bool = 1 or t2.q_bool = 0 or t2.q_bool = 1)' ,
         '(t1.q_bigint between  -9223372036854775807 and 9223372036854775807 or t2.q_bigint between  -9223372036854775807 and 9223372036854775807)',
         '(t1.q_int between -2147483647 and 2147483647 or t2.q_int between -2147483647 and 2147483647)',
-        '(t1.q_smallint between -32767 and 32767 or t2.q_smallint between -32767 and 32767)', 
+        '(t1.q_smallint between -32767 and 32767 or t2.q_smallint between -32767 and 32767)',
         '(t1.q_tinyint between -127 and 127 or t2.q_tinyint between -127 and 127 )','(t1.q_float between -1.7E308 and 1.7E308 or t2.q_float between -1.7E308 and 1.7E308)',
         '(t1.q_double between -1.7E308 and 1.7E308 or t2.q_double between -1.7E308 and 1.7E308)']
 
         # tag column where
         t_where = ['ts < now +1s','t_bigint >= -9223372036854775807 and t_bigint <= 9223372036854775807','t_int <= 2147483647 and t_int >= -2147483647',
         't_smallint >= -32767 and t_smallint <= 32767','q_tinyint >= -127 and t_tinyint <= 127','t_float >= -1.7E308 and t_float <= 1.7E308',
-        't_double >= -1.7E308 and t_double <= 1.7E308', 't_binary like \'binary%\'   or t_binary = \'0\' ' , 't_nchar like \'nchar%\' or t_nchar = \'0\'' , 
+        't_double >= -1.7E308 and t_double <= 1.7E308', 't_binary like \'binary%\'   or t_binary = \'0\' ' , 't_nchar like \'nchar%\' or t_nchar = \'0\'' ,
         't_bool = true or  t_bool = false' , 't_bool in (0 , 1)' , 't_bool in ( true , false)' , 't_bool = 0 or t_bool = 1',
-        't_bigint between  -9223372036854775807 and 9223372036854775807',' t_int between -2147483647 and 2147483647','t_smallint between -32767 and 32767', 
+        't_bigint between  -9223372036854775807 and 9223372036854775807',' t_int between -2147483647 and 2147483647','t_smallint between -32767 and 32767',
         't_tinyint between -127 and 127 ','t_float between -1.7E308 and 1.7E308','t_double between -1.7E308 and 1.7E308']
         #TD-6201,'t_bool between 0 and 1'
 
@@ -320,27 +320,27 @@ class TDTestCase:
         't1.t_smallint >= -32767 and t1.t_smallint <= 32767 and t2.t_smallint >= -32767 and t2.t_smallint <= 32767',
         't1.t_tinyint >= -127 and t1.t_tinyint <= 127 and t2.t_tinyint >= -127 and t2.t_tinyint <= 127',
         't1.t_float >= -1.7E308 and t1.t_float <= 1.7E308 and t2.t_float >= -1.7E308 and t2.t_float <= 1.7E308',
-        't1.t_double >= -1.7E308 and t1.t_double <= 1.7E308 and t2.t_double >= -1.7E308 and t2.t_double <= 1.7E308', 
-        '(t1.t_binary like \'binary%\'  or t1.t_binary = \'0\'  or t2.t_binary like \'binary%\'  or t2.t_binary = \'0\') ' , 
-        '(t1.t_nchar like \'nchar%\' or t1.t_nchar = \'0\' or t2.t_nchar like \'nchar%\' or t2.t_nchar = \'0\' )' , '(t1.t_bool = true or  t1.t_bool = false or t2.t_bool = true or  t2.t_bool = false)' , 
+        't1.t_double >= -1.7E308 and t1.t_double <= 1.7E308 and t2.t_double >= -1.7E308 and t2.t_double <= 1.7E308',
+        '(t1.t_binary like \'binary%\'  or t1.t_binary = \'0\'  or t2.t_binary like \'binary%\'  or t2.t_binary = \'0\') ' ,
+        '(t1.t_nchar like \'nchar%\' or t1.t_nchar = \'0\' or t2.t_nchar like \'nchar%\' or t2.t_nchar = \'0\' )' , '(t1.t_bool = true or  t1.t_bool = false or t2.t_bool = true or  t2.t_bool = false)' ,
         't1.t_bool in (0 , 1) and t2.t_bool in (0 , 1)' , 't1.t_bool in ( true , false) and t2.t_bool in ( true , false)' , '(t1.t_bool = 0 or t1.t_bool = 1 or t2.t_bool = 0 or t2.t_bool = 1)',
         't1.t_bigint between  -9223372036854775807 and 9223372036854775807 and t2.t_bigint between  -9223372036854775807 and 9223372036854775807',
         't1.t_int between -2147483647 and 2147483647 and t2.t_int between -2147483647 and 2147483647',
-        't1.t_smallint between -32767 and 32767 and t2.t_smallint between -32767 and 32767', 
+        't1.t_smallint between -32767 and 32767 and t2.t_smallint between -32767 and 32767',
         '(t1.t_tinyint between -127 and 127 and t2.t_tinyint between -127 and 127) ','t1.t_float between -1.7E308 and 1.7E308 and t2.t_float between -1.7E308 and 1.7E308',
         '(t1.t_double between -1.7E308 and 1.7E308 and t2.t_double between -1.7E308 and 1.7E308)']
         #TD-6201,'t1.t_bool between 0 and 1 or t2.q_bool between 0 and 1']
 
-        t_u_or_where = ['(t1.t_binary like \'binary%\'  or t1.t_binary = \'0\'  or t2.t_binary like \'binary%\'  or t2.t_binary = \'0\' )' , 
-        '(t1.t_nchar like \'nchar%\' or t1.t_nchar = \'0\' or t2.t_nchar like \'nchar%\' or t2.t_nchar = \'0\' )' , '(t1.t_bool = true or  t1.t_bool = false or t2.t_bool = true or  t2.t_bool = false)' , 
+        t_u_or_where = ['(t1.t_binary like \'binary%\'  or t1.t_binary = \'0\'  or t2.t_binary like \'binary%\'  or t2.t_binary = \'0\' )' ,
+        '(t1.t_nchar like \'nchar%\' or t1.t_nchar = \'0\' or t2.t_nchar like \'nchar%\' or t2.t_nchar = \'0\' )' , '(t1.t_bool = true or  t1.t_bool = false or t2.t_bool = true or  t2.t_bool = false)' ,
         '(t1.t_bool in (0 , 1) or t2.t_bool in (0 , 1))' , '(t1.t_bool in ( true , false) or t2.t_bool in ( true , false))' , '(t1.t_bool = 0 or t1.t_bool = 1 or t2.t_bool = 0 or t2.t_bool = 1)',
         '(t1.t_bigint between  -9223372036854775807 and 9223372036854775807 or t2.t_bigint between  -9223372036854775807 and 9223372036854775807)',
         '(t1.t_int between -2147483647 and 2147483647 or t2.t_int between -2147483647 and 2147483647)',
-        '(t1.t_smallint between -32767 and 32767 or t2.t_smallint between -32767 and 32767)', 
+        '(t1.t_smallint between -32767 and 32767 or t2.t_smallint between -32767 and 32767)',
         '(t1.t_tinyint between -127 and 127 or t2.t_tinyint between -127 and 127 )','(t1.t_float between -1.7E308 and 1.7E308 or t2.t_float between -1.7E308 and 1.7E308)',
         '(t1.t_double between -1.7E308 and 1.7E308 or t2.t_double between -1.7E308 and 1.7E308)']
 
-        # regular and tag column where 
+        # regular and tag column where
         qt_where = q_where + t_where
         qt_u_where = q_u_where + t_u_where
         # now,qt_u_or_where is not support
@@ -354,78 +354,78 @@ class TDTestCase:
         session_where = ['session(ts,10a)' , 'session(ts,10s)', 'session(ts,10m)' , 'session(ts,10h)','session(ts,10d)' , 'session(ts,10w)']
         session_u_where = ['session(t1.ts,10a)' , 'session(t1.ts,10s)', 'session(t1.ts,10m)' , 'session(t1.ts,10h)','session(t1.ts,10d)' , 'session(t1.ts,10w)',
                     'session(t2.ts,10a)' , 'session(t2.ts,10s)', 'session(t2.ts,10m)' , 'session(t2.ts,10h)','session(t2.ts,10d)' , 'session(t2.ts,10w)']
-        
+
         fill_where = ['FILL(NONE)','FILL(PREV)','FILL(NULL)','FILL(LINEAR)','FILL(NEXT)','FILL(VALUE, 1.23)']
-        
+
         state_window = ['STATE_WINDOW(q_tinyint)','STATE_WINDOW(q_bigint)','STATE_WINDOW(q_int)','STATE_WINDOW(q_bool)','STATE_WINDOW(q_smallint)']
         state_u_window = ['STATE_WINDOW(t1.q_tinyint)','STATE_WINDOW(t1.q_bigint)','STATE_WINDOW(t1.q_int)','STATE_WINDOW(t1.q_bool)','STATE_WINDOW(t1.q_smallint)',
                     'STATE_WINDOW(t2.q_tinyint)','STATE_WINDOW(t2.q_bigint)','STATE_WINDOW(t2.q_int)','STATE_WINDOW(t2.q_bool)','STATE_WINDOW(t2.q_smallint)']
 
-        # order by where 
+        # order by where
         order_where = ['order by ts' , 'order by ts asc']
         order_u_where = ['order by t1.ts' , 'order by t1.ts asc' , 'order by t2.ts' , 'order by t2.ts asc']
         order_desc_where = ['order by ts' , 'order by ts asc' , 'order by ts desc' ]
         orders_desc_where = ['order by ts' , 'order by ts asc' , 'order by ts desc' , 'order by loc' , 'order by loc asc' , 'order by loc desc']
- 
-        group_where = ['group by tbname , loc' , 'group by tbname', 'group by tbname, t_bigint', 'group by tbname,t_int', 'group by tbname, t_smallint', 'group by tbname,t_tinyint', 
+
+        group_where = ['group by tbname , loc' , 'group by tbname', 'group by tbname, t_bigint', 'group by tbname,t_int', 'group by tbname, t_smallint', 'group by tbname,t_tinyint',
                     'group by tbname,t_float', 'group by tbname,t_double' , 'group by tbname,t_binary', 'group by tbname,t_nchar', 'group by tbname,t_bool' ,'group by tbname ,loc ,t_bigint',
                     'group by tbname,t_binary ,t_nchar ,t_bool' , 'group by tbname,t_int ,t_smallint ,t_tinyint' , 'group by tbname,t_float ,t_double ' ,
-                    'PARTITION BY tbname , loc' , 'PARTITION BY tbname', 'PARTITION BY tbname, t_bigint', 'PARTITION BY tbname,t_int', 'PARTITION BY tbname, t_smallint', 'PARTITION BY tbname,t_tinyint', 
+                    'PARTITION BY tbname , loc' , 'PARTITION BY tbname', 'PARTITION BY tbname, t_bigint', 'PARTITION BY tbname,t_int', 'PARTITION BY tbname, t_smallint', 'PARTITION BY tbname,t_tinyint',
                     'PARTITION BY tbname,t_float', 'PARTITION BY tbname,t_double' , 'PARTITION BY tbname,t_binary', 'PARTITION BY tbname,t_nchar', 'PARTITION BY tbname,t_bool' ,'PARTITION BY tbname ,loc ,t_bigint',
                     'PARTITION BY tbname,t_binary ,t_nchar ,t_bool' , 'PARTITION BY tbname,t_int ,t_smallint ,t_tinyint' , 'PARTITION BY tbname,t_float ,t_double ']
-        group_where_j = ['group by  t1.loc' , 'group by t1.t_bigint', 'group by t1.t_int', 'group by t1.t_smallint', 'group by t1.t_tinyint', 
+        group_where_j = ['group by  t1.loc' , 'group by t1.t_bigint', 'group by t1.t_int', 'group by t1.t_smallint', 'group by t1.t_tinyint',
                     'group by t1.t_float', 'group by t1.t_double' , 'group by t1.t_binary', 'group by t1.t_nchar', 'group by t1.t_bool' ,'group by t1.loc ,t1.t_bigint',
                     'group by t1.t_binary ,t1.t_nchar ,t1.t_bool' , 'group by t1.t_int ,t1.t_smallint ,t1.t_tinyint' , 'group by t1.t_float ,t1.t_double ' ,
-                    'PARTITION BY t1.loc' , 'PARTITION by t1.t_bigint', 'PARTITION by t1.t_int', 'PARTITION by t1.t_smallint', 'PARTITION by t1.t_tinyint', 
+                    'PARTITION BY t1.loc' , 'PARTITION by t1.t_bigint', 'PARTITION by t1.t_int', 'PARTITION by t1.t_smallint', 'PARTITION by t1.t_tinyint',
                     'PARTITION by t1.t_float', 'PARTITION by t1.t_double' , 'PARTITION by t1.t_binary', 'PARTITION by t1.t_nchar', 'PARTITION by t1.t_bool' ,'PARTITION BY t1.loc ,t1.t_bigint',
                     'PARTITION by t1.t_binary ,t1.t_nchar ,t1.t_bool' , 'PARTITION by t1.t_int ,t1.t_smallint ,t1.t_tinyint' , 'PARTITION by t1.t_float ,t1.t_double ',
-                    'group by  t2.loc' , 'group by t2.t_bigint', 'group by t2.t_int', 'group by t2.t_smallint', 'group by t2.t_tinyint', 
+                    'group by  t2.loc' , 'group by t2.t_bigint', 'group by t2.t_int', 'group by t2.t_smallint', 'group by t2.t_tinyint',
                     'group by t2.t_float', 'group by t2.t_double' , 'group by t2.t_binary', 'group by t2.t_nchar', 'group by t2.t_bool' ,'group by t2.loc ,t2.t_bigint',
                     'group by t2.t_binary ,t2.t_nchar ,t2.t_bool' , 'group by t2.t_int ,t2.t_smallint ,t2.t_tinyint' , 'group by t2.t_float ,t2.t_double ' ,
-                    'PARTITION BY t2.loc' , 'PARTITION by t2.t_bigint', 'PARTITION by t2.t_int', 'PARTITION by t2.t_smallint', 'PARTITION by t2.t_tinyint', 
+                    'PARTITION BY t2.loc' , 'PARTITION by t2.t_bigint', 'PARTITION by t2.t_int', 'PARTITION by t2.t_smallint', 'PARTITION by t2.t_tinyint',
                     'PARTITION by t2.t_float', 'PARTITION by t2.t_double' , 'PARTITION by t2.t_binary', 'PARTITION by t2.t_nchar', 'PARTITION by t2.t_bool' ,'PARTITION BY t2.loc ,t2.t_bigint',
-                    'PARTITION by t2.t_binary ,t2.t_nchar ,t2.t_bool' , 'PARTITION by t2.t_int ,t2.t_smallint ,t2.t_tinyint' , 'PARTITION by t2.t_float ,t2.t_double ']        
- 
-        partiton_where = ['PARTITION BY tbname , loc' , 'PARTITION BY tbname', 'PARTITION BY tbname, t_bigint', 'PARTITION BY tbname,t_int', 'PARTITION BY tbname, t_smallint', 'PARTITION BY tbname,t_tinyint', 
+                    'PARTITION by t2.t_binary ,t2.t_nchar ,t2.t_bool' , 'PARTITION by t2.t_int ,t2.t_smallint ,t2.t_tinyint' , 'PARTITION by t2.t_float ,t2.t_double ']
+
+        partiton_where = ['PARTITION BY tbname , loc' , 'PARTITION BY tbname', 'PARTITION BY tbname, t_bigint', 'PARTITION BY tbname,t_int', 'PARTITION BY tbname, t_smallint', 'PARTITION BY tbname,t_tinyint',
                     'PARTITION BY tbname,t_float', 'PARTITION BY tbname,t_double' , 'PARTITION BY tbname,t_binary', 'PARTITION BY tbname,t_nchar', 'PARTITION BY tbname,t_bool' ,'PARTITION BY tbname ,loc ,t_bigint',
                     'PARTITION BY tbname,t_binary ,t_nchar ,t_bool' , 'PARTITION BY tbname,t_int ,t_smallint ,t_tinyint' , 'PARTITION BY tbname,t_float ,t_double ']
-        partiton_where_j = ['PARTITION BY t1.loc' , 'PARTITION by t1.t_bigint', 'PARTITION by t1.t_int', 'PARTITION by t1.t_smallint', 'PARTITION by t1.t_tinyint', 
+        partiton_where_j = ['PARTITION BY t1.loc' , 'PARTITION by t1.t_bigint', 'PARTITION by t1.t_int', 'PARTITION by t1.t_smallint', 'PARTITION by t1.t_tinyint',
                     'PARTITION by t1.t_float', 'PARTITION by t1.t_double' , 'PARTITION by t1.t_binary', 'PARTITION by t1.t_nchar', 'PARTITION by t1.t_bool' ,'PARTITION BY t1.loc ,t1.t_bigint',
                     'PARTITION by t1.t_binary ,t1.t_nchar ,t1.t_bool' , 'PARTITION by t1.t_int ,t1.t_smallint ,t1.t_tinyint' , 'PARTITION by t1.t_float ,t1.t_double ',
-                    'PARTITION BY t2.loc' , 'PARTITION by t2.t_bigint', 'PARTITION by t2.t_int', 'PARTITION by t2.t_smallint', 'PARTITION by t2.t_tinyint', 
+                    'PARTITION BY t2.loc' , 'PARTITION by t2.t_bigint', 'PARTITION by t2.t_int', 'PARTITION by t2.t_smallint', 'PARTITION by t2.t_tinyint',
                     'PARTITION by t2.t_float', 'PARTITION by t2.t_double' , 'PARTITION by t2.t_binary', 'PARTITION by t2.t_nchar', 'PARTITION by t2.t_bool' ,'PARTITION BY t2.loc ,t2.t_bigint',
-                    'PARTITION by t2.t_binary ,t2.t_nchar ,t2.t_bool' , 'PARTITION by t2.t_int ,t2.t_smallint ,t2.t_tinyint' , 'PARTITION by t2.t_float ,t2.t_double '] 
+                    'PARTITION by t2.t_binary ,t2.t_nchar ,t2.t_bool' , 'PARTITION by t2.t_int ,t2.t_smallint ,t2.t_tinyint' , 'PARTITION by t2.t_float ,t2.t_double ']
 
- 
-        group_where_regular = ['group by tbname ' , 'group by tbname', 'group by tbname, q_bigint', 'group by tbname,q_int', 'group by tbname, q_smallint', 'group by tbname,q_tinyint', 
+
+        group_where_regular = ['group by tbname ' , 'group by tbname', 'group by tbname, q_bigint', 'group by tbname,q_int', 'group by tbname, q_smallint', 'group by tbname,q_tinyint',
                     'group by tbname,q_float', 'group by tbname,q_double' , 'group by tbname,q_binary', 'group by tbname,q_nchar', 'group by tbname,q_bool' ,'group by tbname ,q_bigint',
                     'group by tbname,q_binary ,q_nchar ,q_bool' , 'group by tbname,q_int ,q_smallint ,q_tinyint' , 'group by tbname,q_float ,q_double ' ,
-                    'PARTITION BY tbname ' , 'PARTITION BY tbname', 'PARTITION BY tbname, q_bigint', 'PARTITION BY tbname,q_int', 'PARTITION BY tbname, q_smallint', 'PARTITION BY tbname,q_tinyint', 
+                    'PARTITION BY tbname ' , 'PARTITION BY tbname', 'PARTITION BY tbname, q_bigint', 'PARTITION BY tbname,q_int', 'PARTITION BY tbname, q_smallint', 'PARTITION BY tbname,q_tinyint',
                     'PARTITION BY tbname,q_float', 'PARTITION BY tbname,q_double' , 'PARTITION BY tbname,q_binary', 'PARTITION BY tbname,q_nchar', 'PARTITION BY tbname,q_bool' ,'PARTITION BY tbname ,q_bigint',
                     'PARTITION BY tbname,q_binary ,q_nchar ,q_bool' , 'PARTITION BY tbname,q_int ,q_smallint ,q_tinyint' , 'PARTITION BY tbname,q_float ,q_double ']
-        group_where_regular_j = ['group by t1.q_bigint', 'group by t1.q_int', 'group by t1.q_smallint', 'group by t1.q_tinyint', 
+        group_where_regular_j = ['group by t1.q_bigint', 'group by t1.q_int', 'group by t1.q_smallint', 'group by t1.q_tinyint',
                     'group by t1.q_float', 'group by t1.q_double' , 'group by t1.q_binary', 'group by t1.q_nchar', 'group by t1.q_bool' ,'group by t1.q_bigint',
                     'group by t1.q_binary ,t1.q_nchar ,t1.q_bool' , 'group by t1.q_int ,t1.q_smallint ,t1.q_tinyint' , 'group by t1.q_float ,t1.q_double ' ,
-                    'PARTITION by t1.q_bigint', 'PARTITION by t1.q_int', 'PARTITION by t1.q_smallint', 'PARTITION by t1.q_tinyint', 
+                    'PARTITION by t1.q_bigint', 'PARTITION by t1.q_int', 'PARTITION by t1.q_smallint', 'PARTITION by t1.q_tinyint',
                     'PARTITION by t1.q_float', 'PARTITION by t1.q_double' , 'PARTITION by t1.q_binary', 'PARTITION by t1.q_nchar', 'PARTITION by t1.q_bool' ,'PARTITION BY t1.q_bigint',
                     'PARTITION by t1.q_binary ,t1.q_nchar ,t1.q_bool' , 'PARTITION by t1.q_int ,t1.q_smallint ,t1.q_tinyint' , 'PARTITION by t1.q_float ,t1.q_double ',
-                    'group by t2.q_bigint', 'group by t2.q_int', 'group by t2.q_smallint', 'group by t2.q_tinyint', 
+                    'group by t2.q_bigint', 'group by t2.q_int', 'group by t2.q_smallint', 'group by t2.q_tinyint',
                     'group by t2.q_float', 'group by t2.q_double' , 'group by t2.q_binary', 'group by t2.q_nchar', 'group by t2.q_bool' ,'group by t2.q_bigint',
                     'group by t2.q_binary ,t2.q_nchar ,t2.q_bool' , 'group by t2.q_int ,t2.q_smallint ,t2.q_tinyint' , 'group by t2.q_float ,t2.q_double ' ,
-                    'PARTITION by t2.q_bigint', 'PARTITION by t2.q_int', 'PARTITION by t2.q_smallint', 'PARTITION by t2.q_tinyint', 
+                    'PARTITION by t2.q_bigint', 'PARTITION by t2.q_int', 'PARTITION by t2.q_smallint', 'PARTITION by t2.q_tinyint',
                     'PARTITION by t2.q_float', 'PARTITION by t2.q_double' , 'PARTITION by t2.q_binary', 'PARTITION by t2.q_nchar', 'PARTITION by t2.q_bool' ,'PARTITION BY t2.q_bigint',
-                    'PARTITION by t2.q_binary ,t2.q_nchar ,t2.q_bool' , 'PARTITION by t2.q_int ,t2.q_smallint ,t2.q_tinyint' , 'PARTITION by t2.q_float ,t2.q_double ']   
- 
-        partiton_where_regular = ['PARTITION BY tbname ' , 'PARTITION BY tbname', 'PARTITION BY tbname, q_bigint', 'PARTITION BY tbname,q_int', 'PARTITION BY tbname, q_smallint', 'PARTITION BY tbname,q_tinyint', 
+                    'PARTITION by t2.q_binary ,t2.q_nchar ,t2.q_bool' , 'PARTITION by t2.q_int ,t2.q_smallint ,t2.q_tinyint' , 'PARTITION by t2.q_float ,t2.q_double ']
+
+        partiton_where_regular = ['PARTITION BY tbname ' , 'PARTITION BY tbname', 'PARTITION BY tbname, q_bigint', 'PARTITION BY tbname,q_int', 'PARTITION BY tbname, q_smallint', 'PARTITION BY tbname,q_tinyint',
                     'PARTITION BY tbname,q_float', 'PARTITION BY tbname,q_double' , 'PARTITION BY tbname,q_binary', 'PARTITION BY tbname,q_nchar', 'PARTITION BY tbname,q_bool' ,'PARTITION BY tbname ,q_bigint',
                     'PARTITION BY tbname,q_binary ,q_nchar ,q_bool' , 'PARTITION BY tbname,q_int ,q_smallint ,q_tinyint' , 'PARTITION BY tbname,q_float ,q_double ']
-        partiton_where_regular_j = ['PARTITION by t1.q_bigint', 'PARTITION by t1.q_int', 'PARTITION by t1.q_smallint', 'PARTITION by t1.q_tinyint', 
+        partiton_where_regular_j = ['PARTITION by t1.q_bigint', 'PARTITION by t1.q_int', 'PARTITION by t1.q_smallint', 'PARTITION by t1.q_tinyint',
                     'PARTITION by t1.q_float', 'PARTITION by t1.q_double' , 'PARTITION by t1.q_binary', 'PARTITION by t1.q_nchar', 'PARTITION by t1.q_bool' ,'PARTITION BY t1.q_bigint',
                     'PARTITION by t1.q_binary ,t1.q_nchar ,t1.q_bool' , 'PARTITION by t1.q_int ,t1.q_smallint ,t1.q_tinyint' , 'PARTITION by t1.q_float ,t1.q_double ',
-                    'PARTITION by t2.q_bigint', 'PARTITION by t2.q_int', 'PARTITION by t2.q_smallint', 'PARTITION by t2.q_tinyint', 
+                    'PARTITION by t2.q_bigint', 'PARTITION by t2.q_int', 'PARTITION by t2.q_smallint', 'PARTITION by t2.q_tinyint',
                     'PARTITION by t2.q_float', 'PARTITION by t2.q_double' , 'PARTITION by t2.q_binary', 'PARTITION by t2.q_nchar', 'PARTITION by t2.q_bool' ,'PARTITION BY t2.q_bigint',
-                    'PARTITION by t2.q_binary ,t2.q_nchar ,t2.q_bool' , 'PARTITION by t2.q_int ,t2.q_smallint ,t2.q_tinyint' , 'PARTITION by t2.q_float ,t2.q_double ']           
-                
+                    'PARTITION by t2.q_binary ,t2.q_nchar ,t2.q_bool' , 'PARTITION by t2.q_int ,t2.q_smallint ,t2.q_tinyint' , 'PARTITION by t2.q_float ,t2.q_double ']
+
         having_support = ['having count(q_int) > 0','having count(q_bigint) > 0','having count(q_smallint) > 0','having count(q_tinyint) > 0','having count(q_float) > 0','having count(q_double) > 0','having count(q_bool) > 0',
                     'having avg(q_int) > 0','having avg(q_bigint) > 0','having avg(q_smallint) > 0','having avg(q_tinyint) > 0','having avg(q_float) > 0','having avg(q_double) > 0',
                     'having sum(q_int) > 0','having sum(q_bigint) > 0','having sum(q_smallint) > 0','having sum(q_tinyint) > 0','having sum(q_float) > 0','having sum(q_double) > 0',
@@ -440,9 +440,9 @@ class TDTestCase:
         having_not_support = ['having TOP(q_int,10) > 0','having TOP(q_bigint,10) > 0','having TOP(q_smallint,10) > 0','having TOP(q_tinyint,10) > 0','having TOP(q_float,10) > 0','having TOP(q_double,10) > 0','having TOP(q_bool,10) > 0',
                     'having BOTTOM(q_int,10) > 0','having BOTTOM(q_bigint,10) > 0','having BOTTOM(q_smallint,10) > 0','having BOTTOM(q_tinyint,10) > 0','having BOTTOM(q_float,10) > 0','having BOTTOM(q_double,10) > 0','having BOTTOM(q_bool,10) > 0',
                     'having LEASTSQUARES(q_int) > 0','having  LEASTSQUARES(q_bigint) > 0','having  LEASTSQUARES(q_smallint) > 0','having  LEASTSQUARES(q_tinyint) > 0','having  LEASTSQUARES(q_float) > 0','having  LEASTSQUARES(q_double) > 0','having  LEASTSQUARES(q_bool) > 0',
-                    'having FIRST(q_bool) > 0','having IRATE(q_bool) > 0','having PERCENTILE(q_bool,10) > 0','having avg(q_bool) > 0','having LAST_ROW(q_bool) > 0','having sum(q_bool) > 0','having STDDEV(q_bool) > 0','having APERCENTILE(q_bool,10) > 0','having  TWA(q_bool) > 0','having LAST(q_bool) > 0',                    
+                    'having FIRST(q_bool) > 0','having IRATE(q_bool) > 0','having PERCENTILE(q_bool,10) > 0','having avg(q_bool) > 0','having LAST_ROW(q_bool) > 0','having sum(q_bool) > 0','having STDDEV(q_bool) > 0','having APERCENTILE(q_bool,10) > 0','having  TWA(q_bool) > 0','having LAST(q_bool) > 0',
                     'having PERCENTILE(q_int,10) > 0','having PERCENTILE(q_bigint,10) > 0','having PERCENTILE(q_smallint,10) > 0','having PERCENTILE(q_tinyint,10) > 0','having PERCENTILE(q_float,10) > 0','having PERCENTILE(q_double,10) > 0']
-        having_tagnot_support = ['having LAST_ROW(q_int) > 0','having LAST_ROW(q_bigint) > 0','having LAST_ROW(q_smallint) > 0','having LAST_ROW(q_tinyint) > 0','having LAST_ROW(q_float) > 0','having LAST_ROW(q_double) > 0']    
+        having_tagnot_support = ['having LAST_ROW(q_int) > 0','having LAST_ROW(q_bigint) > 0','having LAST_ROW(q_smallint) > 0','having LAST_ROW(q_tinyint) > 0','having LAST_ROW(q_float) > 0','having LAST_ROW(q_double) > 0']
 
         having_support_j = ['having count(t1.q_int) > 0','having count(t1.q_bigint) > 0','having count(t1.q_smallint) > 0','having count(t1.q_tinyint) > 0','having count(t1.q_float) > 0','having count(t1.q_double) > 0','having count(t1.q_bool) > 0',
                     'having avg(t1.q_int) > 0','having avg(t1.q_bigint) > 0','having avg(t1.q_smallint) > 0','having avg(t1.q_tinyint) > 0','having avg(t1.q_float) > 0','having avg(t1.q_double) > 0',
@@ -455,7 +455,7 @@ class TDTestCase:
                     'having FIRST(t1.q_int) > 0','having FIRST(t1.q_bigint) > 0','having FIRST(t1.q_smallint) > 0','having FIRST(t1.q_tinyint) > 0','having FIRST(t1.q_float) > 0','having FIRST(t1.q_double) > 0',
                     'having LAST(t1.q_int) > 0','having LAST(t1.q_bigint) > 0','having LAST(t1.q_smallint) > 0','having LAST(t1.q_tinyint) > 0','having LAST(t1.q_float) > 0','having LAST(t1.q_double) > 0',
                     'having APERCENTILE(t1.q_int,10) > 0','having APERCENTILE(t1.q_bigint,10) > 0','having APERCENTILE(t1.q_smallint,10) > 0','having APERCENTILE(t1.q_tinyint,10) > 0','having APERCENTILE(t1.q_float,10) > 0','having APERCENTILE(t1.q_double,10) > 0']
-        
+
         # limit offset where
         limit_where = ['limit 1 offset 1' , 'limit 1' , 'limit 2 offset 1' , 'limit 2', 'limit 12 offset 1' , 'limit 20', 'limit 20 offset 10' , 'limit 200']
         limit1_where = ['limit 1 offset 1' , 'limit 1' ]
@@ -464,8 +464,8 @@ class TDTestCase:
         # slimit soffset where
         slimit_where = ['slimit 1 soffset 1' , 'slimit 1' , 'slimit 2 soffset 1' , 'slimit 2']
         slimit1_where = ['slimit 2 soffset 1' , 'slimit 1' ]
-        
-        # aggregate function include [all:count(*)\avg\sum\stddev ||regualr:twa\irate\leastsquares ||group by tbname:twa\irate\]       
+
+        # aggregate function include [all:count(*)\avg\sum\stddev ||regualr:twa\irate\leastsquares ||group by tbname:twa\irate\]
         # select function include [all: min\max\first(*)\last(*)\top\bottom\apercentile\last_row(*)(not with interval)\interp(*)(FILL) ||regualr: percentile]
         # calculation function include [all:spread\+-*/ ||regualr:diff\derivative ||group by tbname:diff\derivative\]
         # **_ns_**  express is not support stable, therefore, separated from regular tables
@@ -475,7 +475,7 @@ class TDTestCase:
 
         # calc_select_all   calc_select_regular  calc_select_in_ts  calc_select_fill  calc_select_not_interval
         # select function include [all: min\max\first(*)\last(*)\top\bottom\apercentile\last_row(*)(not with interval)\interp(*)(FILL) ||regualr: percentile]
-        
+
         calc_select_all = ['bottom(q_int,20)' , 'bottom(q_bigint,20)' , 'bottom(q_smallint,20)' , 'bottom(q_tinyint,20)' ,'bottom(q_float,20)' , 'bottom(q_double,20)' ,
                     'top(q_int,20)' , 'top(q_bigint,20)' , 'top(q_smallint,20)' ,'top(q_tinyint,20)' ,'top(q_float,20)' ,'top(q_double,20)' ,
                     'first(q_int)' , 'first(q_bigint)' , 'first(q_smallint)' , 'first(q_tinyint)' , 'first(q_float)' ,'first(q_double)' ,'first(q_binary)' ,'first(q_nchar)' ,'first(q_bool)' ,'first(q_ts)' ,
@@ -483,7 +483,7 @@ class TDTestCase:
                     'min(q_int)' , 'min(q_bigint)' , 'min(q_smallint)' , 'min(q_tinyint)' , 'min(q_float)' ,'min(q_double)' ,
                     'max(q_int)' ,  'max(q_bigint)' , 'max(q_smallint)' , 'max(q_tinyint)' ,'max(q_float)' ,'max(q_double)' ,
                     'apercentile(q_int,20)' ,  'apercentile(q_bigint,20)'  ,'apercentile(q_smallint,20)'  ,'apercentile(q_tinyint,20)' ,'apercentile(q_float,20)'  ,'apercentile(q_double,20)' ,
-                    'last_row(q_int)' ,  'last_row(q_bigint)' , 'last_row(q_smallint)' , 'last_row(q_tinyint)' , 'last_row(q_float)' , 
+                    'last_row(q_int)' ,  'last_row(q_bigint)' , 'last_row(q_smallint)' , 'last_row(q_tinyint)' , 'last_row(q_float)' ,
                     'last_row(q_double)' , 'last_row(q_bool)' ,'last_row(q_binary)' ,'last_row(q_nchar)' ,'last_row(q_ts)']
 
         calc_select_in_ts = ['bottom(q_int,20)' , 'bottom(q_bigint,20)' , 'bottom(q_smallint,20)' , 'bottom(q_tinyint,20)' ,'bottom(q_float,20)' , 'bottom(q_double,20)' ,
@@ -494,23 +494,23 @@ class TDTestCase:
         calc_select_in = ['min(q_int)' , 'min(q_bigint)' , 'min(q_smallint)' , 'min(q_tinyint)' , 'min(q_float)' ,'min(q_double)' ,
                     'max(q_int)' ,  'max(q_bigint)' , 'max(q_smallint)' , 'max(q_tinyint)' ,'max(q_float)' ,'max(q_double)' ,
                     'apercentile(q_int,20)' ,  'apercentile(q_bigint,20)'  ,'apercentile(q_smallint,20)'  ,'apercentile(q_tinyint,20)' ,'apercentile(q_float,20)'  ,'apercentile(q_double,20)' ,
-                    'last_row(q_int)' ,  'last_row(q_bigint)' , 'last_row(q_smallint)' , 'last_row(q_tinyint)' , 'last_row(q_float)' , 
+                    'last_row(q_int)' ,  'last_row(q_bigint)' , 'last_row(q_smallint)' , 'last_row(q_tinyint)' , 'last_row(q_float)' ,
                     'last_row(q_double)' , 'last_row(q_bool)' ,'last_row(q_binary)' ,'last_row(q_nchar)' ,'last_row(q_ts)']
-        
+
         calc_select_not_support_ts = ['first(q_int)' , 'first(q_bigint)' , 'first(q_smallint)' , 'first(q_tinyint)' , 'first(q_float)' ,'first(q_double)' ,'first(q_binary)' ,'first(q_nchar)' ,'first(q_bool)' ,'first(q_ts)' ,
                     'last(q_int)' ,  'last(q_bigint)' , 'last(q_smallint)'  , 'last(q_tinyint)' , 'last(q_float)'  ,'last(q_double)' , 'last(q_binary)' ,'last(q_nchar)' ,'last(q_bool)' ,'last(q_ts)' ,
-                    'last_row(q_int)' ,  'last_row(q_bigint)' , 'last_row(q_smallint)' , 'last_row(q_tinyint)' , 'last_row(q_float)' , 
+                    'last_row(q_int)' ,  'last_row(q_bigint)' , 'last_row(q_smallint)' , 'last_row(q_tinyint)' , 'last_row(q_float)' ,
                     'last_row(q_double)' , 'last_row(q_bool)' ,'last_row(q_binary)' ,'last_row(q_nchar)' ,'last_row(q_ts)',
-                    'apercentile(q_int,20)' ,  'apercentile(q_bigint,20)'  ,'apercentile(q_smallint,20)'  ,'apercentile(q_tinyint,20)' ,'apercentile(q_float,20)'  ,'apercentile(q_double,20)']  
-              
+                    'apercentile(q_int,20)' ,  'apercentile(q_bigint,20)'  ,'apercentile(q_smallint,20)'  ,'apercentile(q_tinyint,20)' ,'apercentile(q_float,20)'  ,'apercentile(q_double,20)']
+
         calc_select_support_ts = ['bottom(q_int,20)' , 'bottom(q_bigint,20)' , 'bottom(q_smallint,20)' , 'bottom(q_tinyint,20)' ,'bottom(q_float,20)' , 'bottom(q_double,20)' ,
                     'top(q_int,20)' , 'top(q_bigint,20)' , 'top(q_smallint,20)' ,'top(q_tinyint,20)' ,'top(q_float,20)' ,'top(q_double,20)' ,
                     'min(q_int)' , 'min(q_bigint)' , 'min(q_smallint)' , 'min(q_tinyint)' , 'min(q_float)' ,'min(q_double)' ,
                     'max(q_int)' ,  'max(q_bigint)' , 'max(q_smallint)' , 'max(q_tinyint)' ,'max(q_float)' ,'max(q_double)'  ]
-        
+
         calc_select_regular = [ 'PERCENTILE(q_int,10)' ,'PERCENTILE(q_bigint,20)' , 'PERCENTILE(q_smallint,30)' ,'PERCENTILE(q_tinyint,40)' ,'PERCENTILE(q_float,50)' ,'PERCENTILE(q_double,60)']
 
-                    
+
         calc_select_fill = ['INTERP(q_int)' ,'INTERP(q_bigint)' ,'INTERP(q_smallint)' ,'INTERP(q_tinyint)', 'INTERP(q_float)' ,'INTERP(q_double)']
         interp_where = ['ts = now' , 'ts = \'2020-09-13 20:26:40.000\'' , 'ts = \'2020-09-13 20:26:40.009\'' ,'tbname in (\'table_1\') and ts = now' ,'tbname in (\'table_0\' ,\'table_1\',\'table_2\',\'table_3\',\'table_4\',\'table_5\') and ts =  \'2020-09-13 20:26:40.000\'','tbname like \'table%\'  and ts =  \'2020-09-13 20:26:40.002\'']
 
@@ -535,28 +535,28 @@ class TDTestCase:
                     ]
 
         calc_select_in_not_support_ts_j = ['apercentile(t1.q_int,20)' ,  'apercentile(t1.q_bigint,20)'  ,'apercentile(t1.q_smallint,20)'  ,'apercentile(t1.q_tinyint,20)' ,'apercentile(t1.q_float,20)'  ,'apercentile(t1.q_double,20)' ,
-                    'last_row(t1.q_int)' ,  'last_row(t1.q_bigint)' , 'last_row(t1.q_smallint)' , 'last_row(t1.q_tinyint)' , 'last_row(t1.q_float)' , 
+                    'last_row(t1.q_int)' ,  'last_row(t1.q_bigint)' , 'last_row(t1.q_smallint)' , 'last_row(t1.q_tinyint)' , 'last_row(t1.q_float)' ,
                     'last_row(t1.q_double)' , 'last_row(t1.q_bool)' ,'last_row(t1.q_binary)' ,'last_row(t1.q_nchar)' ,'last_row(t1.q_ts)' ,
                     'apercentile(t2.q_int,20)' ,  'apercentile(t2.q_bigint,20)'  ,'apercentile(t2.q_smallint,20)'  ,'apercentile(t2.q_tinyint,20)' ,'apercentile(t2.q_float,20)'  ,'apercentile(t2.q_double,20)' ,
-                    'last_row(t2.q_int)' ,  'last_row(t2.q_bigint)' , 'last_row(t2.q_smallint)' , 'last_row(t2.q_tinyint)' , 'last_row(t2.q_float)' , 
+                    'last_row(t2.q_int)' ,  'last_row(t2.q_bigint)' , 'last_row(t2.q_smallint)' , 'last_row(t2.q_tinyint)' , 'last_row(t2.q_float)' ,
                     'last_row(t2.q_double)' , 'last_row(t2.q_bool)' ,'last_row(t2.q_binary)' ,'last_row(t2.q_nchar)' ,'last_row(t2.q_ts)']
 
         calc_select_in_j = ['min(t1.q_int)' , 'min(t1.q_bigint)' , 'min(t1.q_smallint)' , 'min(t1.q_tinyint)' , 'min(t1.q_float)' ,'min(t1.q_double)' ,
                     'max(t1.q_int)' ,  'max(t1.q_bigint)' , 'max(t1.q_smallint)' , 'max(t1.q_tinyint)' ,'max(t1.q_float)' ,'max(t1.q_double)' ,
                     'apercentile(t1.q_int,20)' ,  'apercentile(t1.q_bigint,20)'  ,'apercentile(t1.q_smallint,20)'  ,'apercentile(t1.q_tinyint,20)' ,'apercentile(t1.q_float,20)'  ,'apercentile(t1.q_double,20)' ,
-                    'last_row(t1.q_int)' ,  'last_row(t1.q_bigint)' , 'last_row(t1.q_smallint)' , 'last_row(t1.q_tinyint)' , 'last_row(t1.q_float)' , 
+                    'last_row(t1.q_int)' ,  'last_row(t1.q_bigint)' , 'last_row(t1.q_smallint)' , 'last_row(t1.q_tinyint)' , 'last_row(t1.q_float)' ,
                     'last_row(t1.q_double)' , 'last_row(t1.q_bool)' ,'last_row(t1.q_binary)' ,'last_row(t1.q_nchar)' ,'last_row(t1.q_ts)' ,
                     'min(t2.q_int)' , 'min(t2.q_bigint)' , 'min(t2.q_smallint)' , 'min(t2.q_tinyint)' , 'min(t2.q_float)' ,'min(t2.q_double)' ,
                     'max(t2.q_int)' ,  'max(t2.q_bigint)' , 'max(t2.q_smallint)' , 'max(t2.q_tinyint)' ,'max(t2.q_float)' ,'max(t2.q_double)' ,
                     'apercentile(t2.q_int,20)' ,  'apercentile(t2.q_bigint,20)'  ,'apercentile(t2.q_smallint,20)'  ,'apercentile(t2.q_tinyint,20)' ,'apercentile(t2.q_float,20)'  ,'apercentile(t2.q_double,20)' ,
-                    'last_row(t2.q_int)' ,  'last_row(t2.q_bigint)' , 'last_row(t2.q_smallint)' , 'last_row(t2.q_tinyint)' , 'last_row(t2.q_float)' , 
-                    'last_row(t2.q_double)' , 'last_row(t2.q_bool)' ,'last_row(t2.q_binary)' ,'last_row(t2.q_nchar)' ,'last_row(t2.q_ts)']        
+                    'last_row(t2.q_int)' ,  'last_row(t2.q_bigint)' , 'last_row(t2.q_smallint)' , 'last_row(t2.q_tinyint)' , 'last_row(t2.q_float)' ,
+                    'last_row(t2.q_double)' , 'last_row(t2.q_bool)' ,'last_row(t2.q_binary)' ,'last_row(t2.q_nchar)' ,'last_row(t2.q_ts)']
         calc_select_all_j = calc_select_in_ts_j + calc_select_in_j
 
         calc_select_regular_j = [ 'PERCENTILE(t1.q_int,10)' ,'PERCENTILE(t1.q_bigint,20)' , 'PERCENTILE(t1.q_smallint,30)' ,'PERCENTILE(t1.q_tinyint,40)' ,'PERCENTILE(t1.q_float,50)' ,'PERCENTILE(t1.q_double,60)' ,
                     'PERCENTILE(t2.q_int,10)' ,'PERCENTILE(t2.q_bigint,20)' , 'PERCENTILE(t2.q_smallint,30)' ,'PERCENTILE(t2.q_tinyint,40)' ,'PERCENTILE(t2.q_float,50)' ,'PERCENTILE(t2.q_double,60)']
 
-                    
+
         calc_select_fill_j = ['INTERP(t1.q_int)' ,'INTERP(t1.q_bigint)' ,'INTERP(t1.q_smallint)' ,'INTERP(t1.q_tinyint)', 'INTERP(t1.q_float)' ,'INTERP(t1.q_double)' ,
                     'INTERP(t2.q_int)' ,'INTERP(t2.q_bigint)' ,'INTERP(t2.q_smallint)' ,'INTERP(t2.q_tinyint)', 'INTERP(t2.q_float)' ,'INTERP(t2.q_double)']
         interp_where_j = ['t1.ts = now' , 't1.ts = \'2020-09-13 20:26:40.000\'' , 't1.ts = \'2020-09-13 20:26:40.009\'' ,'t2.ts = now' , 't2.ts = \'2020-09-13 20:26:40.000\'' , 't2.ts = \'2020-09-13 20:26:40.009\'' ,
@@ -578,7 +578,7 @@ class TDTestCase:
                     'PERCENTILE(q_int,10)' ,'PERCENTILE(q_bigint,20)' , 'PERCENTILE(q_smallint,30)' ,'PERCENTILE(q_tinyint,40)' ,'PERCENTILE(q_float,50)' ,'PERCENTILE(q_double,60)']
 
         calc_aggregate_groupbytbname = ['twa(q_int)' ,'twa(q_bigint)' , 'twa(q_smallint)' ,'twa(q_tinyint)' ,'twa (q_float)' ,'twa(q_double)' ,
-                    'IRATE(q_int)' ,'IRATE(q_bigint)' , 'IRATE(q_smallint)' ,'IRATE(q_tinyint)' ,'IRATE (q_float)' ,'IRATE(q_double)' ] 
+                    'IRATE(q_int)' ,'IRATE(q_bigint)' , 'IRATE(q_smallint)' ,'IRATE(q_tinyint)' ,'IRATE (q_float)' ,'IRATE(q_double)' ]
 
         #two table join
         calc_aggregate_all_j = ['count(t1.*)' , 'count(t1.q_int)' ,'count(t1.q_bigint)' , 'count(t1.q_smallint)' ,'count(t1.q_tinyint)' ,'count(t1.q_float)' ,
@@ -606,18 +606,18 @@ class TDTestCase:
         calc_aggregate_groupbytbname_j = ['twa(t1.q_int)' ,'twa(t1.q_bigint)' , 'twa(t1.q_smallint)' ,'twa(t1.q_tinyint)' ,'twa (t1.q_float)' ,'twa(t1.q_double)' ,
                     'IRATE(t1.q_int)' ,'IRATE(t1.q_bigint)' , 'IRATE(t1.q_smallint)' ,'IRATE(t1.q_tinyint)' ,'IRATE (t1.q_float)' ,'IRATE(t1.q_double)' ,
                     'twa(t2.q_int)' ,'twa(t2.q_bigint)' , 'twa(t2.q_smallint)' ,'twa(t2.q_tinyint)' ,'twa (t2.q_float)' ,'twa(t2.q_double)' ,
-                    'IRATE(t2.q_int)' ,'IRATE(t2.q_bigint)' , 'IRATE(t2.q_smallint)' ,'IRATE(t2.q_tinyint)' ,'IRATE (t2.q_float)' ,'IRATE(t2.q_double)' ] 
-        
+                    'IRATE(t2.q_int)' ,'IRATE(t2.q_bigint)' , 'IRATE(t2.q_smallint)' ,'IRATE(t2.q_tinyint)' ,'IRATE (t2.q_float)' ,'IRATE(t2.q_double)' ]
+
         # calc_calculate_all   calc_calculate_regular   calc_calculate_groupbytbname
         # calculation function include [all:spread\+-*/ ||regualr:diff\derivative ||group by tbname:diff\derivative\]
-        calc_calculate_all = ['SPREAD(ts)'  , 'SPREAD(q_ts)'  , 'SPREAD(q_int)' ,'SPREAD(q_bigint)' , 'SPREAD(q_smallint)' ,'SPREAD(q_tinyint)' ,'SPREAD(q_float)' ,'SPREAD(q_double)' , 
+        calc_calculate_all = ['SPREAD(ts)'  , 'SPREAD(q_ts)'  , 'SPREAD(q_int)' ,'SPREAD(q_bigint)' , 'SPREAD(q_smallint)' ,'SPREAD(q_tinyint)' ,'SPREAD(q_float)' ,'SPREAD(q_double)' ,
                      '(SPREAD(q_int) + SPREAD(q_bigint))' , '(SPREAD(q_smallint) - SPREAD(q_float))', '(SPREAD(q_double) * SPREAD(q_tinyint))' , '(SPREAD(q_double) / SPREAD(q_float))']
         calc_calculate_regular = ['DIFF(q_int)' ,'DIFF(q_bigint)' , 'DIFF(q_smallint)' ,'DIFF(q_tinyint)' ,'DIFF(q_float)' ,'DIFF(q_double)' ,
                                   'DIFF(q_int,0)' ,'DIFF(q_bigint,0)' , 'DIFF(q_smallint,0)' ,'DIFF(q_tinyint,0)' ,'DIFF(q_float,0)' ,'DIFF(q_double,0)' ,
                                   'DIFF(q_int,1)' ,'DIFF(q_bigint,1)' , 'DIFF(q_smallint,1)' ,'DIFF(q_tinyint,1)' ,'DIFF(q_float,1)' ,'DIFF(q_double,1)' ,
                     'DERIVATIVE(q_int,15s,0)' , 'DERIVATIVE(q_bigint,10s,1)' , 'DERIVATIVE(q_smallint,20s,0)' ,'DERIVATIVE(q_tinyint,10s,1)' ,'DERIVATIVE(q_float,6s,0)' ,'DERIVATIVE(q_double,3s,1)' ]
         calc_calculate_groupbytbname = calc_calculate_regular
-        
+
         #two table join
         calc_calculate_all_j = ['SPREAD(t1.ts)'  , 'SPREAD(t1.q_ts)'  , 'SPREAD(t1.q_int)' ,'SPREAD(t1.q_bigint)' , 'SPREAD(t1.q_smallint)' ,'SPREAD(t1.q_tinyint)' ,'SPREAD(t1.q_float)' ,'SPREAD(t1.q_double)' ,
                     'SPREAD(t2.ts)'  , 'SPREAD(t2.q_ts)'  , 'SPREAD(t2.q_int)' ,'SPREAD(t2.q_bigint)' , 'SPREAD(t2.q_smallint)' ,'SPREAD(t2.q_tinyint)' ,'SPREAD(t2.q_float)' ,'SPREAD(t2.q_double)' ,
@@ -646,17 +646,17 @@ class TDTestCase:
             #sql = "select  ts , * from  ( select  "   ===暂时不支持select * ,用下面这一行
             sql = "select  ts  from  ( select  "
             sql += "%s, " % random.choice(s_s_select)
-            sql += "%s, " % random.choice(q_select) 
+            sql += "%s, " % random.choice(q_select)
             sql += "ts from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ");"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(100)
-            
-        #1 outer union not support        
+
+        #1 outer union not support
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 1-2 from stable_1;")
         for i in range(self.fornum):
@@ -677,11 +677,11 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(100)
-                   
+
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 1-2 from stable_1;")
         for i in range(self.fornum):
@@ -702,11 +702,11 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(200)
-            
+
         #1 inter union not support
         tdSql.query("select 1-3 from stable_1;")
         for i in range(self.fornum):
@@ -716,7 +716,7 @@ class TDTestCase:
             sql += "%s, " % random.choice(q_select)
             sql += "ts from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
-            sql += ""  
+            sql += ""
             sql += " union select  "
             sql += "%s, " % random.choice(s_r_select)
             sql += "%s, " % random.choice(q_select)
@@ -724,8 +724,8 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15606 tdSql.query(sql)
             # tdSql.checkRows(200)
         tdSql.query("select 1-3 from stable_1;")
@@ -743,60 +743,60 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15607 tdSql.query(sql)
             # tdSql.checkRows(300)
-            
-        #join:TD-6020\TD-6149 select * from (select column form regular_table1，regular_table2 where  t1.ts=t2.ts and <\>\in\and\or order by)       
+
+        #join:TD-6020\TD-6149 select * from (select column form regular_table1，regular_table2 where  t1.ts=t2.ts and <\>\in\and\or order by)
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 1-4 from stable_1;")
         for i in range(self.fornum):
             #sql = "select  ts , * from  ( select  t1.ts ,"
             sql = "select  *  from  ( select  t1.ts ,"
-            sql += "t1.%s, " % random.choice(q_select)            
-            sql += "t1.%s, " % random.choice(q_select) 
-            sql += "t2.%s, " % random.choice(q_select)            
-            sql += "t2.%s, " % random.choice(q_select)            
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
             sql += "t2.ts from regular_table_1 t1 , regular_table_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(order_u_where)
             sql += ");"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(100)
 
         tdSql.query("select 1-5 from stable_1;")
         for i in range(self.fornum):
             sql = "select  ts , * from  ( select  t1.ts ,"
-            sql += "t1.%s, " % random.choice(q_select)            
-            sql += "t1.%s, " % random.choice(q_select) 
-            sql += "t2.%s, " % random.choice(q_select)            
-            sql += "t2.%s, " % random.choice(q_select)            
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
             sql += "t2.ts from regular_table_1 t1 , regular_table_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(order_u_where)
             sql += ");"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.error(sql)
             # TD-15587 tdSql.query(sql)
             # tdSql.checkRows(100)
 
-        #2 select column from (select * form regular_table ) where <\>\in\and\or order by        
+        #2 select column from (select * form regular_table ) where <\>\in\and\or order by
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 2-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  ts ,"
             sql += "%s, " % random.choice(s_r_select)
-            sql += "%s  " % random.choice(q_select) 
+            sql += "%s  " % random.choice(q_select)
             sql += " from  ( select  * from regular_table_1 ) where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += " ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(100)
 
@@ -805,31 +805,31 @@ class TDTestCase:
         tdSql.query("select 2-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select  ts , * from  ( select  t1.ts ,"
-            sql += "t1.%s, " % random.choice(q_select)            
-            sql += "t1.%s, " % random.choice(q_select) 
-            sql += "t2.%s, " % random.choice(q_select)            
-            sql += "t2.%s, " % random.choice(q_select)            
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
             sql += "t2.ts from regular_table_1 t1 , regular_table_2 t2 ) where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(order_u_where)
             #sql += ");"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.error(sql) 
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.error(sql)
 
-        #3 select * from (select column\tag form stable  where <\>\in\and\or order by )        
+        #3 select * from (select column\tag form stable  where <\>\in\and\or order by )
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 3-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   *  from  ( select  "
             sql += "%s, " % random.choice(s_s_select)
-            sql += "%s, " % random.choice(q_select) 
-            sql += "%s, " % random.choice(t_select) 
+            sql += "%s, " % random.choice(q_select)
+            sql += "%s, " % random.choice(t_select)
             sql += "ts from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_where)
             sql += ") ;"
-            tdLog.info(sql) 
+            tdLog.info(sql)
             tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(300)
@@ -839,35 +839,35 @@ class TDTestCase:
             sql += "%s  " % random.choice(s_r_select)
             sql += "from  ( select  "
             sql += "%s, " % random.choice(s_s_select)
-            sql += "%s, " % random.choice(q_select) 
-            sql += "%s, " % random.choice(t_select) 
+            sql += "%s, " % random.choice(q_select)
+            sql += "%s, " % random.choice(t_select)
             sql += "ts from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_where)
             sql += ") ;"
-            tdLog.info(sql) 
+            tdLog.info(sql)
             tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(300)
 
-        # select ts,* from (select column\tag form stable1,stable2  where t1.ts = t2.ts and <\>\in\and\or order by )        
+        # select ts,* from (select column\tag form stable1,stable2  where t1.ts = t2.ts and <\>\in\and\or order by )
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 3-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select  ts , *  from  ( select  t1.ts , "
-            sql += "t1.%s, " % random.choice(s_s_select)            
-            sql += "t1.%s, " % random.choice(q_select) 
-            sql += "t2.%s, " % random.choice(s_s_select)            
-            sql += "t2.%s, " % random.choice(q_select) 
+            sql += "t1.%s, " % random.choice(s_s_select)
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(s_s_select)
+            sql += "t2.%s, " % random.choice(q_select)
             sql += "t2.ts from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(order_u_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             # TD-15609 tdSql.query(sql)
             # tdSql.checkRows(100)
-    
+
         #3 outer union not support
         rsDn = self.restartDnodes()
         tdSql.query("select 3-3 from stable_1;")
@@ -887,8 +887,8 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(200)
         for i in range(self.fornum):
@@ -907,11 +907,11 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(400)
-            
+
         #3 inter union not support
         tdSql.query("select 3-4 from stable_1;")
         for i in range(self.fornum):
@@ -929,57 +929,57 @@ class TDTestCase:
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += ")"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.error(sql)
 
         #join:select * from (select column form stable1，stable2 where  t1.ts=t2.ts and <\>\in\and\or order by)
         tdSql.query("select 3-5 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  t1.ts ,"
-            sql += "t1.%s, " % random.choice(q_select)            
-            sql += "t1.%s, " % random.choice(q_select) 
-            sql += "t2.%s, " % random.choice(q_select)            
-            sql += "t2.%s, " % random.choice(q_select)            
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
             sql += "t2.ts from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(t_u_where)
             sql += "%s " % random.choice(order_u_where)
             sql += ");"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))  
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             # TD-15609 tdSql.query(sql)
             # tdSql.checkRows(100)
 
         tdSql.query("select 3-6 from stable_1;")
         for i in range(self.fornum):
             sql = "select  * from  ( select  t1.ts ,"
-            sql += "t1.%s, " % random.choice(q_select)            
-            sql += "t1.%s, " % random.choice(q_select) 
-            sql += "t2.%s, " % random.choice(q_select)            
-            sql += "t2.%s, " % random.choice(q_select)            
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t1.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
+            sql += "t2.%s, " % random.choice(q_select)
             sql += "t2.ts from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(t_u_or_where)
             sql += "%s " % random.choice(order_u_where)
             sql += ");"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
              # TD-15609 同上 tdSql.query(sql)
             # tdSql.checkRows(100)
 
-        #4 select column from (select * form stable  where <\>\in\and\or order by )        
+        #4 select column from (select * form stable  where <\>\in\and\or order by )
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 4-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  ts , "
             sql += "%s, " % random.choice(s_r_select)
-            sql += "%s, " % random.choice(q_select) 
-            sql += "%s  " % random.choice(t_select) 
+            sql += "%s, " % random.choice(q_select)
+            sql += "%s  " % random.choice(t_select)
             sql += " from  ( select  * from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15616 tdSql.query(sql)
             # tdSql.checkRows(300)
 
@@ -992,8 +992,8 @@ class TDTestCase:
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15500 tdSql.query(sql)
 
         #5-1 select distinct column\tag from (select calc form stable  where <\>\in\and\or order by limit offset )
@@ -1001,13 +1001,13 @@ class TDTestCase:
         for i in range(self.fornum):
             sql = "select  distinct  c5_1 "
             sql += " from  ( select   "
-            sql += "%s " % random.choice(calc_select_in_ts) 
+            sql += "%s " % random.choice(calc_select_in_ts)
             sql += " as c5_1 from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             #sql += "%s " % random.choice(order_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             #tdSql.checkRows(1)有的函数还没有提交，会不返回结果，先忽略
 
@@ -1020,8 +1020,8 @@ class TDTestCase:
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.error(sql)
         tdSql.query("select 6-1 from stable_1;")
         for i in range(self.fornum):
@@ -1029,8 +1029,8 @@ class TDTestCase:
             sql += "%s " % random.choice(dt_select)
             sql += "  from stable_1 where "
             sql += "%s ) ;" % random.choice(qt_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))   
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             #tdSql.checkRows(1)#数量不一致，不在校验
 
@@ -1044,8 +1044,8 @@ class TDTestCase:
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice([limit_where[0] , limit_where[1]] )
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.error(sql)  #distinct 和 order by 不能混合使用
         tdSql.query("select 7-1 from stable_1;")
         for i in range(self.fornum):
@@ -1056,166 +1056,166 @@ class TDTestCase:
             #sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice([limit_where[0] , limit_where[1]] )
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(1)
 
         #calc_select,TWA/Diff/Derivative/Irate are not allowed to apply to super table directly
         #8 select * from (select ts,calc form ragular_table  where <\>\in\and\or order by   )
-        
+
         # dcDB = self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 8-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  ts ,"
-            sql += "%s " % random.choice(calc_select_support_ts) 
+            sql += "%s " % random.choice(calc_select_support_ts)
             sql += "from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql) # 聚合函数不在可以和ts一起使用了 DB error: Not a single-group group function 
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql) # 聚合函数不在可以和ts一起使用了 DB error: Not a single-group group function
         tdSql.query("select 8-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  "
-            sql += "%s " % random.choice(calc_select_not_support_ts) 
+            sql += "%s " % random.choice(calc_select_not_support_ts)
             sql += "from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            #TD-15651 tdSql.query(sql) # 聚合函数不在可以和ts一起使用了 DB error: Not a single-group group function 
-            
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            #TD-15651 tdSql.query(sql) # 聚合函数不在可以和ts一起使用了 DB error: Not a single-group group function
+
         for i in range(self.fornum):
             sql = "select  *  from  ( select  "
-            sql += "%s " % random.choice(calc_select_in_ts) 
+            sql += "%s " % random.choice(calc_select_in_ts)
             sql += "from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             #sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             ##top返回结果有问题nest.sql tdSql.checkRows(1)
 
         tdSql.query("select 8-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select t1.ts, "
-            sql += "%s " % random.choice(calc_select_in_support_ts_j) 
+            sql += "%s " % random.choice(calc_select_in_support_ts_j)
             sql += "from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql)# 聚合函数不在可以和ts一起使用了 DB error: Not a single-group group function 
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)# 聚合函数不在可以和ts一起使用了 DB error: Not a single-group group function
         for i in range(self.fornum):
             sql = "select  *  from  ( select  "
-            sql += "%s " % random.choice(calc_select_in_not_support_ts_j) 
+            sql += "%s " % random.choice(calc_select_in_not_support_ts_j)
             sql += "from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            #TD-15651 tdSql.query(sql) 
-            ##top返回结果有问题 tdSql.checkRows(1)      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            #TD-15651 tdSql.query(sql)
+            ##top返回结果有问题 tdSql.checkRows(1)
 
-        #9 select * from (select ts,calc form stable  where <\>\in\and\or order by   )      
+        #9 select * from (select ts,calc form stable  where <\>\in\and\or order by   )
         # self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 9-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  "
-            sql += "%s " % random.choice(calc_select_not_support_ts) 
+            sql += "%s " % random.choice(calc_select_not_support_ts)
             sql += "from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
         tdSql.query("select 9-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  ts ,"
-            sql += "%s " % random.choice(calc_select_support_ts) 
+            sql += "%s " % random.choice(calc_select_support_ts)
             sql += "from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-            
+
         tdSql.query("select 9-3 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  "
-            sql += "%s " % random.choice(calc_select_in_not_support_ts_j) 
+            sql += "%s " % random.choice(calc_select_in_not_support_ts_j)
             sql += "from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += " and %s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
         tdSql.query("select 9-4 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  t1.ts,"
-            sql += "%s " % random.choice(calc_select_in_support_ts_j) 
+            sql += "%s " % random.choice(calc_select_in_support_ts_j)
             sql += "from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += " and %s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-        
-        #10 select calc from (select * form regualr_table  where <\>\in\and\or order by   )       
+
+        #10 select calc from (select * form regualr_table  where <\>\in\and\or order by   )
         tdSql.query("select 10-1 from stable_1;")
         for i in range(self.fornum):
-            sql = "select  " 
-            sql += "%s " % random.choice(calc_select_in_ts) 
+            sql = "select  "
+            sql += "%s " % random.choice(calc_select_in_ts)
             sql += "as calc10_1 from ( select * from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(1)
-        
+
         #10-1 select calc from (select * form regualr_table  where <\>\in\and\or order by   )
-        # rsDn = self.restartDnodes()        
+        # rsDn = self.restartDnodes()
         # self.dropandcreateDB_random("%s" %db, 1)
         # rsDn = self.restartDnodes()
         tdSql.query("select 10-2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select  " 
-            sql += "%s " % random.choice(calc_select_all) 
+            sql = "select  "
+            sql += "%s " % random.choice(calc_select_all)
             sql += "as calc10_2 from ( select * from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
             # tdSql.checkRows(1)
 
-        #10-2 select calc from (select * form regualr_tables  where <\>\in\and\or order by   )        
+        #10-2 select calc from (select * form regualr_tables  where <\>\in\and\or order by   )
         tdSql.query("select 10-3 from stable_1;")
         for i in range(self.fornum):
-            sql = "select  " 
-            sql += "%s as calc10_3 " % random.choice(calc_select_all) 
+            sql = "select  "
+            sql += "%s as calc10_3 " % random.choice(calc_select_all)
             sql += " from ( select * from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_where)
             sql += " and %s " % random.choice(q_u_or_where)
@@ -1223,14 +1223,14 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651  tdSql.query(sql)
 
         tdSql.query("select 10-4 from stable_1;")
         for i in range(self.fornum):
-            sql = "select  " 
-            sql += "%s as calc10_4 " % random.choice(calc_select_all) 
+            sql = "select  "
+            sql += "%s as calc10_4 " % random.choice(calc_select_all)
             sql += " from ( select * from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_or_where)
             sql += " and %s " % random.choice(q_u_or_where)
@@ -1238,112 +1238,112 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651  tdSql.query(sql)
             # tdSql.checkRows(1)
 
-        #11 select calc from (select * form stable  where <\>\in\and\or order by limit  )        
+        #11 select calc from (select * form stable  where <\>\in\and\or order by limit  )
         tdSql.query("select 11-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   "
-            sql += "%s " % random.choice(calc_select_in_ts) 
+            sql += "%s " % random.choice(calc_select_in_ts)
             sql += "as calc11_1 from ( select * from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
             tdSql.checkRows(1)
 
-        #11-1 select calc from (select * form stable  where <\>\in\and\or order by limit  )        
+        #11-1 select calc from (select * form stable  where <\>\in\and\or order by limit  )
         tdSql.query("select 11-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   "
-            sql += "%s " % random.choice(calc_select_all) 
+            sql += "%s " % random.choice(calc_select_all)
             sql += "as calc11_1 from ( select * from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
             #不好计算结果 tdSql.checkRows(1)
- 
+
         #11-2 select calc from (select * form stables  where <\>\in\and\or order by limit  )
         tdSql.query("select 11-3 from stable_1;")
         for i in range(self.fornum):
             sql = "select   "
-            sql += "%s " % random.choice(calc_select_all) 
+            sql += "%s " % random.choice(calc_select_all)
             sql += "as calc11_1 from ( select * from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
 
         tdSql.query("select 11-4 from stable_1;")
         for i in range(self.fornum):
             sql = "select   "
-            sql += "%s " % random.choice(calc_select_all) 
+            sql += "%s " % random.choice(calc_select_all)
             sql += "as calc11_1 from ( select * from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
 
-        #12 select calc-diff from (select * form regualr_table  where <\>\in\and\or order by limit  )        
+        #12 select calc-diff from (select * form regualr_table  where <\>\in\and\or order by limit  )
         ##self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 12-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  "
-            sql += "%s " % random.choice(calc_calculate_regular) 
+            sql += "%s " % random.choice(calc_calculate_regular)
             sql += " from ( select * from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             ##目前derivative不支持  tdSql.query(sql)
             # tdSql.checkRows(1)
 
         tdSql.query("select 12-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select  "
-            sql += "%s " % random.choice(calc_calculate_regular) 
+            sql += "%s " % random.choice(calc_calculate_regular)
             sql += " from ( select * from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #目前derivative不支持 tdSql.query(sql)
             # tdSql.checkRows(1)
 
         tdSql.query("select 12-2.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select  "
-            sql += "%s " % random.choice(calc_calculate_regular) 
+            sql += "%s " % random.choice(calc_calculate_regular)
             sql += " from ( select * from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #目前derivative不支持 tdSql.query(sql)
 
         #12-1 select calc-diff from (select * form stable  where <\>\in\and\or order by limit  )
@@ -1351,7 +1351,7 @@ class TDTestCase:
         rsDn = self.restartDnodes()
         for i in range(self.fornum):
             sql = "select  * from ( select "
-            sql += "%s " % random.choice(calc_calculate_regular) 
+            sql += "%s " % random.choice(calc_calculate_regular)
             sql += "  from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(group_where)
@@ -1359,15 +1359,15 @@ class TDTestCase:
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += " ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #目前derivative不支持 tdSql.query(sql)
 
         tdSql.query("select 12-4 from stable_1;")
         #join query does not support group by
         for i in range(self.fornum):
             sql = "select  * from ( select "
-            sql += "%s " % random.choice(calc_calculate_regular_j) 
+            sql += "%s " % random.choice(calc_calculate_regular_j)
             sql += "  from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(group_where_j)
@@ -1375,15 +1375,15 @@ class TDTestCase:
             #sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += " ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql) 目前de函数不支持，另外看看需要不需要将group by和pari by分开
 
         tdSql.query("select 12-5 from stable_1;")
         #join query does not support group by
         for i in range(self.fornum):
             sql = "select  * from ( select "
-            sql += "%s " % random.choice(calc_calculate_regular_j) 
+            sql += "%s " % random.choice(calc_calculate_regular_j)
             sql += "  from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(group_where_j)
@@ -1391,41 +1391,41 @@ class TDTestCase:
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += " ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #derivative not support  tdSql.query(sql)
-        
+
 
         #13 select calc-diff as diffns from (select * form stable  where <\>\in\and\or order by limit  )
         tdSql.query("select 13-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   "
-            sql += "%s " % random.choice(calc_calculate_regular) 
+            sql += "%s " % random.choice(calc_calculate_regular)
             sql += " as calc13_1 from ( select * from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(orders_desc_where)
             sql += "%s " % random.choice([limit_where[2] , limit_where[3]] )
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #derivative not support tdSql.query(sql)
 
         #14 select * from (select calc_aggregate_alls as agg from stable  where <\>\in\and\or group by order by slimit soffset )
-        # TD-5955 select   * from  ( select count (q_double)  from stable_1 where t_bool = true or  t_bool = false group by loc order by ts asc slimit 1 ) ;       
+        # TD-5955 select   * from  ( select count (q_double)  from stable_1 where t_bool = true or  t_bool = false group by loc order by ts asc slimit 1 ) ;
         tdSql.query("select 14-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all) 
-            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all) 
-            sql += "%s " % random.choice(calc_aggregate_all) 
+            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all)
+            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all)
+            sql += "%s " % random.choice(calc_aggregate_all)
             sql += " as calc14_3 from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(group_where)
             sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice(slimit1_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15678 tdSql.query(sql)
             # tdSql.checkRows(1)
 
@@ -1433,9 +1433,9 @@ class TDTestCase:
         tdSql.query("select 14-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all) 
-            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all) 
-            sql += "%s " % random.choice(calc_aggregate_all) 
+            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all)
+            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all)
+            sql += "%s " % random.choice(calc_aggregate_all)
             sql += " as calc14_3 from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(group_where)
@@ -1444,310 +1444,310 @@ class TDTestCase:
             sql += "%s " % random.choice(slimit1_where)
             sql += ") "
             sql += "%s " % random.choice(group_where)
-            tdLog.info(sql) 
+            tdLog.info(sql)
             tdLog.info(len(sql))
             #TD-15678 tdSql.query(sql)
-            # tdSql.checkRows(1) 
+            # tdSql.checkRows(1)
 
         #14-2 select * from (select calc_aggregate_all_js as agg from stables  where <\>\in\and\or group by order by slimit soffset )
         tdSql.query("select 14-3 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all_j) 
-            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all_j) 
-            sql += "%s " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all_j)
+            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all_j)
+            sql += "%s " % random.choice(calc_aggregate_all_j)
             sql += " as calc14_3 from stable_1  t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(partiton_where_j)
             sql += "%s " % random.choice(slimit1_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 14-4 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all_j) 
-            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all_j) 
-            sql += "%s " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as calc14_1, " % random.choice(calc_aggregate_all_j)
+            sql += "%s as calc14_2, " % random.choice(calc_aggregate_all_j)
+            sql += "%s " % random.choice(calc_aggregate_all_j)
             sql += " as calc14_3 from stable_1  t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(partiton_where_j)
             sql += "%s " % random.choice(slimit1_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         #15 TD-6320 select * from (select calc_aggregate_regulars as agg from regular_table  where <\>\in\and\or  order by slimit soffset )
         tdSql.query("select 15-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_regular) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_regular) 
-            sql += "%s " % random.choice(calc_aggregate_regular) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_regular)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_regular)
+            sql += "%s " % random.choice(calc_aggregate_regular)
             sql += " as calc15_3 from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
-            sql += "%s " % random.choice(group_where_regular)     
+            sql += "%s " % random.choice(group_where_regular)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql) #Invalid function name: twa'
             # tdSql.checkRows(1)
-                
+
         tdSql.query("select 15-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_regular_j) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_regular_j) 
-            sql += "%s " % random.choice(calc_aggregate_regular_j) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_regular_j)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_regular_j)
+            sql += "%s " % random.choice(calc_aggregate_regular_j)
             sql += " as calc15_3 from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_where)
-            sql += "%s " % random.choice(group_where_regular_j)            
+            sql += "%s " % random.choice(group_where_regular_j)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql) #Invalid function name: twa'
 
         tdSql.query("select 15-2.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_regular_j) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_regular_j) 
-            sql += "%s " % random.choice(calc_aggregate_regular_j) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_regular_j)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_regular_j)
+            sql += "%s " % random.choice(calc_aggregate_regular_j)
             sql += " as calc15_3 from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_or_where)
-            sql += "%s " % random.choice(group_where_regular_j)            
+            sql += "%s " % random.choice(group_where_regular_j)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             sql += "%s ;" % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql) #Invalid function name: twa'
 
         rsDn = self.restartDnodes()
         tdSql.query("select 15-3 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname) 
-            sql += "%s " % random.choice(calc_aggregate_groupbytbname) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname)
+            sql += "%s " % random.choice(calc_aggregate_groupbytbname)
             sql += " as calc15_3 from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(group_where)
             sql += "%s " % random.choice(having_support)
             sql += "%s " % random.choice(order_desc_where)
             sql += ") "
-            sql += "order by  calc15_1  " 
+            sql += "order by  calc15_1  "
             sql += "%s " % random.choice(limit_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql) #Invalid function name: twa',可能还的去掉order by
 
         tdSql.query("select 15-4 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname_j) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname_j) 
-            sql += "%s " % random.choice(calc_aggregate_groupbytbname_j) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname_j)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname_j)
+            sql += "%s " % random.choice(calc_aggregate_groupbytbname_j)
             sql += " as calc15_3 from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and   "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(group_where_j)
             sql += "%s " % random.choice(having_support_j)
             #sql += "%s " % random.choice(orders_desc_where)
             sql += ") "
-            sql += "order by  calc15_1  " 
+            sql += "order by  calc15_1  "
             sql += "%s " % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql)  #'Invalid function name: irate'
 
         tdSql.query("select 15-4.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname_j) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname_j) 
-            sql += "%s " % random.choice(calc_aggregate_groupbytbname_j) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname_j)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname_j)
+            sql += "%s " % random.choice(calc_aggregate_groupbytbname_j)
             sql += " as calc15_3 from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and   "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(group_where_j)
             sql += "%s " % random.choice(having_support_j)
             sql += "%s " % random.choice(orders_desc_where)
             sql += ") "
-            sql += "order by  calc15_1  " 
+            sql += "order by  calc15_1  "
             sql += "%s " % random.choice(limit_u_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15678 #tdSql.query(sql)
 
         tdSql.query("select 15-5 from stable_1;")
         for i in range(self.fornum):
             sql = "select   * from  ( select "
-            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname) 
-            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname) 
-            sql += "%s " % random.choice(calc_aggregate_groupbytbname) 
+            sql += "%s as calc15_1, " % random.choice(calc_aggregate_groupbytbname)
+            sql += "%s as calc15_2, " % random.choice(calc_aggregate_groupbytbname)
+            sql += "%s " % random.choice(calc_aggregate_groupbytbname)
             sql += " as calc15_3 from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(group_where)
             sql += ") "
-            sql += "order by calc15_1  " 
+            sql += "order by calc15_1  "
             sql += "%s " % random.choice(limit_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql) #'Invalid function name: irate'
 
-        #16 select * from (select calc_aggregate_regulars as agg from regular_table  where <\>\in\and\or  order by limit offset )       
+        #16 select * from (select calc_aggregate_regulars as agg from regular_table  where <\>\in\and\or  order by limit offset )
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 16-1 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s as calc16_0 , " % random.choice(calc_calculate_all)
-            sql += "%s as calc16_1 , " % random.choice(calc_aggregate_all)  
-            sql += "%s as calc16_2 " % random.choice(calc_select_in) 
+            sql += "%s as calc16_1 , " % random.choice(calc_aggregate_all)
+            sql += "%s as calc16_2 " % random.choice(calc_select_in)
             sql += "  from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(group_where)
             #sql += "%s " % random.choice(having_support)having和 partition不能混合使用
             sql += ") "
-            sql += "order by calc16_0  " 
+            sql += "order by calc16_0  "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15651 tdSql.query(sql)
 
         tdSql.query("select 16-2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s as calc16_0  " % random.choice(calc_calculate_all_j)
-            sql += ", %s as calc16_1  " % random.choice(calc_aggregate_all_j)  
-            #sql += ", %s as calc16_2  " % random.choice(calc_select_in_j) 
+            sql += ", %s as calc16_1  " % random.choice(calc_aggregate_all_j)
+            #sql += ", %s as calc16_2  " % random.choice(calc_select_in_j)
             sql += "  from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += ") "
-            sql += "order by calc16_0  " 
+            sql += "order by calc16_0  "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 16-2.2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s as calc16_0  " % random.choice(calc_calculate_all_j)
-            sql += ", %s as calc16_1  " % random.choice(calc_aggregate_all_j) 
+            sql += ", %s as calc16_1  " % random.choice(calc_aggregate_all_j)
             sql += "  from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += ") "
-            sql += "order by calc16_0  " 
+            sql += "order by calc16_0  "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-        
+
         tdSql.query("select 16-3 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
-            sql += "%s as calc16_1  " % random.choice(calc_calculate_regular) 
+            sql = "select   * from  ( select  "
+            sql += "%s as calc16_1  " % random.choice(calc_calculate_regular)
             sql += "  from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "limit 2 ) "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql)#Invalid function name: derivative'
 
         tdSql.query("select 16-4 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
-            sql += "%s as calc16_1  " % random.choice(calc_calculate_regular_j) 
+            sql = "select   * from  ( select  "
+            sql += "%s as calc16_1  " % random.choice(calc_calculate_regular_j)
             sql += "  from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_where)
             sql += "limit 2 ) "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql)#Invalid function name: derivative'
 
         tdSql.query("select 16-4.2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
-            sql += "%s as calc16_1  " % random.choice(calc_calculate_regular_j) 
+            sql = "select   * from  ( select  "
+            sql += "%s as calc16_1  " % random.choice(calc_calculate_regular_j)
             sql += "  from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "limit 2 ) "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #tdSql.query(sql)#Invalid function name: derivative'
-        
+
         tdSql.query("select 16-5 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s as calc16_1 , " % random.choice(calc_calculate_all)
-            sql += "%s as calc16_1 , " % random.choice(calc_calculate_regular) 
-            sql += "%s as calc16_2 " % random.choice(calc_select_all) 
+            sql += "%s as calc16_1 , " % random.choice(calc_calculate_regular)
+            sql += "%s as calc16_2 " % random.choice(calc_select_all)
             sql += "  from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(group_where)
             #sql += "%s " % random.choice(having_support)
             sql += ") "
-            sql += "order by calc16_1  " 
+            sql += "order by calc16_1  "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
            # tdSql.query(sql)
-        
+
         tdSql.query("select 16-6 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
-            sql += "%s as calc16_1  " % random.choice(calc_calculate_groupbytbname) 
+            sql = "select   * from  ( select  "
+            sql += "%s as calc16_1  " % random.choice(calc_calculate_groupbytbname)
             sql += "  from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(group_where)
             sql += "limit 2 ) "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #Invalid function name: derivative'  tdSql.query(sql)
 
         tdSql.query("select 16-7 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
-            sql += "%s as calc16_1  " % random.choice(calc_calculate_groupbytbname_j) 
+            sql = "select   * from  ( select  "
+            sql += "%s as calc16_1  " % random.choice(calc_calculate_groupbytbname_j)
             sql += "  from stable_1  t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += "limit 2 ) "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #Invalid function name: derivative' tdSql.query(sql)
 
         tdSql.query("select 16-8 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
-            sql += "%s as calc16_1  " % random.choice(calc_calculate_groupbytbname_j) 
+            sql = "select   * from  ( select  "
+            sql += "%s as calc16_1  " % random.choice(calc_calculate_groupbytbname_j)
             sql += "  from stable_1  t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "limit 2 ) "
             sql += "%s " % random.choice(limit1_where)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #Invalid function name: derivative' tdSql.query(sql)
 
         #17 select apercentile from (select calc_aggregate_alls form regualr_table or stable  where <\>\in\and\or interval_sliding group by having order by limit offset  )interval_sliding
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 17-1 from stable_1;")
         for i in range(self.fornum):
-            #this is having_support , but tag-select cannot mix with last_row,other select can 
+            #this is having_support , but tag-select cannot mix with last_row,other select can
             sql = "select   apercentile(cal17_0, %d)/10 ,apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
             sql += "%s as cal17_0 , " % random.choice(calc_calculate_all)
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(partiton_where)
@@ -1757,17 +1757,17 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15719 tdSql.query(sql)
-        
+
         tdSql.query("select 17-2 from stable_1;")
         for i in range(self.fornum):
-            #this is having_support , but tag-select cannot mix with last_row,other select can 
+            #this is having_support , but tag-select cannot mix with last_row,other select can
             sql = "select   apercentile(cal17_0, %d)/10 ,apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
             sql += "%s as cal17_0 , " % random.choice(calc_calculate_all_j)
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1775,17 +1775,17 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 17-2.2 from stable_1;")
         for i in range(self.fornum):
-            #this is having_support , but tag-select cannot mix with last_row,other select can 
+            #this is having_support , but tag-select cannot mix with last_row,other select can
             sql = "select   apercentile(cal17_0, %d)/10 ,apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
             sql += "%s as cal17_0 , " % random.choice(calc_calculate_all_j)
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1793,8 +1793,8 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         self.restartDnodes()
@@ -1802,8 +1802,8 @@ class TDTestCase:
         for i in range(self.fornum):
             #this is having_tagnot_support , because tag-select cannot mix with last_row...
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(partiton_where)
@@ -1813,16 +1813,16 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15770 tdSql.query(sql)
 
         tdSql.query("select 17-4 from stable_1;")
         for i in range(self.fornum):
             #this is having_tagnot_support , because tag-select cannot mix with last_row...
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1830,16 +1830,16 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 17-4.2 from stable_1;")
         for i in range(self.fornum):
             #this is having_tagnot_support , because tag-select cannot mix with last_row...
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1847,16 +1847,16 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 17-5 from stable_1;")
         for i in range(self.fornum):
-            #having_not_support  
+            #having_not_support
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(partiton_where)
@@ -1866,15 +1866,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
            #TD-15719 tdSql.query(sql)
-       
+
         tdSql.query("select 17-6 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1882,15 +1882,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15770 tdSql.query(sql)
 
         tdSql.query("select 17-7 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1_1 t1, stable_1_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1898,15 +1898,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 17-7.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1_1 t1, stable_1_2 t2 where t1.ts = t2.ts and "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1914,16 +1914,16 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         self.restartDnodes()
         tdSql.query("select 17-8 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all)
             sql += " from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1931,15 +1931,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-       
+
         tdSql.query("select 17-9 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1947,15 +1947,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 17-10 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal17_1, %d)/1000 ,apercentile(cal17_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal17_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal17_2 " % random.choice(calc_aggregate_all_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(interval_sliding)
@@ -1963,16 +1963,16 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         #18 select apercentile from (select calc_aggregate_alls form regualr_table or stable  where <\>\in\and\or session order by  limit )interval_sliding
         tdSql.query("select 18-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all)
             sql += " from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(session_where)
@@ -1981,15 +1981,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-               
+
         tdSql.query("select 18-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and   "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(session_u_where)
@@ -1997,15 +1997,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 18-2.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and   "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(session_u_where)
@@ -2013,16 +2013,16 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         self.restartDnodes()
         tdSql.query("select 18-3 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(session_where)
@@ -2031,15 +2031,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 18-4 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(session_u_where)
@@ -2047,15 +2047,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 18-4.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1_1 t1, regular_table_2 t2 where t1.ts = t2.ts and  "
             sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(session_u_where)
@@ -2063,15 +2063,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 18-5 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(session_where)
@@ -2080,15 +2080,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #TD-15770 tdSql.query(sql)
 
         tdSql.query("select 18-6 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and   "
             sql += "%s " % random.choice(t_join_where)
             sql += "%s " % random.choice(session_u_where)
@@ -2096,15 +2096,15 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-        
+
         tdSql.query("select 18-7 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal18_1, %d)/1000 ,apercentile(cal18_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal18_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal18_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1, stable_2 t2 where t1.ts = t2.ts and   "
             sql += "%s " % random.choice(qt_u_or_where)
             sql += "%s " % random.choice(session_u_where)
@@ -2112,426 +2112,426 @@ class TDTestCase:
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
-        #19 select apercentile from (select calc_aggregate_alls form regualr_table or stable  where <\>\in\and\or session order by  limit )interval_sliding       
+        #19 select apercentile from (select calc_aggregate_alls form regualr_table or stable  where <\>\in\and\or session order by  limit )interval_sliding
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 19-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all)
             sql += " from regular_table_1 where "
-            sql += "%s " % random.choice(q_where)        
+            sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(state_window)
             #sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 19-2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and   "
-            sql += "%s " % random.choice(q_u_where)        
+            sql += "%s " % random.choice(q_u_where)
             sql += "%s " % random.choice(state_u_window)
             #sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 19-2.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and   "
-            sql += "%s " % random.choice(q_u_or_where)        
+            sql += "%s " % random.choice(q_u_or_where)
             sql += "%s " % random.choice(state_u_window)
             #sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-        
+
         tdSql.query("select 19-3 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1_1 where "
-            sql += "%s " % random.choice(q_where)        
+            sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(state_window)
             #sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 19-4 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1_1  t1, stable_1_2 t2 where t1.ts = t2.ts and  "
-            sql += "%s " % random.choice(q_u_where)        
+            sql += "%s " % random.choice(q_u_where)
             #sql += "%s " % random.choice(state_window)
             #sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 19-4.2 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1_1  t1, stable_1_2 t2 where t1.ts = t2.ts and  "
-            sql += "%s " % random.choice(q_u_or_where)  
+            sql += "%s " % random.choice(q_u_or_where)
             #sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 19-5 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all)
             sql += " from stable_1 where "
-            sql += "%s " % random.choice(q_where)        
+            sql += "%s " % random.choice(q_where)
             sql += "%s " % random.choice(state_window)
             sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit1_where)
             sql += ") "
             sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.error(sql)   #'STATE_WINDOW not support for super table query'
-       
+
         tdSql.query("select 19-6 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and "
-            sql += "%s " % random.choice(q_u_where)        
+            sql += "%s " % random.choice(q_u_where)
             #sql += "%s " % random.choice(state_window)
             #sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
         tdSql.query("select 19-7 from stable_1;")
         for i in range(self.fornum):
             sql = "select   apercentile(cal19_1, %d)/1000 ,apercentile(cal19_2, %d)*10+%d  from  ( select  " %(random.randint(0,100) , random.randint(0,100) ,random.randint(-1000,1000))
-            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j) 
-            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j) 
+            sql += "%s as cal19_1 ," % random.choice(calc_aggregate_all_j)
+            sql += "%s as cal19_2 " % random.choice(calc_aggregate_all_j)
             sql += " from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and "
-            sql += "%s " % random.choice(qt_u_or_where)    
+            sql += "%s " % random.choice(qt_u_or_where)
             #sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
             #sql += "%s " % random.choice(interval_sliding)
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
 
-        #20 select * from (select calc_select_fills form regualr_table or stable  where <\>\in\and\or fill_where group by  order by limit offset  )        
+        #20 select * from (select calc_select_fills form regualr_table or stable  where <\>\in\and\or fill_where group by  order by limit offset  )
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 20-1 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill)
-            sql += "%s ," % random.choice(calc_select_fill) 
-            sql += "%s  " % random.choice(calc_select_fill) 
+            sql += "%s ," % random.choice(calc_select_fill)
+            sql += "%s  " % random.choice(calc_select_fill)
             sql += " from stable_1 where  "
-            sql += "%s " % random.choice(interp_where)  
+            sql += "%s " % random.choice(interp_where)
             sql += "%s " % random.choice(fill_where)
             sql += "%s " % random.choice(group_where)
             sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #interp不支持 tdSql.query(sql)
 
         rsDn = self.restartDnodes()
         tdSql.query("select 20-2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill_j)
-            sql += "%s ," % random.choice(calc_select_fill_j) 
-            sql += "%s  " % random.choice(calc_select_fill_j) 
+            sql += "%s ," % random.choice(calc_select_fill_j)
+            sql += "%s  " % random.choice(calc_select_fill_j)
             sql += " from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s and " % random.choice(t_join_where)
-            sql += "%s " % random.choice(interp_where_j)  
+            sql += "%s " % random.choice(interp_where_j)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #interp不支持 tdSql.query(sql)
 
         tdSql.query("select 20-2.2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill_j)
-            sql += "%s ," % random.choice(calc_select_fill_j) 
-            sql += "%s  " % random.choice(calc_select_fill_j) 
+            sql += "%s ," % random.choice(calc_select_fill_j)
+            sql += "%s  " % random.choice(calc_select_fill_j)
             sql += " from stable_1 t1 , stable_2 t2 where t1.ts = t2.ts and  "
             sql += "%s and " % random.choice(qt_u_or_where)
-            sql += "%s " % random.choice(interp_where_j)  
+            sql += "%s " % random.choice(interp_where_j)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #interp不支持 tdSql.query(sql)
 
         tdSql.query("select 20-3 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill)
-            sql += "%s ," % random.choice(calc_select_fill) 
-            sql += "%s  " % random.choice(calc_select_fill) 
+            sql += "%s ," % random.choice(calc_select_fill)
+            sql += "%s  " % random.choice(calc_select_fill)
             sql += " from stable_1 where  "
-            sql += "%s " % interp_where[2]  
+            sql += "%s " % interp_where[2]
             sql += "%s " % random.choice(fill_where)
             sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #interp不支持 tdSql.query(sql)
-        
+
         tdSql.query("select 20-4 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill_j)
-            sql += "%s ," % random.choice(calc_select_fill_j) 
-            sql += "%s  " % random.choice(calc_select_fill_j) 
-            sql += " from stable_1 t1, table_1 t2 where t1.ts = t2.ts and    "             
+            sql += "%s ," % random.choice(calc_select_fill_j)
+            sql += "%s  " % random.choice(calc_select_fill_j)
+            sql += " from stable_1 t1, table_1 t2 where t1.ts = t2.ts and    "
             #sql += "%s and " % random.choice(t_join_where)
             sql += "%s " % interp_where_j[random.randint(0,5)]
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             #interp不支持 tdSql.query(sql)
 
         tdSql.query("select 20-4.2 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill_j)
-            sql += "%s ," % random.choice(calc_select_fill_j) 
-            sql += "%s  " % random.choice(calc_select_fill_j) 
-            sql += " from stable_1 t1, stable_1_1 t2 where t1.ts = t2.ts and    "             
+            sql += "%s ," % random.choice(calc_select_fill_j)
+            sql += "%s  " % random.choice(calc_select_fill_j)
+            sql += " from stable_1 t1, stable_1_1 t2 where t1.ts = t2.ts and    "
             sql += "%s and " % random.choice(qt_u_or_where)
             sql += "%s " % interp_where_j[random.randint(0,5)]
             sql += "%s " % random.choice(fill_where)
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
          ##interp不支持    tdSql.error(sql)
-               
+
         tdSql.query("select 20-5 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill)
-            sql += "%s ," % random.choice(calc_select_fill) 
-            sql += "%s  " % random.choice(calc_select_fill) 
+            sql += "%s ," % random.choice(calc_select_fill)
+            sql += "%s  " % random.choice(calc_select_fill)
             sql += " from regular_table_1 where  "
-            sql += "%s " % interp_where[1]  
+            sql += "%s " % interp_where[1]
             sql += "%s " % random.choice(fill_where)
             sql += "%s " % random.choice(order_where)
             sql += "%s " % random.choice(limit_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             ##interp不支持 tdSql.query(sql)
 
         tdSql.query("select 20-6 from stable_1;")
         for i in range(self.fornum):
-            sql = "select   * from  ( select  " 
+            sql = "select   * from  ( select  "
             sql += "%s , " % random.choice(calc_select_fill_j)
-            sql += "%s ," % random.choice(calc_select_fill_j) 
-            sql += "%s  " % random.choice(calc_select_fill_j) 
+            sql += "%s ," % random.choice(calc_select_fill_j)
+            sql += "%s  " % random.choice(calc_select_fill_j)
             sql += " from regular_table_1 t1, regular_table_2 t2 where t1.ts = t2.ts and   "
-            #sql += "%s " % random.choice(interp_where_j) 
-            sql += "%s " % interp_where_j[random.randint(0,5)] 
+            #sql += "%s " % random.choice(interp_where_j)
+            sql += "%s " % interp_where_j[random.randint(0,5)]
             sql += "%s " % random.choice(order_u_where)
             sql += "%s " % random.choice(limit_u_where)
             sql += ") "
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             ##interp不支持 tdSql.query(sql)
 
         #1 select * from (select * from (select * form regular_table  where <\>\in\and\or order by limit  ))
         tdSql.query("select 1-1 from stable_1;")
-        for i in range(self.fornum):            
+        for i in range(self.fornum):
             # sql_start = "select  *  from ( "
             # sql_end = ")"
             for_num = random.randint(1, 15);
-            sql = "select  *  from ("  * for_num  
+            sql = "select  *  from ("  * for_num
             sql += "select  *  from  ( select * from ( select  "
-            sql += "%s, " % random.choice(s_r_select) 
-            sql += "%s, " % random.choice(q_select)  
+            sql += "%s, " % random.choice(s_r_select)
+            sql += "%s, " % random.choice(q_select)
             sql += "ts from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += ")) "
-            sql += ")"  * for_num     
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql)  
-            
+            sql += ")"  * for_num
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             sql2 =  "select  *  from  ( select * from ( select  "
-            sql2 += "%s, " % random.choice(s_r_select) 
-            sql2 += "%s, " % random.choice(q_select)  
+            sql2 += "%s, " % random.choice(s_r_select)
+            sql2 += "%s, " % random.choice(q_select)
             sql2 += "ts from regular_table_1 where "
             sql2 += "%s " % random.choice(q_where)
-            sql2 += ")) "  
-            tdLog.info(sql2) 
-            tdLog.info(len(sql2)) 
-            
+            sql2 += ")) "
+            tdLog.info(sql2)
+            tdLog.info(len(sql2))
+
             self.data_matrix_equal('%s' %sql ,1,10,1,1,'%s' %sql2 ,1,10,1,1)
             self.data_matrix_equal('%s' %sql ,1,10,1,1,'%s' %sql ,1,10,3,3)
             self.data_matrix_equal('%s' %sql ,1,10,3,3,'%s' %sql2 ,1,10,3,3)
-            
+
         for i in range(self.fornum):
             for_num = random.randint(1, 15);
-            sql = "select  ts  from ("  * for_num  
+            sql = "select  ts  from ("  * for_num
             sql += "select  *  from  ( select * from ( select  "
-            sql += "%s, " % random.choice(s_r_select) 
-            sql += "%s, " % random.choice(q_select)  
+            sql += "%s, " % random.choice(s_r_select)
+            sql += "%s, " % random.choice(q_select)
             sql += "ts from regular_table_1 where "
             sql += "%s " % random.choice(q_where)
             sql += ")) "
-            sql += ")"  * for_num     
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql)  
-            
+            sql += ")"  * for_num
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             sql2 =  "select  *  from  ( select * from ( select  "
-            sql2 += "%s, " % random.choice(s_r_select) 
-            sql2 += "%s, " % random.choice(q_select)  
+            sql2 += "%s, " % random.choice(s_r_select)
+            sql2 += "%s, " % random.choice(q_select)
             sql2 += "ts from regular_table_1 where "
             sql2 += "%s " % random.choice(q_where)
-            sql2 += ")) "   
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql) 
-            
+            sql2 += ")) "
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             self.data_matrix_equal('%s' %sql ,1,10,1,1,'%s' %sql2 ,1,10,1,1)
-            
+
         #2 select * from (select * from (select * form stable  where <\>\in\and\or order by limit  ))
         tdSql.query("select 2-1 from stable_1;")
         for i in range(self.fornum):
             for_num = random.randint(1, 15);
-            sql = "select  *  from ("  * for_num  
+            sql = "select  *  from ("  * for_num
             sql += "select  *  from  ( select * from ( select  "
-            sql += "%s, " % random.choice(s_s_select) 
-            sql += "%s, " % random.choice(qt_select) 
+            sql += "%s, " % random.choice(s_s_select)
+            sql += "%s, " % random.choice(qt_select)
             sql += "ts from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += ")) "
-            sql += ")"  * for_num  
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql) 
-            
+            sql += ")"  * for_num
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             sql2 = "select  *  from  ( select * from ( select  "
-            sql2 += "%s, " % random.choice(s_s_select) 
-            sql2 += "%s, " % random.choice(qt_select) 
+            sql2 += "%s, " % random.choice(s_s_select)
+            sql2 += "%s, " % random.choice(qt_select)
             sql2 += "ts from stable_1 where "
             sql2 += "%s " % random.choice(q_where)
-            sql2 += ")) " 
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql) 
-            
+            sql2 += ")) "
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             self.data_matrix_equal('%s' %sql ,1,10,3,3,'%s' %sql2 ,1,10,3,3)
-            
+
         for i in range(self.fornum):
             for_num = random.randint(1, 15);
-            sql = "select  ts  from ("  * for_num  
+            sql = "select  ts  from ("  * for_num
             sql += "select  *  from  ( select * from ( select  "
-            sql += "%s, " % random.choice(s_s_select) 
-            sql += "%s, " % random.choice(qt_select) 
+            sql += "%s, " % random.choice(s_s_select)
+            sql += "%s, " % random.choice(qt_select)
             sql += "ts from stable_1 where "
             sql += "%s " % random.choice(q_where)
             sql += ")) "
-            sql += ")"  * for_num  
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql) 
-            
+            sql += ")"  * for_num
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             sql2 = "select  ts  from  ( select * from ( select  "
-            sql2 += "%s, " % random.choice(s_s_select) 
-            sql2 += "%s, " % random.choice(qt_select) 
+            sql2 += "%s, " % random.choice(s_s_select)
+            sql2 += "%s, " % random.choice(qt_select)
             sql2 += "ts from stable_1 where "
             sql2 += "%s " % random.choice(q_where)
-            sql2 += ")) " 
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.query(sql) 
-            
+            sql2 += ")) "
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.query(sql)
+
             self.data_matrix_equal('%s' %sql ,1,10,1,1,'%s' %sql2 ,1,10,1,1)
-                         
-        #3 select ts ,calc from  (select * form stable  where <\>\in\and\or order by limit  )       
+
+        #3 select ts ,calc from  (select * form stable  where <\>\in\and\or order by limit  )
         #self.dropandcreateDB_random("%s" %db, 1)
         tdSql.query("select 3-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   "
-            sql += "%s " % random.choice(calc_calculate_regular) 
+            sql += "%s " % random.choice(calc_calculate_regular)
             sql += " from ( select * from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             sql += "%s " % random.choice(orders_desc_where)
             sql += "%s " % random.choice(limit_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            #'Invalid function name: derivative'  tdSql.query(sql)   
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            #'Invalid function name: derivative'  tdSql.query(sql)
 
         #4 select * from  (select calc form stable  where <\>\in\and\or order by limit  )
         tdSql.query("select 4-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select  *  from  ( select  "
-            sql += "%s " % random.choice(calc_select_in_ts) 
+            sql += "%s " % random.choice(calc_select_in_ts)
             sql += "from stable_1 where "
             sql += "%s " % random.choice(qt_where)
             #sql += "%s " % random.choice(order_desc_where)
             sql += "%s " % random.choice(limit_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
+            tdLog.info(sql)
+            tdLog.info(len(sql))
             tdSql.query(sql)
-            
+
         #5 select ts ,tbname from  (select * form stable  where <\>\in\and\or order by limit  )
         tdSql.query("select 5-1 from stable_1;")
         for i in range(self.fornum):
             sql = "select   ts , tbname , "
-            sql += "%s ," % random.choice(calc_calculate_regular) 
+            sql += "%s ," % random.choice(calc_calculate_regular)
             sql += "%s ," % random.choice(dqt_select)
             sql += "%s " % random.choice(qt_select)
             sql += " from ( select * from stable_1 where "
@@ -2539,9 +2539,9 @@ class TDTestCase:
             sql += "%s " % random.choice(orders_desc_where)
             sql += "%s " % random.choice(limit_where)
             sql += ") ;"
-            tdLog.info(sql) 
-            tdLog.info(len(sql))      
-            tdSql.error(sql) 
+            tdLog.info(sql)
+            tdLog.info(len(sql))
+            tdSql.error(sql)
 
         #special sql
         tdSql.query("select 6-1 from stable_1;")
@@ -2570,7 +2570,7 @@ class TDTestCase:
         endTime = time.time()
         print("total time %ds" % (endTime - startTime))
 
-        
+
 
 
     def stop(self):
diff --git a/tests/system-test/2-query/percentile.py b/tests/system-test/2-query/percentile.py
index 21bb8763dc..43b5c5610a 100644
--- a/tests/system-test/2-query/percentile.py
+++ b/tests/system-test/2-query/percentile.py
@@ -134,31 +134,16 @@ class TDTestCase:
                         tdSql.query(f'select percentile({k}, {param}) from {self.stbname}_{i}')
                         tdSql.checkData(0, 0, np.percentile(floatData, param))
             
-            #!bug TD-17119
-            # for k,v in self.tag_dict.items():
-            #     for param in self.param:
-            #         if v.lower() in ['timestamp','bool'] or 'binary' in v.lower() or 'nchar' in v.lower():
-            #             tdSql.error(f'select percentile({k},{param}) from {self.stbname}_{i}')
-            #         elif v.lower() == 'tinyint':
-            #             self.check_tags(k,param,i,self.tag_tinyint)
-            #         elif v.lower() == 'smallint':
-            #             self.check_tags(k,param,i,self.tag_smallint)
-            #         elif v.lower() == 'int':
-            #             self.check_tags(k,param,i,self.tag_int)
-            #         elif v.lower() == 'bigint':
-            #             self.check_tags(k,param,i,self.tag_bigint)
-            #         elif v.lower() == 'tinyint unsigned':
-            #             self.check_tags(k,param,i,self.tag_utint)
-            #         elif v.lower() == 'smallint unsigned':
-            #             self.check_tags(k,param,i,self.tag_usint)   
-            #         elif v.lower() == 'int unsigned':
-            #             self.check_tags(k,param,i,self.tag_uint) 
-            #         elif v.lower() == 'bigint unsigned':
-            #             self.check_tags(k,param,i,self.tag_ubint)
-            #         elif v.lower() == 'float':
-            #             self.check_tags(k,param,i,self.tag_float)
-            #         elif v.lower() == 'double':
-            #             self.check_tags(k,param,i,self.tag_double)
+            for k,v in self.tag_dict.items():
+                for param in self.param:
+                    if v.lower() in ['timestamp','bool'] or 'binary' in v.lower() or 'nchar' in v.lower():
+                        tdSql.error(f'select percentile({k},{param}) from {self.stbname}_{i}')
+                    else:
+                        tdSql.query(f'select {k} from {self.stbname}_{i}')
+                        data_num = tdSql.queryResult[0][0]
+                        tdSql.query(f'select percentile({k},{param}) from {self.stbname}_{i}')
+                        tdSql.checkData(0,0,data_num)
+                    
     def run(self):
         self.function_check_ntb()
         self.function_check_ctb()
diff --git a/tests/system-test/2-query/round.py b/tests/system-test/2-query/round.py
index 9111586472..551e225a4d 100644
--- a/tests/system-test/2-query/round.py
+++ b/tests/system-test/2-query/round.py
@@ -8,14 +8,14 @@ from util.sql import *
 from util.cases import *
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
 
     def init(self, conn, logSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
-    
+
     def prepare_datas(self):
         tdSql.execute(
             '''create table stb1
@@ -23,7 +23,7 @@ class TDTestCase:
             tags (t1 int)
             '''
         )
-        
+
         tdSql.execute(
             '''
             create table t1
@@ -65,14 +65,14 @@ class TDTestCase:
             ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             '''
         )
-    
+
     def check_result_auto(self ,origin_query , round_query):
         pass
         round_result = tdSql.getResult(round_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -87,13 +87,13 @@ class TDTestCase:
         for row_index , row in enumerate(round_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("round function value has not as expected , sql is \"%s\" "%round_query )
             sys.exit(1)
         else:
             tdLog.info("round value check pass , it work as expected ,sql is \"%s\"   "%round_query )
-        
+
     def test_errors(self):
         error_sql_lists = [
             "select round from t1",
@@ -127,42 +127,42 @@ class TDTestCase:
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
-    
+
     def support_types(self):
         type_error_sql_lists = [
-            "select round(ts) from t1" , 
+            "select round(ts) from t1" ,
             "select round(c7) from t1",
             "select round(c8) from t1",
             "select round(c9) from t1",
-            "select round(ts) from ct1" , 
+            "select round(ts) from ct1" ,
             "select round(c7) from ct1",
             "select round(c8) from ct1",
             "select round(c9) from ct1",
-            "select round(ts) from ct3" , 
+            "select round(ts) from ct3" ,
             "select round(c7) from ct3",
             "select round(c8) from ct3",
             "select round(c9) from ct3",
-            "select round(ts) from ct4" , 
+            "select round(ts) from ct4" ,
             "select round(c7) from ct4",
             "select round(c8) from ct4",
             "select round(c9) from ct4",
-            "select round(ts) from stb1" , 
+            "select round(ts) from stb1" ,
             "select round(c7) from stb1",
             "select round(c8) from stb1",
             "select round(c9) from stb1" ,
 
-            "select round(ts) from stbbb1" , 
+            "select round(ts) from stbbb1" ,
             "select round(c7) from stbbb1",
 
             "select round(ts) from tbname",
             "select round(c9) from tbname"
 
         ]
-        
+
         for type_sql in type_error_sql_lists:
             tdSql.error(type_sql)
-        
-        
+
+
         type_sql_lists = [
             "select round(c1) from t1",
             "select round(c2) from t1",
@@ -192,16 +192,16 @@ class TDTestCase:
             "select round(c5) from stb1",
             "select round(c6) from stb1",
 
-            "select round(c6) as alisb from stb1", 
-            "select round(c6) alisb from stb1", 
+            "select round(c6) as alisb from stb1",
+            "select round(c6) alisb from stb1",
         ]
 
         for type_sql in type_sql_lists:
             tdSql.query(type_sql)
-    
+
     def basic_round_function(self):
 
-        # basic query 
+        # basic query
         tdSql.query("select c1 from ct3")
         tdSql.checkRows(0)
         tdSql.query("select c1 from t1")
@@ -221,7 +221,7 @@ class TDTestCase:
         tdSql.query("select round(c5) from ct3")
         tdSql.checkRows(0)
         tdSql.query("select round(c6) from ct3")
-        
+
         # used for regular table
         tdSql.query("select round(c1) from t1")
         tdSql.checkData(0, 0, None)
@@ -239,7 +239,7 @@ class TDTestCase:
         tdSql.checkData(5, 5, None)
 
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from t1", "select (c1), round(c2) ,round(c3), round(c4), round(c5) from t1")
-        
+
         # used for sub table
         tdSql.query("select round(c1) from ct1")
         tdSql.checkData(0, 0, 8)
@@ -251,20 +251,20 @@ class TDTestCase:
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct1", "select (c1), round(c2) ,round(c3), round(c4), round(c5) from ct1")
         self.check_result_auto("select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from ct1;","select c1 from ct1" )
 
-        # used for stable table 
-        
+        # used for stable table
+
         tdSql.query("select round(c1) from stb1")
         tdSql.checkRows(25)
         self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct4 ", "select (c1), round(c2) ,round(c3), round(c4), round(c5) from ct4")
         self.check_result_auto("select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from ct4;" , "select c1 from ct4" )
-        
+
 
         # used for not exists table
         tdSql.error("select round(c1) from stbbb1")
         tdSql.error("select round(c1) from tbname")
         tdSql.error("select round(c1) from ct5")
 
-        # mix with common col 
+        # mix with common col
         tdSql.query("select c1, round(c1) from ct1")
         tdSql.checkData(0 , 0 ,8)
         tdSql.checkData(0 , 1 ,8)
@@ -289,7 +289,7 @@ class TDTestCase:
         tdSql.checkData(0 , 1 ,None)
         tdSql.checkData(0 , 2 ,None)
         tdSql.checkData(0 , 3 ,None)
-        
+
         tdSql.checkData(3 , 0 , 6)
         tdSql.checkData(3 , 1 , 6)
         tdSql.checkData(3 , 2 ,6.66000)
@@ -315,7 +315,7 @@ class TDTestCase:
         tdSql.query("select max(c5), count(c5) from stb1")
         tdSql.query("select max(c5), count(c5) from ct1")
 
-        
+
         # bug fix for count
         tdSql.query("select count(c1) from ct4 ")
         tdSql.checkData(0,0,9)
@@ -326,7 +326,7 @@ class TDTestCase:
         tdSql.query("select count(*) from stb1 ")
         tdSql.checkData(0,0,25)
 
-        # bug fix for compute 
+        # bug fix for compute
         tdSql.query("select c1, abs(c1) -0 ,round(c1)-0 from ct4 ")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
@@ -378,10 +378,10 @@ class TDTestCase:
         tdSql.checkData(0,4,7.900000000)
         tdSql.checkData(0,5,3.000000000)
         tdSql.checkData(0,6,7.500000000)
-        
+
     def round_Arithmetic(self):
         pass
-    
+
     def check_boundary_values(self):
 
         tdSql.execute("drop database if exists bound_test")
@@ -410,14 +410,14 @@ class TDTestCase:
         tdSql.execute(
                 f"insert into sub1_bound values ( now(), -2147483643, -9223372036854775803, -32763, -123, -3.39E+38, -1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
-        
+
         tdSql.error(
                 f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
         self.check_result_auto( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select round(c1), round(c2) ,round(c3), round(c4), round(c5) ,round(c6) from sub1_bound")
         self.check_result_auto( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select round(c1), round(c2) ,round(c3), round(c3), round(c2) ,round(c1) from sub1_bound")
         self.check_result_auto("select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from sub1_bound;" , "select round(c1) from sub1_bound" )
-        
+
         # check basic elem for table per row
         tdSql.query("select round(c1+0.2) ,round(c2) , round(c3+0.3) , round(c4-0.3), round(c5/2), round(c6/2) from sub1_bound ")
         tdSql.checkData(0, 0, 2147483647.000000000)
@@ -444,32 +444,32 @@ class TDTestCase:
         self.check_result_auto( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select round(t1) ,round(c5) from stb1 where c1 > 0 order by tbname" )
         self.check_result_auto( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select round(t1) , round(c5) from stb1 where c1 > 0 order by tbname" )
         pass
-    
-    
+
+
     def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4: round basic query ============") 
+        tdLog.printNoPrefix("==========step4: round basic query ============")
 
         self.basic_round_function()
 
-        tdLog.printNoPrefix("==========step5: round boundary query ============") 
+        tdLog.printNoPrefix("==========step5: round boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step6: round filter query ============") 
+        tdLog.printNoPrefix("==========step6: round filter query ============")
 
         self.abs_func_filter()
 
diff --git a/tests/system-test/2-query/sqrt.py b/tests/system-test/2-query/sqrt.py
index e21f5b397e..425d59f118 100644
--- a/tests/system-test/2-query/sqrt.py
+++ b/tests/system-test/2-query/sqrt.py
@@ -9,13 +9,13 @@ from util.cases import *
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
     def init(self, conn, powSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
-    
+
     def prepare_datas(self):
         tdSql.execute(
             '''create table stb1
@@ -23,7 +23,7 @@ class TDTestCase:
             tags (t1 int)
             '''
         )
-        
+
         tdSql.execute(
             '''
             create table t1
@@ -65,14 +65,14 @@ class TDTestCase:
             ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             '''
         )
-    
+
     def check_result_auto_sqrt(self ,origin_query , pow_query):
 
         pow_result = tdSql.getResult(pow_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -92,7 +92,7 @@ class TDTestCase:
                 if auto_result[row_index][col_index] == None  and not (auto_result[row_index][col_index] == None and elem == None):
                     check_status = False
                 elif auto_result[row_index][col_index] != None  and (auto_result[row_index][col_index] - elem > 0.00000001):
-                    check_status = False 
+                    check_status = False
                 else:
                     pass
         if not check_status:
@@ -100,7 +100,7 @@ class TDTestCase:
             sys.exit(1)
         else:
             tdLog.info("sqrt value check pass , it work as expected ,sql is \"%s\"   "%pow_query )
-        
+
     def test_errors(self):
         error_sql_lists = [
             "select sqrt from t1",
@@ -134,42 +134,42 @@ class TDTestCase:
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
-    
+
     def support_types(self):
         type_error_sql_lists = [
-            "select sqrt(ts) from t1" , 
+            "select sqrt(ts) from t1" ,
             "select sqrt(c7) from t1",
             "select sqrt(c8) from t1",
             "select sqrt(c9) from t1",
-            "select sqrt(ts) from ct1" , 
+            "select sqrt(ts) from ct1" ,
             "select sqrt(c7) from ct1",
             "select sqrt(c8) from ct1",
             "select sqrt(c9) from ct1",
-            "select sqrt(ts) from ct3" , 
+            "select sqrt(ts) from ct3" ,
             "select sqrt(c7) from ct3",
             "select sqrt(c8) from ct3",
             "select sqrt(c9) from ct3",
-            "select sqrt(ts) from ct4" , 
+            "select sqrt(ts) from ct4" ,
             "select sqrt(c7) from ct4",
             "select sqrt(c8) from ct4",
             "select sqrt(c9) from ct4",
-            "select sqrt(ts) from stb1" , 
+            "select sqrt(ts) from stb1" ,
             "select sqrt(c7) from stb1",
             "select sqrt(c8) from stb1",
             "select sqrt(c9) from stb1" ,
 
-            "select sqrt(ts) from stbbb1" , 
+            "select sqrt(ts) from stbbb1" ,
             "select sqrt(c7) from stbbb1",
 
             "select sqrt(ts) from tbname",
             "select sqrt(c9) from tbname"
 
         ]
-        
+
         for type_sql in type_error_sql_lists:
             tdSql.error(type_sql)
-        
-        
+
+
         type_sql_lists = [
             "select sqrt(c1) from t1",
             "select sqrt(c2) from t1",
@@ -199,16 +199,16 @@ class TDTestCase:
             "select sqrt(c5) from stb1",
             "select sqrt(c6) from stb1",
 
-            "select sqrt(c6) as alisb from stb1", 
-            "select sqrt(c6) alisb from stb1", 
+            "select sqrt(c6) as alisb from stb1",
+            "select sqrt(c6) alisb from stb1",
         ]
 
         for type_sql in type_sql_lists:
             tdSql.query(type_sql)
-    
+
     def basic_sqrt_function(self):
 
-        # basic query 
+        # basic query
         tdSql.query("select c1 from ct3")
         tdSql.checkRows(0)
         tdSql.query("select c1 from t1")
@@ -249,7 +249,7 @@ class TDTestCase:
         tdSql.checkData(5, 5, None)
 
         self.check_result_auto_sqrt( "select abs(c1), abs(c2), abs(c3) , abs(c4), abs(c5) from t1", "select sqrt(abs(c1)), sqrt(abs(c2)) ,sqrt(abs(c3)), sqrt(abs(c4)), sqrt(abs(c5)) from t1")
-        
+
         # used for sub table
         tdSql.query("select c2 ,sqrt(c2) from ct1")
         tdSql.checkData(0, 1, 298.140906284)
@@ -265,7 +265,7 @@ class TDTestCase:
         tdSql.checkData(5 , 2, None)
 
         self.check_result_auto_sqrt( "select c1, c2, c3 , c4, c5 from ct1", "select sqrt(c1), sqrt(c2) ,sqrt(c3), sqrt(c4), sqrt(c5) from ct1")
-       
+
         # nest query for sqrt functions
         tdSql.query("select c4  , sqrt(c4) ,sqrt(sqrt(c4)) , sqrt(sqrt(sqrt(c4))) from ct1;")
         tdSql.checkData(0 , 0 , 88)
@@ -283,18 +283,18 @@ class TDTestCase:
         tdSql.checkData(11 , 2 , None)
         tdSql.checkData(11 , 3 , None)
 
-        # used for stable table 
-        
+        # used for stable table
+
         tdSql.query("select sqrt(c1) from stb1")
         tdSql.checkRows(25)
-      
+
 
         # used for not exists table
         tdSql.error("select sqrt(c1) from stbbb1")
         tdSql.error("select sqrt(c1) from tbname")
         tdSql.error("select sqrt(c1) from ct5")
 
-        # mix with common col 
+        # mix with common col
         tdSql.query("select c1, sqrt(c1) from ct1")
         tdSql.checkData(0 , 0 ,8)
         tdSql.checkData(0 , 1 ,2.828427125)
@@ -314,7 +314,7 @@ class TDTestCase:
         tdSql.checkData(0 , 1 ,None)
         tdSql.checkData(0 , 2 ,None)
         tdSql.checkData(0 , 3 ,None)
-        
+
         tdSql.checkData(3 , 0 , 6)
         tdSql.checkData(3 , 1 ,2.449489743)
         tdSql.checkData(3 , 2 ,2.449489743)
@@ -335,7 +335,7 @@ class TDTestCase:
         tdSql.query("select max(c5), count(c5) from stb1")
         tdSql.query("select max(c5), count(c5) from ct1")
 
-        
+
         # bug fix for count
         tdSql.query("select count(c1) from ct4 ")
         tdSql.checkData(0,0,9)
@@ -346,7 +346,7 @@ class TDTestCase:
         tdSql.query("select count(*) from stb1 ")
         tdSql.checkData(0,0,25)
 
-        # # bug fix for compute 
+        # # bug fix for compute
         tdSql.query("select c1, sqrt(c1) -0 ,sqrt(c1-4)-0 from ct4 ")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
@@ -397,16 +397,16 @@ class TDTestCase:
         tdSql.checkRows(13)
 
         # # bug for compute in functions
-        # tdSql.query("select c1, abs(1/0) from ct1") 
+        # tdSql.query("select c1, abs(1/0) from ct1")
         # tdSql.checkData(0, 0, 8)
         # tdSql.checkData(0, 1, 1)
 
-        tdSql.query("select c1, sqrt(1) from ct1")  
+        tdSql.query("select c1, sqrt(1) from ct1")
         tdSql.checkData(0, 1, 1.000000000)
         tdSql.checkRows(13)
 
         # two cols start sqrt(x,y)
-        tdSql.query("select c1,c2, sqrt(c2) from ct1") 
+        tdSql.query("select c1,c2, sqrt(c2) from ct1")
         tdSql.checkData(0, 2, 298.140906284)
         tdSql.checkData(1, 2, 278.885281074)
         tdSql.checkData(4, 2, 0.000000000)
@@ -445,10 +445,10 @@ class TDTestCase:
         tdSql.checkData(0,3,1.000000000)
         tdSql.checkData(0,4,0.900000000)
         tdSql.checkData(0,5,1.000000000)
-        
+
     def pow_Arithmetic(self):
         pass
-    
+
     def check_boundary_values(self):
 
         tdSql.execute("drop database if exists bound_test")
@@ -475,11 +475,11 @@ class TDTestCase:
                 f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
             )
         self.check_result_auto_sqrt( "select abs(c1), abs(c2), abs(c3) , abs(c4), abs(c5) from sub1_bound ", "select sqrt(abs(c1)), sqrt(abs(c2)) ,sqrt(abs(c3)), sqrt(abs(c4)), sqrt(abs(c5)) from sub1_bound")
-       
+
         self.check_result_auto_sqrt( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select sqrt(c1), sqrt(c2) ,sqrt(c3), sqrt(c3), sqrt(c2) ,sqrt(c1) from sub1_bound")
 
         self.check_result_auto_sqrt("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from sub1_bound" , "select sqrt(abs(c1)) from sub1_bound" )
-        
+
         # check basic elem for table per row
         tdSql.query("select sqrt(abs(c1)) ,sqrt(abs(c2)) , sqrt(abs(c3)) , sqrt(abs(c4)), sqrt(abs(c5)), sqrt(abs(c6)) from sub1_bound ")
         tdSql.checkData(0,0,math.sqrt(2147483647))
@@ -504,7 +504,7 @@ class TDTestCase:
         tdSql.checkData(0,1,math.sqrt(9223372036854775807))
         tdSql.checkData(0,2,math.sqrt(32767.000000000))
         tdSql.checkData(0,3,math.sqrt(63.500000000))
-      
+
     def support_super_table_test(self):
         tdSql.execute(" use db ")
         self.check_result_auto_sqrt( " select c5 from stb1 order by ts " , "select sqrt(c5) from stb1 order by ts" )
@@ -522,42 +522,42 @@ class TDTestCase:
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4: sqrt basic query ============") 
+        tdLog.printNoPrefix("==========step4: sqrt basic query ============")
 
         self.basic_sqrt_function()
 
-        tdLog.printNoPrefix("==========step5: big number sqrt query ============") 
+        tdLog.printNoPrefix("==========step5: big number sqrt query ============")
 
         self.test_big_number()
 
-        tdLog.printNoPrefix("==========step6: base  number for sqrt query ============") 
+        tdLog.printNoPrefix("==========step6: base  number for sqrt query ============")
 
         self.pow_base_test()
 
-        tdLog.printNoPrefix("==========step7: sqrt boundary query ============") 
+        tdLog.printNoPrefix("==========step7: sqrt boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step8: sqrt filter query ============") 
+        tdLog.printNoPrefix("==========step8: sqrt filter query ============")
 
         self.abs_func_filter()
 
         tdLog.printNoPrefix("==========step9: check sqrt result of  stable query ============")
 
-        self.support_super_table_test()            
+        self.support_super_table_test()
+
 
-        
 
     def stop(self):
         tdSql.close()
diff --git a/tests/system-test/2-query/statecount.py b/tests/system-test/2-query/statecount.py
index 162a5a61fe..90e8bebab4 100644
--- a/tests/system-test/2-query/statecount.py
+++ b/tests/system-test/2-query/statecount.py
@@ -11,7 +11,7 @@ from util.sql import *
 from util.cases import *
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
 
@@ -476,7 +476,7 @@ class TDTestCase:
 
         self.check_unit_time()
         self.query_precision()
-        
+
 
 
     def stop(self):
diff --git a/tests/system-test/2-query/stateduration.py b/tests/system-test/2-query/stateduration.py
index 23169553dc..6b50446814 100644
--- a/tests/system-test/2-query/stateduration.py
+++ b/tests/system-test/2-query/stateduration.py
@@ -25,10 +25,10 @@ class TDTestCase:
     def run(self):
         tdSql.prepare()
         # timestamp = 1ms , time_unit = 1s
-        tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
+        tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''')
         for i in range(self.row_num):
-            tdSql.execute("insert into test values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into test values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
         integer_list = [1,2,3,4,11,12,13,14]
         float_list = [5,6]
@@ -72,10 +72,10 @@ class TDTestCase:
                 tdSql.error(f"select stateduration(col1,{i},5) from test")
 
         # timestamp = 1s, time_unit =1s
-        tdSql.execute('''create table test1(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
+        tdSql.execute('''create table test1(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double,
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''')
         for i in range(self.row_num):
-            tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+            tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)"
                         % (self.ts + i*1000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
 
         for i in integer_list:
diff --git a/tests/system-test/2-query/timezone.py b/tests/system-test/2-query/timezone.py
index ce2cdc062e..3707d25c88 100644
--- a/tests/system-test/2-query/timezone.py
+++ b/tests/system-test/2-query/timezone.py
@@ -18,24 +18,24 @@ class TDTestCase:
         self.arithmetic_operators = ['+','-','*','/']
         self.arithmetic_values = [0,1,100,15.5]
         # name of normal table
-        self.ntbname = 'ntb'    
+        self.ntbname = 'ntb'
         # name of stable
-        self.stbname = 'stb'    
+        self.stbname = 'stb'
         # structure of column
-        self.column_dict = {    
+        self.column_dict = {
             'ts':'timestamp',
             'c1':'int',
             'c2':'float',
             'c3':'double'
         }
         # structure of tag
-        self.tag_dict = {       
+        self.tag_dict = {
             't0':'int'
         }
         # number of child tables
-        self.tbnum = 2       
+        self.tbnum = 2
         # values of tag,the number of values should equal to tbnum
-        self.tag_values = [     
+        self.tag_values = [
             f'10',
             f'100'
         ]
@@ -62,7 +62,7 @@ class TDTestCase:
                 time_zone = time_zone_1 + " " + time_zone_2
         print("expected time zone: " + time_zone)
         return time_zone
-    
+
     def tb_type_check(self,tb_type):
         if tb_type in ['normal_table','child_table']:
             tdSql.checkRows(len(self.values_list))
@@ -115,7 +115,7 @@ class TDTestCase:
         timezone = self.get_system_timezone()
         self.timezone_check_ntb(timezone)
         self.timezone_check_stb(timezone)
-        
+
     def stop(self):
         tdSql.close()
         tdLog.success(f"{__file__} successfully executed")
diff --git a/tests/system-test/2-query/top.py b/tests/system-test/2-query/top.py
index 6120f81e6d..a7a433a897 100644
--- a/tests/system-test/2-query/top.py
+++ b/tests/system-test/2-query/top.py
@@ -45,7 +45,7 @@ class TDTestCase:
             'col12': 'binary(20)',
             'col13': 'nchar(20)'
         }
-        
+
         self.param_list = [1,100]
 
     def insert_data(self,column_dict,tbname,row_num):
@@ -107,7 +107,7 @@ class TDTestCase:
         tdSql.execute(f"create database if not exists {dbname} vgroups 2")
         tdSql.execute(f'use {dbname}')
         tdSql.execute(self.setsql.set_create_stable_sql(stbname,self.column_dict,tag_dict))
-        
+
         for i in range(self.tbnum):
             tdSql.execute(f"create table {stbname}_{i} using {stbname} tags({tag_values[0]})")
             self.insert_data(self.column_dict,f'{stbname}_{i}',self.rowNum)
@@ -141,7 +141,7 @@ class TDTestCase:
         self.top_check_ntb()
         self.top_check_stb()
 
-        
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/system-test/7-tmq/tmqAutoCreateTbl.py b/tests/system-test/7-tmq/tmqAutoCreateTbl.py
index 6a9f10ebbf..1622ad7621 100644
--- a/tests/system-test/7-tmq/tmqAutoCreateTbl.py
+++ b/tests/system-test/7-tmq/tmqAutoCreateTbl.py
@@ -16,9 +16,9 @@ from tmqCommon import *
 
 class TDTestCase:
     def __init__(self):
-        self.vgroups    = 2
-        self.ctbNum     = 100
-        self.rowsPerTbl = 10000
+        self.vgroups    = 4
+        self.ctbNum     = 1000
+        self.rowsPerTbl = 1000
         
     def init(self, conn, logSql):
         tdLog.debug(f"start to excute {__file__}")
@@ -29,7 +29,7 @@ class TDTestCase:
         paraDict = {'dbName':     'dbt',
                     'dropFlag':   1,
                     'event':      '',
-                    'vgroups':    3,
+                    'vgroups':    4,
                     'stbName':    'stb',
                     'colPrefix':  'c',
                     'tagPrefix':  't',
@@ -37,14 +37,14 @@ class TDTestCase:
                     'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
                     'ctbPrefix':  'ctb',
                     'ctbStartIdx': 0,
-                    'ctbNum':     500,
+                    'ctbNum':     1000,
                     'rowsPerTbl': 1000,
-                    'batchNum':   500,
+                    'batchNum':   400,
                     'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
                     'pollDelay':  3,
                     'showMsg':    1,
                     'showRow':    1,
-                    'snapshot':   0}
+                    'snapshot':   1}
 
         paraDict['vgroups'] = self.vgroups
         paraDict['ctbNum'] = self.ctbNum
@@ -54,20 +54,21 @@ class TDTestCase:
         tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
         tdLog.info("create stb")
         tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
-        tdLog.info("create ctb")
-        tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
-                             ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
-        tdLog.info("insert data")
-        tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
-                                               ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
-                                               startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+        # tdLog.info("create ctb")
+        # tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
+        #                      ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
+        # tdLog.info("insert data")
+        # tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
+        #                                        ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
+        #                                        startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+                
+        tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctbx",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"])
         
-        tdLog.info("restart taosd to ensure that the data falls into the disk")
-        # tdDnodes.stop(1)
-        # tdDnodes.start(1)
-        tdSql.query("flush database %s"%(paraDict['dbName']))
+        # tdLog.info("restart taosd to ensure that the data falls into the disk")        
+        # tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
+    # 自动建表完成数据插入，启动消费
     def tmqCase1(self):
         tdLog.printNoPrefix("======== test case 1: ")
         paraDict = {'dbName':     'dbt',
@@ -90,28 +91,23 @@ class TDTestCase:
                     'showRow':    1,
                     'snapshot':   1}
 
-        # paraDict['vgroups'] = self.vgroups
-        # paraDict['ctbNum'] = self.ctbNum
-        # paraDict['rowsPerTbl'] = self.rowsPerTbl
+        paraDict['vgroups'] = self.vgroups
+        paraDict['ctbNum'] = self.ctbNum
+        paraDict['rowsPerTbl'] = self.rowsPerTbl
         
-        tmqCom.initConsumerTable()
-        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
-        tdLog.info("create stb")
-        tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
-        tdLog.info("create ctb")
-        tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
-                             ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
-        tdLog.info("insert data")
-        tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
-                                               ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
-                                               startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+        # tmqCom.initConsumerTable()
+        # tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        # tdLog.info("create stb")
+        # tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
+        # tdLog.info("insert data by auto create ctb")
+        # tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"])
 
         tdLog.info("create topics from stb1")
         topicFromStb1 = 'topic_stb1'                
         queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName'])
         sqlString = "create topic %s as %s" %(topicFromStb1, queryString)
         tdLog.info("create topic sql: %s"%sqlString)
-        tdSql.execute(sqlString)
+        tdSql.execute(sqlString)        
         
         consumerId     = 0
         expectrowcnt   = paraDict["rowsPerTbl"] * paraDict["ctbNum"]
@@ -120,19 +116,12 @@ class TDTestCase:
         ifManualCommit = 0
         keyList        = 'group.id:cgrp1,\
                         enable.auto.commit:true,\
-                        auto.commit.interval.ms:500,\
+                        auto.commit.interval.ms:1000,\
                         auto.offset.reset:earliest'
         tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
 
         tdLog.info("start consume processor")
         tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
-        
-        # time.sleep(3)
-        tmqCom.getStartCommitNotifyFromTmqsim()
-        tdLog.info("================= restart dnode ===========================")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
-        time.sleep(5)
 
         tdLog.info("insert process end, and start to check consume result")
         expectRows = 1
@@ -172,23 +161,23 @@ class TDTestCase:
                     'pollDelay':  5,
                     'showMsg':    1,
                     'showRow':    1,
-                    'snapshot':   1}
+                    'snapshot':   0}
 
-        # paraDict['vgroups'] = self.vgroups
-        # paraDict['ctbNum'] = self.ctbNum
-        # paraDict['rowsPerTbl'] = self.rowsPerTbl
+        paraDict['vgroups'] = self.vgroups
+        paraDict['ctbNum'] = self.ctbNum
+        paraDict['rowsPerTbl'] = self.rowsPerTbl
         
         tmqCom.initConsumerTable()
-        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
-        tdLog.info("create stb")
-        tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
-        tdLog.info("create ctb")
-        tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
-                             ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
-        tdLog.info("insert data")
-        tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
-                                               ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
-                                               startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+        # tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        # tdLog.info("create stb")
+        # tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
+        # tdLog.info("create ctb")
+        # tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
+        #                      ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
+        # tdLog.info("insert data")
+        # tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
+        #                                        ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
+        #                                        startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         tdLog.info("create topics from stb1")
         topicFromStb1 = 'topic_stb1'                
         queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName'])
@@ -211,14 +200,8 @@ class TDTestCase:
         tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
 
         tdLog.info("create some new child table and insert data ")
-        tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"])
+        tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctby",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"])
         
-        tmqCom.getStartCommitNotifyFromTmqsim()
-        tdLog.info("================= restart dnode ===========================")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
-        time.sleep(5)
-
         tdLog.info("insert process end, and start to check consume result")
         expectRows = 1
         resultList = tmqCom.selectConsumeResult(expectRows)
@@ -237,91 +220,13 @@ class TDTestCase:
 
         tdLog.printNoPrefix("======== test case 2 end ...... ")
 
-    # 自动建表完成数据插入，启动消费
-    def tmqCase3(self):
-        tdLog.printNoPrefix("======== test case 3: ")   
-        paraDict = {'dbName':     'dbt',
-                    'dropFlag':   1,
-                    'event':      '',
-                    'vgroups':    4,
-                    'stbName':    'stb',
-                    'colPrefix':  'c',
-                    'tagPrefix':  't',
-                    'colSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}],
-                    'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
-                    'ctbPrefix':  'ctb',
-                    'ctbStartIdx': 0,
-                    'ctbNum':     1000,
-                    'rowsPerTbl': 1000,
-                    'batchNum':   400,
-                    'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
-                    'pollDelay':  5,
-                    'showMsg':    1,
-                    'showRow':    1,
-                    'snapshot':   1}
-
-        paraDict['vgroups'] = self.vgroups
-        paraDict['ctbNum'] = self.ctbNum
-        paraDict['rowsPerTbl'] = self.rowsPerTbl
-        
-        tmqCom.initConsumerTable()
-        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
-        tdLog.info("create stb")
-        tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
-        tdLog.info("insert data by auto create ctb")
-        tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"])
-
-        tdLog.info("create topics from stb1")
-        topicFromStb1 = 'topic_stb1'                
-        queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName'])
-        sqlString = "create topic %s as %s" %(topicFromStb1, queryString)
-        tdLog.info("create topic sql: %s"%sqlString)
-        tdSql.execute(sqlString)        
-        
-        consumerId     = 0
-        expectrowcnt   = paraDict["rowsPerTbl"] * paraDict["ctbNum"]
-        topicList      = topicFromStb1
-        ifcheckdata    = 0
-        ifManualCommit = 0
-        keyList        = 'group.id:cgrp1,\
-                        enable.auto.commit:true,\
-                        auto.commit.interval.ms:1000,\
-                        auto.offset.reset:earliest'
-        tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
-
-        tdLog.info("start consume processor")
-        tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
-
-        # tdLog.info("================= restart dnode ===========================")
-        # tdDnodes.stop(1)
-        # tdDnodes.start(1)
-        # time.sleep(2)
-
-        tdLog.info("insert process end, and start to check consume result")
-        expectRows = 1
-        resultList = tmqCom.selectConsumeResult(expectRows)
-        totalConsumeRows = 0
-        for i in range(expectRows):
-            totalConsumeRows += resultList[i]
-
-        tdSql.query(queryString)
-        totalRowsInserted = tdSql.getRows()
-        
-        if totalConsumeRows != totalRowsInserted:
-            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, totalRowsInserted))
-            tdLog.exit("tmq consume rows error!")
-
-        tdSql.query("drop topic %s"%topicFromStb1)
-
-        tdLog.printNoPrefix("======== test case 3 end ...... ")
-
 
     def run(self):
         tdSql.prepare()
-
-        # self.tmqCase1()
-        # self.tmqCase2() 
-        self.tmqCase3()
+        self.prepareTestEnv()
+        self.tmqCase1()
+        # self.tmqCase2()     TD-17267
+        
 
     def stop(self):
         tdSql.close()
diff --git a/tests/system-test/7-tmq/tmqDnodeRestart.py b/tests/system-test/7-tmq/tmqDnodeRestart.py
new file mode 100644
index 0000000000..8354991578
--- /dev/null
+++ b/tests/system-test/7-tmq/tmqDnodeRestart.py
@@ -0,0 +1,253 @@
+
+import taos
+import sys
+import time
+import socket
+import os
+import threading
+from enum import Enum
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+sys.path.append("./7-tmq")
+from tmqCommon import *
+
+class TDTestCase:
+    def __init__(self):
+        self.vgroups    = 2
+        self.ctbNum     = 100
+        self.rowsPerTbl = 10000
+        
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor(), False)
+
+    def prepareTestEnv(self):
+        tdLog.printNoPrefix("======== prepare test env include database, stable, ctables, and insert data: ")
+        paraDict = {'dbName':     'dbt',
+                    'dropFlag':   1,
+                    'event':      '',
+                    'vgroups':    3,
+                    'stbName':    'stb',
+                    'colPrefix':  'c',
+                    'tagPrefix':  't',
+                    'colSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}],
+                    'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
+                    'ctbPrefix':  'ctb',
+                    'ctbStartIdx': 0,
+                    'ctbNum':     500,
+                    'rowsPerTbl': 1000,
+                    'batchNum':   500,
+                    'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
+                    'pollDelay':  3,
+                    'showMsg':    1,
+                    'showRow':    1,
+                    'snapshot':   0}
+
+        paraDict['vgroups'] = self.vgroups
+        paraDict['ctbNum'] = self.ctbNum
+        paraDict['rowsPerTbl'] = self.rowsPerTbl
+        
+        tmqCom.initConsumerTable()
+        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        tdLog.info("create stb")
+        tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
+        tdLog.info("create ctb")
+        tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
+                             ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
+        tdLog.info("insert data")
+        tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
+                                               ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
+                                               startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+        
+        tdLog.info("restart taosd to ensure that the data falls into the disk")
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
+        return
+
+    def tmqCase1(self):
+        tdLog.printNoPrefix("======== test case 1: ")
+        paraDict = {'dbName':     'dbt',
+                    'dropFlag':   1,
+                    'event':      '',
+                    'vgroups':    4,
+                    'stbName':    'stb',
+                    'colPrefix':  'c',
+                    'tagPrefix':  't',
+                    'colSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}],
+                    'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
+                    'ctbPrefix':  'ctb',
+                    'ctbStartIdx': 0,
+                    'ctbNum':     1000,
+                    'rowsPerTbl': 1000,
+                    'batchNum':   400,
+                    'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
+                    'pollDelay':  5,
+                    'showMsg':    1,
+                    'showRow':    1,
+                    'snapshot':   1}
+
+        # paraDict['vgroups'] = self.vgroups
+        # paraDict['ctbNum'] = self.ctbNum
+        # paraDict['rowsPerTbl'] = self.rowsPerTbl
+        
+        tmqCom.initConsumerTable()
+        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        tdLog.info("create stb")
+        tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
+        tdLog.info("create ctb")
+        tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
+                             ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
+        tdLog.info("insert data")
+        tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
+                                               ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
+                                               startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'                
+        queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName'])
+        sqlString = "create topic %s as %s" %(topicFromStb1, queryString)
+        tdLog.info("create topic sql: %s"%sqlString)
+        tdSql.execute(sqlString)
+        
+        consumerId     = 0
+        expectrowcnt   = paraDict["rowsPerTbl"] * paraDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 0
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:true,\
+                        auto.commit.interval.ms:500,\
+                        auto.offset.reset:earliest'
+        tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
+        
+        # time.sleep(3)
+        tmqCom.getStartCommitNotifyFromTmqsim()
+        tdLog.info("================= restart dnode ===========================")
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        time.sleep(5)
+
+        tdLog.info("insert process end, and start to check consume result")
+        expectRows = 1
+        resultList = tmqCom.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+
+        tdSql.query(queryString)
+        totalRowsInserted = tdSql.getRows()
+        
+        if totalConsumeRows != totalRowsInserted:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, totalRowsInserted))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 1 end ...... ")
+
+    def tmqCase2(self):
+        tdLog.printNoPrefix("======== test case 2: ")  
+        paraDict = {'dbName':     'dbt',
+                    'dropFlag':   1,
+                    'event':      '',
+                    'vgroups':    4,
+                    'stbName':    'stb',
+                    'colPrefix':  'c',
+                    'tagPrefix':  't',
+                    'colSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}],
+                    'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
+                    'ctbPrefix':  'ctb',
+                    'ctbStartIdx': 0,
+                    'ctbNum':     1000,
+                    'rowsPerTbl': 1000,
+                    'batchNum':   1000,
+                    'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
+                    'pollDelay':  5,
+                    'showMsg':    1,
+                    'showRow':    1,
+                    'snapshot':   1}
+
+        # paraDict['vgroups'] = self.vgroups
+        # paraDict['ctbNum'] = self.ctbNum
+        # paraDict['rowsPerTbl'] = self.rowsPerTbl
+        
+        tmqCom.initConsumerTable()
+        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        tdLog.info("create stb")
+        tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"])
+        tdLog.info("create ctb")
+        tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'],
+                             ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx'])
+        tdLog.info("insert data")
+        tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"],
+                                               ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"],
+                                               startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'                
+        queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName'])
+        sqlString = "create topic %s as %s" %(topicFromStb1, queryString)
+        tdLog.info("create topic sql: %s"%sqlString)
+        tdSql.execute(sqlString)
+        
+        consumerId     = 0
+        expectrowcnt   = paraDict["rowsPerTbl"] * paraDict["ctbNum"] * 2
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 0
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:true,\
+                        auto.commit.interval.ms:1000,\
+                        auto.offset.reset:earliest'
+        tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
+
+        tdLog.info("create some new child table and insert data ")
+        tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"])
+        
+        tmqCom.getStartCommitNotifyFromTmqsim()
+        tdLog.info("================= restart dnode ===========================")
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        time.sleep(5)
+
+        tdLog.info("insert process end, and start to check consume result")
+        expectRows = 1
+        resultList = tmqCom.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+
+        tdSql.query(queryString)
+        totalRowsInserted = tdSql.getRows()
+        
+        if totalConsumeRows != totalRowsInserted:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, totalRowsInserted))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 2 end ...... ")
+
+    def run(self):
+        tdSql.prepare()
+
+        self.tmqCase1()
+        self.tmqCase2() 
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+event = threading.Event()
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh
index 2d1ca64914..269f83a139 100755
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
@@ -21,7 +21,7 @@ python3 ./test.py -f 1-insert/opentsdb_json_taosc_insert.py
 python3 ./test.py -f 1-insert/test_stmt_muti_insert_query.py
 python3 ./test.py -f 1-insert/test_stmt_set_tbname_tag.py
 python3 ./test.py -f 1-insert/alter_stable.py
-#python3 ./test.py -f 1-insert/alter_table.py
+python3 ./test.py -f 1-insert/alter_table.py
 python3 ./test.py -f 1-insert/insertWithMoreVgroup.py
 python3 ./test.py -f 1-insert/table_comment.py
 python3 ./test.py -f 1-insert/time_range_wise.py
@@ -176,8 +176,8 @@ python3 ./test.py -f 7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb.py
 python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py
 python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
 python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py
-
-
+python3 ./test.py -f 7-tmq/tmqAutoCreateTbl.py
+#python3 ./test.py -f 7-tmq/tmqDnodeRestart.py
 
 #------------querPolicy  2-----------