From 54890e481558fcdb17e3d05ac25353b3cff14127 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 22 May 2020 22:45:47 +0800
Subject: [PATCH 01/27] [td-225] fix bug in test script

---
 tests/script/general/parser/slimit.sim | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/script/general/parser/slimit.sim b/tests/script/general/parser/slimit.sim
index 161463a7c1..be63f91803 100644
--- a/tests/script/general/parser/slimit.sim
+++ b/tests/script/general/parser/slimit.sim
@@ -22,7 +22,7 @@ $db = $dbPrefix . $i
 $stb = $stbPrefix . $i
 
 sql drop database if exists $db
-sql create database $db maxrows 200 cache 1024 tblocks 200 maxTables 4
+sql create database $db maxrows 200 cache 16 maxTables 4
 print ====== create tables
 sql use $db
 sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 binary(15), t2 int, t3 bigint, t4 nchar(10), t5 double, t6 bool)
@@ -64,7 +64,7 @@ print ====== $db tables created
 
 $db = $dbPrefix . 1
 sql drop database if exists $db
-sql create database $db maxrows 200 cache 1024
+sql create database $db maxrows 200 cache 16
 sql use $db
 sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 binary(15), t2 int, t3 bigint, t4 nchar(10), t5 double, t6 bool)
 

From 95c97a5df812fa9c81ca35550b2ce8d2dffb4905 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 22 May 2020 22:46:11 +0800
Subject: [PATCH 02/27] [td-225]refactor code: remove useless codes

---
 src/client/src/tscLocal.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 79fa1e28cc..5ffdcd2167 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -384,13 +384,10 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
 
   // keep the code in local variable in order to avoid invalid read in case of async query
   int32_t code = pSql->res.code;
-
-  if (pSql->fp != NULL) {  // callback function
-    if (code == 0) {
-      (*pSql->fp)(pSql->param, pSql, 0);
-    } else {
-      tscQueueAsyncRes(pSql);
-    }
+  if (code == TSDB_CODE_SUCCESS) {
+    (*pSql->fp)(pSql->param, pSql, 0);
+  } else {
+    tscQueueAsyncRes(pSql);
   }
 
   return code;

From 7f514df778ce4545eec6e317273c905a0b8cf935 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 11:40:52 +0800
Subject: [PATCH 03/27] [td-338]

---
 src/client/src/tscSQLParser.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index a134410bc4..d68290653a 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -5606,7 +5606,8 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   const char* msg3 = "fill only available for interval query";
   const char* msg4 = "fill option not supported in stream computing";
   const char* msg5 = "sql too long";  // todo ADD support
-
+  const char* msg6 = "from missing in subclause";
+  
   SSqlCmd*    pCmd = &pSql->cmd;
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   assert(pQueryInfo->numOfTables == 1);
@@ -5621,10 +5622,13 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   if (tscValidateName(pzTableName) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
-
+  
   tVariantList* pSrcMeterName = pInfo->pCreateTableInfo->pSelect->from;
-  tVariant*     pVar = &pSrcMeterName->a[0].pVar;
-
+  if (pSrcMeterName == NULL || pSrcMeterName->nExpr == 0) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+  }
+  
+  tVariant* pVar = &pSrcMeterName->a[0].pVar;
   SSQLToken srcToken = {.z = pVar->pz, .n = pVar->nLen, .type = TK_STRING};
   if (tscValidateName(&srcToken) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);

From 7221f5a62497652d445182275b0a5c9d952e9943 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 16:10:44 +0800
Subject: [PATCH 04/27] [td-227]

---
 src/inc/taosdef.h         |   3 +-
 src/query/src/qExecutor.c |  40 +++---
 src/tsdb/src/tsdbRead.c   | 266 ++++++++++++++++++++------------------
 3 files changed, 159 insertions(+), 150 deletions(-)

diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index b6a37d85a2..74de811c59 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -326,8 +326,7 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 
 #define TSDB_QUERY_TYPE_TAG_FILTER_QUERY              0x400u
 #define TSDB_QUERY_TYPE_INSERT                        0x100u    // insert type
-#define TSDB_QUERY_TYPE_IMPORT                        0x200u    // import data
-#define TSDB_QUERY_TYPE_MULTITABLE_QUERY              0x800u
+#define TSDB_QUERY_TYPE_MULTITABLE_QUERY              0x200u
 
 #define TSDB_QUERY_HAS_TYPE(x, _type)         (((x) & (_type)) != 0)
 #define TSDB_QUERY_SET_TYPE(x, _type)         ((x) |= (_type))
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 052273a90c..a8158a386d 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -403,23 +403,24 @@ static bool isTopBottomQuery(SQuery *pQuery) {
   return false;
 }
 
-static SDataStatis *getStatisInfo(SQuery *pQuery, SDataStatis *pStatis, SDataBlockInfo *pDataBlockInfo, int32_t index) {
+static SDataStatis *getStatisInfo(SQuery *pQuery, SDataStatis *pStatis, int32_t numOfCols, int32_t index) {
   // for a tag column, no corresponding field info
-  SColIndex *pColIndexEx = &pQuery->pSelectExpr[index].base.colInfo;
-  if (TSDB_COL_IS_TAG(pColIndexEx->flag)) {
+  SColIndex *pColIndex = &pQuery->pSelectExpr[index].base.colInfo;
+  if (TSDB_COL_IS_TAG(pColIndex->flag)) {
     return NULL;
   }
-
+  
   /*
    * Choose the right column field info by field id, since the file block may be out of date,
    * which means the newest table schema is not equalled to the schema of this block.
+   * TODO: speedup by using bsearch
    */
-  for (int32_t i = 0; i < pDataBlockInfo->numOfCols; ++i) {
-    if (pColIndexEx->colId == pStatis[i].colId) {
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    if (pColIndex->colId == pStatis[i].colId) {
       return &pStatis[i];
     }
   }
-
+  
   return NULL;
 }
 
@@ -431,8 +432,7 @@ static SDataStatis *getStatisInfo(SQuery *pQuery, SDataStatis *pStatis, SDataBlo
  * @param pColStatis
  * @return
  */
-static bool hasNullValue(SQuery *pQuery, int32_t col, SDataBlockInfo *pDataBlockInfo, SDataStatis *pStatis,
-                         SDataStatis **pColStatis) {
+static bool hasNullValue(SQuery *pQuery, int32_t col, int32_t numOfCols, SDataStatis *pStatis, SDataStatis **pColStatis) {
   SColIndex *pColIndex = &pQuery->pSelectExpr[col].base.colInfo;
   if (TSDB_COL_IS_TAG(pColIndex->flag)) {
     return false;
@@ -444,7 +444,7 @@ static bool hasNullValue(SQuery *pQuery, int32_t col, SDataBlockInfo *pDataBlock
   }
 
   if (pStatis != NULL) {
-    *pColStatis = getStatisInfo(pQuery, pStatis, pDataBlockInfo, col);
+    *pColStatis = getStatisInfo(pQuery, pStatis, numOfCols, col);
   } else {
     *pColStatis = NULL;
   }
@@ -936,7 +936,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
 
     SDataStatis *tpField = NULL;
 
-    bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo, pStatis, &tpField);
+    bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo->numOfCols, pStatis, &tpField);
     char *dataBlock = getDataBlock(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
 
     setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, tpField, hasNull,
@@ -1157,7 +1157,7 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
 
     SDataStatis *pColStatis = NULL;
 
-    bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo, pStatis, &pColStatis);
+    bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo->numOfCols, pStatis, &pColStatis);
     char *dataBlock = getDataBlock(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
 
     setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, pColStatis, hasNull,
@@ -2455,9 +2455,9 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     }
 
     SDataStatis *pStatis = NULL;
-    SArray *     pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, pQueryHandle, &blockInfo, &pStatis);
-
     pQuery->pos = QUERY_IS_ASC_QUERY(pQuery) ? 0 : blockInfo.rows - 1;
+    
+    SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, pQueryHandle, &blockInfo, &pStatis);
     int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, pStatis, binarySearchForKey, pDataBlock);
 
     qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d", GET_QINFO_ADDR(pRuntimeEnv),
@@ -5610,18 +5610,18 @@ static void doUpdateExprColumnIndex(SQuery *pQuery) {
       continue;
     }
 
-    SColIndex *pColIndexEx = &pSqlExprMsg->colInfo;
-    if (!TSDB_COL_IS_TAG(pColIndexEx->flag)) {
+    SColIndex *pColIndex = &pSqlExprMsg->colInfo;
+    if (!TSDB_COL_IS_TAG(pColIndex->flag)) {
       for (int32_t f = 0; f < pQuery->numOfCols; ++f) {
-        if (pColIndexEx->colId == pQuery->colList[f].colId) {
-          pColIndexEx->colIndex = f;
+        if (pColIndex->colId == pQuery->colList[f].colId) {
+          pColIndex->colIndex = f;
           break;
         }
       }
     } else {
       for (int32_t f = 0; f < pQuery->numOfTags; ++f) {
-        if (pColIndexEx->colId == pQuery->tagColList[f].colId) {
-          pColIndexEx->colIndex = f;
+        if (pColIndex->colId == pQuery->tagColList[f].colId) {
+          pColIndex->colIndex = f;
           break;
         }
       }
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index b5340d4ba9..cc191f3900 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -40,10 +40,6 @@ enum {
   TSDB_QUERY_TYPE_EXTERNAL = 3,
 };
 
-typedef struct SField {
-  // todo need the definition
-} SField;
-
 typedef struct SQueryFilePos {
   int32_t fid;
   int32_t slot;
@@ -68,66 +64,56 @@ typedef struct SLoadCompBlockInfo {
 } SLoadCompBlockInfo;
 
 typedef struct STableCheckInfo {
-  STableId   tableId;
-  TSKEY      lastKey;
-  STable*    pTableObj;
-  int32_t    start;
-  SCompInfo* pCompInfo;
-  int32_t    compSize;
-  int32_t    numOfBlocks;    // number of qualified data blocks not the original blocks
-  SDataCols* pDataCols;
-  
-  SSkipListIterator* iter;   // skip list iterator
-  SSkipListIterator* iiter;  // imem iterator
-  
-  bool       initBuf;   // if we should initialize the in-memory skip list iterator
+  STableId      tableId;
+  TSKEY         lastKey;
+  STable*       pTableObj;
+  SCompInfo*    pCompInfo;
+  int32_t       compSize;
+  int32_t       numOfBlocks;    // number of qualified data blocks not the original blocks
+  SDataCols*    pDataCols;
+  bool          initBuf;        // whether to initialize the in-memory skip list iterator or not
+  SSkipListIterator* iter;      // mem buffer skip list iterator
+  SSkipListIterator* iiter;     // imem buffer skip list iterator
 } STableCheckInfo;
 
-typedef struct {
-  SCompBlock* compBlock;
-  SField*     fields;
-} SCompBlockFields;
-
 typedef struct STableBlockInfo {
-  SCompBlockFields pBlock;
-  STableCheckInfo* pTableCheckInfo;
-  int32_t          blockIndex;
-  int32_t          groupIdx; /* number of group is less than the total number of tables */
+  SCompBlock*        compBlock;
+  STableCheckInfo*   pTableCheckInfo;
+//  int32_t            blockIndex;
+//  int32_t            groupIdx; /* number of group is less than the total number of tables */
 } STableBlockInfo;
 
 typedef struct SBlockOrderSupporter {
   int32_t             numOfTables;
-  STableBlockInfo** pDataBlockInfo;
+  STableBlockInfo**   pDataBlockInfo;
   int32_t*            blockIndexArray;
   int32_t*            numOfBlocksPerTable;
 } SBlockOrderSupporter;
 
 typedef struct STsdbQueryHandle {
-  STsdbRepo*    pTsdb;
-  SQueryFilePos cur;    // current position
-
-  SDataBlockLoadInfo dataBlockLoadInfo; /* record current block load information */
-  SLoadCompBlockInfo compBlockLoadInfo; /* record current compblock information in SQuery */
-
-  int16_t     order;
-  STimeWindow window;  // the primary query time window that applies to all queries
-  SCompBlock* pBlock;
-  int32_t     numOfBlocks;
-  SField**    pFields;
-  SArray*     pColumns;    // column list, SColumnInfoData array list
-  bool        locateStart;
-  int32_t     outputCapacity;
-  int32_t     realNumOfRows;
-  SArray*     pTableCheckInfo;  //SArray<STableCheckInfo>
-  int32_t     activeIndex;
-  bool        checkFiles;  // check file stage
-  void*       qinfo;       // query info handle, for debug purpose
-  int32_t     type;        // query type: retrieve all data blocks, 2. retrieve only last row, 3. retrieve direct prev|next rows
-  STableBlockInfo* pDataBlockInfo;
-
+  STsdbRepo*     pTsdb;
+  SQueryFilePos  cur;              // current position
+  int16_t        order;
+  STimeWindow    window;           // the primary query time window that applies to all queries
+  SCompBlock*    pBlock;
+  SDataStatis*   statis;           // query level statistics, only one table block statistics info exists at any time
+  int32_t        numOfBlocks;
+  SArray*        pColumns;         // column list, SColumnInfoData array list
+  bool           locateStart;
+  int32_t        outputCapacity;
+  int32_t        realNumOfRows;
+  SArray*        pTableCheckInfo;  //SArray<STableCheckInfo>
+  int32_t        activeIndex;
+  bool           checkFiles;       // check file stage
+  void*          qinfo;            // query info handle, for debug purpose
+  int32_t        type;             // query type: retrieve all data blocks, 2. retrieve only last row, 3. retrieve direct prev|next rows
   SFileGroup*    pFileGroup;
   SFileGroupIter fileIter;
   SRWHelper      rhelper;
+  STableBlockInfo* pDataBlockInfo;
+  
+  SDataBlockLoadInfo dataBlockLoadInfo; /* record current block load information */
+  SLoadCompBlockInfo compBlockLoadInfo; /* record current compblock information in SQuery */
 } STsdbQueryHandle;
 
 static void changeQueryHandleForLastrowQuery(TsdbQueryHandleT pqHandle);
@@ -148,23 +134,43 @@ TsdbQueryHandleT* tsdbQueryTables(TsdbRepoT* tsdb, STsdbQueryCond* pCond, STable
   // todo 2. add the reference count for each table that is involved in query
 
   STsdbQueryHandle* pQueryHandle = calloc(1, sizeof(STsdbQueryHandle));
-  pQueryHandle->order  = pCond->order;
-  pQueryHandle->window = pCond->twindow;
-  pQueryHandle->pTsdb  = tsdb;
-  pQueryHandle->type   = TSDB_QUERY_TYPE_ALL;
+  pQueryHandle->order       = pCond->order;
+  pQueryHandle->window      = pCond->twindow;
+  pQueryHandle->pTsdb       = tsdb;
+  pQueryHandle->type        = TSDB_QUERY_TYPE_ALL;
+  pQueryHandle->cur.fid     = -1;
+  pQueryHandle->cur.win     = TSWINDOW_INITIALIZER;
+  pQueryHandle->checkFiles  = true;//ASCENDING_TRAVERSE(pQueryHandle->order);
+  pQueryHandle->activeIndex = 0;   // current active table index
+  pQueryHandle->outputCapacity = ((STsdbRepo*)tsdb)->config.maxRowsPerFileBlock;
+  
   tsdbInitReadHelper(&pQueryHandle->rhelper, (STsdbRepo*) tsdb);
 
-  pQueryHandle->cur.fid = -1;
-  pQueryHandle->cur.win = TSWINDOW_INITIALIZER;
-
   size_t sizeOfGroup = taosArrayGetSize(groupList->pGroupList);
   assert(sizeOfGroup >= 1 && pCond != NULL && pCond->numOfCols > 0);
 
+  // allocate buffer in order to load data blocks from file
+  int32_t numOfCols = pCond->numOfCols;
+  
+  pQueryHandle->statis = calloc(numOfCols, sizeof(SDataStatis));
+  pQueryHandle->pColumns = taosArrayInit(numOfCols, sizeof(SColumnInfoData));  // todo: use list instead of array?
+  
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfoData  colInfo = {{0}, 0};
+  
+    colInfo.info = pCond->colList[i];
+    colInfo.pData = calloc(1, EXTRA_BYTES + pQueryHandle->outputCapacity * pCond->colList[i].bytes);
+    taosArrayPush(pQueryHandle->pColumns, &colInfo);
+    pQueryHandle->statis[i].colId = colInfo.info.colId;
+  }
+  
   pQueryHandle->pTableCheckInfo = taosArrayInit(groupList->numOfTables, sizeof(STableCheckInfo));
+  STsdbMeta* pMeta = tsdbGetMeta(tsdb);
+  assert(pMeta != NULL);
   
   for (int32_t i = 0; i < sizeOfGroup; ++i) {
     SArray* group = *(SArray**) taosArrayGet(groupList->pGroupList, i);
-
+    
     size_t gsize = taosArrayGetSize(group);
     assert(gsize > 0);
     
@@ -174,35 +180,18 @@ TsdbQueryHandleT* tsdbQueryTables(TsdbRepoT* tsdb, STsdbQueryCond* pCond, STable
       STableCheckInfo info = {
           .lastKey = pQueryHandle->window.skey,
           .tableId = *id,
-          .pTableObj = tsdbGetTableByUid(tsdbGetMeta(tsdb), id->uid),
+          .pTableObj = tsdbGetTableByUid(pMeta, id->uid),
       };
-
+      
       assert(info.pTableObj != NULL && info.pTableObj->tableId.tid == id->tid);
       taosArrayPush(pQueryHandle->pTableCheckInfo, &info);
     }
   }
-
-  uTrace("%p total numOfTable:%d in query", pQueryHandle, taosArrayGetSize(pQueryHandle->pTableCheckInfo));
   
-  /*
-   * For ascending timestamp order query, query starts from data files. In contrast, buffer will be checked in the first place
-   * in case of descending timestamp order query.
-   */
-  pQueryHandle->checkFiles  = true;//ASCENDING_TRAVERSE(pQueryHandle->order);
-  pQueryHandle->activeIndex = 0;
-
-  // allocate buffer in order to load data blocks from file
-  int32_t numOfCols = pCond->numOfCols;
-  pQueryHandle->outputCapacity = 4096;
-  
-  pQueryHandle->pColumns = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
-  for (int32_t i = 0; i < pCond->numOfCols; ++i) {
-    SColumnInfoData  colInfo = {{0}, 0};
-  
-    colInfo.info = pCond->colList[i];
-    colInfo.pData = calloc(1, EXTRA_BYTES + pQueryHandle->outputCapacity * pCond->colList[i].bytes);
-    taosArrayPush(pQueryHandle->pColumns, &colInfo);
+  for(int32_t i = 0; i < numOfCols; ++i) {
   }
+  
+  uTrace("%p total numOfTable:%d in query", pQueryHandle, taosArrayGetSize(pQueryHandle->pTableCheckInfo));
 
   tsdbInitDataBlockLoadInfo(&pQueryHandle->dataBlockLoadInfo);
   tsdbInitCompBlockLoadInfo(&pQueryHandle->compBlockLoadInfo);
@@ -499,8 +488,9 @@ static bool doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlo
   bool    blockLoaded = false;
   SArray* sa = getDefaultLoadColumns(pQueryHandle, true);
 
-  if (pCheckInfo->pDataCols == NULL) { // todo: why not the real data?
-    pCheckInfo->pDataCols = tdNewDataCols(pRepo->tsdbMeta->maxRowBytes, pRepo->tsdbMeta->maxCols, pRepo->config.maxRowsPerFileBlock);
+  if (pCheckInfo->pDataCols == NULL) {
+    STsdbMeta* pMeta = tsdbGetMeta(pRepo);
+    pCheckInfo->pDataCols = tdNewDataCols(pMeta->maxRowBytes, pMeta->maxCols, pRepo->config.maxRowsPerFileBlock);
   }
 
   tdInitDataCols(pCheckInfo->pDataCols, tsdbGetTableSchema(tsdbGetMeta(pQueryHandle->pTsdb), pCheckInfo->pTableObj));
@@ -522,8 +512,6 @@ static bool doLoadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlo
 }
 
 static void handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock, STableCheckInfo* pCheckInfo){
-  SArray* sa = getDefaultLoadColumns(pQueryHandle, true);
-  
   SQueryFilePos* cur = &pQueryHandle->cur;
   SDataBlockInfo binfo = getTrueDataBlockInfo(pCheckInfo, pBlock);
   /*bool hasData = */ initTableMemIterator(pQueryHandle, pCheckInfo);
@@ -591,9 +579,12 @@ static void handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SCompBlock*
       cur->blockCompleted = false;
       return;
     }
-    
+  
+    SArray* sa = getDefaultLoadColumns(pQueryHandle, true);
     doLoadFileDataBlock(pQueryHandle, pBlock, pCheckInfo);
     doMergeTwoLevelData(pQueryHandle, pCheckInfo, pBlock, sa);
+    taosArrayDestroy(sa);
+    
   } else {
     pQueryHandle->realNumOfRows = binfo.rows;
     
@@ -1074,7 +1065,9 @@ static void cleanBlockOrderSupporter(SBlockOrderSupporter* pSupporter, int32_t n
   tfree(pSupporter->blockIndexArray);
 
   for (int32_t i = 0; i < numOfTables; ++i) {
-    tfree(pSupporter->pDataBlockInfo[i]);
+    STableBlockInfo* pBlockInfo = pSupporter->pDataBlockInfo[i];
+//    tfree(pBlockInfo->statis);
+    tfree(pBlockInfo);
   }
 
   tfree(pSupporter->pDataBlockInfo);
@@ -1100,14 +1093,14 @@ static int32_t dataBlockOrderCompar(const void* pLeft, const void* pRight, void*
   STableBlockInfo* pLeftBlockInfoEx = &pSupporter->pDataBlockInfo[leftTableIndex][leftTableBlockIndex];
   STableBlockInfo* pRightBlockInfoEx = &pSupporter->pDataBlockInfo[rightTableIndex][rightTableBlockIndex];
 
-  //    assert(pLeftBlockInfoEx->pBlock.compBlock->offset != pRightBlockInfoEx->pBlock.compBlock->offset);
-  if (pLeftBlockInfoEx->pBlock.compBlock->offset == pRightBlockInfoEx->pBlock.compBlock->offset &&
-      pLeftBlockInfoEx->pBlock.compBlock->last == pRightBlockInfoEx->pBlock.compBlock->last) {
+  //    assert(pLeftBlockInfoEx->compBlock->offset != pRightBlockInfoEx->compBlock->offset);
+  if (pLeftBlockInfoEx->compBlock->offset == pRightBlockInfoEx->compBlock->offset &&
+      pLeftBlockInfoEx->compBlock->last == pRightBlockInfoEx->compBlock->last) {
     // todo add more information
-    uError("error in header file, two block with same offset:%p", pLeftBlockInfoEx->pBlock.compBlock->offset);
+    uError("error in header file, two block with same offset:%p", pLeftBlockInfoEx->compBlock->offset);
   }
 
-  return pLeftBlockInfoEx->pBlock.compBlock->offset > pRightBlockInfoEx->pBlock.compBlock->offset ? 1 : -1;
+  return pLeftBlockInfoEx->compBlock->offset > pRightBlockInfoEx->compBlock->offset ? 1 : -1;
 }
 
 static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numOfBlocks, int32_t* numOfAllocBlocks) {
@@ -1116,7 +1109,7 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
     return TSDB_CODE_SERV_OUT_OF_MEMORY;
   }
 
-  pQueryHandle->pDataBlockInfo = (STableBlockInfo*)tmp;
+  pQueryHandle->pDataBlockInfo = (STableBlockInfo*) tmp;
   memset(pQueryHandle->pDataBlockInfo, 0, sizeof(STableBlockInfo) * numOfBlocks);
   *numOfAllocBlocks = numOfBlocks;
 
@@ -1132,9 +1125,10 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
     cleanBlockOrderSupporter(&sup, 0);
     return TSDB_CODE_SERV_OUT_OF_MEMORY;
   }
-
+  
   int32_t cnt = 0;
   int32_t numOfQualTables = 0;
+  
   for (int32_t j = 0; j < numOfTables; ++j) {
     STableCheckInfo* pTableCheck = (STableCheckInfo*)taosArrayGet(pQueryHandle->pTableCheckInfo, j);
     if (pTableCheck->numOfBlocks <= 0) {
@@ -1153,14 +1147,12 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
     sup.pDataBlockInfo[numOfQualTables] = (STableBlockInfo*)buf;
 
     for (int32_t k = 0; k < pTableCheck->numOfBlocks; ++k) {
-      STableBlockInfo* pBlockInfoEx = &sup.pDataBlockInfo[numOfQualTables][k];
+      STableBlockInfo* pBlockInfo = &sup.pDataBlockInfo[numOfQualTables][k];
 
-      pBlockInfoEx->pBlock.compBlock = &pBlock[k];
-      pBlockInfoEx->pBlock.fields = NULL;
-
-      pBlockInfoEx->pTableCheckInfo = pTableCheck;
-      //      pBlockInfoEx->groupIdx = pTableCheckInfo[j]->groupIdx;     // set the group index
-      //      pBlockInfoEx->blockIndex = pTableCheckInfo[j]->start + k;    // set the block index in original table
+      pBlockInfo->compBlock = &pBlock[k];
+      pBlockInfo->pTableCheckInfo = pTableCheck;
+      //      pBlockInfo->groupIdx = pTableCheckInfo[j]->groupIdx;     // set the group index
+      //      pBlockInfo->blockIndex = pTableCheckInfo[j]->start + k;    // set the block index in original table
       cnt++;
     }
 
@@ -1185,8 +1177,8 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
     int32_t pos = pTree->pNode[0].index;
     int32_t index = sup.blockIndexArray[pos]++;
 
-    STableBlockInfo* pBlocksInfoEx = sup.pDataBlockInfo[pos];
-    pQueryHandle->pDataBlockInfo[numOfTotal++] = pBlocksInfoEx[index];
+    STableBlockInfo* pBlocksInfo = sup.pDataBlockInfo[pos];
+    pQueryHandle->pDataBlockInfo[numOfTotal++] = pBlocksInfo[index];
 
     // set data block index overflow, in order to disable the offset comparator
     if (sup.blockIndexArray[pos] >= sup.numOfBlocksPerTable[pos]) {
@@ -1199,7 +1191,7 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO
   /*
    * available when no import exists
    * for(int32_t i = 0; i < cnt - 1; ++i) {
-   *   assert((*pDataBlockInfo)[i].pBlock.compBlock->offset < (*pDataBlockInfo)[i+1].pBlock.compBlock->offset);
+   *   assert((*pDataBlockInfo)[i].compBlock->offset < (*pDataBlockInfo)[i+1].compBlock->offset);
    * }
    */
 
@@ -1255,7 +1247,7 @@ static bool getDataBlocksInFilesImpl(STsdbQueryHandle* pQueryHandle) {
   cur->fid = pQueryHandle->pFileGroup->fileId;
   
   STableBlockInfo* pBlockInfo = &pQueryHandle->pDataBlockInfo[cur->slot];
-  return loadFileDataBlock(pQueryHandle, pBlockInfo->pBlock.compBlock, pBlockInfo->pTableCheckInfo);
+  return loadFileDataBlock(pQueryHandle, pBlockInfo->compBlock, pBlockInfo->pTableCheckInfo);
 }
 
 static bool getDataBlocksInFiles(STsdbQueryHandle* pQueryHandle) {
@@ -1291,10 +1283,10 @@ static bool getDataBlocksInFiles(STsdbQueryHandle* pQueryHandle) {
         cur->blockCompleted = false;
         
         STableBlockInfo* pNext = &pQueryHandle->pDataBlockInfo[cur->slot];
-        return loadFileDataBlock(pQueryHandle, pNext->pBlock.compBlock, pNext->pTableCheckInfo);
+        return loadFileDataBlock(pQueryHandle, pNext->compBlock, pNext->pTableCheckInfo);
       }
     } else {
-      handleDataMergeIfNeeded(pQueryHandle, pBlockInfo->pBlock.compBlock, pCheckInfo);
+      handleDataMergeIfNeeded(pQueryHandle, pBlockInfo->compBlock, pCheckInfo);
       return pQueryHandle->realNumOfRows > 0;
     }
   }
@@ -1484,35 +1476,33 @@ SDataBlockInfo tsdbRetrieveDataBlockInfo(TsdbQueryHandleT* pQueryHandle) {
   // there are data in file
   if (pHandle->cur.fid >= 0) {
     STableBlockInfo* pBlockInfo = &pHandle->pDataBlockInfo[pHandle->cur.slot];
-    STableCheckInfo* pCheckInfo = pBlockInfo->pTableCheckInfo;
-  
-    STable* pTable = pCheckInfo->pTableObj;
+    STable* pTable = pBlockInfo->pTableCheckInfo->pTableObj;
 
-    if (pHandle->cur.mixBlock) {
-      SDataBlockInfo blockInfo = {
-          .uid = pTable->tableId.uid,
-          .tid = pTable->tableId.tid,
-          .rows = pHandle->cur.rows,
-          .window = pHandle->cur.win,
-      };
-  
-      return blockInfo;
-    } else {
-      return getTrueDataBlockInfo(pCheckInfo, pBlockInfo->pBlock.compBlock);
-    }
+    SDataBlockInfo blockInfo = {
+        .uid = pTable->tableId.uid,
+        .tid = pTable->tableId.tid,
+        .rows = pHandle->cur.rows,
+        .window = pHandle->cur.win,
+        .numOfCols = QH_GET_NUM_OF_COLS(pHandle),
+    };
+
+    return blockInfo;
   } else {
     STableCheckInfo* pCheckInfo = taosArrayGet(pHandle->pTableCheckInfo, pHandle->activeIndex);
+    SQueryFilePos* cur = &pHandle->cur;
     
     STable* pTable = pCheckInfo->pTableObj;
     if (pTable->mem != NULL) { // create mem table iterator if it is not created yet
       assert(pCheckInfo->iter != NULL);
-      STimeWindow* win = &pHandle->cur.win;
+      STimeWindow* win = &cur->win;
       
       pHandle->cur.rows = tsdbReadRowsFromCache(pCheckInfo->iter, pCheckInfo->pTableObj, pHandle->window.ekey,
           pHandle->outputCapacity, &win->skey, &win->ekey, pHandle);  // todo refactor API
 
       // update the last key value
       pCheckInfo->lastKey = win->ekey + step;
+      cur->lastKey = win->ekey + step;
+      cur->mixBlock = true;
     }
   
     if (!ASCENDING_TRAVERSE(pHandle->order)) {
@@ -1524,15 +1514,34 @@ SDataBlockInfo tsdbRetrieveDataBlockInfo(TsdbQueryHandleT* pQueryHandle) {
         .tid = pTable->tableId.tid,
         .rows = pHandle->cur.rows,
         .window = pHandle->cur.win,
+        .numOfCols = QH_GET_NUM_OF_COLS(pHandle),
     };
   
     return blockInfo;
   }
 }
 
-// return null for data block in cache
+/*
+ * return null for mixed data block, if not a complete file data block, the statistics value will always return NULL
+ */
 int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT* pQueryHandle, SDataStatis** pBlockStatis) {
-  *pBlockStatis = NULL;
+  STsdbQueryHandle* pHandle = (STsdbQueryHandle*) pQueryHandle;
+  
+  SQueryFilePos* cur = &pHandle->cur;
+  if (cur->mixBlock) {
+    *pBlockStatis = NULL;
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  assert((cur->slot >= 0 && cur->slot < pHandle->numOfBlocks) ||
+      ((cur->slot == pHandle->numOfBlocks) && (cur->slot == 0)));
+  
+  STableBlockInfo* pBlockInfo = &pHandle->pDataBlockInfo[cur->slot];
+  tsdbLoadCompData(&pHandle->rhelper, pBlockInfo->compBlock, NULL);
+  
+  tsdbGetDataStatis(&pHandle->rhelper, pHandle->statis, QH_GET_NUM_OF_COLS(pHandle));
+  *pBlockStatis = pHandle->statis;
+  
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1546,13 +1555,13 @@ SArray* tsdbRetrieveDataBlock(TsdbQueryHandleT* pQueryHandle, SArray* pIdList) {
   if (pHandle->cur.fid < 0) {
     return pHandle->pColumns;
   } else {
-    STableBlockInfo* pBlockInfoEx = &pHandle->pDataBlockInfo[pHandle->cur.slot];
-    STableCheckInfo* pCheckInfo = pBlockInfoEx->pTableCheckInfo;
+    STableBlockInfo* pBlockInfo = &pHandle->pDataBlockInfo[pHandle->cur.slot];
+    STableCheckInfo* pCheckInfo = pBlockInfo->pTableCheckInfo;
 
     if (pHandle->cur.mixBlock) {
       return pHandle->pColumns;
     } else {
-      SDataBlockInfo binfo = getTrueDataBlockInfo(pCheckInfo, pBlockInfoEx->pBlock.compBlock);
+      SDataBlockInfo binfo = getTrueDataBlockInfo(pCheckInfo, pBlockInfo->compBlock);
       assert(pHandle->realNumOfRows <= binfo.rows);
   
       // data block has been loaded, todo extract method
@@ -1562,7 +1571,7 @@ SArray* tsdbRetrieveDataBlock(TsdbQueryHandleT* pQueryHandle, SArray* pIdList) {
           pBlockLoadInfo->tid == pCheckInfo->pTableObj->tableId.tid) {
         return pHandle->pColumns;
       } else {  // only load the file block
-        SCompBlock* pBlock = pBlockInfoEx->pBlock.compBlock;
+        SCompBlock* pBlock = pBlockInfo->compBlock;
         doLoadFileDataBlock(pHandle, pBlock, pCheckInfo);
   
         // todo refactor
@@ -2006,8 +2015,9 @@ void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle) {
    }
 
   taosArrayDestroy(pQueryHandle->pColumns);
-  
   tfree(pQueryHandle->pDataBlockInfo);
+  tfree(pQueryHandle->statis);
+  
   tsdbDestroyHelper(&pQueryHandle->rhelper);
   
   tfree(pQueryHandle);

From e46896bfcd7d4596d7000685a247875a8895b26d Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 16:12:18 +0800
Subject: [PATCH 05/27] [td-225] support hex/bin numeric data to insert

---
 src/client/src/tscAsync.c        |  2 +-
 src/client/src/tscFunctionImpl.c | 23 ++++++++-------
 src/client/src/tscParseInsert.c  | 50 ++++++++++++++++++--------------
 3 files changed, 42 insertions(+), 33 deletions(-)

diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 26de2a51a8..6fba0efd97 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -48,7 +48,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
   pSql->param     = param;
   pSql->pTscObj   = pObj;
   pSql->maxRetry  = TSDB_MAX_REPLICA_NUM;
-  pSql->fp = fp;
+  pSql->fp        = fp;
   
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) {
     tscError("failed to malloc payload");
diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index f3e24e43a9..168863d322 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -947,18 +947,21 @@ static void minMax_function(SQLFunctionCtx *pCtx, char *pOutput, int32_t isMin,
       index = pCtx->preAggVals.statis.maxIndex;
     }
     
-    /**
-     * NOTE: work around the bug caused by invalid pre-calculated function.
-     * Here the selectivity + ts will not return correct value.
-     *
-     * The following codes of 3 lines will be removed later.
-     */
-    if (index < 0 || index >= pCtx->size + pCtx->startOffset) {
-      index = 0;
+    TSKEY key = TSKEY_INITIAL_VAL;
+    if (pCtx->ptsList != NULL) {
+      /**
+       * NOTE: work around the bug caused by invalid pre-calculated function.
+       * Here the selectivity + ts will not return correct value.
+       *
+       * The following codes of 3 lines will be removed later.
+       */
+      if (index < 0 || index >= pCtx->size + pCtx->startOffset) {
+        index = 0;
+      }
+      
+      key = pCtx->ptsList[index];
     }
     
-    TSKEY key = pCtx->ptsList[index];
-    
     if (pCtx->inputType >= TSDB_DATA_TYPE_TINYINT && pCtx->inputType <= TSDB_DATA_TYPE_BIGINT) {
       int64_t val = GET_INT64_VAL(tval);
       if (pCtx->inputType == TSDB_DATA_TYPE_TINYINT) {
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 62f27c0960..3e1f0787c3 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -42,35 +42,42 @@ enum {
 static int32_t tscAllocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int32_t * numOfRows);
 
 static int32_t tscToInteger(SSQLToken *pToken, int64_t *value, char **endPtr) {
-//  int32_t numType = isValidNumber(pToken);
-//  if (TK_ILLEGAL == numType) {
-//    return numType;
-//  }
-
+  if (pToken->n == 0) {
+    return TK_ILLEGAL;
+  }
+  
   int32_t radix = 10;
-  if (pToken->type == TK_HEX) {
-    radix = 16;
-  } else if (pToken->type == TK_OCT) {
-    radix = 8;
-  } else if (pToken->type == TK_BIN) {
-    radix = 2;
+  
+  int32_t radixList[3] = {16, 8, 2};
+  if (pToken->type == TK_HEX || pToken->type == TK_OCT || pToken->type == TK_BIN) {
+    radix = radixList[pToken->type - TK_HEX];
   }
 
   errno = 0;
   *value = strtoll(pToken->z, endPtr, radix);
+  
+  // not a valid integer number, return error
+  if ((pToken->type == TK_STRING || pToken->type == TK_ID) && ((*endPtr - pToken->z) != pToken->n)) {
+    return TK_ILLEGAL;
+  }
 
   return pToken->type;
 }
 
 static int32_t tscToDouble(SSQLToken *pToken, double *value, char **endPtr) {
-//  int32_t numType = isValidNumber(pToken);
-//  if (TK_ILLEGAL == numType) {
-//    return numType;
-//  }
-
+  if (pToken->n == 0) {
+    return TK_ILLEGAL;
+  }
+  
   errno = 0;
   *value = strtod(pToken->z, endPtr);
-  return pToken->type;
+  
+  // not a valid integer number, return error
+  if ((pToken->type == TK_STRING || pToken->type == TK_ID) && ((*endPtr - pToken->z) != pToken->n)) {
+    return TK_ILLEGAL;
+  } else {
+    return pToken->type;
+  }
 }
 
 int tsParseTime(SSQLToken *pToken, int64_t *time, char **next, char *error, int16_t timePrec) {
@@ -422,9 +429,9 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[
       return -1;
     }
 
-    if (((sToken.type != TK_NOW) && (sToken.type != TK_INTEGER) && (sToken.type != TK_STRING) &&
-         (sToken.type != TK_FLOAT) && (sToken.type != TK_BOOL) && (sToken.type != TK_NULL)) ||
-        (sToken.n == 0) || (sToken.type == TK_RP)) {
+    int16_t type = sToken.type;
+    if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
+         type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) || (sToken.n == 0) || (type == TK_RP)) {
       tscInvalidSQLErrMsg(error, "invalid data or symbol", sToken.z);
       *code = TSDB_CODE_INVALID_SQL;
       return -1;
@@ -1306,8 +1313,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
   SQueryInfo *pQueryInfo = NULL;
   tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex, &pQueryInfo);
 
-  uint16_t type = (sToken.type == TK_INSERT)? TSDB_QUERY_TYPE_INSERT:TSDB_QUERY_TYPE_IMPORT;
-  TSDB_QUERY_SET_TYPE(pQueryInfo->type, type);
+  TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT);
 
   sToken = tStrGetToken(pSql->sqlstr, &index, false, 0, NULL);
   if (sToken.type != TK_INTO) {

From c6cb40bf5728a31db550995939cef8bb064a0e55 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 17:34:15 +0800
Subject: [PATCH 06/27] [td-225] fix bugs in tbname in query

---
 src/client/src/tscSQLParser.c | 15 +++++++++------
 src/client/src/tscSub.c       |  6 +++---
 src/query/src/qExecutor.c     |  2 +-
 src/query/src/qast.c          | 26 ++++++++++++++------------
 src/tsdb/src/tsdbRead.c       |  2 +-
 src/util/inc/tarray.h         |  6 +++---
 src/util/inc/tcompare.h       |  8 +++++---
 src/util/src/tarray.c         | 21 +++++++--------------
 src/util/src/tcompare.c       | 19 +++++++++++++------
 9 files changed, 56 insertions(+), 49 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index d68290653a..f338bbc644 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -3290,14 +3290,15 @@ static int32_t setExprToCond(tSQLExpr** parent, tSQLExpr* pExpr, const char* msg
 
 static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, SCondExpr* pCondExpr, int32_t* type,
                                      int32_t parentOptr) {
-  const char* msg1 = "meter query cannot use tags filter";
+  const char* msg1 = "table query cannot use tags filter";
   const char* msg2 = "illegal column name";
   const char* msg3 = "only one query time range allowed";
   const char* msg4 = "only one join condition allowed";
   const char* msg5 = "not support ordinary column join";
   const char* msg6 = "only one query condition on tbname allowed";
   const char* msg7 = "only in/like allowed in filter table name";
-
+  const char* msg8 = "wildcard string should be less than 20 characters";
+  
   tSQLExpr* pLeft = (*pExpr)->pLeft;
   tSQLExpr* pRight = (*pExpr)->pRight;
 
@@ -3344,7 +3345,7 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S
     // check for like expression
     if ((*pExpr)->nSQLOptr == TK_LIKE) {
       if (pRight->val.nLen > TSDB_PATTERN_STRING_MAX_LEN) {
-        return TSDB_CODE_INVALID_SQL;
+        return invalidSqlErrMsg(pQueryInfo->msg, msg8);
       }
 
       SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
@@ -3360,6 +3361,10 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S
       if (!validTableNameOptr(*pExpr)) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg7);
       }
+  
+      if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+        return invalidSqlErrMsg(pQueryInfo->msg, msg1);
+      }
 
       if (pCondExpr->pTableCond == NULL) {
         pCondExpr->pTableCond = *pExpr;
@@ -3808,9 +3813,7 @@ int32_t parseWhereClause(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, SSqlObj* pSql
   const char* msg2 = "invalid filter expression";
 
   int32_t ret = TSDB_CODE_SUCCESS;
-
-  pQueryInfo->window.skey = 0;
-  pQueryInfo->window.ekey = INT64_MAX;
+  pQueryInfo->window = TSWINDOW_INITIALIZER;
 
   // tags query condition may be larger than 512bytes, therefore, we need to prepare enough large space
   SStringBuilder sb; memset(&sb, 0, sizeof(sb));
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 9092fdd0b3..5831ddad4a 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -61,7 +61,7 @@ TSKEY tscGetSubscriptionProgress(void* sub, int64_t uid, TSKEY dflt) {
   SSub* pSub = (SSub*)sub;
 
   SSubscriptionProgress target = {.uid = uid, .key = 0};
-  SSubscriptionProgress* p = taosArraySearch(pSub->progress, tscCompareSubscriptionProgress, &target);
+  SSubscriptionProgress* p = taosArraySearch(pSub->progress, &target, tscCompareSubscriptionProgress);
   if (p == NULL) {
     return dflt;
   }
@@ -74,7 +74,7 @@ void tscUpdateSubscriptionProgress(void* sub, int64_t uid, TSKEY ts) {
   SSub* pSub = (SSub*)sub;
 
   SSubscriptionProgress target = {.uid = uid, .key = ts};
-  SSubscriptionProgress* p = taosArraySearch(pSub->progress, tscCompareSubscriptionProgress, &target);
+  SSubscriptionProgress* p = taosArraySearch(pSub->progress, &target, tscCompareSubscriptionProgress);
   if (p != NULL) {
     p->key = ts;
   }
@@ -211,7 +211,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
   if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
     STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
     SSubscriptionProgress target = {.uid = pTableMeta->uid, .key = 0};
-    SSubscriptionProgress* p = taosArraySearch(pSub->progress, tscCompareSubscriptionProgress, &target);
+    SSubscriptionProgress* p = taosArraySearch(pSub->progress, &target, tscCompareSubscriptionProgress);
     if (p == NULL) {
       taosArrayClear(pSub->progress);
       taosArrayPush(pSub->progress, &target);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index a8158a386d..e9f1ffb49f 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -5745,7 +5745,7 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SArray* pTableIdList,
       SGroupItem item = { .id = id };
       // NOTE: compare STableIdInfo with STableId
       // not a problem at present because we only use their 1st int64_t field
-      STableIdInfo* pTableId = taosArraySearch( pTableIdList, compareTableIdInfo, &id );
+      STableIdInfo* pTableId = taosArraySearch( pTableIdList, &id, compareTableIdInfo);
       if (pTableId != NULL ) {
         window.skey = pTableId->key;
       } else {
diff --git a/src/query/src/qast.c b/src/query/src/qast.c
index d784fa4102..f35f4d0184 100644
--- a/src/query/src/qast.c
+++ b/src/query/src/qast.c
@@ -773,9 +773,6 @@ static void tQueryIndexlessColumn(SSkipList* pSkipList, tQueryInfo* pQueryInfo,
 
     // todo refactor:
     tstr *name = ((STableIndexElem *)pData)->pTable->name;
-    //    char* name = NULL;
-//        tsdbGetTableName(pQueryInfo->, pTable, &name);
-
     // todo speed up by using hash
     if (pQueryInfo->colIndex == TSDB_TBNAME_COLUMN_INDEX) {
       if (pQueryInfo->optr == TSDB_RELATION_IN) {
@@ -1051,7 +1048,7 @@ static void* exception_malloc(size_t size) {
   return p;
 }
 
-static char* exception_strdup(const char* str) {
+static UNUSED_FUNC char* exception_strdup(const char* str) {
   char* p = strdup(str);
   if (p == NULL) {
     THROW(TSDB_CODE_SERV_OUT_OF_MEMORY);
@@ -1154,28 +1151,33 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
     tVariant* pVal = exception_calloc(1, sizeof(tVariant));
     right->pVal = pVal;
     pVal->nType = TSDB_DATA_TYPE_ARRAY;
-    pVal->arr = taosArrayInit(2, sizeof(char*));
+    pVal->arr = taosArrayInit(2, POINTER_BYTES);
 
     const char* cond = tbnameCond + QUERY_COND_REL_PREFIX_IN_LEN;
     for (const char *e = cond; *e != 0; e++) {
       if (*e == TS_PATH_DELIMITER[0]) {
         cond = e + 1;
       } else if (*e == ',') {
-        size_t len = e - cond + 1;
-        char* p = exception_malloc( len );
-        memcpy(p, cond, len);
-        p[len - 1] = 0;
+        size_t len = e - cond + VARSTR_HEADER_SIZE;
+        char* p = exception_malloc(len);
+        varDataSetLen(p, len - VARSTR_HEADER_SIZE);
+        memcpy(varDataVal(p), cond, len);
         cond += len;
         taosArrayPush(pVal->arr, &p);
       }
     }
 
     if (*cond != 0) {
-        char* p = exception_strdup( cond );
-        taosArrayPush(pVal->arr, &p);
+      size_t len = strlen(cond) + VARSTR_HEADER_SIZE;
+      
+      char* p = exception_malloc(len);
+      varDataSetLen(p, len - VARSTR_HEADER_SIZE);
+      memcpy(varDataVal(p), cond, len);
+      
+      taosArrayPush(pVal->arr, &p);
     }
 
-    taosArraySortString(pVal->arr);
+    taosArraySortString(pVal->arr, taosArrayCompareString);
   }
 
   CLEANUP_EXECUTE_TO(anchor, false);
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index cc191f3900..7a70312259 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -1678,7 +1678,7 @@ void filterPrepare(void* expr, void* param) {
   tVariant*   pCond = pExpr->_node.pRight->pVal;
   SSchema*    pSchema = pExpr->_node.pLeft->pSchema;
 
-  // todo : if current super table does not change schema yet, this function may failed, add test case
+  // todo : if current super table does not change schema yet, this function may fail to get correct schema, test case
   int32_t index = getTagColumnIndex(pTSSchema, pSchema);
   assert((index >= 0 && i < TSDB_MAX_TAGS) || (index == TSDB_TBNAME_COLUMN_INDEX));
 
diff --git a/src/util/inc/tarray.h b/src/util/inc/tarray.h
index 866bde0938..4d44e82b1b 100644
--- a/src/util/inc/tarray.h
+++ b/src/util/inc/tarray.h
@@ -129,7 +129,7 @@ void taosArraySort(SArray* pArray, int (*compar)(const void*, const void*));
  * sort string array
  * @param pArray
  */
-void taosArraySortString(SArray* pArray);
+void taosArraySortString(SArray* pArray, __compar_fn_t comparFn);
 
 /**
  * search the array
@@ -137,14 +137,14 @@ void taosArraySortString(SArray* pArray);
  * @param compar
  * @param key
  */
-void* taosArraySearch(const SArray* pArray, int (*compar)(const void*, const void*), const void* key);
+void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn);
 
 /**
  * search the array
  * @param pArray
  * @param key
  */
-char* taosArraySearchString(const SArray* pArray, const char* key);
+char* taosArraySearchString(const SArray* pArray, const char* key, __compar_fn_t comparFn);
 
 #ifdef __cplusplus
 }
diff --git a/src/util/inc/tcompare.h b/src/util/inc/tcompare.h
index 8aaa39e483..5e951923c1 100644
--- a/src/util/inc/tcompare.h
+++ b/src/util/inc/tcompare.h
@@ -34,16 +34,18 @@ typedef struct SPatternCompareInfo {
   char matchOne;  // symbol for match one wildcard, default: '_'
 } SPatternCompareInfo;
 
-int patternMatch(const char *zPattern, const char *zString, size_t size, const SPatternCompareInfo *pInfo);
+int patternMatch(const char *pattern, const char *str, size_t size, const SPatternCompareInfo *pInfo);
 
-int WCSPatternMatch(const wchar_t *zPattern, const wchar_t *zString, size_t size, const SPatternCompareInfo *pInfo);
+int WCSPatternMatch(const wchar_t *pattern, const wchar_t *str, size_t size, const SPatternCompareInfo *pInfo);
 
-int32_t doCompare(const char* f1, const char* f2, int32_t type, size_t size);
+int32_t doCompare(const char* a, const char* b, int32_t type, size_t size);
 
 __compar_fn_t getKeyComparFunc(int32_t keyType);
 
 __compar_fn_t getComparFunc(int32_t type, int32_t optr);
 
+int32_t taosArrayCompareString(const void* a, const void* b);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/util/src/tarray.c b/src/util/src/tarray.c
index 5198597ff7..8908dc2e65 100755
--- a/src/util/src/tarray.c
+++ b/src/util/src/tarray.c
@@ -197,30 +197,23 @@ void taosArraySort(SArray* pArray, int (*compar)(const void*, const void*)) {
   qsort(pArray->pData, pArray->size, pArray->elemSize, compar);
 }
 
-void* taosArraySearch(const SArray* pArray, int (*compar)(const void*, const void*), const void* key) {
-  assert(pArray != NULL);
-  assert(compar != NULL);
+void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn) {
+  assert(pArray != NULL && comparFn != NULL);
   assert(key != NULL);
 
-  return bsearch(key, pArray->pData, pArray->size, pArray->elemSize, compar);
+  return bsearch(key, pArray->pData, pArray->size, pArray->elemSize, comparFn);
 }
 
-static int taosArrayCompareString(const void* a, const void* b) {
-  const char* x = *(const char**)a;
-  const char* y = *(const char**)b;
-  return strcmp(x, y);
-}
-
-void taosArraySortString(SArray* pArray) {
+void taosArraySortString(SArray* pArray, __compar_fn_t comparFn) {
   assert(pArray != NULL);
-  qsort(pArray->pData, pArray->size, pArray->elemSize, taosArrayCompareString);
+  qsort(pArray->pData, pArray->size, pArray->elemSize, comparFn);
 }
 
-char* taosArraySearchString(const SArray* pArray, const char* key) {
+char* taosArraySearchString(const SArray* pArray, const char* key, __compar_fn_t comparFn) {
   assert(pArray != NULL);
   assert(key != NULL);
 
-  void* p = bsearch(&key, pArray->pData, pArray->size, pArray->elemSize, taosArrayCompareString);
+  void* p = bsearch(&key, pArray->pData, pArray->size, pArray->elemSize, comparFn);
   if (p == NULL) {
     return NULL;
   }
diff --git a/src/util/src/tcompare.c b/src/util/src/tcompare.c
index 751bd0fc34..cb9f339f6a 100644
--- a/src/util/src/tcompare.c
+++ b/src/util/src/tcompare.c
@@ -227,9 +227,16 @@ static int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
   return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
 }
 
+int32_t taosArrayCompareString(const void* a, const void* b) {
+  const char* x = *(const char**)a;
+  const char* y = *(const char**)b;
+  
+  return compareLenPrefixedStr(x, y);
+}
+
 static int32_t compareFindStrInArray(const void* pLeft, const void* pRight) {
   const SArray* arr = (const SArray*) pRight;
-  return taosArraySearchString(arr, pLeft) == NULL ? 0 : 1;
+  return taosArraySearchString(arr, pLeft, taosArrayCompareString) == NULL ? 0 : 1;
 }
 
 static int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
@@ -248,25 +255,25 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
   
   switch (type) {
     case TSDB_DATA_TYPE_SMALLINT: {
-      comparFn = compareInt16Val; break;
+      comparFn = compareInt16Val;  break;
     }
     
     case TSDB_DATA_TYPE_INT: {
-      comparFn = compareInt32Val; break;
+      comparFn = compareInt32Val;  break;
     }
     
     case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_TIMESTAMP: {
-      comparFn = compareInt64Val; break;
+      comparFn = compareInt64Val;  break;
     }
 
     case TSDB_DATA_TYPE_BOOL:
     case TSDB_DATA_TYPE_TINYINT:{
-      comparFn = compareInt8Val; break;
+      comparFn = compareInt8Val;   break;
     }
 
     case TSDB_DATA_TYPE_FLOAT: {
-      comparFn = compareFloatVal; break;
+      comparFn = compareFloatVal;  break;
     }
     
     case TSDB_DATA_TYPE_DOUBLE: {

From c44bf0ff17afa33a4c7bb08648564d3e245d4483 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 17:36:19 +0800
Subject: [PATCH 07/27] [td-225] update the script

---
 tests/script/general/parser/testSuite.sim | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 3d5f33842e..ac867c9f7f 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -56,15 +56,17 @@ sleep 2000
 run general/parser/limit1_tblocks100.sim
 sleep 2000
 run general/parser/select_across_vnodes.sim
+sleep 2000
+run general/parser/slimit1.sim
+sleep 2000
+run general/parser/tbnameIn.sim
+sleep 2000
+run general/parser/projection_limit_offset.sim
 
 sleep 2000
 run general/parser/limit2.sim
 sleep 2000
-run general/parser/tbnameIn.sim
-sleep 2000
 run general/parser/slimit.sim
-sleep 2000
-run general/parser/slimit1.sim
 
 sleep 2000
 run general/parser/fill.sim
@@ -94,8 +96,7 @@ sleep 2000
 run general/parser/join.sim
 sleep 2000
 run general/parser/join_multivnode.sim
-sleep 2000
-run general/parser/projection_limit_offset.sim
+
 sleep 2000
 run general/parser/select_with_tags.sim
 sleep 2000

From 4737c8cd44765bd5330f53e5cd3357004d4e852d Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 17:36:38 +0800
Subject: [PATCH 08/27] [td-225]

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

diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 5d76e69e10..e68707e710 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -109,9 +109,9 @@ cd ../../../debug; make
 ./test.sh -f general/parser/auto_create_tb.sim
 ./test.sh -f general/parser/auto_create_tb_drop_tb.sim
 ./test.sh -f general/parser/col_arithmetic_operation.sim
-#/test.sh -f general/parser/columnValue.sim
+./test.sh -f general/parser/columnValue.sim
 ./test.sh -f general/parser/commit.sim
-# ./test.sh -f general/parser/create_db.sim
+./test.sh -f general/parser/create_db.sim
 ./test.sh -f general/parser/create_mt.sim
 ./test.sh -f general/parser/create_tb.sim
 ./test.sh -f general/parser/dbtbnameValidate.sim
@@ -121,39 +121,39 @@ cd ../../../debug; make
 ./test.sh -f general/parser/insert_tb.sim
 ./test.sh -f general/parser/first_last.sim
 # ./test.sh -f general/parser/import_file.sim
-# ./test.sh -f general/parser/lastrow.sim
-# ./test.sh -f general/parser/nchar.sim
-# ./test.sh -f general/parser/null_char.sim
-# ./test.sh -f general/parser/single_row_in_tb.sim
+./test.sh -f general/parser/lastrow.sim
+./test.sh -f general/parser/nchar.sim
+./test.sh -f general/parser/null_char.sim
+./test.sh -f general/parser/single_row_in_tb.sim
 ./test.sh -f general/parser/select_from_cache_disk.sim
-# ./test.sh -f general/parser/limit.sim
+./test.sh -f general/parser/limit.sim
+./test.sh -f general/parser/limit1.sim
+./test.sh -f general/parser/limit1_tblocks100.sim
+./test.sh -f general/parser/mixed_blocks.sim
+./test.sh -f general/parser/selectResNum.sim
+./test.sh -f general/parser/select_across_vnodes.sim
+./test.sh -f general/parser/slimit1.sim
+./test.sh -f general/parser/tbnameIn.sim
+./test.sh -f general/parser/binary_escapeCharacter.sim
+# ./test.sh -f general/parser/limit2.sim
+# ./test.sh -f general/parser/set_tag_vals.sim
+# ./test.sh -f general/parser/slimit.sim
 # ./test.sh -f general/parser/fill.sim
 # ./test.sh -f general/parser/fill_stb.sim
 # ./test.sh -f general/parser/tags_dynamically_specifiy.sim
 # ./test.sh -f general/parser/interp.sim
-# ./test.sh -f general/parser/limit1.sim
-# ./test.sh -f general/parser/limit1_tblocks100.sim
-# ./test.sh -f general/parser/limit2.sim
-# ./test.sh -f general/parser/mixed_blocks.sim
-./test.sh -f general/parser/selectResNum.sim
-# ./test.sh -f general/parser/select_across_vnodes.sim
-# ./test.sh -f general/parser/set_tag_vals.sim
-# ./test.sh -f general/parser/slimit.sim
-./test.sh -f general/parser/slimit1.sim
-#unsupport ./test.sh -f general/parser/slimit_alter_tags.sim
-#unsupport ./test.sh -f general/parser/stream_on_sys.sim
-#unsupport ./test.sh -f general/parser/stream.sim
-# ./test.sh -f general/parser/tbnameIn.sim
 # ./test.sh -f general/parser/where.sim
 # ./test.sh -f general/parser/repeatAlter.sim
-#unsupport ./test.sh -f general/parser/repeatStream.sim
 # ./test.sh -f general/parser/join.sim
 # ./test.sh -f general/parser/join_multivnode.sim
 # ./test.sh -f general/parser/projection_limit_offset.sim
 # ./test.sh -f general/parser/select_with_tags.sim
 # ./test.sh -f general/parser/groupby.sim
-./test.sh -f general/parser/binary_escapeCharacter.sim
 #./test.sh -f general/parser/bug.sim
+#unsupport ./test.sh -f general/parser/slimit_alter_tags.sim
+#unsupport ./test.sh -f general/parser/stream_on_sys.sim
+#unsupport ./test.sh -f general/parser/stream.sim
+#unsupport ./test.sh -f general/parser/repeatStream.sim
 
 ./test.sh -f general/stable/disk.sim
 ./test.sh -f general/stable/dnode3.sim

From 5bc556381609d957326dc3ba8cde1352fc5c8cf1 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 18:12:51 +0800
Subject: [PATCH 09/27] [td-225]

---
 .../general/parser/projection_limit_offset.sim  | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/tests/script/general/parser/projection_limit_offset.sim b/tests/script/general/parser/projection_limit_offset.sim
index 52be50c032..0091bfa59e 100644
--- a/tests/script/general/parser/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.sim
@@ -133,7 +133,7 @@ if $rows != 4007 then
   return -1
 endi
 
-if $data00 != @70-01-01 08:01:43.499@ then
+if $data00 != @70-01-01 08:01:43.500@ then
    return -1
 endi
 
@@ -143,7 +143,7 @@ if $rows != 3907 then
   return -1
 endi
 
-if $data00 != @70-01-01 08:01:43.399@ then
+if $data00 != @70-01-01 08:01:43.488@ then
    return -1
 endi
 
@@ -152,7 +152,7 @@ if $rows != 3106 then
   return -1
 endi
 
-if $data00 != @70-01-01 08:01:43.099@ then
+if $data00 != @70-01-01 08:01:43.388@ then
    return -1
 endi
 
@@ -161,7 +161,7 @@ if $rows != 3608 then
   return -1
 endi
 
-if $data00 != @70-01-01 08:01:43.100@ then
+if $data00 != @70-01-01 08:01:43.450@ then
    return -1
 endi
 
@@ -344,11 +344,11 @@ if $data11 != 1 then
    return -1
 endi
 
-if $data12 != NULL then
+if $data12 != null then
    return -1
 endi
 
-if $data13 != NULL then
+if $data13 != null then
    return -1
 endi
 
@@ -371,8 +371,11 @@ sql_error select 1 interval(1h);
 sql_error select count(*);
 sql_error select sum(k);
 sql_error select 'abc';
+sql_error select k+1,sum(k) from tm0;
+sql_error select k, sum(k) from tm0;
+sql_error select k, sum(k)+1 from tm0;
 
 #=============================tbase-1205
 sql select count(*) from tm1 where ts<now and ts>= now -1d interval(1h) fill(NULL);
 
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file
+

From afc8b5a3cd00bc3aa8ffa6f05b472dcb61b8aaba Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 23 May 2020 18:27:29 +0800
Subject: [PATCH 10/27] [td-225]refactor codes

---
 src/client/src/tscFunctionImpl.c | 16 ++++++----------
 src/query/inc/tsqlfunction.h     |  2 --
 src/query/src/qExecutor.c        |  5 +++--
 3 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index 168863d322..fff8823a83 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -396,10 +396,6 @@ static void function_finalizer(SQLFunctionCtx *pCtx) {
   doFinalizer(pCtx);
 }
 
-static bool usePreVal(SQLFunctionCtx *pCtx) {
-  return pCtx->preAggVals.isSet && pCtx->size == pCtx->preAggVals.size;
-}
-
 /*
  * count function does need the finalize, if data is missing, the default value, which is 0, is used
  * count function does not use the pCtx->interResBuf to keep the intermediate buffer
@@ -412,7 +408,7 @@ static void count_function(SQLFunctionCtx *pCtx) {
    * 2. for general non-primary key columns, pCtx->hasNull may be true or false, pCtx->preAggVals.isSet == true;
    * 3. for primary key column, pCtx->hasNull always be false, pCtx->preAggVals.isSet == false;
    */
-  if (usePreVal(pCtx)) {
+  if (pCtx->preAggVals.isSet) {
     numOfElem = pCtx->size - pCtx->preAggVals.statis.numOfNull;
   } else {
     if (pCtx->hasNull) {
@@ -537,7 +533,7 @@ static void do_sum(SQLFunctionCtx *pCtx) {
   int32_t notNullElems = 0;
   
   // Only the pre-computing information loaded and actual data does not loaded
-  if (pCtx->preAggVals.isSet && pCtx->preAggVals.size == pCtx->size) {
+  if (pCtx->preAggVals.isSet) {
     notNullElems = pCtx->size - pCtx->preAggVals.statis.numOfNull;
     assert(pCtx->size >= pCtx->preAggVals.statis.numOfNull);
     
@@ -768,7 +764,7 @@ static void avg_function(SQLFunctionCtx *pCtx) {
   SAvgInfo *pAvgInfo = (SAvgInfo *)pResInfo->interResultBuf;
   double *  pVal = &pAvgInfo->sum;
   
-  if (usePreVal(pCtx)) {
+  if (pCtx->preAggVals.isSet) {
     // Pre-aggregation
     notNullElems = pCtx->size - pCtx->preAggVals.statis.numOfNull;
     assert(notNullElems >= 0);
@@ -932,7 +928,7 @@ static void avg_finalizer(SQLFunctionCtx *pCtx) {
 
 static void minMax_function(SQLFunctionCtx *pCtx, char *pOutput, int32_t isMin, int32_t *notNullElems) {
   // data in current data block are qualified to the query
-  if (usePreVal(pCtx)) {
+  if (pCtx->preAggVals.isSet) {
     *notNullElems = pCtx->size - pCtx->preAggVals.statis.numOfNull;
     assert(*notNullElems >= 0);
     
@@ -2916,7 +2912,7 @@ static void leastsquares_finalizer(SQLFunctionCtx *pCtx) {
 }
 
 static void date_col_output_function(SQLFunctionCtx *pCtx) {
-  if (pCtx->scanFlag == REVERSE_SCAN) {
+  if (pCtx->scanFlag == REVERSE_SCAN) {  // todo : remove it
     return;
   }
   
@@ -3423,7 +3419,7 @@ static void spread_function(SQLFunctionCtx *pCtx) {
   
   // todo : opt with pre-calculated result
   // column missing cause the hasNull to be true
-  if (usePreVal(pCtx)) {
+  if (pCtx->preAggVals.isSet) {
     numOfElems = pCtx->size - pCtx->preAggVals.statis.numOfNull;
     
     // all data are null in current data block, ignore current data block
diff --git a/src/query/inc/tsqlfunction.h b/src/query/inc/tsqlfunction.h
index a11c03f2c0..6e591b28d2 100644
--- a/src/query/inc/tsqlfunction.h
+++ b/src/query/inc/tsqlfunction.h
@@ -126,7 +126,6 @@ typedef struct SArithmeticSupport {
 
 typedef struct SQLPreAggVal {
   bool    isSet;
-  int32_t size;
   SDataStatis statis;
 } SQLPreAggVal;
 
@@ -174,7 +173,6 @@ typedef struct SQLFunctionCtx {
   int16_t  outputBytes;  // size of results, determined by function and input column data type
   bool     hasNull;      // null value exist in current block
   int16_t  functionId;   // function id
-  int32_t  blockStatus;  // Indicate if data is loaded, it is first/last/internal block. Only for file blocks
   void *   aInputElemBuf;
   char *   aOutputBuf;            // final result output buffer, point to sdata->data
   uint8_t  currentStage;          // record current running step, default: 0
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index e9f1ffb49f..5ef2f128ad 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1342,14 +1342,13 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY
 
   if (pStatis != NULL) {
     pCtx->preAggVals.isSet = true;
-    pCtx->preAggVals.size = size;
     pCtx->preAggVals.statis = *pStatis;
   } else {
     pCtx->preAggVals.isSet = false;
   }
 
   pCtx->startOffset = QUERY_IS_ASC_QUERY(pQuery) ? pQuery->pos : 0;
-  pCtx->size = QUERY_IS_ASC_QUERY(pQuery) ? size - pQuery->pos : pQuery->pos + 1;
+  pCtx->size = size;
 
   uint32_t status = aAggs[functionId].nStatus;
   if (((status & (TSDB_FUNCSTATE_SELECTIVITY | TSDB_FUNCSTATE_NEED_TS)) != 0) && (tsCol != NULL)) {
@@ -1377,6 +1376,8 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY
 
   } else if (functionId == TSDB_FUNC_ARITHM) {
     pCtx->param[1].pz = param;
+  } else if (functionId == TSDB_FUNC_SPREAD) {
+    pCtx->
   }
 
 #if defined(_DEBUG_VIEW)

From be671585380a4af0154170521589d07d3d252b74 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 24 May 2020 22:40:07 +0800
Subject: [PATCH 11/27] [td-225] update the sim script

---
 src/query/src/qExecutor.c                     | 76 ++++++++++---------
 tests/script/general/parser/create_db.sim     |  4 +-
 .../general/parser/first_last_query.sim       |  7 --
 tests/script/general/parser/null_char.sim     | 12 ++-
 .../parser/projection_limit_offset.sim        | 13 +++-
 5 files changed, 63 insertions(+), 49 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 5ef2f128ad..0609ed1870 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -110,7 +110,7 @@ static void resetMergeResultBuf(SQuery *pQuery, SQLFunctionCtx *pCtx, SResultInf
 static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t functionId);
 static void getNextTimeWindow(SQuery *pQuery, STimeWindow *pTimeWindow);
 
-static void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY *tsCol, int32_t size,
+static void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void* pData, TSKEY *tsCol, SDataBlockInfo* pBlockInfo,
                           int32_t functionId, SDataStatis *pStatis, bool hasNull, void *param, int32_t scanFlag);
 static void initCtxOutputBuf(SQueryRuntimeEnv *pRuntimeEnv);
 static void destroyTableQueryInfo(STableQueryInfo *pTableQueryInfo, int32_t numOfCols);
@@ -733,7 +733,7 @@ static int32_t getNumOfRowsInTimeWindow(SQuery *pQuery, SDataBlockInfo *pDataBlo
 }
 
 static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStatus *pStatus, STimeWindow *pWin,
-                                      int32_t startPos, int32_t forwardStep, TSKEY *tsBuf) {
+                                      int32_t offset, int32_t forwardStep, TSKEY *tsBuf, int32_t numOfTotal) {
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
@@ -743,12 +743,17 @@ static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStat
 
       pCtx[k].nStartQueryTimestamp = pWin->skey;
       pCtx[k].size = forwardStep;
-      pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? startPos : startPos - (forwardStep - 1);
+      pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
 
       if ((aAggs[functionId].nStatus & TSDB_FUNCSTATE_SELECTIVITY) != 0) {
-        pCtx[k].ptsList = &tsBuf[pCtx[k].startOffset];
+        pCtx[k].ptsList = tsBuf;
       }
 
+      // not a whole block involved in query processing, statistics data can not be used
+      if (forwardStep != numOfTotal) {
+        pCtx[k].preAggVals.isSet = false;
+      }
+      
       if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
         aAggs[functionId].xFunction(&pCtx[k]);
       }
@@ -890,7 +895,7 @@ static char *getDataBlock(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas
       }
       
       assert(dataBlock != NULL);
-      sas->data[i] = dataBlock + pCtx->startOffset * pQuery->colList[i].bytes;  // start from the offset
+      sas->data[i] = dataBlock/* + pQuery->colList[i].bytes*/;  // start from the offset
     }
 
   } else {  // other type of query function
@@ -933,14 +938,15 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
   
   for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
     int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
+    int32_t colId = pQuery->pSelectExpr[k].base.colInfo.colId;
 
     SDataStatis *tpField = NULL;
 
     bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo->numOfCols, pStatis, &tpField);
     char *dataBlock = getDataBlock(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
 
-    setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, tpField, hasNull,
-                  &sasArray[k], pRuntimeEnv->scanFlag);
+    setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo, functionId, tpField, hasNull,
+                  &sasArray[k], colId);
   }
 
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
@@ -958,7 +964,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
         getNumOfRowsInTimeWindow(pQuery, pDataBlockInfo, primaryKeyCol, pQuery->pos, ekey, searchFn, true);
 
     SWindowStatus *pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
-    doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &win, pQuery->pos, forwardStep, primaryKeyCol);
+    doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &win, pQuery->pos, forwardStep, primaryKeyCol, pDataBlockInfo->rows);
 
     int32_t     index = pWindowResInfo->curIndex;
     STimeWindow nextWin = win;
@@ -978,7 +984,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
       forwardStep = getNumOfRowsInTimeWindow(pQuery, pDataBlockInfo, primaryKeyCol, startPos, ekey, searchFn, true);
 
       pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
-      doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &nextWin, startPos, forwardStep, primaryKeyCol);
+      doBlockwiseApplyFunctions(pRuntimeEnv, pStatus, &nextWin, startPos, forwardStep, primaryKeyCol, pDataBlockInfo->rows);
     }
 
     pWindowResInfo->curIndex = index;
@@ -1154,14 +1160,15 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
 
   for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
     int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
-
+    int32_t colId = pQuery->pSelectExpr[k].base.colInfo.colId;
+    
     SDataStatis *pColStatis = NULL;
 
     bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo->numOfCols, pStatis, &pColStatis);
     char *dataBlock = getDataBlock(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
 
-    setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, pColStatis, hasNull,
-                  &sasArray[k], pRuntimeEnv->scanFlag);
+    setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo, functionId, pColStatis, hasNull,
+                  &sasArray[k], colId);
   }
 
   // set the input column data
@@ -1214,7 +1221,7 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
       }
 
       // all startOffset are identical
-      offset -= pCtx[0].startOffset;
+//      offset -= pCtx[0].startOffset;
 
       SWindowStatus *pStatus = getTimeWindowResStatus(pWindowResInfo, curTimeWindow(pWindowResInfo));
       doRowwiseApplyFunctions(pRuntimeEnv, pStatus, &win, offset);
@@ -1255,9 +1262,6 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
         }
       }
 
-      // all startOffset are identical
-      offset -= pCtx[0].startOffset;
-
       for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
         int32_t functionId = pQuery->pSelectExpr[k].base.functionId;
         if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
@@ -1333,26 +1337,28 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
   return numOfRes;
 }
 
-void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY *tsCol, int32_t size,
-                   int32_t functionId, SDataStatis *pStatis, bool hasNull, void *param, int32_t scanFlag) {
-  pCtx->scanFlag = scanFlag;
-
+void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void* inputData, TSKEY *tsCol, SDataBlockInfo* pBlockInfo,
+                   int32_t functionId, SDataStatis *pStatis, bool hasNull, void *param, int32_t colId) {
+  pCtx->hasNull  = hasNull;
   pCtx->aInputElemBuf = inputData;
-  pCtx->hasNull = hasNull;
 
   if (pStatis != NULL) {
-    pCtx->preAggVals.isSet = true;
+    pCtx->preAggVals.isSet  = true;
     pCtx->preAggVals.statis = *pStatis;
+    if (pCtx->preAggVals.statis.numOfNull == -1) {
+      pCtx->preAggVals.statis.numOfNull = pBlockInfo->rows;  // todo :can not be -1
+    }
   } else {
     pCtx->preAggVals.isSet = false;
   }
 
-  pCtx->startOffset = QUERY_IS_ASC_QUERY(pQuery) ? pQuery->pos : 0;
-  pCtx->size = size;
+  // limit/offset query will affect this value
+  pCtx->startOffset = QUERY_IS_ASC_QUERY(pQuery) ? pQuery->pos:0;
+  pCtx->size = QUERY_IS_ASC_QUERY(pQuery) ? pBlockInfo->rows - pQuery->pos : pQuery->pos + 1;
 
   uint32_t status = aAggs[functionId].nStatus;
   if (((status & (TSDB_FUNCSTATE_SELECTIVITY | TSDB_FUNCSTATE_NEED_TS)) != 0) && (tsCol != NULL)) {
-    pCtx->ptsList = &tsCol[pCtx->startOffset];
+    pCtx->ptsList = tsCol;
   }
 
   if (functionId >= TSDB_FUNC_FIRST_DST && functionId <= TSDB_FUNC_LAST_DST) {
@@ -1362,7 +1368,7 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY
   } else if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_TWA ||
              functionId == TSDB_FUNC_DIFF || (functionId >= TSDB_FUNC_RATE && functionId <= TSDB_FUNC_AVG_IRATE)) {
     /*
-     * leastsquares function needs two columns of input, currently, the x value of linear equation is set to
+     * least squares function needs two columns of input, currently, the x value of linear equation is set to
      * timestamp column, and the y-value is the column specified in pQuery->pSelectExpr[i].colIdxInBuffer
      *
      * top/bottom function needs timestamp to indicate when the
@@ -1376,8 +1382,12 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY
 
   } else if (functionId == TSDB_FUNC_ARITHM) {
     pCtx->param[1].pz = param;
-  } else if (functionId == TSDB_FUNC_SPREAD) {
-    pCtx->
+  } else if (functionId == TSDB_FUNC_SPREAD) {  // set the statistics data for primary time stamp column
+    if (colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+      pCtx->preAggVals.isSet  = true;
+      pCtx->preAggVals.statis.min = pBlockInfo->window.skey;
+      pCtx->preAggVals.statis.max = pBlockInfo->window.ekey;
+    }
   }
 
 #if defined(_DEBUG_VIEW)
@@ -3634,12 +3644,14 @@ void setIntervalQueryRange(SQInfo *pQInfo, TSKEY key) {
     STimeWindow     w = {0};
     SWindowResInfo *pWindowResInfo = &pTableQueryInfo->windowResInfo;
 
-    getAlignQueryTimeWindow(pQuery, win.skey, win.skey, win.ekey, &skey1, &ekey1, &w);
+    TSKEY sk = MIN(win.skey, win.ekey);
+    TSKEY ek = MAX(win.skey, win.ekey);
+    getAlignQueryTimeWindow(pQuery, win.skey, sk, ek, &skey1, &ekey1, &w);
     pWindowResInfo->startTime = pTableQueryInfo->win.skey;  // windowSKey may be 0 in case of 1970 timestamp
 
     if (pWindowResInfo->prevSKey == TSKEY_INITIAL_VAL) {
       if (!QUERY_IS_ASC_QUERY(pQuery)) {
-        assert(win.ekey == pQuery->window.skey);
+        assert(win.ekey == pQuery->window.ekey);
       }
       
       pWindowResInfo->prevSKey = w.skey;
@@ -3674,10 +3686,6 @@ bool needPrimaryTimestampCol(SQuery *pQuery, SDataBlockInfo *pDataBlockInfo) {
   return loadPrimaryTS;
 }
 
-bool onDemandLoadDatablock(SQuery *pQuery, int16_t queryRangeSet) {
-  return (pQuery->intervalTime == 0) || ((queryRangeSet == 1) && (isIntervalQuery(pQuery)));
-}
-
 static int32_t getNumOfSubset(SQInfo *pQInfo) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
diff --git a/tests/script/general/parser/create_db.sim b/tests/script/general/parser/create_db.sim
index 817d712aa6..7b08d942fd 100644
--- a/tests/script/general/parser/create_db.sim
+++ b/tests/script/general/parser/create_db.sim
@@ -104,14 +104,14 @@ $replica = 1 # max=3
 $days = 10
 $keep = 365
 $rows_db = 1000
-$cache = 4096 # 4 kb
+$cache = 16 # 16MB
 $ablocks = 100 
 $tblocks = 32 # max=512, automatically trimmed when exceeding
 $ctime = 36000 # 10 hours
 $wal = 0 # valid value is 0, 1, 2
 $comp = 1 # max=32, automatically trimmed when exceeding
 
-sql create database $db replica $replica days $days keep $keep maxrows $rows_db cache $cache ablocks $ablocks tblocks $tblocks ctime $ctime wal $wal comp $comp
+sql create database $db replica $replica days $days keep $keep maxrows $rows_db cache $cache ctime $ctime wal $wal comp $comp
 sql show databases
 if $rows != 1 then
   return -1
diff --git a/tests/script/general/parser/first_last_query.sim b/tests/script/general/parser/first_last_query.sim
index c6237198c5..fa5ed8b4ad 100644
--- a/tests/script/general/parser/first_last_query.sim
+++ b/tests/script/general/parser/first_last_query.sim
@@ -27,32 +27,25 @@ endi
 if $data00 != @18-09-17 08:59:00.000@ then
   return -1
 endi
-#if $data01 != NULL then
 if $data01 != 0 then
   return -1   
 endi  
-#if $data02 != NULL then
 if $data02 != 0 then
   return -1  
 endi 
-#if $data03 != NULL then
 print data03 = $data03
 if $data03 != 0.00000 then
   return -1  
 endi    
-#if $data04 != NULL then
 if $data04 != 0.000000000 then
   return -1
 endi
-#if $data05 != NULL then
 if $data05 != 0 then
   return -1
 endi 
-#if $data06 != NULL then
 if $data06 != 0 then
   return -1
 endi
-#if $data07 != NULL then
 if $data07 != 1 then
   return -1
 endi
diff --git a/tests/script/general/parser/null_char.sim b/tests/script/general/parser/null_char.sim
index 7a6c40c1a3..6da419cd4c 100644
--- a/tests/script/general/parser/null_char.sim
+++ b/tests/script/general/parser/null_char.sim
@@ -177,7 +177,7 @@ sql_error insert into st34 using mt3 tags ('NULL', '123aBc', 105, NULL)   values
 #### case 3: set tag value
 sql create table mt4 (ts timestamp, c1 int) tags (tag_binary binary(16), tag_nchar nchar(16), tag_int int, tag_bool bool, tag_float float, tag_double double)
 sql create table st41 using mt4 tags ("beijing", 'nchar_tag', 100, false, 9.12345, 7.123456789)
-sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double st41
+sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from st41
 if $rows != 1 then
   return -1
 endi
@@ -190,13 +190,17 @@ endi
 if $data02 != 100 then
   return -1
 endi
-if $data03 != false then
+if $data03 != 0 then
   return -1
 endi
-if $dat04 != 9.123450 then
+
+if $data04 != 9.12345 then
+  print expect 9.12345 , actual: $data04
   return -1
 endi
-if $data05 != 7.123457 then
+
+if $data05 != 7.123456789 then
+  print expect 7.123456789 , actual: $data05
   return -1
 endi
 
diff --git a/tests/script/general/parser/projection_limit_offset.sim b/tests/script/general/parser/projection_limit_offset.sim
index 0091bfa59e..5f006d0eb7 100644
--- a/tests/script/general/parser/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.sim
@@ -344,11 +344,11 @@ if $data11 != 1 then
    return -1
 endi
 
-if $data12 != null then
+if $data12 != NULL then
    return -1
 endi
 
-if $data13 != null then
+if $data13 != NULL then
    return -1
 endi
 
@@ -358,6 +358,15 @@ if $row != 8 then
    return -1
 endi
 
+sql select diff(k) from tm0
+if $row != 3 then
+   return -1
+endi
+
+if $data21 != -1 then
+   return -1
+endi
+
 #error sql
 sql_error select * from 1;
 sql_error select 1;

From c4fe461f72f95846a539ca12bac3e3d0c139380a Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 24 May 2020 22:41:01 +0800
Subject: [PATCH 12/27] [td-225] fix bugs in diff and spread

---
 src/client/src/tscFunctionImpl.c | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index fff8823a83..52d904d314 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -2912,10 +2912,6 @@ static void leastsquares_finalizer(SQLFunctionCtx *pCtx) {
 }
 
 static void date_col_output_function(SQLFunctionCtx *pCtx) {
-  if (pCtx->scanFlag == REVERSE_SCAN) {  // todo : remove it
-    return;
-  }
-  
   SET_VAL(pCtx, pCtx->size, 1);
   *(int64_t *)(pCtx->aOutputBuf) = pCtx->nStartQueryTimestamp;
 }
@@ -3080,7 +3076,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pData[i - step];
+          *pOutput = pData[i] - pCtx->param[1].i64Key;  // direct previous may be null
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;
@@ -3112,7 +3108,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pData[i - step];
+          *pOutput = pData[i] - pCtx->param[1].i64Key;
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;
@@ -3143,7 +3139,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pData[i - step];
+          *pOutput = pData[i] - pCtx->param[1].i64Key;
           *pTimestamp = pCtx->ptsList[i];
           pOutput += 1;
           pTimestamp += 1;
@@ -3174,7 +3170,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pData[i - step];
+          *pOutput = pData[i] - pCtx->param[1].i64Key;
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;
@@ -3206,7 +3202,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pData[i - step];
+          *pOutput = pData[i] - pCtx->param[1].i64Key;
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;
@@ -3238,7 +3234,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pData[i - step];
+          *pOutput = pData[i] - pCtx->param[1].i64Key;
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;
@@ -3445,14 +3441,8 @@ static void spread_function(SQLFunctionCtx *pCtx) {
         pInfo->max = GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.max));
       }
     }
-  } else {
-//    if (pInfo->min > pCtx->param[1].dKey) {
-//      pInfo->min = pCtx->param[1].dKey;
-//    }
-//
-//    if (pInfo->max < pCtx->param[2].dKey) {
-//      pInfo->max = pCtx->param[2].dKey;
-//    }
+    
+    goto _spread_over;
   }
   
   void *pData = GET_INPUT_CHAR(pCtx);

From f8564866c90358b51559a6b24a2ffcfe5717288c Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 24 May 2020 22:41:29 +0800
Subject: [PATCH 13/27] [td-225] fix bugs in data block statistics generation

---
 src/common/src/ttypes.c | 39 +++++++++------------------------------
 1 file changed, 9 insertions(+), 30 deletions(-)

diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index 265e63222c..d45ceb2a4b 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -42,9 +42,6 @@ static void getStatics_i8(const TSKEY *primaryKey, const void *pData, int32_t nu
   
   ASSERT(numOfRow <= INT16_MAX);
   
-  //  int64_t lastKey = 0;
-  //  int8_t  lastVal = TSDB_DATA_TINYINT_NULL;
-  
   for (int32_t i = 0; i < numOfRow; ++i) {
     if (isNull((char *)&data[i], TSDB_DATA_TYPE_TINYINT)) {
       (*numOfNull) += 1;
@@ -213,15 +210,6 @@ static void getStatics_f(const TSKEY *primaryKey, const void *pData, int32_t num
       fmax = fv;
       *maxIndex = i;
     }
-    
-    //    if (isNull(&lastVal, TSDB_DATA_TYPE_FLOAT)) {
-    //      lastKey = primaryKey[i];
-    //      lastVal = data[i];
-    //    } else {
-    //      *wsum = lastVal * (primaryKey[i] - lastKey);
-    //      lastKey = primaryKey[i];
-    //      lastVal = data[i];
-    //    }
   }
   
   double csum = 0;
@@ -232,9 +220,9 @@ static void getStatics_f(const TSKEY *primaryKey, const void *pData, int32_t num
   SET_DOUBLE_VAL_ALIGN(max, &fmax);
   SET_DOUBLE_VAL_ALIGN(min, &fmin);
 #else
-  *sum = csum;
-  *max = fmax;
-  *min = fmin;
+  *(double*)sum = csum;
+  *(double*)max = fmax;
+  *(double*)min = fmin;
 #endif
 }
 
@@ -267,15 +255,6 @@ static void getStatics_d(const TSKEY *primaryKey, const void *pData, int32_t num
       dmax = dv;
       *maxIndex = i;
     }
-    
-    //    if (isNull(&lastVal, TSDB_DATA_TYPE_DOUBLE)) {
-    //      lastKey = primaryKey[i];
-    //      lastVal = data[i];
-    //    } else {
-    //      *wsum = lastVal * (primaryKey[i] - lastKey);
-    //      lastKey = primaryKey[i];
-    //      lastVal = data[i];
-    //    }
   }
   
   double csum = 0;
@@ -285,18 +264,18 @@ static void getStatics_d(const TSKEY *primaryKey, const void *pData, int32_t num
 
 #ifdef _TD_ARM_32_
   SET_DOUBLE_VAL_ALIGN(sum, &csum);
-    SET_DOUBLE_VAL_ALIGN(max, &dmax);
-    SET_DOUBLE_VAL_ALIGN(min, &dmin);
+  SET_DOUBLE_VAL_ALIGN(max, &dmax);
+  SET_DOUBLE_VAL_ALIGN(min, &dmin);
 #else
-  *sum = csum;
-  *max = dmax;
-  *min = dmin;
+  *(double*) sum = csum;
+  *(double*) max = dmax;
+  *(double*) min = dmin;
 #endif
 }
 
 tDataTypeDescriptor tDataTypeDesc[11] = {
   {TSDB_DATA_TYPE_NULL,      6, 1,            "NOTYPE",    NULL,                NULL,                  NULL},
-  {TSDB_DATA_TYPE_BOOL,      4, CHAR_BYTES,   "BOOL",      tsCompressBool,      tsDecompressBool,      NULL},
+  {TSDB_DATA_TYPE_BOOL,      4, CHAR_BYTES,   "BOOL",      tsCompressBool,      tsDecompressBool,      getStatics_i8},
   {TSDB_DATA_TYPE_TINYINT,   7, CHAR_BYTES,   "TINYINT",   tsCompressTinyint,   tsDecompressTinyint,   getStatics_i8},
   {TSDB_DATA_TYPE_SMALLINT,  8, SHORT_BYTES,  "SMALLINT",  tsCompressSmallint,  tsDecompressSmallint,  getStatics_i16},
   {TSDB_DATA_TYPE_INT,       3, INT_BYTES,    "INT",       tsCompressInt,       tsDecompressInt,       getStatics_i32},

From 5f3fce3577a9ccf1e5ee2a067c72004b9d2210c3 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 24 May 2020 22:44:21 +0800
Subject: [PATCH 14/27] [td-225]fix crash in parsing the following sql: create
 table t1 as select count(*);

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

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index f338bbc644..d23d0e1860 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -5337,13 +5337,6 @@ int32_t doLocalQueryProcess(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
     }
   }
 
-  SColumnIndex ind = {0};
-  SSqlExpr* pExpr1 = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG_DUMMY, &ind, TSDB_DATA_TYPE_INT,
-      tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, false);
-  
-  const char* name = (pExprList->a[0].aliasName != NULL)? pExprList->a[0].aliasName:functionsInfo[index].name;
-  strncpy(pExpr1->aliasName, name, tListLen(pExpr1->aliasName));
-
   switch (index) {
     case 0:
       pQueryInfo->command = TSDB_SQL_CURRENT_DB;
@@ -5362,6 +5355,13 @@ int32_t doLocalQueryProcess(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
       return TSDB_CODE_SUCCESS;
     default: { return invalidSqlErrMsg(pQueryInfo->msg, msg3); }
   }
+  
+  SColumnIndex ind = {0};
+  SSqlExpr* pExpr1 = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG_DUMMY, &ind, TSDB_DATA_TYPE_INT,
+                                      tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize, false);
+  
+  const char* name = (pExprList->a[0].aliasName != NULL)? pExprList->a[0].aliasName:functionsInfo[index].name;
+  strncpy(pExpr1->aliasName, name, tListLen(pExpr1->aliasName));
 }
 
 // can only perform the parameters based on the macro definitation

From 569bde3044286181576988e04ec3c22d2497ae41 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 24 May 2020 22:54:06 +0800
Subject: [PATCH 15/27] [td-225]update the basic.txt

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

diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index e68707e710..dc8c564fd9 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -111,7 +111,7 @@ cd ../../../debug; make
 ./test.sh -f general/parser/col_arithmetic_operation.sim
 ./test.sh -f general/parser/columnValue.sim
 ./test.sh -f general/parser/commit.sim
-./test.sh -f general/parser/create_db.sim
+#./test.sh -f general/parser/create_db.sim   #there are bugs in this sim script
 ./test.sh -f general/parser/create_mt.sim
 ./test.sh -f general/parser/create_tb.sim
 ./test.sh -f general/parser/dbtbnameValidate.sim
@@ -135,21 +135,21 @@ cd ../../../debug; make
 ./test.sh -f general/parser/slimit1.sim
 ./test.sh -f general/parser/tbnameIn.sim
 ./test.sh -f general/parser/binary_escapeCharacter.sim
+./test.sh -f general/parser/projection_limit_offset.sim
 # ./test.sh -f general/parser/limit2.sim
-# ./test.sh -f general/parser/set_tag_vals.sim
 # ./test.sh -f general/parser/slimit.sim
 # ./test.sh -f general/parser/fill.sim
 # ./test.sh -f general/parser/fill_stb.sim
-# ./test.sh -f general/parser/tags_dynamically_specifiy.sim
 # ./test.sh -f general/parser/interp.sim
 # ./test.sh -f general/parser/where.sim
-# ./test.sh -f general/parser/repeatAlter.sim
 # ./test.sh -f general/parser/join.sim
 # ./test.sh -f general/parser/join_multivnode.sim
-# ./test.sh -f general/parser/projection_limit_offset.sim
 # ./test.sh -f general/parser/select_with_tags.sim
 # ./test.sh -f general/parser/groupby.sim
-#./test.sh -f general/parser/bug.sim
+# ./test.sh -f general/parser/bug.sim
+#unsupport ./test.sh -f general/parser/tags_dynamically_specifiy.sim
+#unsupport ./test.sh -f general/parser/set_tag_vals.sim
+#unsupport ./test.sh -f general/parser/repeatAlter.sim
 #unsupport ./test.sh -f general/parser/slimit_alter_tags.sim
 #unsupport ./test.sh -f general/parser/stream_on_sys.sim
 #unsupport ./test.sh -f general/parser/stream.sim

From 77ef030ef1d8e6cf780b79763736d64b24714e44 Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Mon, 25 May 2020 01:41:05 +0000
Subject: [PATCH 16/27] getFileInfo bug

---
 src/common/src/tglobal.c | 2 +-
 src/tsdb/src/tsdbMain.c  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index 250b79febe..faf15c4215 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -142,7 +142,7 @@ int32_t rpcDebugFlag = 135;
 int32_t uDebugFlag = 131;
 int32_t debugFlag = 131;
 int32_t sDebugFlag = 135;
-int32_t tsdbDebugFlag = 131;
+int32_t tsdbDebugFlag = 135;
 
 // the maximum number of results for projection query on super table that are returned from
 // one virtual node, to order according to timestamp
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index a9f0d9b6ec..7db61db429 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -1196,7 +1196,7 @@ uint32_t tsdbGetFileInfo(TsdbRepoT *repo, char *name, uint32_t *index, int32_t *
     // Map index to the file name
     int fid = (*index) / 3;
 
-    if (fid > pFileH->numOfFGroups) {
+    if (fid >= pFileH->numOfFGroups) {
       // return meta data file
       if ((*index) % 3 > 0) { // it is finished
         tfree(spath);

From 9c3ddab8c563c8d8ae569c1b35fe9a6079ef8633 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 25 May 2020 03:04:51 +0000
Subject: [PATCH 17/27] scripts

---
 tests/script/unique/mnode/mgmt22.sim | 1 +
 tests/script/unique/mnode/mgmt24.sim | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tests/script/unique/mnode/mgmt22.sim b/tests/script/unique/mnode/mgmt22.sim
index 37e38fbf66..c6ea026af9 100644
--- a/tests/script/unique/mnode/mgmt22.sim
+++ b/tests/script/unique/mnode/mgmt22.sim
@@ -47,6 +47,7 @@ print should not drop master
 
 print ============== step4
 system sh/exec_up.sh -n dnode1 -s stop -x SIGINT
+sleep 2000
 sql_error show mnodes
 print error of no master
 
diff --git a/tests/script/unique/mnode/mgmt24.sim b/tests/script/unique/mnode/mgmt24.sim
index 4c61cbd7ae..4813d96f5f 100644
--- a/tests/script/unique/mnode/mgmt24.sim
+++ b/tests/script/unique/mnode/mgmt24.sim
@@ -42,6 +42,7 @@ endi
 
 print ============== step3
 system sh/exec_up.sh -n dnode1 -s stop
+sleep 2000
 sql_error show mnodes
 
 print ============== step4

From 5447600648fe7ba6a04b8a47b4e7650d98027765 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 25 May 2020 11:21:36 +0800
Subject: [PATCH 18/27] [td-225] add statistics for binary/nchar data

---
 src/common/src/ttypes.c | 44 +++++++++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index d45ceb2a4b..654cb65ec3 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -273,6 +273,46 @@ static void getStatics_d(const TSKEY *primaryKey, const void *pData, int32_t num
 #endif
 }
 
+static void getStatics_bin(const TSKEY *primaryKey, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max,
+                         int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+  const char* data = pData;
+  ASSERT(numOfRow <= INT16_MAX);
+  
+  for (int32_t i = 0; i < numOfRow; ++i) {
+    if (isNull((const char*) varDataVal(data), TSDB_DATA_TYPE_BINARY)) {
+      (*numOfNull) += 1;
+    }
+    
+    data += varDataLen(data);
+  }
+  
+  *sum = 0;
+  *max = 0;
+  *min = 0;
+  *minIndex = 0;
+  *maxIndex = 0;
+}
+
+static void getStatics_nchr(const TSKEY *primaryKey, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max,
+                           int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+  const char* data = pData;
+  ASSERT(numOfRow <= INT16_MAX);
+  
+  for (int32_t i = 0; i < numOfRow; ++i) {
+    if (isNull((const char*) varDataVal(data), TSDB_DATA_TYPE_NCHAR)) {
+      (*numOfNull) += 1;
+    }
+    
+    data += varDataLen(data);
+  }
+  
+  *sum = 0;
+  *max = 0;
+  *min = 0;
+  *minIndex = 0;
+  *maxIndex = 0;
+}
+
 tDataTypeDescriptor tDataTypeDesc[11] = {
   {TSDB_DATA_TYPE_NULL,      6, 1,            "NOTYPE",    NULL,                NULL,                  NULL},
   {TSDB_DATA_TYPE_BOOL,      4, CHAR_BYTES,   "BOOL",      tsCompressBool,      tsDecompressBool,      getStatics_i8},
@@ -282,9 +322,9 @@ tDataTypeDescriptor tDataTypeDesc[11] = {
   {TSDB_DATA_TYPE_BIGINT,    6, LONG_BYTES,   "BIGINT",    tsCompressBigint,    tsDecompressBigint,    getStatics_i64},
   {TSDB_DATA_TYPE_FLOAT,     5, FLOAT_BYTES,  "FLOAT",     tsCompressFloat,     tsDecompressFloat,     getStatics_f},
   {TSDB_DATA_TYPE_DOUBLE,    6, DOUBLE_BYTES, "DOUBLE",    tsCompressDouble,    tsDecompressDouble,    getStatics_d},
-  {TSDB_DATA_TYPE_BINARY,    6, 0,            "BINARY",    tsCompressString,    tsDecompressString,    NULL},
+  {TSDB_DATA_TYPE_BINARY,    6, 0,            "BINARY",    tsCompressString,    tsDecompressString,    getStatics_bin},
   {TSDB_DATA_TYPE_TIMESTAMP, 9, LONG_BYTES,   "TIMESTAMP", tsCompressTimestamp, tsDecompressTimestamp, getStatics_i64},
-  {TSDB_DATA_TYPE_NCHAR,     5, 8,            "NCHAR",     tsCompressString,    tsDecompressString,    NULL},
+  {TSDB_DATA_TYPE_NCHAR,     5, 8,            "NCHAR",     tsCompressString,    tsDecompressString,    getStatics_nchr},
 };
 
 char tTokenTypeSwitcher[13] = {

From 0c4b90f3b42862131ca47cfbaf279fd586a23ebd Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 25 May 2020 11:51:50 +0800
Subject: [PATCH 19/27] [td-225] refactor codes

---
 src/client/inc/tscLog.h      |  2 +-
 src/client/inc/tsclient.h    |  6 +--
 src/common/inc/tdataformat.h |  8 +--
 src/common/src/tdataformat.c | 52 ++++++++++----------
 src/query/src/qExecutor.c    | 20 ++++----
 src/tsdb/inc/tsdbMain.h      |  6 +--
 src/tsdb/src/tsdbCache.c     |  4 +-
 src/tsdb/src/tsdbFile.c      |  4 +-
 src/tsdb/src/tsdbMain.c      | 12 ++---
 src/tsdb/src/tsdbRWHelper.c  | 94 ++++++++++++++++++------------------
 src/tsdb/src/tsdbRead.c      | 49 +++++++++++--------
 11 files changed, 131 insertions(+), 126 deletions(-)

diff --git a/src/client/inc/tscLog.h b/src/client/inc/tscLog.h
index 346e1a6795..5e57847daa 100644
--- a/src/client/inc/tscLog.h
+++ b/src/client/inc/tscLog.h
@@ -30,7 +30,7 @@ extern int32_t cDebugFlag;
   }
 #define tscWarn(...)                                \
   if (cDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN  TSC ", cDebugFlag, __VA_ARGS__); \
+    taosPrintLog("WARN TSC ", cDebugFlag, __VA_ARGS__); \
   }
 #define tscTrace(...)                         \
   if (cDebugFlag & DEBUG_TRACE) {             \
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 7cfa923f9e..13f5ebc86e 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -53,11 +53,7 @@ typedef struct STableComInfo {
 } STableComInfo;
 
 typedef struct STableMeta {
-  // super table if it is created according to super table, otherwise, tableInfo is used
-  union {
-    struct STableMeta *pSTable;
-    STableComInfo      tableInfo;
-  };
+  STableComInfo tableInfo;
   uint8_t       tableType;
   int16_t       sversion;
   SCMVgroupInfo vgroupInfo;
diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index 956121086c..8990b69c5a 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -154,8 +154,8 @@ typedef struct SDataCol {
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }
 
 void dataColInit(SDataCol *pDataCol, STColumn *pCol, void **pBuf, int maxPoints);
-void dataColAppendVal(SDataCol *pCol, void *value, int numOfPoints, int maxPoints);
-void dataColPopPoints(SDataCol *pCol, int pointsToPop, int numOfPoints);
+void dataColAppendVal(SDataCol *pCol, void *value, int numOfRows, int maxPoints);
+void dataColPopPoints(SDataCol *pCol, int pointsToPop, int numOfRows);
 void dataColSetOffset(SDataCol *pCol, int nEle);
 
 bool isNEleNull(SDataCol *pCol, int nEle);
@@ -195,7 +195,7 @@ typedef struct {
   int      maxPoints;  // max number of points
   int      bufSize;
 
-  int      numOfPoints;
+  int      numOfRows;
   int      numOfCols;  // Total number of cols
   int      sversion;   // TODO: set sversion
   void *   buf;
@@ -205,7 +205,7 @@ typedef struct {
 #define keyCol(pCols) (&((pCols)->cols[0]))  // Key column
 #define dataColsKeyAt(pCols, idx) ((TSKEY *)(keyCol(pCols)->pData))[(idx)]
 #define dataColsKeyFirst(pCols) dataColsKeyAt(pCols, 0)
-#define dataColsKeyLast(pCols) ((pCols->numOfPoints == 0) ? 0 : dataColsKeyAt(pCols, (pCols)->numOfPoints - 1))
+#define dataColsKeyLast(pCols) ((pCols->numOfRows == 0) ? 0 : dataColsKeyAt(pCols, (pCols)->numOfRows - 1))
 
 SDataCols *tdNewDataCols(int maxRowSize, int maxCols, int maxRows);
 void       tdResetDataCols(SDataCols *pCols);
diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c
index cf1b77d12c..81ea801c94 100644
--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
@@ -187,29 +187,29 @@ void dataColInit(SDataCol *pDataCol, STColumn *pCol, void **pBuf, int maxPoints)
 
 }
 
-void dataColAppendVal(SDataCol *pCol, void *value, int numOfPoints, int maxPoints) {
+void dataColAppendVal(SDataCol *pCol, void *value, int numOfRows, int maxPoints) {
   ASSERT(pCol != NULL && value != NULL);
 
   switch (pCol->type) {
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
       // set offset
-      pCol->dataOff[numOfPoints] = pCol->len;
+      pCol->dataOff[numOfRows] = pCol->len;
       // Copy data
       memcpy(POINTER_SHIFT(pCol->pData, pCol->len), value, varDataTLen(value));
       // Update the length
       pCol->len += varDataTLen(value);
       break;
     default:
-      ASSERT(pCol->len == TYPE_BYTES[pCol->type] * numOfPoints);
+      ASSERT(pCol->len == TYPE_BYTES[pCol->type] * numOfRows);
       memcpy(POINTER_SHIFT(pCol->pData, pCol->len), value, pCol->bytes);
       pCol->len += pCol->bytes;
       break;
   }
 }
 
-void dataColPopPoints(SDataCol *pCol, int pointsToPop, int numOfPoints) {
-  int pointsLeft = numOfPoints - pointsToPop;
+void dataColPopPoints(SDataCol *pCol, int pointsToPop, int numOfRows) {
+  int pointsLeft = numOfRows - pointsToPop;
 
   ASSERT(pointsLeft > 0);
 
@@ -221,7 +221,7 @@ void dataColPopPoints(SDataCol *pCol, int pointsToPop, int numOfPoints) {
     memmove(pCol->pData, POINTER_SHIFT(pCol->pData, toffset), pCol->len);
     dataColSetOffset(pCol, pointsLeft);
   } else {
-    ASSERT(pCol->len == TYPE_BYTES[pCol->type] * numOfPoints);
+    ASSERT(pCol->len == TYPE_BYTES[pCol->type] * numOfRows);
     pCol->len = TYPE_BYTES[pCol->type] * pointsLeft;
     memmove(pCol->pData, POINTER_SHIFT(pCol->pData, TYPE_BYTES[pCol->type] * pointsToPop), pCol->len);
   }
@@ -322,7 +322,7 @@ SDataCols *tdDupDataCols(SDataCols *pDataCols, bool keepData) {
 
   pRet->numOfCols = pDataCols->numOfCols;
   pRet->sversion = pDataCols->sversion;
-  if (keepData) pRet->numOfPoints = pDataCols->numOfPoints;
+  if (keepData) pRet->numOfRows = pDataCols->numOfRows;
 
   for (int i = 0; i < pDataCols->numOfCols; i++) {
     pRet->cols[i].type = pDataCols->cols[i].type;
@@ -352,7 +352,7 @@ SDataCols *tdDupDataCols(SDataCols *pDataCols, bool keepData) {
 }
 
 void tdResetDataCols(SDataCols *pCols) {
-  pCols->numOfPoints = 0;
+  pCols->numOfRows = 0;
   for (int i = 0; i < pCols->maxCols; i++) {
     dataColReset(pCols->cols + i);
   }
@@ -365,14 +365,14 @@ void tdAppendDataRowToDataCol(SDataRow row, SDataCols *pCols) {
     SDataCol *pCol = pCols->cols + i;
     void *    value = tdGetRowDataOfCol(row, pCol->type, pCol->offset);
 
-    dataColAppendVal(pCol, value, pCols->numOfPoints, pCols->maxPoints);
+    dataColAppendVal(pCol, value, pCols->numOfRows, pCols->maxPoints);
   }
-  pCols->numOfPoints++;
+  pCols->numOfRows++;
 }
 
 // Pop pointsToPop points from the SDataCols
 void tdPopDataColsPoints(SDataCols *pCols, int pointsToPop) {
-  int pointsLeft = pCols->numOfPoints - pointsToPop;
+  int pointsLeft = pCols->numOfRows - pointsToPop;
   if (pointsLeft <= 0) {
     tdResetDataCols(pCols);
     return;
@@ -380,14 +380,14 @@ void tdPopDataColsPoints(SDataCols *pCols, int pointsToPop) {
 
   for (int iCol = 0; iCol < pCols->numOfCols; iCol++) {
     SDataCol *pCol = pCols->cols + iCol;
-    dataColPopPoints(pCol, pointsToPop, pCols->numOfPoints);
+    dataColPopPoints(pCol, pointsToPop, pCols->numOfRows);
   }
-  pCols->numOfPoints = pointsLeft;
+  pCols->numOfRows = pointsLeft;
 }
 
 int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge) {
-  ASSERT(rowsToMerge > 0 && rowsToMerge <= source->numOfPoints);
-  ASSERT(target->numOfPoints + rowsToMerge <= target->maxPoints);
+  ASSERT(rowsToMerge > 0 && rowsToMerge <= source->numOfRows);
+  ASSERT(target->numOfRows + rowsToMerge <= target->maxPoints);
   ASSERT(target->numOfCols == source->numOfCols);
 
   SDataCols *pTarget = NULL;
@@ -395,10 +395,10 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge) {
   if (dataColsKeyLast(target) < dataColsKeyFirst(source)) {  // No overlap
     for (int i = 0; i < rowsToMerge; i++) {
       for (int j = 0; j < source->numOfCols; j++) {
-        dataColAppendVal(target->cols + j, tdGetColDataOfRow(source->cols + j, i), target->numOfPoints,
+        dataColAppendVal(target->cols + j, tdGetColDataOfRow(source->cols + j, i), target->numOfRows,
                          target->maxPoints);
       }
-      target->numOfPoints++;
+      target->numOfRows++;
     }
   } else {
     pTarget = tdDupDataCols(target, true);
@@ -406,7 +406,7 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge) {
 
     int iter1 = 0;
     int iter2 = 0;
-    tdMergeTwoDataCols(target, pTarget, &iter1, source, &iter2, pTarget->numOfPoints + rowsToMerge);
+    tdMergeTwoDataCols(target, pTarget, &iter1, source, &iter2, pTarget->numOfRows + rowsToMerge);
   }
 
   tdFreeDataCols(pTarget);
@@ -421,30 +421,30 @@ void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SDataCol
   // TODO: add resolve duplicate key here
   tdResetDataCols(target);
 
-  while (target->numOfPoints < tRows) {
-    if (*iter1 >= src1->numOfPoints && *iter2 >= src2->numOfPoints) break;
+  while (target->numOfRows < tRows) {
+    if (*iter1 >= src1->numOfRows && *iter2 >= src2->numOfRows) break;
 
-    TSKEY key1 = (*iter1 >= src1->numOfPoints) ? INT64_MAX : ((TSKEY *)(src1->cols[0].pData))[*iter1];
-    TSKEY key2 = (*iter2 >= src2->numOfPoints) ? INT64_MAX : ((TSKEY *)(src2->cols[0].pData))[*iter2];
+    TSKEY key1 = (*iter1 >= src1->numOfRows) ? INT64_MAX : ((TSKEY *)(src1->cols[0].pData))[*iter1];
+    TSKEY key2 = (*iter2 >= src2->numOfRows) ? INT64_MAX : ((TSKEY *)(src2->cols[0].pData))[*iter2];
 
     if (key1 <= key2) {
       for (int i = 0; i < src1->numOfCols; i++) {
         ASSERT(target->cols[i].type == src1->cols[i].type);
-        dataColAppendVal(&(target->cols[i]), tdGetColDataOfRow(src1->cols + i, *iter1), target->numOfPoints,
+        dataColAppendVal(&(target->cols[i]), tdGetColDataOfRow(src1->cols + i, *iter1), target->numOfRows,
                          target->maxPoints);
       }
 
-      target->numOfPoints++;
+      target->numOfRows++;
       (*iter1)++;
       if (key1 == key2) (*iter2)++;
     } else {
       for (int i = 0; i < src2->numOfCols; i++) {
         ASSERT(target->cols[i].type == src2->cols[i].type);
-        dataColAppendVal(&(target->cols[i]), tdGetColDataOfRow(src2->cols + i, *iter2), target->numOfPoints,
+        dataColAppendVal(&(target->cols[i]), tdGetColDataOfRow(src2->cols + i, *iter2), target->numOfRows,
                          target->maxPoints);
       }
 
-      target->numOfPoints++;
+      target->numOfRows++;
       (*iter2)++;
     }
   }
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 0609ed1870..0bd6f2ab34 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -200,7 +200,7 @@ bool getNeighborPoints(SQInfo *pQInfo, void *pMeterObj, SPointInterpoSupporter *
       return false;
     } else {  // prev has been located
       if (pQuery->fileId >= 0) {
-        pQuery->pos = pQuery->pBlock[pQuery->slot].numOfPoints - 1;
+        pQuery->pos = pQuery->pBlock[pQuery->slot].numOfRows - 1;
         getOneRowFromDataBlock(pRuntimeEnv, pPointInterpSupporter->pPrevPoint, pQuery->pos);
 
         qTrace("QInfo:%p get prev data point, fileId:%d, slot:%d, pos:%d, pQuery->pos:%d", GET_QINFO_ADDR(pQuery),
@@ -210,11 +210,11 @@ bool getNeighborPoints(SQInfo *pQInfo, void *pMeterObj, SPointInterpoSupporter *
         assert(vnodeIsDatablockLoaded(pRuntimeEnv, pMeterObj, -1, true) == DISK_BLOCK_NO_NEED_TO_LOAD);
         pBlock = &pRuntimeEnv->cacheBlock;
 
-        pQuery->pos = pBlock->numOfPoints - 1;
+        pQuery->pos = pBlock->numOfRows - 1;
         getOneRowFromDataBlock(pRuntimeEnv, pPointInterpSupporter->pPrevPoint, pQuery->pos);
 
         qTrace("QInfo:%p get prev data point, fileId:%d, slot:%d, pos:%d, pQuery->pos:%d", GET_QINFO_ADDR(pQuery),
-               pQuery->fileId, pQuery->slot, pBlock->numOfPoints - 1, pQuery->pos);
+               pQuery->fileId, pQuery->slot, pBlock->numOfRows - 1, pQuery->pos);
       }
     }
   }
@@ -603,9 +603,9 @@ static SWindowStatus *getTimeWindowResStatus(SWindowResInfo *pWindowResInfo, int
   return &pWindowResInfo->pResult[slot].status;
 }
 
-static int32_t getForwardStepsInBlock(int32_t numOfPoints, __block_search_fn_t searchFn, TSKEY ekey, int16_t pos,
+static int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t searchFn, TSKEY ekey, int16_t pos,
                                       int16_t order, int64_t *pData) {
-  int32_t endPos = searchFn((char *)pData, numOfPoints, ekey, order);
+  int32_t endPos = searchFn((char *)pData, numOfRows, ekey, order);
   int32_t forwardStep = 0;
 
   if (endPos >= 0) {
@@ -2329,7 +2329,7 @@ SArray *loadDataBlockOnDemand(SQueryRuntimeEnv *pRuntimeEnv, void* pQueryHandle,
 
 int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) {
   int32_t midPos = -1;
-  int32_t numOfPoints;
+  int32_t numOfRows;
 
   if (num <= 0) {
     return -1;
@@ -2348,8 +2348,8 @@ int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) {
       if (key == keyList[firstPos]) return firstPos;
       if (key < keyList[firstPos]) return firstPos - 1;
 
-      numOfPoints = lastPos - firstPos + 1;
-      midPos = (numOfPoints >> 1) + firstPos;
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
 
       if (key < keyList[midPos]) {
         lastPos = midPos - 1;
@@ -2374,8 +2374,8 @@ int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) {
           return lastPos;
       }
 
-      numOfPoints = lastPos - firstPos + 1;
-      midPos = (numOfPoints >> 1) + firstPos;
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
 
       if (key < keyList[midPos]) {
         lastPos = midPos - 1;
diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h
index 4225602292..20a704db49 100644
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
@@ -74,7 +74,7 @@ void       tsdbCloseMetaFile(SMetaFile *mfh);
 typedef struct {
   TSKEY   keyFirst;
   TSKEY   keyLast;
-  int32_t numOfPoints;
+  int32_t numOfRows;
   void *  pData;
 } SMemTable;
 
@@ -173,7 +173,7 @@ typedef struct {
 typedef struct {
   TSKEY   keyFirst;
   TSKEY   keyLast;
-  int64_t numOfPoints;
+  int64_t numOfRows;
   SList * list;
 } SCacheMem;
 
@@ -294,7 +294,7 @@ typedef struct {
   int64_t last : 1;          // If the block in data file or last file
   int64_t offset : 63;       // Offset of data block or sub-block index depending on numOfSubBlocks
   int32_t algorithm : 8;     // Compression algorithm
-  int32_t numOfPoints : 24;  // Number of total points
+  int32_t numOfRows : 24;    // Number of total points
   int32_t sversion;          // Schema version
   int32_t len;               // Data block length or nothing
   int16_t numOfSubBlocks;    // Number of sub-blocks;
diff --git a/src/tsdb/src/tsdbCache.c b/src/tsdb/src/tsdbCache.c
index be339d2816..edc8472b34 100644
--- a/src/tsdb/src/tsdbCache.c
+++ b/src/tsdb/src/tsdbCache.c
@@ -82,7 +82,7 @@ void *tsdbAllocFromCache(STsdbCache *pCache, int bytes, TSKEY key) {
   memset(ptr, 0, bytes);
   if (key < pCache->mem->keyFirst) pCache->mem->keyFirst = key;
   if (key > pCache->mem->keyLast) pCache->mem->keyLast = key;
-  pCache->mem->numOfPoints++;
+  pCache->mem->numOfRows++;
 
   return ptr;
 }
@@ -127,7 +127,7 @@ static int tsdbAllocBlockFromPool(STsdbCache *pCache) {
     if (pCache->mem == NULL) return -1;
     pCache->mem->keyFirst = INT64_MAX;
     pCache->mem->keyLast = 0;
-    pCache->mem->numOfPoints = 0;
+    pCache->mem->numOfRows = 0;
     pCache->mem->list = tdListNew(sizeof(STsdbCacheBlock *));
   }
 
diff --git a/src/tsdb/src/tsdbFile.c b/src/tsdb/src/tsdbFile.c
index dcea2737ff..bd5c20bd7a 100644
--- a/src/tsdb/src/tsdbFile.c
+++ b/src/tsdb/src/tsdbFile.c
@@ -233,10 +233,10 @@ SFileGroup *tsdbGetFileGroupNext(SFileGroupIter *pIter) {
 //   SCompBlock *pBlock = pStartBlock;
 //   for (int i = 0; i < numOfBlocks; i++) {
 //     if (tsdbLoadCompCols(pFile, pBlock, (void *)pCompData) < 0) return -1;
-//     pCols->numOfPoints += (pCompData->cols[0].len / 8);
+//     pCols->numOfRows += (pCompData->cols[0].len / 8);
 //     for (int iCol = 0; iCol < pBlock->numOfCols; iCol++) {
 //       SCompCol *pCompCol = &(pCompData->cols[iCol]);
-//       // pCols->numOfPoints += pBlock->numOfPoints;
+//       // pCols->numOfRows += pBlock->numOfRows;
 //       int k = 0;
 //       for (; k < pCols->numOfCols; k++) {
 //         if (pCompCol->colId == pCols->cols[k].colId) break;
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index a9f0d9b6ec..d0b6d5035e 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -830,7 +830,7 @@ static int32_t tdInsertRowToTable(STsdbRepo *pRepo, SDataRow row, STable *pTable
   tSkipListNewNodeInfo(pTable->mem->pData, &level, &headSize);
 
   TSKEY key = dataRowKey(row);
-  // printf("insert:%lld, size:%d\n", key, pTable->mem->numOfPoints);
+  // printf("insert:%lld, size:%d\n", key, pTable->mem->numOfRows);
   
   // Copy row into the memory
   SSkipListNode *pNode = tsdbAllocFromCache(pRepo->tsdbCache, headSize + dataRowLen(row), key);
@@ -854,7 +854,7 @@ static int32_t tdInsertRowToTable(STsdbRepo *pRepo, SDataRow row, STable *pTable
   if (key < pTable->mem->keyFirst) pTable->mem->keyFirst = key;
   if (key > pTable->lastKey) pTable->lastKey = key;
   
-  pTable->mem->numOfPoints = tSkipListGetSize(pTable->mem->pData);
+  pTable->mem->numOfRows = tSkipListGetSize(pTable->mem->pData);
 
   tsdbTrace("vgId:%d, tid:%d, uid:%" PRId64 ", table:%s a row is inserted to table! key:%" PRId64, pRepo->config.tsdbId,
             pTable->tableId.tid, pTable->tableId.uid, varDataVal(pTable->name), dataRowKey(row));
@@ -1063,7 +1063,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SSkipListIterator **iters
     while (true) {
       int rowsRead = tsdbReadRowsFromCache(pIter, maxKey, maxRowsToRead, pDataCols);
       assert(rowsRead >= 0);
-      if (pDataCols->numOfPoints == 0) break;
+      if (pDataCols->numOfRows == 0) break;
       nLoop++;
 
       ASSERT(dataColsKeyFirst(pDataCols) >= minKey && dataColsKeyFirst(pDataCols) <= maxKey);
@@ -1072,13 +1072,13 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SSkipListIterator **iters
       int rowsWritten = tsdbWriteDataBlock(pHelper, pDataCols);
       ASSERT(rowsWritten != 0);
       if (rowsWritten < 0) goto _err;
-      ASSERT(rowsWritten <= pDataCols->numOfPoints);
+      ASSERT(rowsWritten <= pDataCols->numOfRows);
 
       tdPopDataColsPoints(pDataCols, rowsWritten);
-      maxRowsToRead = pCfg->maxRowsPerFileBlock * 4 / 5 - pDataCols->numOfPoints;
+      maxRowsToRead = pCfg->maxRowsPerFileBlock * 4 / 5 - pDataCols->numOfRows;
     }
 
-    ASSERT(pDataCols->numOfPoints == 0);
+    ASSERT(pDataCols->numOfRows == 0);
 
     // Move the last block to the new .l file if neccessary
     if (tsdbMoveLastBlockIfNeccessary(pHelper) < 0) {
diff --git a/src/tsdb/src/tsdbRWHelper.c b/src/tsdb/src/tsdbRWHelper.c
index 82584fc5df..eebe0b6b46 100644
--- a/src/tsdb/src/tsdbRWHelper.c
+++ b/src/tsdb/src/tsdbRWHelper.c
@@ -307,7 +307,7 @@ void tsdbSetHelperTable(SRWHelper *pHelper, STable *pTable, STsdbRepo *pRepo) {
  */
 int tsdbWriteDataBlock(SRWHelper *pHelper, SDataCols *pDataCols) {
   ASSERT(TSDB_HELPER_TYPE(pHelper) == TSDB_WRITE_HELPER);
-  ASSERT(pDataCols->numOfPoints > 0);
+  ASSERT(pDataCols->numOfRows > 0);
 
   SCompBlock compBlock;
   int        rowsToWrite = 0;
@@ -322,7 +322,7 @@ int tsdbWriteDataBlock(SRWHelper *pHelper, SDataCols *pDataCols) {
 
   if (pIdx->offset == 0 || (!pIdx->hasLast && keyFirst > pIdx->maxKey)) {  // Just append as a super block
     ASSERT(pHelper->hasOldLastBlock == false);
-    rowsToWrite = pDataCols->numOfPoints;
+    rowsToWrite = pDataCols->numOfRows;
     SFile *pWFile = NULL;
     bool   isLast = false;
 
@@ -380,10 +380,10 @@ int tsdbMoveLastBlockIfNeccessary(SRWHelper *pHelper) {
 
     if (pCompBlock->numOfSubBlocks > 1) {
       if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, pIdx->numOfBlocks - 1), NULL) < 0) return -1;
-      ASSERT(pHelper->pDataCols[0]->numOfPoints > 0 &&
-             pHelper->pDataCols[0]->numOfPoints < pHelper->config.minRowsPerFileBlock);
+      ASSERT(pHelper->pDataCols[0]->numOfRows > 0 &&
+             pHelper->pDataCols[0]->numOfRows < pHelper->config.minRowsPerFileBlock);
       if (tsdbWriteBlockToFile(pHelper, &(pHelper->files.nLastF), pHelper->pDataCols[0],
-                               pHelper->pDataCols[0]->numOfPoints, &compBlock, true, true) < 0)
+                               pHelper->pDataCols[0]->numOfRows, &compBlock, true, true) < 0)
         return -1;
 
       if (tsdbUpdateSuperBlock(pHelper, &compBlock, pIdx->numOfBlocks - 1) < 0) return -1;
@@ -625,13 +625,13 @@ int tsdbLoadBlockDataCols(SRWHelper *pHelper, SDataCols *pDataCols, int blkIdx,
   for (int i = 1; i < numOfSubBlocks; i++) {
     pStartBlock++;
     if (tsdbLoadSingleBlockDataCols(pHelper, pStartBlock, colIds, numOfColIds, pHelper->pDataCols[1]) < 0) return -1;
-    tdMergeDataCols(pDataCols, pHelper->pDataCols[1], pHelper->pDataCols[1]->numOfPoints);
+    tdMergeDataCols(pDataCols, pHelper->pDataCols[1], pHelper->pDataCols[1]->numOfRows);
   }
 
   return 0;
 }
 
-static int tsdbCheckAndDecodeColumnData(SDataCol *pDataCol, char *content, int32_t len, int8_t comp, int numOfPoints,
+static int tsdbCheckAndDecodeColumnData(SDataCol *pDataCol, char *content, int32_t len, int8_t comp, int numOfRows,
                                         int maxPoints, char *buffer, int bufferSize) {
   // Verify by checksum
   if (!taosCheckChecksumWhole((uint8_t *)content, len)) return -1;
@@ -640,16 +640,16 @@ static int tsdbCheckAndDecodeColumnData(SDataCol *pDataCol, char *content, int32
   if (comp) {
     // // Need to decompress
     pDataCol->len = (*(tDataTypeDesc[pDataCol->type].decompFunc))(
-        content, len - sizeof(TSCKSUM), numOfPoints, pDataCol->pData, pDataCol->spaceSize, comp, buffer, bufferSize);
+        content, len - sizeof(TSCKSUM), numOfRows, pDataCol->pData, pDataCol->spaceSize, comp, buffer, bufferSize);
     if (pDataCol->type == TSDB_DATA_TYPE_BINARY || pDataCol->type == TSDB_DATA_TYPE_NCHAR) {
-      dataColSetOffset(pDataCol, numOfPoints);
+      dataColSetOffset(pDataCol, numOfRows);
     }
   } else {
     // No need to decompress, just memcpy it
     pDataCol->len = len - sizeof(TSCKSUM);
     memcpy(pDataCol->pData, content, pDataCol->len);
     if (pDataCol->type == TSDB_DATA_TYPE_BINARY || pDataCol->type == TSDB_DATA_TYPE_NCHAR) {
-      dataColSetOffset(pDataCol, numOfPoints);
+      dataColSetOffset(pDataCol, numOfRows);
     }
   }
   return 0;
@@ -673,7 +673,7 @@ static int tsdbLoadBlockDataImpl(SRWHelper *pHelper, SCompBlock *pCompBlock, SDa
   int32_t tsize = sizeof(SCompData) + sizeof(SCompCol) * pCompBlock->numOfCols + sizeof(TSCKSUM);
   if (!taosCheckChecksumWhole((uint8_t *)pCompData, tsize)) goto _err;
 
-  pDataCols->numOfPoints = pCompBlock->numOfPoints;
+  pDataCols->numOfRows = pCompBlock->numOfRows;
 
   // Recover the data
   int ccol = 0;
@@ -682,7 +682,7 @@ static int tsdbLoadBlockDataImpl(SRWHelper *pHelper, SCompBlock *pCompBlock, SDa
     SDataCol *pDataCol = &(pDataCols->cols[dcol]);
     if (ccol >= pCompData->numOfCols) {
       // Set current column as NULL and forward
-      dataColSetNEleNull(pDataCol, pCompBlock->numOfPoints, pDataCols->maxPoints);
+      dataColSetNEleNull(pDataCol, pCompBlock->numOfRows, pDataCols->maxPoints);
       dcol++;
       continue;
     }
@@ -691,15 +691,15 @@ static int tsdbLoadBlockDataImpl(SRWHelper *pHelper, SCompBlock *pCompBlock, SDa
 
     if (pCompCol->colId == pDataCol->colId) {
       if (pCompBlock->algorithm == TWO_STAGE_COMP) {
-        int zsize = pDataCol->bytes * pCompBlock->numOfPoints + COMP_OVERFLOW_BYTES;
+        int zsize = pDataCol->bytes * pCompBlock->numOfRows + COMP_OVERFLOW_BYTES;
         if (pCompCol->type == TSDB_DATA_TYPE_BINARY || pCompCol->type == TSDB_DATA_TYPE_NCHAR) {
-          zsize += (sizeof(VarDataLenT) * pCompBlock->numOfPoints);
+          zsize += (sizeof(VarDataLenT) * pCompBlock->numOfRows);
         }
         pHelper->compBuffer = trealloc(pHelper->compBuffer, zsize);
         if (pHelper->compBuffer == NULL) goto _err;
       }
       if (tsdbCheckAndDecodeColumnData(pDataCol, (char *)pCompData + tsize + pCompCol->offset, pCompCol->len,
-                                       pCompBlock->algorithm, pCompBlock->numOfPoints, pDataCols->maxPoints,
+                                       pCompBlock->algorithm, pCompBlock->numOfRows, pDataCols->maxPoints,
                                        pHelper->compBuffer, tsizeof(pHelper->compBuffer)) < 0)
         goto _err;
       dcol++;
@@ -708,7 +708,7 @@ static int tsdbLoadBlockDataImpl(SRWHelper *pHelper, SCompBlock *pCompBlock, SDa
       ccol++;
     } else {
       // Set current column as NULL and forward
-      dataColSetNEleNull(pDataCol, pCompBlock->numOfPoints, pDataCols->maxPoints);
+      dataColSetNEleNull(pDataCol, pCompBlock->numOfRows, pDataCols->maxPoints);
       dcol++;
     }
   }
@@ -732,7 +732,7 @@ int tsdbLoadBlockData(SRWHelper *pHelper, SCompBlock *pCompBlock, SDataCols *tar
     tdResetDataCols(pHelper->pDataCols[1]);
     pCompBlock++;
     if (tsdbLoadBlockDataImpl(pHelper, pCompBlock, pHelper->pDataCols[1]) < 0) goto _err;
-    if (tdMergeDataCols(pHelper->pDataCols[0], pHelper->pDataCols[1], pHelper->pDataCols[1]->numOfPoints) < 0) goto _err;
+    if (tdMergeDataCols(pHelper->pDataCols[0], pHelper->pDataCols[1], pHelper->pDataCols[1]->numOfRows) < 0) goto _err;
   }
 
   // if (target) TODO
@@ -753,7 +753,7 @@ static bool tsdbShouldCreateNewLast(SRWHelper *pHelper) {
 
 static int tsdbWriteBlockToFile(SRWHelper *pHelper, SFile *pFile, SDataCols *pDataCols, int rowsToWrite, SCompBlock *pCompBlock,
                                 bool isLast, bool isSuperBlock) {
-  ASSERT(rowsToWrite > 0 && rowsToWrite <= pDataCols->numOfPoints &&
+  ASSERT(rowsToWrite > 0 && rowsToWrite <= pDataCols->numOfRows &&
          rowsToWrite <= pHelper->config.maxRowsPerFileBlock);
 
   SCompData *pCompData = (SCompData *)(pHelper->pBuffer);
@@ -840,7 +840,7 @@ static int tsdbWriteBlockToFile(SRWHelper *pHelper, SFile *pFile, SDataCols *pDa
   pCompBlock->last = isLast;
   pCompBlock->offset = offset;
   pCompBlock->algorithm = pHelper->config.compress;
-  pCompBlock->numOfPoints = rowsToWrite;
+  pCompBlock->numOfRows = rowsToWrite;
   pCompBlock->sversion = pHelper->tableInfo.sversion;
   pCompBlock->len = (int32_t)lsize;
   pCompBlock->numOfSubBlocks = isSuperBlock ? 1 : 0;
@@ -877,7 +877,7 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
   int        rowsWritten = 0;
   SCompBlock compBlock = {0};
 
-  ASSERT(pDataCols->numOfPoints > 0);
+  ASSERT(pDataCols->numOfRows > 0);
   TSKEY keyFirst = dataColsKeyFirst(pDataCols);
 
   SCompIdx *pIdx = pHelper->pCompIdx + pHelper->tableInfo.tid;
@@ -889,32 +889,32 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
   // ASSERT(compareKeyBlock((void *)&keyFirst, (void *)pCompBlock) == 0);
 
   if (keyFirst > blockAtIdx(pHelper, blkIdx)->keyLast) { // Merge with the last block by append
-    ASSERT(blockAtIdx(pHelper, blkIdx)->numOfPoints < pHelper->config.minRowsPerFileBlock && blkIdx == pIdx->numOfBlocks-1);
+    ASSERT(blockAtIdx(pHelper, blkIdx)->numOfRows < pHelper->config.minRowsPerFileBlock && blkIdx == pIdx->numOfBlocks-1);
     int defaultRowsToWrite = pHelper->config.maxRowsPerFileBlock * 4 / 5;  // TODO: make a interface
 
-    rowsWritten = MIN((defaultRowsToWrite - blockAtIdx(pHelper, blkIdx)->numOfPoints), pDataCols->numOfPoints);
+    rowsWritten = MIN((defaultRowsToWrite - blockAtIdx(pHelper, blkIdx)->numOfRows), pDataCols->numOfRows);
     if ((blockAtIdx(pHelper, blkIdx)->numOfSubBlocks < TSDB_MAX_SUBBLOCKS) &&
-        (blockAtIdx(pHelper, blkIdx)->numOfPoints + rowsWritten < pHelper->config.minRowsPerFileBlock) && (pHelper->files.nLastF.fd) > 0) {
+        (blockAtIdx(pHelper, blkIdx)->numOfRows + rowsWritten < pHelper->config.minRowsPerFileBlock) && (pHelper->files.nLastF.fd) > 0) {
       if (tsdbWriteBlockToFile(pHelper, &(pHelper->files.lastF), pDataCols, rowsWritten, &compBlock, true, false) < 0)
         goto _err;
       if (tsdbAddSubBlock(pHelper, &compBlock, blkIdx, rowsWritten) < 0) goto _err;
     } else {
       // Load
       if (tsdbLoadBlockData(pHelper, blockAtIdx(pHelper, blkIdx), NULL) < 0) goto _err;
-      ASSERT(pHelper->pDataCols[0]->numOfPoints == blockAtIdx(pHelper, blkIdx)->numOfPoints);
+      ASSERT(pHelper->pDataCols[0]->numOfRows == blockAtIdx(pHelper, blkIdx)->numOfRows);
       // Merge
       if (tdMergeDataCols(pHelper->pDataCols[0], pDataCols, rowsWritten) < 0) goto _err;
       // Write
       SFile *pWFile = NULL;
       bool isLast = false;
-      if (pHelper->pDataCols[0]->numOfPoints >= pHelper->config.minRowsPerFileBlock) {
+      if (pHelper->pDataCols[0]->numOfRows >= pHelper->config.minRowsPerFileBlock) {
         pWFile = &(pHelper->files.dataF);
       } else {
         isLast = true;
         pWFile = (pHelper->files.nLastF.fd > 0) ? &(pHelper->files.nLastF) : &(pHelper->files.lastF);
       }
       if (tsdbWriteBlockToFile(pHelper, pWFile, pHelper->pDataCols[0],
-                               pHelper->pDataCols[0]->numOfPoints, &compBlock, isLast, true) < 0)
+                               pHelper->pDataCols[0]->numOfRows, &compBlock, isLast, true) < 0)
         goto _err;
       if (tsdbUpdateSuperBlock(pHelper, &compBlock, blkIdx) < 0) goto _err;
     }
@@ -931,7 +931,7 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
     // rows1: number of rows must merge in this block
     int rows1 = tsdbGetRowsInRange(pDataCols, blockAtIdx(pHelper, blkIdx)->keyFirst, blockAtIdx(pHelper, blkIdx)->keyLast);
     // rows2: max nuber of rows the block can have more
-    int rows2 = pHelper->config.maxRowsPerFileBlock - blockAtIdx(pHelper, blkIdx)->numOfPoints;
+    int rows2 = pHelper->config.maxRowsPerFileBlock - blockAtIdx(pHelper, blkIdx)->numOfRows;
     // rows3: number of rows between this block and the next block
     int rows3 = tsdbGetRowsInRange(pDataCols, blockAtIdx(pHelper, blkIdx)->keyFirst, keyLimit);
 
@@ -939,7 +939,7 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
 
     if ((rows2 >= rows1) &&
         (( blockAtIdx(pHelper, blkIdx)->last) ||
-         ((rows1 + blockAtIdx(pHelper, blkIdx)->numOfPoints < pHelper->config.minRowsPerFileBlock) && (pHelper->files.nLastF.fd < 0)))) {
+         ((rows1 + blockAtIdx(pHelper, blkIdx)->numOfRows < pHelper->config.minRowsPerFileBlock) && (pHelper->files.nLastF.fd < 0)))) {
       rowsWritten = rows1;
       bool   isLast = false;
       SFile *pFile = NULL;
@@ -965,11 +965,11 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
       int round = 0;
       // tdResetDataCols(pHelper->pDataCols[1]);
       while (true) {
-        if (iter1 >= pHelper->pDataCols[0]->numOfPoints && iter2 >= rows3) break;
+        if (iter1 >= pHelper->pDataCols[0]->numOfRows && iter2 >= rows3) break;
         tdMergeTwoDataCols(pHelper->pDataCols[1], pHelper->pDataCols[0], &iter1, pDataCols, &iter2, pHelper->config.maxRowsPerFileBlock * 4 / 5);
-        ASSERT(pHelper->pDataCols[1]->numOfPoints > 0);
+        ASSERT(pHelper->pDataCols[1]->numOfRows > 0);
         if (tsdbWriteBlockToFile(pHelper, &(pHelper->files.dataF), pHelper->pDataCols[1],
-                                 pHelper->pDataCols[1]->numOfPoints, &compBlock, false, true) < 0)
+                                 pHelper->pDataCols[1]->numOfRows, &compBlock, false, true) < 0)
           goto _err;
         if (round == 0) {
           tsdbUpdateSuperBlock(pHelper, &compBlock, blkIdx);
@@ -980,17 +980,17 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
         blkIdx++;
         // TODO: the blkIdx here is not correct
 
-        // if (iter1 >= pHelper->pDataCols[0]->numOfPoints && iter2 >= rows3) {
-        //   if (pHelper->pDataCols[1]->numOfPoints > 0) {
+        // if (iter1 >= pHelper->pDataCols[0]->numOfRows && iter2 >= rows3) {
+        //   if (pHelper->pDataCols[1]->numOfRows > 0) {
         //     if (tsdbWriteBlockToFile(pHelper, &pHelper->files.dataF, pHelper->pDataCols[1],
-        //                              pHelper->pDataCols[1]->numOfPoints, &compBlock, false, true) < 0)
+        //                              pHelper->pDataCols[1]->numOfRows, &compBlock, false, true) < 0)
         //       goto _err;
         //     // TODO: the blkIdx here is not correct
-        //     tsdbAddSubBlock(pHelper, &compBlock, blkIdx, pHelper->pDataCols[1]->numOfPoints);
+        //     tsdbAddSubBlock(pHelper, &compBlock, blkIdx, pHelper->pDataCols[1]->numOfRows);
         //   }
         // }
 
-        // TSKEY key1 = iter1 >= pHelper->pDataCols[0]->numOfPoints
+        // TSKEY key1 = iter1 >= pHelper->pDataCols[0]->numOfRows
         //                  ? INT64_MAX
         //                  : ((int64_t *)(pHelper->pDataCols[0]->cols[0].pData))[iter1];
         // TSKEY key2 = iter2 >= rowsWritten ? INT64_MAX : ((int64_t *)(pDataCols->cols[0].pData))[iter2];
@@ -998,11 +998,11 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
         // if (key1 < key2) {
         //   for (int i = 0; i < pDataCols->numOfCols; i++) {
         //     SDataCol *pDataCol = pHelper->pDataCols[1]->cols + i;
-        //     memcpy(((char *)pDataCol->pData + TYPE_BYTES[pDataCol->type] * pHelper->pDataCols[1]->numOfPoints),
+        //     memcpy(((char *)pDataCol->pData + TYPE_BYTES[pDataCol->type] * pHelper->pDataCols[1]->numOfRows),
         //            ((char *)pHelper->pDataCols[0]->cols[i].pData + TYPE_BYTES[pDataCol->type] * iter1),
         //            TYPE_BYTES[pDataCol->type]);
         //   }
-        //   pHelper->pDataCols[1]->numOfPoints++;
+        //   pHelper->pDataCols[1]->numOfRows++;
         //   iter1++;
         // } else if (key1 == key2) {
         //   // TODO: think about duplicate key cases
@@ -1010,17 +1010,17 @@ static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDa
         // } else {
         //   for (int i = 0; i < pDataCols->numOfCols; i++) {
         //     SDataCol *pDataCol = pHelper->pDataCols[1]->cols + i;
-        //     memcpy(((char *)pDataCol->pData + TYPE_BYTES[pDataCol->type] * pHelper->pDataCols[1]->numOfPoints),
+        //     memcpy(((char *)pDataCol->pData + TYPE_BYTES[pDataCol->type] * pHelper->pDataCols[1]->numOfRows),
         //            ((char *)pDataCols->cols[i].pData +
         //             TYPE_BYTES[pDataCol->type] * iter2),
         //            TYPE_BYTES[pDataCol->type]);
         //   }
-        //   pHelper->pDataCols[1]->numOfPoints++;
+        //   pHelper->pDataCols[1]->numOfRows++;
         //   iter2++;
         // }
 
-        // if (pHelper->pDataCols[0]->numOfPoints >= pHelper->config.maxRowsPerFileBlock * 4 / 5) {
-        //   if (tsdbWriteBlockToFile(pHelper, &pHelper->files.dataF, pHelper->pDataCols[1], pHelper->pDataCols[1]->numOfPoints, &compBlock, false, true) < 0) goto _err;
+        // if (pHelper->pDataCols[0]->numOfRows >= pHelper->config.maxRowsPerFileBlock * 4 / 5) {
+        //   if (tsdbWriteBlockToFile(pHelper, &pHelper->files.dataF, pHelper->pDataCols[1], pHelper->pDataCols[1]->numOfRows, &compBlock, false, true) < 0) goto _err;
         //   // TODO: blkIdx here is not correct, fix it
         //   tsdbInsertSuperBlock(pHelper, &compBlock, blkIdx);
 
@@ -1133,7 +1133,7 @@ static int tsdbAddSubBlock(SRWHelper *pHelper, SCompBlock *pCompBlock, int blkId
     pSCompBlock->numOfSubBlocks++;
     ASSERT(pSCompBlock->numOfSubBlocks <= TSDB_MAX_SUBBLOCKS);
     pSCompBlock->len += sizeof(SCompBlock);
-    pSCompBlock->numOfPoints += rowsAdded;
+    pSCompBlock->numOfRows += rowsAdded;
     pSCompBlock->keyFirst = MIN(pSCompBlock->keyFirst, pCompBlock->keyFirst);
     pSCompBlock->keyLast = MAX(pSCompBlock->keyLast, pCompBlock->keyLast);
     pIdx->len += sizeof(SCompBlock);
@@ -1164,7 +1164,7 @@ static int tsdbAddSubBlock(SRWHelper *pHelper, SCompBlock *pCompBlock, int blkId
     ((SCompBlock *)ptr)[1] = *pCompBlock;
 
     pSCompBlock->numOfSubBlocks = 2;
-    pSCompBlock->numOfPoints += rowsAdded;
+    pSCompBlock->numOfRows += rowsAdded;
     pSCompBlock->offset = ((char *)ptr) - ((char *)pHelper->pCompInfo);
     pSCompBlock->len = sizeof(SCompBlock) * 2;
     pSCompBlock->keyFirst = MIN(((SCompBlock *)ptr)[0].keyFirst, ((SCompBlock *)ptr)[1].keyFirst);
@@ -1219,7 +1219,7 @@ static int tsdbUpdateSuperBlock(SRWHelper *pHelper, SCompBlock *pCompBlock, int
 
 // Get the number of rows in range [minKey, maxKey]
 static int tsdbGetRowsInRange(SDataCols *pDataCols, TSKEY minKey, TSKEY maxKey) {
-  if (pDataCols->numOfPoints == 0) return 0;
+  if (pDataCols->numOfRows == 0) return 0;
 
   ASSERT(minKey <= maxKey);
   TSKEY keyFirst = dataColsKeyFirst(pDataCols);
@@ -1228,11 +1228,11 @@ static int tsdbGetRowsInRange(SDataCols *pDataCols, TSKEY minKey, TSKEY maxKey)
 
   if (minKey > keyLast || maxKey < keyFirst) return 0;
 
-  void *ptr1 = taosbsearch((void *)&minKey, (void *)pDataCols->cols[0].pData, pDataCols->numOfPoints, sizeof(TSKEY),
+  void *ptr1 = taosbsearch((void *)&minKey, (void *)pDataCols->cols[0].pData, pDataCols->numOfRows, sizeof(TSKEY),
                            compTSKEY, TD_GE);
   ASSERT(ptr1 != NULL);
 
-  void *ptr2 = taosbsearch((void *)&maxKey, (void *)pDataCols->cols[0].pData, pDataCols->numOfPoints, sizeof(TSKEY),
+  void *ptr2 = taosbsearch((void *)&maxKey, (void *)pDataCols->cols[0].pData, pDataCols->numOfRows, sizeof(TSKEY),
                            compTSKEY, TD_LE);
   ASSERT(ptr2 != NULL);
 
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 7a70312259..0e70ab2d7e 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -436,7 +436,7 @@ static SDataBlockInfo getTrueDataBlockInfo(STableCheckInfo* pCheckInfo, SCompBlo
   SDataBlockInfo info = {
       .window = {.skey = pBlock->keyFirst, .ekey = pBlock->keyLast},
       .numOfCols = pBlock->numOfCols,
-      .rows = pBlock->numOfPoints,
+      .rows = pBlock->numOfRows,
       .tid = pCheckInfo->tableId.tid,
       .uid = pCheckInfo->tableId.uid,
   };
@@ -608,11 +608,11 @@ static bool loadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock
       }
   
       SDataCols* pTSCol = pQueryHandle->rhelper.pDataCols[0];
-      assert(pTSCol->cols->type == TSDB_DATA_TYPE_TIMESTAMP && pTSCol->numOfPoints == pBlock->numOfPoints);
+      assert(pTSCol->cols->type == TSDB_DATA_TYPE_TIMESTAMP && pTSCol->numOfRows == pBlock->numOfRows);
       
       if (pCheckInfo->lastKey > pBlock->keyFirst) {
         cur->pos =
-            binarySearchForKey(pTSCol->cols[0].pData, pBlock->numOfPoints, pCheckInfo->lastKey, pQueryHandle->order);
+            binarySearchForKey(pTSCol->cols[0].pData, pBlock->numOfRows, pCheckInfo->lastKey, pQueryHandle->order);
       } else {
         cur->pos = 0;
       }
@@ -630,9 +630,9 @@ static bool loadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock
       SDataCols* pDataCols = pCheckInfo->pDataCols;
       if (pCheckInfo->lastKey < pBlock->keyLast) {
         cur->pos =
-            binarySearchForKey(pDataCols->cols[0].pData, pBlock->numOfPoints, pCheckInfo->lastKey, pQueryHandle->order);
+            binarySearchForKey(pDataCols->cols[0].pData, pBlock->numOfRows, pCheckInfo->lastKey, pQueryHandle->order);
       } else {
-        cur->pos = pBlock->numOfPoints - 1;
+        cur->pos = pBlock->numOfRows - 1;
       }
       
       doMergeTwoLevelData(pQueryHandle, pCheckInfo, pBlock, sa);
@@ -647,7 +647,7 @@ static bool loadFileDataBlock(STsdbQueryHandle* pQueryHandle, SCompBlock* pBlock
 
 static int vnodeBinarySearchKey(char* pValue, int num, TSKEY key, int order) {
   int    firstPos, lastPos, midPos = -1;
-  int    numOfPoints;
+  int    numOfRows;
   TSKEY* keyList;
 
   assert(order == TSDB_ORDER_ASC || order == TSDB_ORDER_DESC);
@@ -665,8 +665,8 @@ static int vnodeBinarySearchKey(char* pValue, int num, TSKEY key, int order) {
       if (key == keyList[firstPos]) return firstPos;
       if (key < keyList[firstPos]) return firstPos - 1;
 
-      numOfPoints = lastPos - firstPos + 1;
-      midPos = (numOfPoints >> 1) + firstPos;
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
 
       if (key < keyList[midPos]) {
         lastPos = midPos - 1;
@@ -691,8 +691,8 @@ static int vnodeBinarySearchKey(char* pValue, int num, TSKEY key, int order) {
           return lastPos;
       }
 
-      numOfPoints = lastPos - firstPos + 1;
-      midPos = (numOfPoints >> 1) + firstPos;
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
 
       if (key < keyList[midPos]) {
         lastPos = midPos - 1;
@@ -810,7 +810,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
     cur->mixBlock = (cur->pos != blockInfo.rows - 1);
   } else {
     int32_t order = (pQueryHandle->order == TSDB_ORDER_ASC)? TSDB_ORDER_DESC:TSDB_ORDER_ASC;
-    endPos = vnodeBinarySearchKey(pCols->cols[0].pData, pCols->numOfPoints, pQueryHandle->window.ekey, order);
+    endPos = vnodeBinarySearchKey(pCols->cols[0].pData, pCols->numOfRows, pQueryHandle->window.ekey, order);
     cur->mixBlock = true;
   }
   
@@ -904,7 +904,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
         }
 
         int32_t order = ASCENDING_TRAVERSE(pQueryHandle->order) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC;
-        int32_t end = vnodeBinarySearchKey(pCols->cols[0].pData, pCols->numOfPoints, key, order);
+        int32_t end = vnodeBinarySearchKey(pCols->cols[0].pData, pCols->numOfRows, key, order);
         if (tsArray[end] == key) { // the value of key in cache equals to the end timestamp value, ignore it
           tSkipListIterNext(pCheckInfo->iter);
         }
@@ -1002,7 +1002,7 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
 
 int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order) {
   int    firstPos, lastPos, midPos = -1;
-  int    numOfPoints;
+  int    numOfRows;
   TSKEY* keyList;
 
   if (num <= 0) return -1;
@@ -1018,8 +1018,8 @@ int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order) {
       if (key == keyList[firstPos]) return firstPos;
       if (key < keyList[firstPos]) return firstPos - 1;
 
-      numOfPoints = lastPos - firstPos + 1;
-      midPos = (numOfPoints >> 1) + firstPos;
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
 
       if (key < keyList[midPos]) {
         lastPos = midPos - 1;
@@ -1044,8 +1044,8 @@ int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order) {
           return lastPos;
       }
 
-      numOfPoints = lastPos - firstPos + 1;
-      midPos = (numOfPoints >> 1) + firstPos;
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
 
       if (key < keyList[midPos]) {
         lastPos = midPos - 1;
@@ -1066,7 +1066,6 @@ static void cleanBlockOrderSupporter(SBlockOrderSupporter* pSupporter, int32_t n
 
   for (int32_t i = 0; i < numOfTables; ++i) {
     STableBlockInfo* pBlockInfo = pSupporter->pDataBlockInfo[i];
-//    tfree(pBlockInfo->statis);
     tfree(pBlockInfo);
   }
 
@@ -1539,9 +1538,19 @@ int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT* pQueryHandle, SDataSta
   STableBlockInfo* pBlockInfo = &pHandle->pDataBlockInfo[cur->slot];
   tsdbLoadCompData(&pHandle->rhelper, pBlockInfo->compBlock, NULL);
   
-  tsdbGetDataStatis(&pHandle->rhelper, pHandle->statis, QH_GET_NUM_OF_COLS(pHandle));
+  size_t numOfCols = QH_GET_NUM_OF_COLS(pHandle);
+  memset(pHandle->statis, 0, sizeof(SDataStatis) * numOfCols);
+  tsdbGetDataStatis(&pHandle->rhelper, pHandle->statis, numOfCols);
+  
   *pBlockStatis = pHandle->statis;
   
+  //update the number of NULL data rows
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    if (pHandle->statis[i].numOfNull == -1) {
+      pHandle->statis[i].numOfNull = pBlockInfo->compBlock->numOfRows;
+    }
+  }
+  
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1575,7 +1584,7 @@ SArray* tsdbRetrieveDataBlock(TsdbQueryHandleT* pQueryHandle, SArray* pIdList) {
         doLoadFileDataBlock(pHandle, pBlock, pCheckInfo);
   
         // todo refactor
-        int32_t numOfRows = copyDataFromFileBlock(pHandle, pHandle->outputCapacity, 0, 0, pBlock->numOfPoints - 1);
+        int32_t numOfRows = copyDataFromFileBlock(pHandle, pHandle->outputCapacity, 0, 0, pBlock->numOfRows - 1);
   
         // if the buffer is not full in case of descending order query, move the data in the front of the buffer
         if (!ASCENDING_TRAVERSE(pHandle->order) && numOfRows < pHandle->outputCapacity) {

From 9560f319b24021769c0c569786c22134f22433ce Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sdsang@taosdata.com>
Date: Mon, 25 May 2020 16:12:49 +0800
Subject: [PATCH 20/27] add insert/sparseData.py to test compressing sparse
 file content.

[TD-412]
---
 tests/pytest/insert/randomNullCommit.py |  14 +-
 tests/pytest/insert/sparseData.py       |  67 ++++
 tests/pytest/random-test/random-test.py |   1 +
 tests/pytest/table/boundary.py          |   8 +-
 tests/pytest/tag_lite/3.py              | 206 +++++------
 tests/pytest/tag_lite/4.py              | 290 ++++++++--------
 tests/pytest/tag_lite/5.py              | 342 +++++++++---------
 tests/pytest/tag_lite/6.py              | 410 +++++++++++-----------
 tests/pytest/tag_lite/add.py            | 292 ++++++++--------
 tests/pytest/tag_lite/bigint.py         |  86 ++---
 tests/pytest/tag_lite/binary.py         |  86 ++---
 tests/pytest/tag_lite/binary_binary.py  | 114 +++---
 tests/pytest/tag_lite/bool.py           |  84 ++---
 tests/pytest/tag_lite/bool_binary.py    | 114 +++---
 tests/pytest/tag_lite/bool_int.py       | 122 +++----
 tests/pytest/tag_lite/change.py         | 194 +++++------
 tests/pytest/tag_lite/column.py         |  10 +-
 tests/pytest/tag_lite/commit.py         | 444 ++++++++++++------------
 tests/pytest/tag_lite/create.py         | 182 +++++-----
 tests/pytest/tag_lite/delete.py         | 286 +++++++--------
 tests/pytest/tag_lite/double.py         |  86 ++---
 tests/pytest/tag_lite/filter.py         |  18 +-
 tests/pytest/tag_lite/float.py          |  86 ++---
 tests/pytest/tag_lite/int.py            |  86 ++---
 tests/pytest/tag_lite/int_binary.py     | 114 +++---
 tests/pytest/tag_lite/int_float.py      | 122 +++----
 tests/pytest/tag_lite/set.py            | 204 +++++------
 tests/pytest/tag_lite/smallint.py       |  86 ++---
 tests/pytest/tag_lite/tinyint.py        |  86 ++---
 tests/pytest/util/dnodes.py             |  17 +
 30 files changed, 2174 insertions(+), 2083 deletions(-)
 create mode 100644 tests/pytest/insert/sparseData.py

diff --git a/tests/pytest/insert/randomNullCommit.py b/tests/pytest/insert/randomNullCommit.py
index f90bb9b3e5..ecacd20daf 100644
--- a/tests/pytest/insert/randomNullCommit.py
+++ b/tests/pytest/insert/randomNullCommit.py
@@ -29,7 +29,8 @@ class TDTestCase:
         tdSql.prepare()
 
         tdLog.info("=============== step1")
-        tdSql.execute('create table tb (ts timestamp, speed int, temp float, note binary(5), flag bool)')
+        tdSql.execute(
+            'create table tb (ts timestamp, speed int, temp float, note binary(5), flag bool)')
 
         numOfRecords = 0
         randomList = [10, 50, 100, 500, 1000, 5000]
@@ -38,23 +39,24 @@ class TDTestCase:
             tdLog.info("will insert %d records" % num)
             for x in range(0, num):
                 tdLog.info(
-                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' % x)
+                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' %
+                    x)
                 tdSql.execute(
-                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' % x)
+                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' %
+                    x)
 
             numOfRecords = numOfRecords + num
 
             tdSql.query("select * from tb")
             tdSql.checkRows(numOfRecords)
-            tdSql.checkData(numOfRecords-num, 1, None)
-            tdSql.checkData(numOfRecords-1, 2, None)
+            tdSql.checkData(numOfRecords - num, 1, None)
+            tdSql.checkData(numOfRecords - 1, 2, None)
 
             tdLog.info("stop dnode to commit data to disk")
             tdDnodes.stop(1)
             tdDnodes.start(1)
             tdLog.sleep(5)
 
-
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/pytest/insert/sparseData.py b/tests/pytest/insert/sparseData.py
new file mode 100644
index 0000000000..38b04b339e
--- /dev/null
+++ b/tests/pytest/insert/sparseData.py
@@ -0,0 +1,67 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.prepare()
+
+        tdLog.info("=============== step1")
+        tdSql.execute(
+            'create table tb (ts timestamp, speed int, temp float, note binary(4000), flag bool)')
+
+        numOfRecords = 1000000
+        dividend = 1000
+        tdLog.info("will insert %d records" % numOfRecords)
+
+        ts = 1500000000000
+        for i in range(0, numOfRecords):
+
+            if (i % dividend):
+                print(".", end="")
+                tdSql.execute(
+                    'insert into tb values (%d + %da, NULL, NULL, NULL, TRUE)' %
+                    (ts, i))
+            else:
+                print("a", end="")
+                tdSql.execute(
+                    'insert into tb values (%d + %da, NULL, NULL, "a", FALSE)' %
+                    (ts, i))
+
+        tdSql.query("select * from tb")
+        tdSql.checkRows(numOfRecords)
+        tdSql.checkData(numOfRecords - dividend, 3, 'a')
+        tdSql.checkData(numOfRecords - dividend - 1, 3, None)
+
+        tdLog.info("stop dnode to commit data to disk")
+        tdDnodes.stop(1)
+        tdLog.info("dnodes:%d size is %d" % (1, tdDnodes.getDataSize(1)))
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/random-test/random-test.py b/tests/pytest/random-test/random-test.py
index 4e1e6ac2fa..596f33264f 100644
--- a/tests/pytest/random-test/random-test.py
+++ b/tests/pytest/random-test/random-test.py
@@ -121,6 +121,7 @@ class Test:
         tdDnodes.start(1)
         tdSql.prepare()
 
+
 class TDTestCase:
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)
diff --git a/tests/pytest/table/boundary.py b/tests/pytest/table/boundary.py
index 29fdd5c475..bb5e187f0d 100644
--- a/tests/pytest/table/boundary.py
+++ b/tests/pytest/table/boundary.py
@@ -98,12 +98,16 @@ class TDTestCase:
         # create a super table with name exceed max length
         sname = self.generateString(maxTableNameLen + 1)
         tdLog.info("create a super table with length %d" % len(sname))
-        tdSql.error("create table %s (ts timestamp, value int) tags(id int)" % sname)
+        tdSql.error(
+            "create table %s (ts timestamp, value int) tags(id int)" %
+            sname)
 
         # create a super table with name of max length
         sname = self.generateString(maxTableNameLen)
         tdLog.info("create a super table with length %d" % len(sname))
-        tdSql.execute("create table %s (ts timestamp, value int) tags(id int)" % sname)
+        tdSql.execute(
+            "create table %s (ts timestamp, value int) tags(id int)" %
+            sname)
         tdLog.info("check table count, should be one")
         tdSql.query('show stables')
         tdSql.checkRows(1)
diff --git a/tests/pytest/tag_lite/3.py b/tests/pytest/tag_lite/3.py
index 68d2e6c5ba..373db1c70f 100644
--- a/tests/pytest/tag_lite/3.py
+++ b/tests/pytest/tag_lite/3.py
@@ -69,9 +69,9 @@ class TDTestCase:
                     "insert into %s values (now + %s, %d)" %
                     (tb, ms, x))
                 x = x + 1
-        #TSIM: endw
+        # TSIM: endw
             i = i + 1
-        #TSIM: endw
+        # TSIM: endw
         while (i < 10):
             tb = "%s%d" % (tbPrefix, i)
         # TSIM: sql create table $tb using %s tags( 1, 1, 1 )
@@ -89,9 +89,9 @@ class TDTestCase:
                     "insert into %s values (now + %s, %d)" %
                     (tb, ms, x))
                 x = x + 1
-        #TSIM: endw
+        # TSIM: endw
             i = i + 1
-        #TSIM: endw
+        # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -102,7 +102,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(%d)' % totalNum)
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from %s where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % mt)
@@ -111,7 +111,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % mt)
         tdSql.query('select * from %s where ts > now + 4m' % mt)
@@ -119,7 +119,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % mt)
         tdSql.query('select * from %s where ts = now + 4m' % mt)
@@ -127,7 +127,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -138,7 +138,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -149,14 +149,14 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % mt)
         tdSql.query('select * from %s where tgcol1 <> 0' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % mt)
         tdSql.query('select * from %s where tgcol1 = 1' % mt)
@@ -164,35 +164,35 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % mt)
         tdSql.query('select * from %s where tgcol1 <> 1' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 = true
         tdLog.info('select * from %s where tgcol1 = true' % mt)
         tdSql.query('select * from %s where tgcol1 = true' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> true
         tdLog.info('select * from %s where tgcol1 <> true' % mt)
         tdSql.query('select * from %s where tgcol1 <> true' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 = false
         tdLog.info('select * from %s where tgcol1 = false' % mt)
         tdSql.query('select * from %s where tgcol1 = false' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> false
         tdLog.info('select * from %s where tgcol1 <> false' % mt)
         tdSql.query('select * from %s where tgcol1 <> false' % mt)
@@ -200,7 +200,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -210,28 +210,28 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol2 <> 0
         tdLog.info('select * from %s where tgcol2 <> 0' % mt)
         tdSql.query('select * from %s where tgcol2 <> 0' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol2 = 1
         tdLog.info('select * from %s where tgcol2 = 1' % mt)
         tdSql.query('select * from %s where tgcol2 = 1' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % mt)
         tdSql.query('select * from %s where tgcol2 <> 1' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -242,28 +242,28 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol3 <> 0
         tdLog.info('select * from %s where tgcol3 <> 0' % mt)
         tdSql.query('select * from %s where tgcol3 <> 0' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol3 = 1
         tdLog.info('select * from %s where tgcol3 = 1' % mt)
         tdSql.query('select * from %s where tgcol3 = 1' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol3 <> 1
         tdLog.info('select * from %s where tgcol3 <> 1' % mt)
         tdSql.query('select * from %s where tgcol3 <> 1' % mt)
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -277,7 +277,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> true
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol1 <> true' %
@@ -288,7 +288,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 = false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol1 = false' %
@@ -299,7 +299,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 <> false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol1 <> false' %
@@ -310,7 +310,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 = false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 = false' %
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 <> false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 <> false' %
@@ -332,7 +332,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> false
         tdLog.info(
@@ -344,7 +344,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> false
         # and ts < now + 5m
         tdLog.info(
@@ -357,7 +357,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -368,7 +368,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 1
         tdLog.info('select * from %s where ts > now + 4m and tgcol2 <> 1' % mt)
         tdSql.query(
@@ -378,7 +378,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol2 = 0' % mt)
         tdSql.query('select * from %s where ts < now + 4m and tgcol2 = 0' % mt)
@@ -386,7 +386,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 <> 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol2 <> 0' % mt)
         tdSql.query(
@@ -396,7 +396,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 = 0
         tdLog.info('select * from %s where ts <= now + 4m and tgcol2 = 0' % mt)
         tdSql.query(
@@ -406,7 +406,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> 0' %
@@ -418,7 +418,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0
         tdLog.info(
@@ -431,7 +431,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -455,7 +455,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1
         tdLog.info('select * from %s where ts > now + 4m and tgcol3 <> 1' % mt)
         tdSql.query(
@@ -465,7 +465,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol3 = 0' % mt)
         tdSql.query('select * from %s where ts < now + 4m and tgcol3 = 0' % mt)
@@ -473,7 +473,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol3 <> 0' % mt)
         tdSql.query(
@@ -483,7 +483,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0
         tdLog.info('select * from %s where ts <= now + 4m and tgcol3 = 0' % mt)
         tdSql.query(
@@ -493,7 +493,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol3 <> 0' %
@@ -505,7 +505,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0
         tdLog.info(
@@ -518,7 +518,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -531,7 +531,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -547,7 +547,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 1 and
         # tgcol1 <> true
         tdLog.info(
@@ -560,7 +560,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 = 0 and
         # tgcol1 = false
         tdLog.info(
@@ -573,7 +573,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 <> 0 and
         # tgcol1 <> false
         tdLog.info(
@@ -586,7 +586,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 = 0 and
         # tgcol1 = false
         tdLog.info(
@@ -599,7 +599,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 <> 0 and
         # tgcol1 <> false
         tdLog.info(
@@ -612,7 +612,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0 and tgcol1 <> false
         tdLog.info(
@@ -625,7 +625,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol1 <> false
         tdLog.info(
@@ -638,7 +638,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -654,7 +654,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1 and
         # tgcol1 <> true
         tdLog.info(
@@ -667,7 +667,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0 and
         # tgcol1 = false
         tdLog.info(
@@ -680,7 +680,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0 and
         # tgcol1 <> false
         tdLog.info(
@@ -693,7 +693,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0 and
         # tgcol1 = false
         tdLog.info(
@@ -706,7 +706,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol1 <> false
         tdLog.info(
@@ -719,7 +719,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol1 <> false
         tdLog.info(
@@ -732,7 +732,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol1 <> false
         tdLog.info(
@@ -745,7 +745,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -761,7 +761,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1 and
         # tgcol2 <> 1
         tdLog.info(
@@ -774,7 +774,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -787,7 +787,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -800,7 +800,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -813,7 +813,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -826,7 +826,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol2 <> 0
         tdLog.info(
@@ -839,7 +839,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol2 <> 0
         tdLog.info(
@@ -852,7 +852,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -868,7 +868,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -881,7 +881,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -894,7 +894,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -907,7 +907,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -920,7 +920,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -933,7 +933,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -946,7 +946,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -959,7 +959,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -977,7 +977,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -995,7 +995,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = true and
@@ -1012,7 +1012,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = true and
@@ -1029,7 +1029,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
@@ -1047,7 +1047,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1064,7 +1064,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1081,7 +1081,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1096,7 +1096,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step16
         tdLog.info('=============== step16')
@@ -1114,7 +1114,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s group by tgcol2
@@ -1130,7 +1130,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s group by tgcol3
@@ -1146,7 +1146,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step17
         tdLog.info('=============== step17')
@@ -1165,7 +1165,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = true and
@@ -1182,7 +1182,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = true and
@@ -1199,7 +1199,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step18
         tdLog.info('=============== step18')
@@ -1218,7 +1218,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1235,7 +1235,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1250,7 +1250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1263,7 +1263,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step19
         tdLog.info('=============== step19')
@@ -1278,7 +1278,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = true and
@@ -1291,7 +1291,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = true and
@@ -1304,7 +1304,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -1318,7 +1318,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/4.py b/tests/pytest/tag_lite/4.py
index 66641f9dfe..aae930ecdf 100644
--- a/tests/pytest/tag_lite/4.py
+++ b/tests/pytest/tag_lite/4.py
@@ -73,9 +73,9 @@ class TDTestCase:
                     "insert into %s values (now + %s, %d)" %
                     (tb, ms, x))
                 x = x + 1
-        #TSIM: endw
+        # TSIM: endw
             i = i + 1
-        #TSIM: endw
+        # TSIM: endw
         while (i < 10):
             tb = "%s%d" % (tbPrefix, i)
         # TSIM: sql create table $tb using %s tags( 1, 1, 1, 1 )
@@ -96,9 +96,9 @@ class TDTestCase:
                     "insert into %s values (now + %s, %d)" %
                     (tb, ms, x))
                 x = x + 1
-        #TSIM: endw
+        # TSIM: endw
             i = i + 1
-        #TSIM: endw
+        # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -109,7 +109,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from %s where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % mt)
@@ -118,7 +118,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % mt)
         tdSql.query('select * from %s where ts > now + 4m' % mt)
@@ -126,7 +126,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % mt)
         tdSql.query('select * from %s where ts = now + 4m' % mt)
@@ -134,7 +134,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -146,7 +146,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -157,7 +157,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % mt)
         tdSql.query('select * from %s where tgcol1 <> 0' % mt)
@@ -165,7 +165,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % mt)
         tdSql.query('select * from %s where tgcol1 = 1' % mt)
@@ -173,7 +173,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % mt)
         tdSql.query('select * from %s where tgcol1 <> 1' % mt)
@@ -181,7 +181,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % mt)
         tdSql.query('select * from %s where tgcol1 = 1' % mt)
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % mt)
         tdSql.query('select * from %s where tgcol1 <> 1' % mt)
@@ -197,7 +197,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 = 0
         tdLog.info('select * from %s where tgcol1 = 0' % mt)
         tdSql.query('select * from %s where tgcol1 = 0' % mt)
@@ -205,7 +205,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % mt)
         tdSql.query('select * from %s where tgcol1 <> 0' % mt)
@@ -213,7 +213,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -224,7 +224,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol2 <> 0
         tdLog.info('select * from %s where tgcol2 <> 0' % mt)
         tdSql.query('select * from %s where tgcol2 <> 0' % mt)
@@ -232,7 +232,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol2 = 1
         tdLog.info('select * from %s where tgcol2 = 1' % mt)
         tdSql.query('select * from %s where tgcol2 = 1' % mt)
@@ -240,7 +240,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % mt)
         tdSql.query('select * from %s where tgcol2 <> 1' % mt)
@@ -248,7 +248,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -259,7 +259,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol3 <> 0
         tdLog.info('select * from %s where tgcol3 <> 0' % mt)
         tdSql.query('select * from %s where tgcol3 <> 0' % mt)
@@ -267,7 +267,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol3 = 1
         tdLog.info('select * from %s where tgcol3 = 1' % mt)
         tdSql.query('select * from %s where tgcol3 = 1' % mt)
@@ -275,7 +275,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol3 <> 1
         tdLog.info('select * from %s where tgcol3 <> 1' % mt)
         tdSql.query('select * from %s where tgcol3 <> 1' % mt)
@@ -283,7 +283,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -294,7 +294,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol4 <> 0
         tdLog.info('select * from %s where tgcol4 <> 0' % mt)
         tdSql.query('select * from %s where tgcol4 <> 0' % mt)
@@ -302,7 +302,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol4 = 1
         tdLog.info('select * from %s where tgcol4 = 1' % mt)
         tdSql.query('select * from %s where tgcol4 = 1' % mt)
@@ -310,7 +310,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where tgcol4 <> 1
         tdLog.info('select * from %s where tgcol4 <> 1' % mt)
         tdSql.query('select * from %s where tgcol4 <> 1' % mt)
@@ -318,7 +318,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> 1
         tdLog.info('select * from %s where ts > now + 4m and tgcol1 <> 1' % mt)
         tdSql.query(
@@ -339,7 +339,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol1 = 0' % mt)
         tdSql.query('select * from %s where ts < now + 4m and tgcol1 = 0' % mt)
@@ -347,7 +347,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 <> 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol1 <> 0' % mt)
         tdSql.query(
@@ -357,7 +357,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 = 0
         tdLog.info('select * from %s where ts <= now + 4m and tgcol1 = 0' % mt)
         tdSql.query(
@@ -367,7 +367,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 <> 0' %
@@ -379,7 +379,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0
         tdLog.info(
@@ -392,7 +392,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -405,7 +405,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -416,7 +416,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 1
         tdLog.info('select * from %s where ts > now + 4m and tgcol2 <> 1' % mt)
         tdSql.query(
@@ -426,7 +426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol2 = 0' % mt)
         tdSql.query('select * from %s where ts < now + 4m and tgcol2 = 0' % mt)
@@ -434,7 +434,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 <> 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol2 <> 0' % mt)
         tdSql.query(
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 = 0
         tdLog.info('select * from %s where ts <= now + 4m and tgcol2 = 0' % mt)
         tdSql.query(
@@ -454,7 +454,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> 0' %
@@ -466,7 +466,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0
         tdLog.info(
@@ -479,7 +479,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -492,7 +492,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -503,7 +503,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1
         tdLog.info('select * from %s where ts > now + 4m and tgcol3 <> 1' % mt)
         tdSql.query(
@@ -513,7 +513,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol3 = 0' % mt)
         tdSql.query('select * from %s where ts < now + 4m and tgcol3 = 0' % mt)
@@ -521,7 +521,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol3 <> 0' % mt)
         tdSql.query(
@@ -531,7 +531,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0
         tdLog.info('select * from %s where ts <= now + 4m and tgcol3 = 0' % mt)
         tdSql.query(
@@ -541,7 +541,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol3 <> 0' %
@@ -553,7 +553,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0
         tdLog.info(
@@ -566,7 +566,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -579,7 +579,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -590,7 +590,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol4 <> 1
         tdLog.info('select * from %s where ts > now + 4m and tgcol4 <> 1' % mt)
         tdSql.query(
@@ -600,7 +600,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol4 = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol4 = 0' % mt)
         tdSql.query('select * from %s where ts < now + 4m and tgcol4 = 0' % mt)
@@ -608,7 +608,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol4 <> 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol4 <> 0' % mt)
         tdSql.query(
@@ -618,7 +618,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol4 = 0
         tdLog.info('select * from %s where ts <= now + 4m and tgcol4 = 0' % mt)
         tdSql.query(
@@ -628,7 +628,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol4 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol4 <> 0' %
@@ -640,7 +640,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0
         tdLog.info(
@@ -653,7 +653,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol4 <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -666,7 +666,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -682,7 +682,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 1 and
         # tgcol1 <> 1
         tdLog.info(
@@ -695,7 +695,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -708,7 +708,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol2 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -721,7 +721,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -734,7 +734,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol2 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -747,7 +747,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -760,7 +760,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol2 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol1 <> 0
         tdLog.info(
@@ -773,7 +773,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -789,7 +789,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1 and
         # tgcol1 <> 1
         tdLog.info(
@@ -802,7 +802,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -815,7 +815,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -828,7 +828,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -841,7 +841,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -854,7 +854,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -867,7 +867,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol1 <> 0
         tdLog.info(
@@ -880,7 +880,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -896,7 +896,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1 and
         # tgcol2 <> 1
         tdLog.info(
@@ -909,7 +909,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -922,7 +922,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -935,7 +935,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -948,7 +948,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -961,7 +961,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol2 <> 0
         tdLog.info(
@@ -974,7 +974,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol2 <> 0
         tdLog.info(
@@ -987,7 +987,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -1003,7 +1003,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 1 and
         # tgcol4 <> 1
         tdLog.info(
@@ -1016,7 +1016,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1029,7 +1029,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol3 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1042,7 +1042,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1055,7 +1055,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1068,7 +1068,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol4 <> 0
         tdLog.info(
@@ -1081,7 +1081,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol3 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol4 <> 0
         tdLog.info(
@@ -1094,7 +1094,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
@@ -1110,7 +1110,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -1123,7 +1123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1136,7 +1136,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1149,7 +1149,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1162,7 +1162,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1175,7 +1175,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1188,7 +1188,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol1 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1201,7 +1201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step16
         tdLog.info('=============== step16')
@@ -1217,7 +1217,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -1230,7 +1230,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1243,7 +1243,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1256,7 +1256,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1269,7 +1269,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1282,7 +1282,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1295,7 +1295,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol4 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1308,7 +1308,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step17
         tdLog.info('=============== step17')
@@ -1324,7 +1324,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1 and tgcol1 <> 1
         tdLog.info(
@@ -1337,7 +1337,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0
         tdLog.info(
@@ -1350,7 +1350,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1363,7 +1363,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0
         tdLog.info(
@@ -1376,7 +1376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1389,7 +1389,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1402,7 +1402,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from %s where ts > now + 4m and tgcol4 <> 0 and ts
         # < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0 and
         # tgcol1 <> 0
@@ -1416,7 +1416,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step18
         tdLog.info('=============== step18')
@@ -1434,7 +1434,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step19
         tdLog.info('=============== step19')
@@ -1452,7 +1452,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1469,7 +1469,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1486,7 +1486,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1503,7 +1503,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step20
         tdLog.info('=============== step20')
@@ -1521,7 +1521,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1538,7 +1538,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1555,7 +1555,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1572,7 +1572,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1585,7 +1585,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step21
         tdLog.info('=============== step21')
@@ -1603,7 +1603,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s group by tgcol2
@@ -1619,7 +1619,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s group by tgcol3
@@ -1635,7 +1635,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s group by tgcol4
@@ -1651,7 +1651,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step22
         tdLog.info('=============== step22')
@@ -1670,7 +1670,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1687,7 +1687,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1704,7 +1704,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1717,7 +1717,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step23
         tdLog.info('=============== step23')
@@ -1736,7 +1736,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1753,7 +1753,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1768,7 +1768,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1781,7 +1781,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where ts < now + 4m and
@@ -1795,7 +1795,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step24
         tdLog.info('=============== step24')
@@ -1810,7 +1810,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1823,7 +1823,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1836,7 +1836,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from %s where tgcol1 = 1 and
@@ -1849,7 +1849,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -1863,7 +1863,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/5.py b/tests/pytest/tag_lite/5.py
index 6e94e692cd..b3608bebee 100644
--- a/tests/pytest/tag_lite/5.py
+++ b/tests/pytest/tag_lite/5.py
@@ -86,10 +86,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             tb = "%s%d" % (tbPrefix, i)
@@ -115,10 +115,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -129,7 +129,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -138,7 +138,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -146,7 +146,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -154,7 +154,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -166,7 +166,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -177,7 +177,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 0' % (mt))
@@ -185,7 +185,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % (mt))
         tdSql.query('select * from %s where tgcol1 = 1' % (mt))
@@ -193,7 +193,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 1' % (mt))
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % (mt))
         tdSql.query('select * from %s where tgcol1 = 1' % (mt))
@@ -209,7 +209,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 1' % (mt))
@@ -217,7 +217,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 = 0
         tdLog.info('select * from %s where tgcol1 = 0' % (mt))
         tdSql.query('select * from %s where tgcol1 = 0' % (mt))
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 0' % (mt))
@@ -233,7 +233,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -244,7 +244,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 0
         tdLog.info('select * from %s where tgcol2 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 0' % (mt))
@@ -252,7 +252,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 1
         tdLog.info('select * from %s where tgcol2 = 1' % (mt))
         tdSql.query('select * from %s where tgcol2 = 1' % (mt))
@@ -260,7 +260,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 1' % (mt))
@@ -268,7 +268,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -279,7 +279,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 <> 0
         tdLog.info('select * from %s where tgcol3 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol3 <> 0' % (mt))
@@ -287,7 +287,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 = 1
         tdLog.info('select * from %s where tgcol3 = 1' % (mt))
         tdSql.query('select * from %s where tgcol3 = 1' % (mt))
@@ -295,7 +295,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 <> 1
         tdLog.info('select * from %s where tgcol3 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol3 <> 1' % (mt))
@@ -303,7 +303,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -314,7 +314,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 <> 0
         tdLog.info('select * from %s where tgcol4 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol4 <> 0' % (mt))
@@ -322,7 +322,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 = 1
         tdLog.info('select * from %s where tgcol4 = 1' % (mt))
         tdSql.query('select * from %s where tgcol4 = 1' % (mt))
@@ -330,7 +330,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 <> 1
         tdLog.info('select * from %s where tgcol4 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol4 <> 1' % (mt))
@@ -338,7 +338,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -349,7 +349,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 <> 0
         tdLog.info('select * from %s where tgcol5 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol5 <> 0' % (mt))
@@ -357,7 +357,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 = 1
         tdLog.info('select * from %s where tgcol5 = 1' % (mt))
         tdSql.query('select * from %s where tgcol5 = 1' % (mt))
@@ -365,7 +365,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 <> 1
         tdLog.info('select * from %s where tgcol5 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol5 <> 1' % (mt))
@@ -373,7 +373,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -388,7 +388,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol1 <> 1' %
@@ -400,7 +400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol1 = 0' %
@@ -412,7 +412,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol1 <> 0' %
@@ -424,7 +424,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 = 0' %
@@ -436,7 +436,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 <> 0' %
@@ -448,7 +448,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0
         tdLog.info(
@@ -461,7 +461,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -474,7 +474,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -489,7 +489,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> 1' %
@@ -501,7 +501,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = 0' %
@@ -513,7 +513,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> 0' %
@@ -525,7 +525,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = 0' %
@@ -537,7 +537,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> 0' %
@@ -549,7 +549,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0
         tdLog.info(
@@ -562,7 +562,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -575,7 +575,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -590,7 +590,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol3 <> 1' %
@@ -602,7 +602,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol3 = 0' %
@@ -614,7 +614,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol3 <> 0' %
@@ -626,7 +626,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol3 = 0' %
@@ -638,7 +638,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol3 <> 0' %
@@ -650,7 +650,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0
         tdLog.info(
@@ -663,7 +663,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -676,7 +676,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -691,7 +691,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol4 <> 1' %
@@ -703,7 +703,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol4 = 0' %
@@ -715,7 +715,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol4 <> 0' %
@@ -727,7 +727,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol4 = 0' %
@@ -739,7 +739,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol4 <> 0' %
@@ -751,7 +751,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0
         tdLog.info(
@@ -764,7 +764,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -777,7 +777,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -792,7 +792,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol5 <> 1' %
@@ -804,7 +804,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol5 = 0' %
@@ -816,7 +816,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol5 <> 0' %
@@ -828,7 +828,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol5 = 0' %
@@ -840,7 +840,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol5 <> 0' %
@@ -852,7 +852,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol5 <> 0
         tdLog.info(
@@ -865,7 +865,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -878,7 +878,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -894,7 +894,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1 and
         # tgcol1 <> 1
         tdLog.info(
@@ -907,7 +907,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -920,7 +920,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -933,7 +933,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -946,7 +946,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -959,7 +959,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -972,7 +972,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol1 <> 0
         tdLog.info(
@@ -985,7 +985,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -1001,7 +1001,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 1 and
         # tgcol2 <> 1
         tdLog.info(
@@ -1014,7 +1014,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -1027,7 +1027,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -1040,7 +1040,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -1053,7 +1053,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -1066,7 +1066,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol2 <> 0
         tdLog.info(
@@ -1079,7 +1079,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0
         tdLog.info(
@@ -1092,7 +1092,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
@@ -1108,7 +1108,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 1 and
         # tgcol4 <> 1
         tdLog.info(
@@ -1121,7 +1121,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1134,7 +1134,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1147,7 +1147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1160,7 +1160,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1173,7 +1173,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol4 <> 0
         tdLog.info(
@@ -1186,7 +1186,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol4 <> 0
         tdLog.info(
@@ -1199,7 +1199,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step16
         tdLog.info('=============== step16')
@@ -1215,7 +1215,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 1 and
         # tgcol4 <> 1
         tdLog.info(
@@ -1228,7 +1228,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1241,7 +1241,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1254,7 +1254,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1267,7 +1267,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1280,7 +1280,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol5 <> 0 and tgcol4 <> 0
         tdLog.info(
@@ -1293,7 +1293,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol4 <> 0
         tdLog.info(
@@ -1306,7 +1306,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step17
         tdLog.info('=============== step17')
@@ -1322,7 +1322,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -1335,7 +1335,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1348,7 +1348,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1361,7 +1361,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1374,7 +1374,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1387,7 +1387,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1400,7 +1400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1413,7 +1413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step18
         tdLog.info('=============== step18')
@@ -1429,7 +1429,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -1442,7 +1442,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1455,7 +1455,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1468,7 +1468,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1481,7 +1481,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1494,7 +1494,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1507,7 +1507,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1520,7 +1520,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step19
         tdLog.info('=============== step19')
@@ -1536,7 +1536,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1 and tgcol1 <> 1
         tdLog.info(
@@ -1549,7 +1549,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0
         tdLog.info(
@@ -1562,7 +1562,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1575,7 +1575,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0
         tdLog.info(
@@ -1588,7 +1588,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1601,7 +1601,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1614,7 +1614,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0 and
         # tgcol1 <> 0
@@ -1628,7 +1628,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step20
         tdLog.info('=============== step20')
@@ -1644,7 +1644,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1 and tgcol1 <> 1 and tgcol5 <> 1
         tdLog.info(
@@ -1657,7 +1657,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0 and tgcol5 = 0
         tdLog.info(
@@ -1670,7 +1670,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0 and tgcol5 <> 0
         tdLog.info(
@@ -1683,7 +1683,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0 and tgcol5 = 0
         tdLog.info(
@@ -1696,7 +1696,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0 and tgcol5 <> 0
         tdLog.info(
@@ -1709,7 +1709,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0 and tgcol1 <> 0 and
         # tgcol5 <> 0
@@ -1723,7 +1723,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0 and tgcol3 <> 0 and
         # tgcol1 <> 0 and tgcol5 <> 0
@@ -1737,7 +1737,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step21
         tdLog.info('=============== step21')
@@ -1755,7 +1755,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step22
         tdLog.info('=============== step22')
@@ -1773,7 +1773,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -1790,7 +1790,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -1807,7 +1807,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -1824,7 +1824,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -1839,7 +1839,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step23
         tdLog.info('=============== step23')
@@ -1857,7 +1857,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -1874,7 +1874,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -1891,7 +1891,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -1908,7 +1908,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -1923,7 +1923,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -1937,7 +1937,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step24
         tdLog.info('=============== step24')
@@ -1955,7 +1955,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol2
@@ -1971,7 +1971,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol3
@@ -1987,7 +1987,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol4
@@ -2003,7 +2003,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol5
@@ -2019,7 +2019,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step25
         tdLog.info('=============== step25')
@@ -2038,7 +2038,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2055,7 +2055,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2072,7 +2072,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2087,7 +2087,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2101,7 +2101,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step26
         tdLog.info('=============== step26')
@@ -2120,7 +2120,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2137,7 +2137,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2154,7 +2154,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2169,7 +2169,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2183,7 +2183,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2197,7 +2197,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step27
@@ -2217,7 +2217,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2234,7 +2234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2251,7 +2251,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2264,7 +2264,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2278,7 +2278,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -2292,7 +2292,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/6.py b/tests/pytest/tag_lite/6.py
index 52f6fe1b37..b789e41794 100644
--- a/tests/pytest/tag_lite/6.py
+++ b/tests/pytest/tag_lite/6.py
@@ -89,10 +89,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -120,10 +120,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -134,7 +134,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -143,7 +143,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -151,7 +151,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -159,7 +159,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -171,7 +171,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -182,7 +182,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 0' % (mt))
@@ -190,7 +190,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % (mt))
         tdSql.query('select * from %s where tgcol1 = 1' % (mt))
@@ -198,7 +198,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 1' % (mt))
@@ -206,7 +206,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 = 1
         tdLog.info('select * from %s where tgcol1 = 1' % (mt))
         tdSql.query('select * from %s where tgcol1 = 1' % (mt))
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 1
         tdLog.info('select * from %s where tgcol1 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 1' % (mt))
@@ -222,7 +222,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 = 0
         tdLog.info('select * from %s where tgcol1 = 0' % (mt))
         tdSql.query('select * from %s where tgcol1 = 0' % (mt))
@@ -230,7 +230,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol1 <> 0
         tdLog.info('select * from %s where tgcol1 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol1 <> 0' % (mt))
@@ -238,7 +238,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -249,7 +249,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 0
         tdLog.info('select * from %s where tgcol2 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 0' % (mt))
@@ -257,7 +257,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 1
         tdLog.info('select * from %s where tgcol2 = 1' % (mt))
         tdSql.query('select * from %s where tgcol2 = 1' % (mt))
@@ -265,7 +265,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 1' % (mt))
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -284,7 +284,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 <> 0
         tdLog.info('select * from %s where tgcol3 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol3 <> 0' % (mt))
@@ -292,7 +292,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 = 1
         tdLog.info('select * from %s where tgcol3 = 1' % (mt))
         tdSql.query('select * from %s where tgcol3 = 1' % (mt))
@@ -300,7 +300,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 <> 1
         tdLog.info('select * from %s where tgcol3 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol3 <> 1' % (mt))
@@ -308,7 +308,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -319,7 +319,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 <> 0
         tdLog.info('select * from %s where tgcol4 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol4 <> 0' % (mt))
@@ -327,7 +327,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 = 1
         tdLog.info('select * from %s where tgcol4 = 1' % (mt))
         tdSql.query('select * from %s where tgcol4 = 1' % (mt))
@@ -335,7 +335,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 <> 1
         tdLog.info('select * from %s where tgcol4 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol4 <> 1' % (mt))
@@ -343,7 +343,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 <> 0
         tdLog.info('select * from %s where tgcol5 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol5 <> 0' % (mt))
@@ -362,7 +362,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 = 1
         tdLog.info('select * from %s where tgcol5 = 1' % (mt))
         tdSql.query('select * from %s where tgcol5 = 1' % (mt))
@@ -370,7 +370,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 <> 1
         tdLog.info('select * from %s where tgcol5 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol5 <> 1' % (mt))
@@ -378,7 +378,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -389,7 +389,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol6 <> 0
         tdLog.info('select * from %s where tgcol6 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol6 <> 0' % (mt))
@@ -397,7 +397,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol6 = 1
         tdLog.info('select * from %s where tgcol6 = 1' % (mt))
         tdSql.query('select * from %s where tgcol6 = 1' % (mt))
@@ -405,7 +405,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol6 <> 1
         tdLog.info('select * from %s where tgcol6 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol6 <> 1' % (mt))
@@ -413,7 +413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -428,7 +428,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol1 <> 1' %
@@ -440,7 +440,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol1 = 0' %
@@ -452,7 +452,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol1 <> 0' %
@@ -464,7 +464,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 = 0' %
@@ -476,7 +476,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol1 <> 0' %
@@ -488,7 +488,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0
         tdLog.info(
@@ -501,7 +501,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -514,7 +514,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -529,7 +529,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> 1' %
@@ -541,7 +541,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = 0' %
@@ -553,7 +553,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> 0' %
@@ -565,7 +565,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = 0' %
@@ -577,7 +577,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> 0' %
@@ -589,7 +589,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0
         tdLog.info(
@@ -602,7 +602,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -615,7 +615,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -630,7 +630,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol3 <> 1' %
@@ -642,7 +642,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol3 = 0' %
@@ -654,7 +654,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol3 <> 0' %
@@ -666,7 +666,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol3 = 0' %
@@ -678,7 +678,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol3 <> 0' %
@@ -690,7 +690,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0
         tdLog.info(
@@ -703,7 +703,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -716,7 +716,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -731,7 +731,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol4 <> 1' %
@@ -743,7 +743,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol4 = 0' %
@@ -755,7 +755,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol4 <> 0' %
@@ -767,7 +767,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol4 = 0' %
@@ -779,7 +779,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol4 <> 0' %
@@ -791,7 +791,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0
         tdLog.info(
@@ -804,7 +804,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -817,7 +817,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -832,7 +832,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol5 <> 1' %
@@ -844,7 +844,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol5 = 0' %
@@ -856,7 +856,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol5 <> 0' %
@@ -868,7 +868,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol5 = 0' %
@@ -880,7 +880,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol5 <> 0' %
@@ -892,7 +892,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol5 <> 0
         tdLog.info(
@@ -905,7 +905,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -918,7 +918,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -933,7 +933,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol6 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol6 <> 1' %
@@ -945,7 +945,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol6 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol6 = 0' %
@@ -957,7 +957,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol6 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol6 <> 0' %
@@ -969,7 +969,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol6 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol6 = 0' %
@@ -981,7 +981,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol6 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol6 <> 0' %
@@ -993,7 +993,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol6 <> 0
         tdLog.info(
@@ -1006,7 +1006,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol6 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -1019,7 +1019,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
@@ -1035,7 +1035,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1 and
         # tgcol1 <> 1
         tdLog.info(
@@ -1048,7 +1048,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -1061,7 +1061,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -1074,7 +1074,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0 and
         # tgcol1 = 0
         tdLog.info(
@@ -1087,7 +1087,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0 and
         # tgcol1 <> 0
         tdLog.info(
@@ -1100,7 +1100,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1113,7 +1113,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol1 <> 0
         tdLog.info(
@@ -1126,7 +1126,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step16
         tdLog.info('=============== step16')
@@ -1142,7 +1142,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 1 and
         # tgcol2 <> 1
         tdLog.info(
@@ -1155,7 +1155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -1168,7 +1168,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -1181,7 +1181,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 = 0 and
         # tgcol2 = 0
         tdLog.info(
@@ -1194,7 +1194,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol2 <> 0
         tdLog.info(
@@ -1207,7 +1207,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol2 <> 0
         tdLog.info(
@@ -1220,7 +1220,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0
         tdLog.info(
@@ -1233,7 +1233,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step17
         tdLog.info('=============== step17')
@@ -1249,7 +1249,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 1 and
         # tgcol4 <> 1
         tdLog.info(
@@ -1262,7 +1262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1275,7 +1275,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol3 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1288,7 +1288,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1301,7 +1301,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol3 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1314,7 +1314,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol3 <> 0 and tgcol4 <> 0
         tdLog.info(
@@ -1327,7 +1327,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol3 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol4 <> 0
         tdLog.info(
@@ -1340,7 +1340,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step18
         tdLog.info('=============== step18')
@@ -1356,7 +1356,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 1 and
         # tgcol4 <> 1
         tdLog.info(
@@ -1369,7 +1369,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1382,7 +1382,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1395,7 +1395,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 = 0 and
         # tgcol4 = 0
         tdLog.info(
@@ -1408,7 +1408,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 <> 0 and
         # tgcol4 <> 0
         tdLog.info(
@@ -1421,7 +1421,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol5 <> 0 and tgcol4 <> 0
         tdLog.info(
@@ -1434,7 +1434,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol4 <> 0
         tdLog.info(
@@ -1447,7 +1447,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step19
         tdLog.info('=============== step19')
@@ -1463,7 +1463,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 1 and
         # tgcol6 <> 1
         tdLog.info(
@@ -1476,7 +1476,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 = 0 and
         # tgcol6 = 0
         tdLog.info(
@@ -1489,7 +1489,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol5 <> 0 and
         # tgcol6 <> 0
         tdLog.info(
@@ -1502,7 +1502,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 = 0 and
         # tgcol6 = 0
         tdLog.info(
@@ -1515,7 +1515,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol5 <> 0 and
         # tgcol6 <> 0
         tdLog.info(
@@ -1528,7 +1528,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol5 <> 0 and tgcol6 <> 0
         tdLog.info(
@@ -1541,7 +1541,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol5 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol6 <> 0
         tdLog.info(
@@ -1554,7 +1554,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step20
         tdLog.info('=============== step20')
@@ -1570,7 +1570,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -1583,7 +1583,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1596,7 +1596,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1609,7 +1609,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1622,7 +1622,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol1 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1635,7 +1635,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol1 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1648,7 +1648,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol1 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1661,7 +1661,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step21
         tdLog.info('=============== step21')
@@ -1677,7 +1677,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1
         tdLog.info(
@@ -1690,7 +1690,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1703,7 +1703,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1716,7 +1716,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0
         tdLog.info(
@@ -1729,7 +1729,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0
         tdLog.info(
@@ -1742,7 +1742,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1755,7 +1755,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0
         tdLog.info(
@@ -1768,7 +1768,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step22
         tdLog.info('=============== step22')
@@ -1784,7 +1784,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1 and tgcol1 <> 1
         tdLog.info(
@@ -1797,7 +1797,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0
         tdLog.info(
@@ -1810,7 +1810,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1823,7 +1823,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0
         tdLog.info(
@@ -1836,7 +1836,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1849,7 +1849,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0 and tgcol1 <> 0
         tdLog.info(
@@ -1862,7 +1862,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0 and
         # tgcol1 <> 0
@@ -1876,7 +1876,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step23
         tdLog.info('=============== step23')
@@ -1892,7 +1892,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1 and tgcol1 <> 1 and tgcol5 <> 1
         tdLog.info(
@@ -1905,7 +1905,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0 and tgcol5 = 0
         tdLog.info(
@@ -1918,7 +1918,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0 and tgcol5 <> 0
         tdLog.info(
@@ -1931,7 +1931,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0 and tgcol5 = 0
         tdLog.info(
@@ -1944,7 +1944,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0 and tgcol5 <> 0
         tdLog.info(
@@ -1957,7 +1957,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0 and tgcol1 <> 0 and
         # tgcol5 <> 0
@@ -1971,7 +1971,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0 and
         # tgcol1 <> 0 and tgcol5 <> 0
@@ -1985,7 +1985,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step24
         tdLog.info('=============== step24')
@@ -2002,7 +2002,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 1 and
         # tgcol2 <> 1  and tgcol3 <> 1 and tgcol1 <> 1 and tgcol5 <> 1 and
         # tgcol6 <> 1
@@ -2016,7 +2016,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0 and tgcol5 = 0 and tgcol6 =
         # 0
@@ -2030,7 +2030,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0 and tgcol5 <> 0 and
         # tgcol6 <> 0
@@ -2044,7 +2044,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 = 0 and
         # tgcol2 = 0 and tgcol3 = 0 and tgcol1 = 0 and tgcol5 = 0 and tgcol6 =
         # 0
@@ -2058,7 +2058,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol4 <> 0 and
         # tgcol2 <> 0 and tgcol3 <> 0 and tgcol1 <> 0 and tgcol5 <> 0 and
         # tgcol6 <> 0
@@ -2072,7 +2072,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol4 <> 0 and tgcol2 <> 0  and tgcol3 <> 0 and tgcol1 <> 0 and
         # tgcol5 <> 0 and tgcol6 <> 0
@@ -2086,7 +2086,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol4 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol2 <> 0  and tgcol3 <> 0 and
         # tgcol1 <> 0 and tgcol5 <> 0 and tgcol6 <> 0
@@ -2100,7 +2100,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step25
         tdLog.info('=============== step25')
@@ -2118,7 +2118,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step26
         tdLog.info('=============== step26')
@@ -2136,7 +2136,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2153,7 +2153,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2170,7 +2170,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2187,7 +2187,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2202,7 +2202,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2216,7 +2216,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step27
         tdLog.info('=============== step27')
@@ -2234,7 +2234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2251,7 +2251,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2268,7 +2268,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2285,7 +2285,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2300,7 +2300,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2314,7 +2314,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2328,7 +2328,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step28
         tdLog.info('=============== step28')
@@ -2346,7 +2346,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol2
@@ -2362,7 +2362,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol3
@@ -2378,7 +2378,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol4
@@ -2394,7 +2394,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol5
@@ -2410,7 +2410,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt group by tgcol6
@@ -2426,7 +2426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step29
         tdLog.info('=============== step29')
@@ -2445,7 +2445,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2462,7 +2462,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2479,7 +2479,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2494,7 +2494,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2508,7 +2508,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2522,7 +2522,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step30
         tdLog.info('=============== step30')
@@ -2541,7 +2541,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2558,7 +2558,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2575,7 +2575,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2590,7 +2590,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2604,7 +2604,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2618,7 +2618,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where ts < now + 4m
@@ -2632,7 +2632,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step31
         tdLog.info('=============== step31')
@@ -2651,7 +2651,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2668,7 +2668,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2685,7 +2685,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2698,7 +2698,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2712,7 +2712,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol1 = 1 and
@@ -2726,7 +2726,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -2740,7 +2740,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/add.py b/tests/pytest/tag_lite/add.py
index e9e3675485..1a45237cb0 100644
--- a/tests/pytest/tag_lite/add.py
+++ b/tests/pytest/tag_lite/add.py
@@ -77,22 +77,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -119,22 +119,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step2
         tdLog.info('select * from %s where tgcol2 = 1 -x step2' % (mt))
@@ -171,22 +171,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -213,22 +213,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step3
         tdLog.info('select * from %s where tgcol2 = 1 -x step3' % (mt))
@@ -265,22 +265,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql describe $tb
         tdLog.info('describe %s' % (tb))
@@ -289,22 +289,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkDataType(2, 1, "BIGINT")')
         tdSql.checkDataType(2, 1, "BIGINT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data31 != FLOAT then
         tdLog.info('tdSql.checkDataType(3, 1, "FLOAT")')
         tdSql.checkDataType(3, 1, "FLOAT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data23 != 1 then
         tdLog.info('tdSql.checkData(2, 3, 1)')
         tdSql.checkData(2, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data33 != 2.000000 then
         tdLog.info('tdSql.checkData(3, 3, 2.000000)')
         tdSql.checkData(3, 3, 2.000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -331,22 +331,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 3, 4.00000)')
         tdSql.checkData(0, 3, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step4
         tdLog.info('select * from %s where tgcol2 = 1 -x step4' % (mt))
@@ -383,22 +383,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -425,22 +425,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = '1' -x step5
         tdLog.info('select * from %s where tgcol3 = "1" -x step5' % (mt))
@@ -477,27 +477,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -540,27 +540,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '6'
         tdLog.info('select * from %s where tgcol6 = "6"' % (mt))
@@ -571,27 +571,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = 1
         tdLog.info('select * from %s where tgcol4 = 1' % (mt))
@@ -600,7 +600,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 = 1 -x step52
         tdLog.info('select * from %s where tgcol3 = 1 -x step52' % (mt))
         tdSql.error('select * from %s where tgcol3 = 12' % (mt))
@@ -636,27 +636,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -699,27 +699,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4 then
         tdLog.info('tdSql.checkData(0, 2, 4)')
         tdSql.checkData(0, 2, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step71
         tdLog.info('select * from %s where tgcol2 = 1 -x step71' % (mt))
@@ -761,27 +761,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -825,27 +825,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4 then
         tdLog.info('tdSql.checkData(0, 2, 4)')
         tdSql.checkData(0, 2, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 1 then
         tdLog.info('tdSql.checkData(0, 4, 1)')
         tdSql.checkData(0, 4, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step81
         tdLog.info('select * from %s where tgcol2 = 1 -x step81' % (mt))
@@ -887,27 +887,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -950,27 +950,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 4.000000000)')
         tdSql.checkData(0, 2, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 1 then
         tdLog.info('tdSql.checkData(0, 3, 1)')
         tdSql.checkData(0, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6.00000 then
         tdLog.info('tdSql.checkData(0, 4, 6.00000)')
         tdSql.checkData(0, 4, 6.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 1 -x step91
         tdLog.info('select * from %s where tgcol3 = 1 -x step91' % (mt))
@@ -1016,32 +1016,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4 -x step103
         tdLog.info('alter table %s change tag tgcol1 tgcol4 -x step103' % (mt))
@@ -1090,32 +1090,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 0 then
         tdLog.info('tdSql.checkData(0, 4, 0)')
         tdSql.checkData(0, 4, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step101
         tdLog.info('select * from %s where tgcol2 = 1 -x step101' % (mt))
@@ -1161,37 +1161,37 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 5, 4.00000)')
         tdSql.checkData(0, 5, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5 then
         tdLog.info('tdSql.checkData(0, 6, 5)')
         tdSql.checkData(0, 6, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4 -x step114
         tdLog.info('alter table %s change tag tgcol1 tgcol4 -x step114' % (mt))
@@ -1261,42 +1261,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5 then
         tdLog.info('tdSql.checkData(0, 4, 5)')
         tdSql.checkData(0, 4, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 6 then
         tdLog.info('tdSql.checkData(0, 5, 6)')
         tdSql.checkData(0, 5, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 7 then
         tdLog.info('tdSql.checkData(0, 6, 7)')
         tdSql.checkData(0, 6, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 8 then
         tdLog.info('tdSql.checkData(0, 7, 8)')
         tdSql.checkData(0, 7, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step111
         tdLog.info('select * from %s where tgcol2 = 1 -x step111' % (mt))
@@ -1348,42 +1348,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3.00000 then
         tdLog.info('tdSql.checkData(0, 4, 3.00000)')
         tdSql.checkData(0, 4, 3.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 4.000000000)')
         tdSql.checkData(0, 5, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5 then
         tdLog.info('tdSql.checkData(0, 6, 5)')
         tdSql.checkData(0, 6, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -1447,42 +1447,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 1 then
         tdLog.info('tdSql.checkData(0, 3, 1)')
         tdSql.checkData(0, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5 then
         tdLog.info('tdSql.checkData(0, 4, 5)')
         tdSql.checkData(0, 4, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 3 then
         tdLog.info('tdSql.checkData(0, 6, 3)')
         tdSql.checkData(0, 6, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 2 then
         tdLog.info('tdSql.checkData(0, 7, 2)')
         tdSql.checkData(0, 7, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = '5'
         tdLog.info('select * from %s where tgcol2 = "5"' % (mt))
@@ -1491,7 +1491,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 4
         tdLog.info('select * from %s where tgcol3 = 4' % (mt))
@@ -1500,7 +1500,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol5 = 2
         tdLog.info('select * from %s where tgcol5 = 2' % (mt))
@@ -1509,7 +1509,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '1'
         tdLog.info('select * from %s where tgcol6 = "1"' % (mt))
@@ -1518,7 +1518,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -1554,42 +1554,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 6, 5.000000000)')
         tdSql.checkData(0, 6, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -1647,42 +1647,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 9 then
         tdLog.info('tdSql.checkData(0, 3, 9)')
         tdSql.checkData(0, 3, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 11.000000000 then
         tdLog.info('tdSql.checkData(0, 4, 11.000000000)')
         tdSql.checkData(0, 4, 11.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 8 then
         tdLog.info('tdSql.checkData(0, 5, 8)')
         tdSql.checkData(0, 5, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 10 then
         tdLog.info('tdSql.checkData(0, 6, 10)')
         tdSql.checkData(0, 6, 10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 12 then
         tdLog.info('tdSql.checkData(0, 7, 12)')
         tdSql.checkData(0, 7, 12)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -1753,7 +1753,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/bigint.py b/tests/pytest/tag_lite/bigint.py
index 77a161c5bc..ecc6fad44d 100644
--- a/tests/pytest/tag_lite/bigint.py
+++ b/tests/pytest/tag_lite/bigint.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -123,7 +123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -155,7 +155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -167,7 +167,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -179,7 +179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -234,7 +234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -242,7 +242,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -250,7 +250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -305,7 +305,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -313,7 +313,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -342,7 +342,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -364,7 +364,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -376,7 +376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -388,7 +388,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -400,7 +400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -413,7 +413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -426,7 +426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -462,7 +462,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -480,7 +480,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -498,7 +498,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -517,7 +517,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -536,7 +536,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -556,7 +556,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -570,7 +570,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/binary.py b/tests/pytest/tag_lite/binary.py
index 543b00b34e..a5757dc5cd 100644
--- a/tests/pytest/tag_lite/binary.py
+++ b/tests/pytest/tag_lite/binary.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -123,7 +123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -155,7 +155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -167,7 +167,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -179,7 +179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -234,7 +234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -242,7 +242,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -250,7 +250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '0'
         tdLog.info('select * from %s where tgcol <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol <> "0"' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '1'
         tdLog.info('select * from %s where tgcol = "1"' % (mt))
         tdSql.query('select * from %s where tgcol = "1"' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '1'
         tdLog.info('select * from %s where tgcol <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol <> "1"' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '1'
         tdLog.info('select * from %s where tgcol = "1"' % (mt))
         tdSql.query('select * from %s where tgcol = "1"' % (mt))
@@ -305,7 +305,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '1'
         tdLog.info('select * from %s where tgcol <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol <> "1"' % (mt))
@@ -313,7 +313,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '0'
         tdLog.info('select * from %s where tgcol = "0"' % (mt))
         tdSql.query('select * from %s where tgcol = "0"' % (mt))
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '0'
         tdLog.info('select * from %s where tgcol <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol <> "0"' % (mt))
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -344,7 +344,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> '1'
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> "1"' %
@@ -356,7 +356,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol = "0"' %
@@ -368,7 +368,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> "0"' %
@@ -380,7 +380,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = "0"' %
@@ -392,7 +392,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> "0"' %
@@ -404,7 +404,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> '0'
         tdLog.info(
@@ -417,7 +417,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> '0' and
         # ts < now + 5m
         tdLog.info(
@@ -430,7 +430,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -448,7 +448,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -466,7 +466,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -484,7 +484,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -502,7 +502,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -521,7 +521,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -540,7 +540,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -560,7 +560,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -574,7 +574,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/binary_binary.py b/tests/pytest/tag_lite/binary_binary.py
index c0d1c0bfe7..9c789eafd6 100644
--- a/tests/pytest/tag_lite/binary_binary.py
+++ b/tests/pytest/tag_lite/binary_binary.py
@@ -84,10 +84,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -112,10 +112,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -126,7 +126,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -135,7 +135,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -143,7 +143,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -151,7 +151,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -163,7 +163,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -174,7 +174,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '0'
         tdLog.info('select * from %s where tgcol <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol <> "0"' % (mt))
@@ -182,7 +182,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '1'
         tdLog.info('select * from %s where tgcol = "1"' % (mt))
         tdSql.query('select * from %s where tgcol = "1"' % (mt))
@@ -190,7 +190,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '1'
         tdLog.info('select * from %s where tgcol <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol <> "1"' % (mt))
@@ -198,7 +198,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '1'
         tdLog.info('select * from %s where tgcol = "1"' % (mt))
         tdSql.query('select * from %s where tgcol = "1"' % (mt))
@@ -206,7 +206,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '1'
         tdLog.info('select * from %s where tgcol <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol <> "1"' % (mt))
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '0'
         tdLog.info('select * from %s where tgcol = "0"' % (mt))
         tdSql.query('select * from %s where tgcol = "0"' % (mt))
@@ -222,7 +222,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> '0'
         tdLog.info('select * from %s where tgcol <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol <> "0"' % (mt))
@@ -230,7 +230,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -241,7 +241,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> '0'
         tdLog.info('select * from %s where tgcol2 <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol2 <> "0"' % (mt))
@@ -249,7 +249,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = '1'
         tdLog.info('select * from %s where tgcol2 = "1"' % (mt))
         tdSql.query('select * from %s where tgcol2 = "1"' % (mt))
@@ -257,7 +257,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> '1'
         tdLog.info('select * from %s where tgcol2 <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol2 <> "1"' % (mt))
@@ -265,7 +265,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -280,7 +280,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> '1'
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> "1"' %
@@ -292,7 +292,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol = "0"' %
@@ -304,7 +304,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> "0"' %
@@ -316,7 +316,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = "0"' %
@@ -328,7 +328,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> "0"' %
@@ -340,7 +340,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> '0'
         tdLog.info(
@@ -353,7 +353,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> '0' and
         # ts < now + 5m
         tdLog.info(
@@ -366,7 +366,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -381,7 +381,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '1'
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> "1"' %
@@ -393,7 +393,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = "0"' %
@@ -405,7 +405,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> "0"' %
@@ -417,7 +417,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = "0"' %
@@ -429,7 +429,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> "0"' %
@@ -441,7 +441,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> '0'
         tdLog.info(
@@ -454,7 +454,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '0' and
         # ts < now + 5m
         tdLog.info(
@@ -467,7 +467,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -483,7 +483,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '1' and
         # tgcol <> '1'
         tdLog.info(
@@ -496,7 +496,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = '0' and
         # tgcol = '0'
         tdLog.info(
@@ -509,7 +509,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> '0' and
         # tgcol <> '0'
         tdLog.info(
@@ -522,7 +522,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = '0' and
         # tgcol = '0'
         tdLog.info(
@@ -535,7 +535,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> '0'
         # and tgcol <> '0'
         tdLog.info(
@@ -548,7 +548,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> '0' and tgcol <> '0'
         tdLog.info(
@@ -561,7 +561,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '0' and
         # ts < now + 5m and ts < now + 5m and tgcol <> '0'
         tdLog.info(
@@ -574,7 +574,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -592,7 +592,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -610,7 +610,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = '1'
@@ -626,7 +626,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = '1' and
@@ -643,7 +643,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -661,7 +661,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -679,7 +679,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -698,7 +698,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = '1'
@@ -715,7 +715,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = '1' and
@@ -732,7 +732,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step13
@@ -752,7 +752,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -771,7 +771,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -785,7 +785,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/bool.py b/tests/pytest/tag_lite/bool.py
index c43d5b2ee5..6f2afd2625 100644
--- a/tests/pytest/tag_lite/bool.py
+++ b/tests/pytest/tag_lite/bool.py
@@ -81,10 +81,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -107,10 +107,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -122,7 +122,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -130,7 +130,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -138,7 +138,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -146,7 +146,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -154,7 +154,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -166,7 +166,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -178,7 +178,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -190,7 +190,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -203,7 +203,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -223,7 +223,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -231,7 +231,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -239,7 +239,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -251,7 +251,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -270,7 +270,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -280,7 +280,7 @@ class TDTestCase:
         # TSIM: print expect 100, actual:$rows
         tdLog.info('expect 100, actual:$rows')
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -288,7 +288,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = true
         tdLog.info('select * from %s where tgcol = true' % (mt))
         tdSql.query('select * from %s where tgcol = true' % (mt))
@@ -296,7 +296,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> true
         tdLog.info('select * from %s where tgcol <> true' % (mt))
         tdSql.query('select * from %s where tgcol <> true' % (mt))
@@ -304,7 +304,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = false
         tdLog.info('select * from %s where tgcol = false' % (mt))
         tdSql.query('select * from %s where tgcol = false' % (mt))
@@ -312,7 +312,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> false
         tdLog.info('select * from %s where tgcol <> false' % (mt))
         tdSql.query('select * from %s where tgcol <> false' % (mt))
@@ -320,7 +320,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -335,7 +335,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> true
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> true' %
@@ -347,7 +347,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol = false' %
@@ -359,7 +359,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> false' %
@@ -371,7 +371,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = false' %
@@ -383,7 +383,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> false' %
@@ -395,7 +395,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> false
         tdLog.info(
@@ -408,7 +408,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> false
         # and ts < now + 5m
         tdLog.info(
@@ -421,7 +421,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -439,7 +439,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -457,7 +457,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -475,7 +475,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -493,7 +493,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -512,7 +512,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -531,7 +531,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -555,7 +555,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -569,7 +569,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/bool_binary.py b/tests/pytest/tag_lite/bool_binary.py
index 7105cc4e78..bfc496e8e4 100644
--- a/tests/pytest/tag_lite/bool_binary.py
+++ b/tests/pytest/tag_lite/bool_binary.py
@@ -81,10 +81,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             tb = "%s%d" % (tbPrefix, i)
@@ -106,10 +106,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -120,7 +120,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -129,7 +129,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -137,7 +137,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -145,7 +145,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -157,7 +157,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -168,7 +168,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -176,7 +176,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -184,7 +184,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -192,7 +192,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = true
         tdLog.info('select * from %s where tgcol = true' % (mt))
         tdSql.query('select * from %s where tgcol = true' % (mt))
@@ -200,7 +200,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> true
         tdLog.info('select * from %s where tgcol <> true' % (mt))
         tdSql.query('select * from %s where tgcol <> true' % (mt))
@@ -208,7 +208,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = false
         tdLog.info('select * from %s where tgcol = false' % (mt))
         tdSql.query('select * from %s where tgcol = false' % (mt))
@@ -216,7 +216,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> false
         tdLog.info('select * from %s where tgcol <> false' % (mt))
         tdSql.query('select * from %s where tgcol <> false' % (mt))
@@ -224,7 +224,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -235,7 +235,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> '0'
         tdLog.info('select * from %s where tgcol2 <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol2 <> "0"' % (mt))
@@ -243,7 +243,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = '1'
         tdLog.info('select * from %s where tgcol2 = "1"' % (mt))
         tdSql.query('select * from %s where tgcol2 = "1"' % (mt))
@@ -251,7 +251,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> "1"
         tdLog.info('select * from %s where tgcol2 <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol2 <> "1"' % (mt))
@@ -259,7 +259,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -274,7 +274,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> true
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> true' %
@@ -286,7 +286,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol = false' %
@@ -298,7 +298,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> false' %
@@ -310,7 +310,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = false' %
@@ -322,7 +322,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> false' %
@@ -334,7 +334,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> false
         tdLog.info(
@@ -347,7 +347,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> false
         # and ts < now + 5m
         tdLog.info(
@@ -360,7 +360,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -375,7 +375,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '1'
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> "1"' %
@@ -387,7 +387,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = "0"' %
@@ -399,7 +399,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> "0"' %
@@ -411,7 +411,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = "0"' %
@@ -423,7 +423,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> "0"' %
@@ -435,7 +435,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> '0'
         tdLog.info(
@@ -448,7 +448,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '0' and
         # ts < now + 5m
         tdLog.info(
@@ -461,7 +461,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -477,7 +477,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '1' and
         # tgcol <> true
         tdLog.info(
@@ -490,7 +490,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = '0' and
         # tgcol = false
         tdLog.info(
@@ -503,7 +503,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> '0' and
         # tgcol <> false
         tdLog.info(
@@ -516,7 +516,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = '0' and
         # tgcol = false
         tdLog.info(
@@ -529,7 +529,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> '0'
         # and tgcol <> false
         tdLog.info(
@@ -542,7 +542,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> '0' and tgcol <> false
         tdLog.info(
@@ -555,7 +555,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '0' and
         # ts < now + 5m and ts < now + 5m and tgcol <> false
         tdLog.info(
@@ -568,7 +568,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -586,7 +586,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -604,7 +604,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = '1'
@@ -620,7 +620,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = true and
@@ -637,7 +637,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -655,7 +655,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -673,7 +673,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -692,7 +692,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = '1'
@@ -709,7 +709,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = true and
@@ -726,7 +726,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step13
@@ -746,7 +746,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -765,7 +765,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -779,7 +779,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/bool_int.py b/tests/pytest/tag_lite/bool_int.py
index b7504b1127..f7bfc7acef 100644
--- a/tests/pytest/tag_lite/bool_int.py
+++ b/tests/pytest/tag_lite/bool_int.py
@@ -81,10 +81,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             tb = "%s%d" % (tbPrefix, i)
@@ -106,10 +106,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -120,7 +120,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -129,7 +129,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -137,7 +137,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -145,7 +145,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -157,7 +157,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -168,7 +168,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -176,7 +176,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -184,7 +184,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -192,7 +192,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = true
         tdLog.info('select * from %s where tgcol = true' % (mt))
         tdSql.query('select * from %s where tgcol = true' % (mt))
@@ -200,7 +200,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> true
         tdLog.info('select * from %s where tgcol <> true' % (mt))
         tdSql.query('select * from %s where tgcol <> true' % (mt))
@@ -208,7 +208,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = false
         tdLog.info('select * from %s where tgcol = false' % (mt))
         tdSql.query('select * from %s where tgcol = false' % (mt))
@@ -216,7 +216,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> false
         tdLog.info('select * from %s where tgcol <> false' % (mt))
         tdSql.query('select * from %s where tgcol <> false' % (mt))
@@ -224,7 +224,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -235,7 +235,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 0
         tdLog.info('select * from %s where tgcol2 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 0' % (mt))
@@ -243,7 +243,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 1
         tdLog.info('select * from %s where tgcol2 = 1' % (mt))
         tdSql.query('select * from %s where tgcol2 = 1' % (mt))
@@ -251,7 +251,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 1' % (mt))
@@ -259,7 +259,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = true
         tdLog.info('select * from %s where tgcol2 = true' % (mt))
         tdSql.query('select * from %s where tgcol2 = true' % (mt))
@@ -267,7 +267,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> true
         tdLog.info('select * from %s where tgcol2 <> true' % (mt))
         tdSql.query('select * from %s where tgcol2 <> true' % (mt))
@@ -275,7 +275,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = false
         tdLog.info('select * from %s where tgcol2 = false' % (mt))
         tdSql.query('select * from %s where tgcol2 = false' % (mt))
@@ -283,7 +283,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> false
         tdLog.info('select * from %s where tgcol2 <> false' % (mt))
         tdSql.query('select * from %s where tgcol2 <> false' % (mt))
@@ -291,7 +291,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -306,7 +306,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> true
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> true' %
@@ -318,7 +318,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol = false' %
@@ -330,7 +330,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> false
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> false' %
@@ -342,7 +342,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = false' %
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> false
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> false' %
@@ -366,7 +366,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> false
         tdLog.info(
@@ -379,7 +379,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> false
         # and ts < now + 5m
         tdLog.info(
@@ -392,7 +392,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -407,7 +407,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> 1' %
@@ -419,7 +419,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = 0' %
@@ -431,7 +431,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> 0' %
@@ -443,7 +443,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = 0' %
@@ -455,7 +455,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> 0' %
@@ -467,7 +467,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0
         tdLog.info(
@@ -480,7 +480,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -493,7 +493,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -509,7 +509,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1 and
         # tgcol <> true
         tdLog.info(
@@ -522,7 +522,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0 and
         # tgcol = false
         tdLog.info(
@@ -535,7 +535,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0 and
         # tgcol <> false
         tdLog.info(
@@ -548,7 +548,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0 and
         # tgcol = false
         tdLog.info(
@@ -561,7 +561,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0 and
         # tgcol <> false
         tdLog.info(
@@ -574,7 +574,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0 and tgcol <> false
         tdLog.info(
@@ -587,7 +587,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol <> false
         tdLog.info(
@@ -600,7 +600,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -618,7 +618,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -636,7 +636,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = 1
@@ -652,7 +652,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = true and
@@ -669,7 +669,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -687,7 +687,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -705,7 +705,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -724,7 +724,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = 1 group
@@ -741,7 +741,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = true and
@@ -758,7 +758,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step13
@@ -778,7 +778,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -797,7 +797,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -811,7 +811,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/change.py b/tests/pytest/tag_lite/change.py
index e1df901d5b..910d11ca7c 100644
--- a/tests/pytest/tag_lite/change.py
+++ b/tests/pytest/tag_lite/change.py
@@ -66,22 +66,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tagcx tgcol3 -x step21
         # TSIM: return -1
@@ -123,22 +123,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol3
         # TSIM: sql alter table $mt change tag tgcol2 tgcol4
@@ -167,22 +167,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol3
         # TSIM: sql alter table $mt change tag tgcol2 tgcol4
@@ -211,22 +211,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol3
         # TSIM: sql alter table $mt change tag tgcol2 tgcol4
@@ -255,42 +255,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 6, 5.000000000)')
         tdSql.checkData(0, 6, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol3
         # TSIM: sql reset query cache
@@ -331,22 +331,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = 2
         tdLog.info('select * from $mt where tgcol4 = 2')
@@ -357,22 +357,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -400,22 +400,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = 2
         tdLog.info('select * from $mt where tgcol4 = 2')
@@ -426,22 +426,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -469,22 +469,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = 2
         tdLog.info('select * from $mt where tgcol4 = 2')
@@ -495,22 +495,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -538,22 +538,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = '2'
         tdLog.info('select * from $mt where tgcol4 = '2'')
@@ -564,22 +564,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -627,42 +627,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 4 then
         tdLog.info('tdSql.checkData(0, 4, 4)')
         tdSql.checkData(0, 4, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 5.000000000)')
         tdSql.checkData(0, 5, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 6 then
         tdLog.info('tdSql.checkData(0, 6, 6)')
         tdSql.checkData(0, 6, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol8 = 2
         tdLog.info('select * from $mt where tgcol8 = 2')
@@ -673,42 +673,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 4 then
         tdLog.info('tdSql.checkData(0, 4, 4)')
         tdSql.checkData(0, 4, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 5.000000000)')
         tdSql.checkData(0, 5, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 6 then
         tdLog.info('tdSql.checkData(0, 6, 6)')
         tdSql.checkData(0, 6, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol9 = '4'
         tdLog.info('select * from $mt where tgcol9 = '4'')
@@ -719,42 +719,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 4 then
         tdLog.info('tdSql.checkData(0, 4, 4)')
         tdSql.checkData(0, 4, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 5.000000000)')
         tdSql.checkData(0, 5, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 6 then
         tdLog.info('tdSql.checkData(0, 6, 6)')
         tdSql.checkData(0, 6, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol10 = 5
         tdLog.info('select * from $mt where tgcol10 = 5')
@@ -765,42 +765,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 4 then
         tdLog.info('tdSql.checkData(0, 4, 4)')
         tdSql.checkData(0, 4, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 5.000000000)')
         tdSql.checkData(0, 5, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 6 then
         tdLog.info('tdSql.checkData(0, 6, 6)')
         tdSql.checkData(0, 6, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol11 = '6'
         tdLog.info('select * from $mt where tgcol11 = '6'')
@@ -811,42 +811,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 4 then
         tdLog.info('tdSql.checkData(0, 4, 4)')
         tdSql.checkData(0, 4, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 5.000000000)')
         tdSql.checkData(0, 5, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 6 then
         tdLog.info('tdSql.checkData(0, 6, 6)')
         tdSql.checkData(0, 6, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -860,7 +860,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/column.py b/tests/pytest/tag_lite/column.py
index 4669f74498..f82f83c356 100644
--- a/tests/pytest/tag_lite/column.py
+++ b/tests/pytest/tag_lite/column.py
@@ -103,7 +103,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(4)')
         tdSql.checkRows(4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -149,7 +149,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -160,7 +160,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(4)')
         tdSql.checkRows(4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
@@ -169,7 +169,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -183,7 +183,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/commit.py b/tests/pytest/tag_lite/commit.py
index 4ad2ecf8f9..478520a586 100644
--- a/tests/pytest/tag_lite/commit.py
+++ b/tests/pytest/tag_lite/commit.py
@@ -77,22 +77,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -119,22 +119,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step2
         tdLog.info('select * from %s where tgcol2 = 1 -x step2' % (mt))
@@ -171,22 +171,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -213,22 +213,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step3
         tdLog.info('select * from %s where tgcol2 = 1 -x step3' % (mt))
@@ -265,22 +265,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql describe $tb
         tdLog.info('describe %s' % (tb))
@@ -289,22 +289,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkDataType(2, 1, "BIGINT")')
         tdSql.checkDataType(2, 1, "BIGINT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data31 != FLOAT then
         tdLog.info('tdSql.checkDataType(3, 1, "FLOAT")')
         tdSql.checkDataType(3, 1, "FLOAT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data23 != 1 then
         tdLog.info('tdSql.checkData(2, 3, 1)')
         tdSql.checkData(2, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data33 != 2.000000 then
         tdLog.info('tdSql.checkData(3, 3, 2.000000)')
         tdSql.checkData(3, 3, 2.000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -331,22 +331,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 3, 4.00000)')
         tdSql.checkData(0, 3, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step4
         tdLog.info('select * from %s where tgcol2 = 1 -x step4' % (mt))
@@ -383,22 +383,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -425,22 +425,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = '1' -x step5
         tdLog.info('select * from %s where tgcol3 = "1" -x step5' % (mt))
@@ -477,27 +477,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -540,27 +540,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '6'
         tdLog.info('select * from %s where tgcol6 = "6"' % (mt))
@@ -571,27 +571,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = 1
         tdLog.info('select * from %s where tgcol4 = 1' % (mt))
@@ -600,7 +600,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 = 1 -x step52
         tdLog.info('select * from %s where tgcol3 = 1 -x step52' % (mt))
         tdSql.error('select * from %s where tgcol3 = 12' % (mt))
@@ -636,27 +636,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -699,27 +699,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4 then
         tdLog.info('tdSql.checkData(0, 2, 4)')
         tdSql.checkData(0, 2, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step71
         tdLog.info('select * from %s where tgcol2 = 1 -x step71' % (mt))
@@ -761,27 +761,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -823,27 +823,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4 then
         tdLog.info('tdSql.checkData(0, 2, 4)')
         tdSql.checkData(0, 2, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 1 then
         tdLog.info('tdSql.checkData(0, 4, 1)')
         tdSql.checkData(0, 4, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step81
         tdLog.info('select * from %s where tgcol2 = 1 -x step81' % (mt))
@@ -885,27 +885,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4
         tdLog.info('alter table %s change tag tgcol1 tgcol4' % (mt))
@@ -948,27 +948,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 4.000000000)')
         tdSql.checkData(0, 2, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 1 then
         tdLog.info('tdSql.checkData(0, 3, 1)')
         tdSql.checkData(0, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6.00000 then
         tdLog.info('tdSql.checkData(0, 4, 6.00000)')
         tdSql.checkData(0, 4, 6.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 1 -x step91
         tdLog.info('select * from %s where tgcol3 = 1 -x step91' % (mt))
@@ -1014,32 +1014,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4 -x step103
         tdLog.info('alter table %s change tag tgcol1 tgcol4 -x step103' % (mt))
@@ -1088,32 +1088,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 0 then
         tdLog.info('tdSql.checkData(0, 4, 0)')
         tdSql.checkData(0, 4, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step101
         tdLog.info('select * from %s where tgcol2 = 1 -x step101' % (mt))
@@ -1159,37 +1159,37 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 5, 4.00000)')
         tdSql.checkData(0, 5, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5 then
         tdLog.info('tdSql.checkData(0, 6, 5)')
         tdSql.checkData(0, 6, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt change tag tgcol1 tgcol4 -x step114
         tdLog.info('alter table %s change tag tgcol1 tgcol4 -x step114' % (mt))
@@ -1259,42 +1259,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5 then
         tdLog.info('tdSql.checkData(0, 4, 5)')
         tdSql.checkData(0, 4, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 6 then
         tdLog.info('tdSql.checkData(0, 5, 6)')
         tdSql.checkData(0, 5, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 7 then
         tdLog.info('tdSql.checkData(0, 6, 7)')
         tdSql.checkData(0, 6, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 8 then
         tdLog.info('tdSql.checkData(0, 7, 8)')
         tdSql.checkData(0, 7, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step111
         tdLog.info('select * from %s where tgcol2 = 1 -x step111' % (mt))
@@ -1346,42 +1346,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3.00000 then
         tdLog.info('tdSql.checkData(0, 4, 3.00000)')
         tdSql.checkData(0, 4, 3.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 4.000000000)')
         tdSql.checkData(0, 5, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5 then
         tdLog.info('tdSql.checkData(0, 6, 5)')
         tdSql.checkData(0, 6, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -1445,42 +1445,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 1 then
         tdLog.info('tdSql.checkData(0, 3, 1)')
         tdSql.checkData(0, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5 then
         tdLog.info('tdSql.checkData(0, 4, 5)')
         tdSql.checkData(0, 4, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 3 then
         tdLog.info('tdSql.checkData(0, 6, 3)')
         tdSql.checkData(0, 6, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 2 then
         tdLog.info('tdSql.checkData(0, 7, 2)')
         tdSql.checkData(0, 7, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = '5'
         tdLog.info('select * from %s where tgcol2 = "5"' % (mt))
@@ -1489,7 +1489,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 4
         tdLog.info('select * from %s where tgcol3 = 4' % (mt))
@@ -1498,7 +1498,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol5 = 2
         tdLog.info('select * from %s where tgcol5 = 2' % (mt))
@@ -1507,7 +1507,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '1'
         tdLog.info('select * from %s where tgcol6 = "1"' % (mt))
@@ -1516,7 +1516,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -1552,42 +1552,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 6, 5.000000000)')
         tdSql.checkData(0, 6, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -1645,42 +1645,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 9 then
         tdLog.info('tdSql.checkData(0, 3, 9)')
         tdSql.checkData(0, 3, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 11.000000000 then
         tdLog.info('tdSql.checkData(0, 4, 11.000000000)')
         tdSql.checkData(0, 4, 11.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 8 then
         tdLog.info('tdSql.checkData(0, 5, 8)')
         tdSql.checkData(0, 5, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 10 then
         tdLog.info('tdSql.checkData(0, 6, 10)')
         tdSql.checkData(0, 6, 10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 12 then
         tdLog.info('tdSql.checkData(0, 7, 12)')
         tdSql.checkData(0, 7, 12)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
         # TSIM: sleep 5000
@@ -1713,22 +1713,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -1748,22 +1748,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -1783,22 +1783,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 3, 4.00000)')
         tdSql.checkData(0, 3, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step5
@@ -1819,22 +1819,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step6
@@ -1855,27 +1855,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '6'
         tdLog.info('select * from %s where tgcol6 = "6"' % (mt))
@@ -1886,27 +1886,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = 1
         tdLog.info('select * from %s where tgcol4 = 1' % (mt))
@@ -1915,7 +1915,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -1935,27 +1935,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4 then
         tdLog.info('tdSql.checkData(0, 2, 4)')
         tdSql.checkData(0, 2, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6 then
         tdLog.info('tdSql.checkData(0, 4, 6)')
         tdSql.checkData(0, 4, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step8
@@ -1976,27 +1976,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4 then
         tdLog.info('tdSql.checkData(0, 2, 4)')
         tdSql.checkData(0, 2, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 5 then
         tdLog.info('tdSql.checkData(0, 3, 5)')
         tdSql.checkData(0, 3, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 1 then
         tdLog.info('tdSql.checkData(0, 4, 1)')
         tdSql.checkData(0, 4, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step9
@@ -2017,27 +2017,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 4.000000000)')
         tdSql.checkData(0, 2, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 1 then
         tdLog.info('tdSql.checkData(0, 3, 1)')
         tdSql.checkData(0, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 6.00000 then
         tdLog.info('tdSql.checkData(0, 4, 6.00000)')
         tdSql.checkData(0, 4, 6.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step10
@@ -2058,32 +2058,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 0 then
         tdLog.info('tdSql.checkData(0, 4, 0)')
         tdSql.checkData(0, 4, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -2103,42 +2103,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5 then
         tdLog.info('tdSql.checkData(0, 4, 5)')
         tdSql.checkData(0, 4, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 6 then
         tdLog.info('tdSql.checkData(0, 5, 6)')
         tdSql.checkData(0, 5, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 7 then
         tdLog.info('tdSql.checkData(0, 6, 7)')
         tdSql.checkData(0, 6, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 8 then
         tdLog.info('tdSql.checkData(0, 7, 8)')
         tdSql.checkData(0, 7, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -2159,42 +2159,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 1 then
         tdLog.info('tdSql.checkData(0, 3, 1)')
         tdSql.checkData(0, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5 then
         tdLog.info('tdSql.checkData(0, 4, 5)')
         tdSql.checkData(0, 4, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 3 then
         tdLog.info('tdSql.checkData(0, 6, 3)')
         tdSql.checkData(0, 6, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 2 then
         tdLog.info('tdSql.checkData(0, 7, 2)')
         tdSql.checkData(0, 7, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = '5'
         tdLog.info('select * from %s where tgcol2 = "5"' % (mt))
@@ -2203,7 +2203,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 4
         tdLog.info('select * from %s where tgcol3 = 4' % (mt))
@@ -2212,7 +2212,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol5 = 2
         tdLog.info('select * from %s where tgcol5 = 2' % (mt))
@@ -2221,7 +2221,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '1'
         tdLog.info('select * from %s where tgcol6 = "1"' % (mt))
@@ -2230,7 +2230,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -2250,42 +2250,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 9 then
         tdLog.info('tdSql.checkData(0, 3, 9)')
         tdSql.checkData(0, 3, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 11.000000000 then
         tdLog.info('tdSql.checkData(0, 4, 11.000000000)')
         tdSql.checkData(0, 4, 11.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 8 then
         tdLog.info('tdSql.checkData(0, 5, 8)')
         tdSql.checkData(0, 5, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 10 then
         tdLog.info('tdSql.checkData(0, 6, 10)')
         tdSql.checkData(0, 6, 10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 12 then
         tdLog.info('tdSql.checkData(0, 7, 12)')
         tdSql.checkData(0, 7, 12)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -2299,7 +2299,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/create.py b/tests/pytest/tag_lite/create.py
index 39a2d83a31..83a1450143 100644
--- a/tests/pytest/tag_lite/create.py
+++ b/tests/pytest/tag_lite/create.py
@@ -76,12 +76,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -89,7 +89,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -120,12 +120,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -133,7 +133,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -164,12 +164,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -177,7 +177,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -207,12 +207,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -220,7 +220,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -251,12 +251,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -264,7 +264,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -295,12 +295,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -310,7 +310,7 @@ class TDTestCase:
         # TSIM: print expect 0, actual: $rows
         tdLog.info('expect 0, actual: $rows')
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -341,12 +341,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -385,12 +385,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = '0'
         tdLog.info('select * from %s where tgcol = "0"' % (mt))
         tdSql.query('select * from %s where tgcol = "0"' % (mt))
@@ -398,7 +398,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -431,12 +431,12 @@ class TDTestCase:
         # TSIM: print expect 1, actual: $rows
         tdLog.info('expect 1, actual: $rows')
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -475,12 +475,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -488,7 +488,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -519,12 +519,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -532,7 +532,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step13
         tdLog.info('=============== step13')
@@ -563,12 +563,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -576,7 +576,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -607,12 +607,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
@@ -621,7 +621,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
         # TSIM: $i = 15
@@ -651,12 +651,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -664,7 +664,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step16
         tdLog.info('=============== step16')
@@ -695,12 +695,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -708,7 +708,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step17
         tdLog.info('=============== step17')
@@ -739,12 +739,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -752,7 +752,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step18
         tdLog.info('=============== step18')
@@ -783,12 +783,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -796,7 +796,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step19
         tdLog.info('=============== step19')
@@ -827,12 +827,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -840,7 +840,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step20
         tdLog.info('=============== step20')
@@ -871,12 +871,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -884,7 +884,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step21
         tdLog.info('=============== step21')
@@ -915,12 +915,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -928,7 +928,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step22
         tdLog.info('=============== step22')
@@ -959,12 +959,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -972,7 +972,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step23
         tdLog.info('=============== step23')
@@ -1003,12 +1003,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -1016,7 +1016,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step24
         tdLog.info('=============== step24')
@@ -1052,12 +1052,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 2
         tdLog.info('select * from %s where tgcol2 = 2' % (mt))
         tdSql.query('select * from %s where tgcol2 = 2' % (mt))
@@ -1065,12 +1065,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 = 3
         tdLog.info('select * from %s where tgcol3 = 3' % (mt))
         tdSql.query('select * from %s where tgcol3 = 3' % (mt))
@@ -1078,12 +1078,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol4 = 4
         tdLog.info('select * from %s where tgcol4 = 4' % (mt))
         tdSql.query('select * from %s where tgcol4 = 4' % (mt))
@@ -1091,12 +1091,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol5 = 5
         tdLog.info('select * from %s where tgcol5 = 5' % (mt))
         tdSql.query('select * from %s where tgcol5 = 5' % (mt))
@@ -1104,12 +1104,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol6 = '6'
         tdLog.info('select * from %s where tgcol6 = "6"' % (mt))
         tdSql.query('select * from %s where tgcol6 = "6"' % (mt))
@@ -1117,12 +1117,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol6 = '0'
         tdLog.info('select * from %s where tgcol6 = "0"' % (mt))
         tdSql.query('select * from %s where tgcol6 = "0"' % (mt))
@@ -1130,7 +1130,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step25
         tdLog.info('=============== step25')
@@ -1166,12 +1166,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol6 = '0'
         tdLog.info('select * from %s where tgcol6 = "0"' % (mt))
         tdSql.query('select * from %s where tgcol6 = "0"' % (mt))
@@ -1179,7 +1179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step26
         tdLog.info('=============== step26')
@@ -1216,12 +1216,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol3 = '0'
         tdLog.info('select * from %s where tgcol3 = "0"' % (mt))
         tdSql.query('select * from %s where tgcol3 = "0"' % (mt))
@@ -1229,7 +1229,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step27
         tdLog.info('=============== step27')
@@ -1280,12 +1280,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step29
         tdLog.info('=============== step29')
@@ -1316,12 +1316,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step30
         tdLog.info('=============== step30')
@@ -1376,7 +1376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print $data00 $data01 $data02
         tdLog.info('$data00 $data01 $data02')
@@ -1384,7 +1384,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 2, "12345")')
         tdSql.checkData(0, 2, "12345")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/delete.py b/tests/pytest/tag_lite/delete.py
index d4a55a4a75..88615e0406 100644
--- a/tests/pytest/tag_lite/delete.py
+++ b/tests/pytest/tag_lite/delete.py
@@ -77,22 +77,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -127,22 +127,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -177,22 +177,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql describe $tb
         tdLog.info('describe %s' % (tb))
@@ -201,17 +201,17 @@ class TDTestCase:
         tdLog.info('tdSql.checkDataType(2, 1, "BIGINT")')
         tdSql.checkDataType(2, 1, "BIGINT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data31 != FLOAT then
         tdLog.info('tdSql.checkDataType(3, 1, "FLOAT")')
         tdSql.checkDataType(3, 1, "FLOAT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data23 != 1 then
         tdLog.info('tdSql.checkData(2, 3, 1)')
         tdSql.checkData(2, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol1 -x step40
         tdLog.info('alter table %s drop tag tgcol1 -x step40' % (mt))
@@ -251,22 +251,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol1 -x step50
         tdLog.info('alter table %s drop tag tgcol1 -x step50' % (mt))
@@ -306,27 +306,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -364,27 +364,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql describe $tb
         tdLog.info('describe %s' % (tb))
@@ -393,47 +393,47 @@ class TDTestCase:
         tdLog.info('tdSql.checkDataType(2, 1, "SMALLINT")')
         tdSql.checkDataType(2, 1, "SMALLINT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data31 != TINYINT then
         tdLog.info('tdSql.checkDataType(3, 1, "TINYINT")')
         tdSql.checkDataType(3, 1, "TINYINT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data41 != BINARY then
         tdLog.info('tdSql.checkDataType(4, 1, "BINARY")')
         tdSql.checkDataType(4, 1, "BINARY")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data22 != 2 then
         tdLog.info('tdSql.checkData(2, 2, 2)')
         tdSql.checkData(2, 2, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data32 != 1 then
         tdLog.info('tdSql.checkData(3, 2, 1)')
         tdSql.checkData(3, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data42 != 10 then
         tdLog.info('tdSql.checkData(4, 2, 10)')
         tdSql.checkData(4, 2, 10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data23 != 1 then
         tdLog.info('tdSql.checkData(2, 3, 1)')
         tdSql.checkData(2, 3, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data33 != 2 then
         tdLog.info('tdSql.checkData(3, 3, 2)')
         tdSql.checkData(3, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data43 != 3 then
         tdLog.info('tdSql.checkData(4, 3, 3)')
         tdSql.checkData(4, 3, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -471,27 +471,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -531,27 +531,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol3
         tdLog.info('alter table %s drop tag tgcol3' % (mt))
@@ -593,32 +593,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol3
         tdLog.info('alter table %s drop tag tgcol3' % (mt))
@@ -663,37 +663,37 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 5, 4.00000)')
         tdSql.checkData(0, 5, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5 then
         tdLog.info('tdSql.checkData(0, 6, 5)')
         tdSql.checkData(0, 6, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -739,42 +739,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3.00000 then
         tdLog.info('tdSql.checkData(0, 4, 3.00000)')
         tdSql.checkData(0, 4, 3.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 4.000000000)')
         tdSql.checkData(0, 5, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5 then
         tdLog.info('tdSql.checkData(0, 6, 5)')
         tdSql.checkData(0, 6, 5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol2
         tdLog.info('alter table %s drop tag tgcol2' % (mt))
@@ -823,42 +823,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 6, 5.000000000)')
         tdSql.checkData(0, 6, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol3
         tdLog.info('alter table %s drop tag tgcol3' % (mt))
@@ -890,22 +890,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step2
         tdLog.info('select * from %s where tgcol2 = 1 -x step2' % (mt))
@@ -931,22 +931,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step3
         tdLog.info('select * from %s where tgcol2 = 1 -x step3' % (mt))
@@ -972,22 +972,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step4
         tdLog.info('select * from %s where tgcol2 = 1 -x step4' % (mt))
@@ -1013,22 +1013,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = '1' -x step5
         tdLog.info('select * from %s where tgcol2 = "1" -x step5' % (mt))
@@ -1054,27 +1054,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step51
         tdLog.info('select * from %s where tgcol2 = 1 -x step51' % (mt))
@@ -1105,27 +1105,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step71
         tdLog.info('select * from %s where tgcol2 = 1 -x step71' % (mt))
@@ -1156,27 +1156,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step81
         tdLog.info('select * from %s where tgcol2 = 1 -x step81' % (mt))
@@ -1207,27 +1207,27 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 1 -x step91
         tdLog.info('select * from %s where tgcol3 = 1 -x step91' % (mt))
@@ -1258,32 +1258,32 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != NULL then
         tdLog.info('tdSql.checkData(0, 3, NULL)')
         tdSql.checkData(0, 3, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step101
         tdLog.info('select * from %s where tgcol2 = 1 -x step101' % (mt))
@@ -1319,37 +1319,37 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 3, 4.00000)')
         tdSql.checkData(0, 3, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != NULL then
         tdLog.info('tdSql.checkData(0, 6, NULL)')
         tdSql.checkData(0, 6, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step111
         tdLog.info('select * from %s where tgcol2 = 1 -x step111' % (mt))
@@ -1385,42 +1385,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.000000000 then
         tdLog.info('tdSql.checkData(0, 3, 4.000000000)')
         tdSql.checkData(0, 3, 4.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != NULL then
         tdLog.info('tdSql.checkData(0, 4, NULL)')
         tdSql.checkData(0, 4, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != NULL then
         tdLog.info('tdSql.checkData(0, 6, NULL)')
         tdSql.checkData(0, 6, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 1 -x step120
         tdLog.info('select * from %s where tgcol2 = 1 -x step120' % (mt))
@@ -1464,42 +1464,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 4, 5.000000000)')
         tdSql.checkData(0, 4, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != NULL then
         tdLog.info('tdSql.checkData(0, 5, NULL)')
         tdSql.checkData(0, 5, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != NULL then
         tdLog.info('tdSql.checkData(0, 6, NULL)')
         tdSql.checkData(0, 6, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol3 = 1 -x step130
         tdLog.info('select * from %s where tgcol3 = 1 -x step130' % (mt))
@@ -1583,7 +1583,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/double.py b/tests/pytest/tag_lite/double.py
index f70c6871af..b1f29f592e 100644
--- a/tests/pytest/tag_lite/double.py
+++ b/tests/pytest/tag_lite/double.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -123,7 +123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -155,7 +155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -167,7 +167,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -179,7 +179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -234,7 +234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -242,7 +242,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -250,7 +250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -305,7 +305,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -313,7 +313,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -342,7 +342,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -364,7 +364,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -376,7 +376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -388,7 +388,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -400,7 +400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -413,7 +413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -426,7 +426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -462,7 +462,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -480,7 +480,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -498,7 +498,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -517,7 +517,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -536,7 +536,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -556,7 +556,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -570,7 +570,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/filter.py b/tests/pytest/tag_lite/filter.py
index cdba8964ef..aeb13a1715 100644
--- a/tests/pytest/tag_lite/filter.py
+++ b/tests/pytest/tag_lite/filter.py
@@ -120,7 +120,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tg = '1' -x
@@ -162,12 +162,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data00 != 10 then
         tdLog.info('tdSql.checkData(0, 0, 10)')
         tdSql.checkData(0, 0, 10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -194,7 +194,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -263,7 +263,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -293,7 +293,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -313,7 +313,7 @@ class TDTestCase:
         # TSIM: print expect 100, actual $data00
         tdLog.info('expect 100, actual $data00')
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
@@ -344,7 +344,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -358,7 +358,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/float.py b/tests/pytest/tag_lite/float.py
index 1bfb1ac94d..7b93cb0ac9 100644
--- a/tests/pytest/tag_lite/float.py
+++ b/tests/pytest/tag_lite/float.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -123,7 +123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -155,7 +155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -167,7 +167,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -179,7 +179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -234,7 +234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -242,7 +242,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -250,7 +250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -305,7 +305,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -313,7 +313,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -342,7 +342,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -364,7 +364,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -376,7 +376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -388,7 +388,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -400,7 +400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -413,7 +413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -426,7 +426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -462,7 +462,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -480,7 +480,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -498,7 +498,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -517,7 +517,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -536,7 +536,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -556,7 +556,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -570,7 +570,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/int.py b/tests/pytest/tag_lite/int.py
index b831244790..99d4a69624 100644
--- a/tests/pytest/tag_lite/int.py
+++ b/tests/pytest/tag_lite/int.py
@@ -81,10 +81,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -107,10 +107,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -122,7 +122,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -130,7 +130,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -138,7 +138,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -146,7 +146,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -154,7 +154,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -166,7 +166,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -178,7 +178,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -188,7 +188,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -200,7 +200,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -213,7 +213,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -224,7 +224,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -233,7 +233,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -241,7 +241,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -249,7 +249,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -261,7 +261,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -272,7 +272,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -280,7 +280,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -288,7 +288,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -296,7 +296,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -304,7 +304,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -312,7 +312,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -320,7 +320,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -328,7 +328,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -341,7 +341,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -353,7 +353,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -363,7 +363,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -375,7 +375,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -387,7 +387,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -399,7 +399,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -412,7 +412,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -425,7 +425,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -443,7 +443,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -461,7 +461,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -479,7 +479,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -497,7 +497,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -516,7 +516,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -535,7 +535,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -555,7 +555,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -569,7 +569,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/int_binary.py b/tests/pytest/tag_lite/int_binary.py
index 62d8f2a604..7760814f66 100644
--- a/tests/pytest/tag_lite/int_binary.py
+++ b/tests/pytest/tag_lite/int_binary.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -122,7 +122,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -159,7 +159,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -170,7 +170,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -178,7 +178,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -186,7 +186,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -194,7 +194,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -202,7 +202,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -210,7 +210,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -218,7 +218,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -226,7 +226,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -237,7 +237,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> '0'
         tdLog.info('select * from %s where tgcol2 <> "0"' % (mt))
         tdSql.query('select * from %s where tgcol2 <> "0"' % (mt))
@@ -245,7 +245,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = '1'
         tdLog.info('select * from %s where tgcol2 = "1"' % (mt))
         tdSql.query('select * from %s where tgcol2 = "1"' % (mt))
@@ -253,7 +253,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> '1'
         tdLog.info('select * from %s where tgcol2 <> "1"' % (mt))
         tdSql.query('select * from %s where tgcol2 <> "1"' % (mt))
@@ -261,7 +261,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -274,7 +274,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -286,7 +286,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -296,7 +296,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -308,7 +308,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -320,7 +320,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -332,7 +332,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -345,7 +345,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -358,7 +358,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -373,7 +373,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '1'
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> "1"' %
@@ -385,7 +385,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = "0"' %
@@ -397,7 +397,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> '0'
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> "0"' %
@@ -409,7 +409,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = "0"' %
@@ -421,7 +421,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> '0'
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> "0"' %
@@ -433,7 +433,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> '0'
         tdLog.info(
@@ -446,7 +446,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '0' and
         # ts < now + 5m
         tdLog.info(
@@ -459,7 +459,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -475,7 +475,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '1' and
         # tgcol <> 1
         tdLog.info(
@@ -488,7 +488,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = '0' and
         # tgcol = 0
         tdLog.info(
@@ -501,7 +501,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> '0' and
         # tgcol <> 0
         tdLog.info(
@@ -514,7 +514,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = '0' and
         # tgcol = 0
         tdLog.info(
@@ -527,7 +527,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> '0'
         # and tgcol <> 0
         tdLog.info(
@@ -540,7 +540,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> '0' and tgcol <> 0
         tdLog.info(
@@ -553,7 +553,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> '0' and
         # ts < now + 5m and ts < now + 5m and tgcol <> 0
         tdLog.info(
@@ -566,7 +566,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -584,7 +584,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -602,7 +602,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = '1'
@@ -618,7 +618,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = 1 and
@@ -635,7 +635,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -653,7 +653,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -671,7 +671,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -690,7 +690,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = '1'
@@ -707,7 +707,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = 1 and
@@ -724,7 +724,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step13
@@ -744,7 +744,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -763,7 +763,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -777,7 +777,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/int_float.py b/tests/pytest/tag_lite/int_float.py
index 8a544c6110..31c94130ab 100644
--- a/tests/pytest/tag_lite/int_float.py
+++ b/tests/pytest/tag_lite/int_float.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -122,7 +122,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -159,7 +159,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -170,7 +170,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -178,7 +178,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -186,7 +186,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -194,7 +194,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -202,7 +202,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -210,7 +210,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -218,7 +218,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -226,7 +226,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -237,7 +237,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 < 0.5
         tdLog.info('select * from %s where tgcol2 < 0.5' % (mt))
         tdSql.query('select * from %s where tgcol2 < 0.5' % (mt))
@@ -245,7 +245,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 > 0.5 and tgcol2 < 1.5
         tdLog.info(
             'select * from %s where tgcol2 > 0.5 and tgcol2 < 1.5' %
@@ -257,7 +257,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 1' % (mt))
@@ -265,7 +265,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 1
         tdLog.info('select * from %s where tgcol2 = 1' % (mt))
         tdSql.query('select * from %s where tgcol2 = 1' % (mt))
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 1
         tdLog.info('select * from %s where tgcol2 <> 1' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 1' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 = 0
         tdLog.info('select * from %s where tgcol2 = 0' % (mt))
         tdSql.query('select * from %s where tgcol2 = 0' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol2 <> 0
         tdLog.info('select * from %s where tgcol2 <> 0' % (mt))
         tdSql.query('select * from %s where tgcol2 <> 0' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -310,7 +310,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -322,7 +322,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -332,7 +332,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -344,7 +344,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -356,7 +356,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -368,7 +368,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -381,7 +381,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -394,7 +394,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -409,7 +409,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol2 <> 1' %
@@ -421,7 +421,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 = 0' %
@@ -433,7 +433,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol2 <> 0' %
@@ -445,7 +445,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 = 0' %
@@ -457,7 +457,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol2 <> 0' %
@@ -469,7 +469,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0
         tdLog.info(
@@ -482,7 +482,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m
         tdLog.info(
@@ -495,7 +495,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -511,7 +511,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 1 and
         # tgcol <> 1
         tdLog.info(
@@ -524,7 +524,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 = 0 and
         # tgcol = 0
         tdLog.info(
@@ -537,7 +537,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol2 <> 0 and
         # tgcol <> 0
         tdLog.info(
@@ -550,7 +550,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 = 0 and
         # tgcol = 0
         tdLog.info(
@@ -563,7 +563,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol2 <> 0 and
         # tgcol <> 0
         tdLog.info(
@@ -576,7 +576,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol2 <> 0 and tgcol <> 0
         tdLog.info(
@@ -589,7 +589,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol2 <> 0 and
         # ts < now + 5m and ts < now + 5m and tgcol <> 0
         tdLog.info(
@@ -602,7 +602,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -620,7 +620,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -638,7 +638,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = 1
@@ -654,7 +654,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = 1 and
@@ -671,7 +671,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -689,7 +689,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -707,7 +707,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step12
         tdLog.info('=============== step12')
@@ -726,7 +726,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol2 = 1 group
@@ -743,7 +743,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tgcol = 1 and
@@ -760,7 +760,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step13
@@ -780,7 +780,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -799,7 +799,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -813,7 +813,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/set.py b/tests/pytest/tag_lite/set.py
index 44f5a0890d..2573600dc4 100644
--- a/tests/pytest/tag_lite/set.py
+++ b/tests/pytest/tag_lite/set.py
@@ -77,22 +77,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $tb set tag tagcx 1 -x step21
         tdLog.info('alter table %s set tag tagcx 1 -x step21' % (tb))
@@ -119,22 +119,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 4
         tdLog.info('select * from %s where tgcol2 = 4' % (mt))
@@ -145,22 +145,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 0 then
         tdLog.info('tdSql.checkData(0, 2, 0)')
         tdSql.checkData(0, 2, 0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql describe $tb
         tdLog.info('describe %s' % (tb))
@@ -171,22 +171,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkDataType(2, 1, "BOOL")')
         tdSql.checkDataType(2, 1, "BOOL")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data31 != INT then
         tdLog.info('tdSql.checkDataType(3, 1, "INT")')
         tdSql.checkDataType(3, 1, "INT")
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data23 != false then
         tdLog.info('tdSql.checkData(2, 3, false)')
         tdSql.checkData(2, 3, false)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data33 != 4 then
         tdLog.info('tdSql.checkData(3, 3, 4)')
         tdSql.checkData(3, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -217,22 +217,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $tb set tag tgcol1=3
         tdLog.info('alter table %s set tag tgcol1=3' % (tb))
@@ -254,22 +254,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 3 then
         tdLog.info('tdSql.checkData(0, 2, 3)')
         tdSql.checkData(0, 2, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 4
         tdLog.info('select * from %s where tgcol2 = 4' % (mt))
@@ -280,22 +280,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 3 then
         tdLog.info('tdSql.checkData(0, 2, 3)')
         tdSql.checkData(0, 2, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 2
         tdLog.info('select * from %s where tgcol2 = 2' % (mt))
@@ -304,7 +304,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step4
@@ -336,22 +336,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2.00000 then
         tdLog.info('tdSql.checkData(0, 3, 2.00000)')
         tdSql.checkData(0, 3, 2.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $tb set tag tgcol1=3
         tdLog.info('alter table %s set tag tgcol1=3' % (tb))
@@ -373,22 +373,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 3 then
         tdLog.info('tdSql.checkData(0, 2, 3)')
         tdSql.checkData(0, 2, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 3, 4.00000)')
         tdSql.checkData(0, 3, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 4
         tdLog.info('select * from %s where tgcol2 = 4' % (mt))
@@ -399,22 +399,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 3 then
         tdLog.info('tdSql.checkData(0, 2, 3)')
         tdSql.checkData(0, 2, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4.00000 then
         tdLog.info('tdSql.checkData(0, 3, 4.00000)')
         tdSql.checkData(0, 3, 4.00000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step5
@@ -446,22 +446,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 1.000000000)')
         tdSql.checkData(0, 2, 1.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $tb set tag tgcol1=3
         tdLog.info('alter table %s set tag tgcol1=3' % (tb))
@@ -483,22 +483,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 3.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 3.000000000)')
         tdSql.checkData(0, 2, 3.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = '4'
         tdLog.info('select * from %s where tgcol2 = "4"' % (mt))
@@ -509,22 +509,22 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 3.000000000 then
         tdLog.info('tdSql.checkData(0, 2, 3.000000000)')
         tdSql.checkData(0, 2, 3.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 4 then
         tdLog.info('tdSql.checkData(0, 3, 4)')
         tdSql.checkData(0, 3, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -560,42 +560,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 1 then
         tdLog.info('tdSql.checkData(0, 2, 1)')
         tdSql.checkData(0, 2, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 2 then
         tdLog.info('tdSql.checkData(0, 3, 2)')
         tdSql.checkData(0, 3, 2)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 3 then
         tdLog.info('tdSql.checkData(0, 4, 3)')
         tdSql.checkData(0, 4, 3)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 4 then
         tdLog.info('tdSql.checkData(0, 5, 4)')
         tdSql.checkData(0, 5, 4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 5.000000000 then
         tdLog.info('tdSql.checkData(0, 6, 5.000000000)')
         tdSql.checkData(0, 6, 5.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != 6 then
         tdLog.info('tdSql.checkData(0, 7, 6)')
         tdSql.checkData(0, 7, 6)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql alter table $mt drop tag tgcol3
         tdLog.info('alter table %s drop tag tgcol3' % (mt))
@@ -629,42 +629,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 8 then
         tdLog.info('tdSql.checkData(0, 3, 8)')
         tdSql.checkData(0, 3, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 9 then
         tdLog.info('tdSql.checkData(0, 4, 9)')
         tdSql.checkData(0, 4, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 10.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 10.000000000)')
         tdSql.checkData(0, 5, 10.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 11 then
         tdLog.info('tdSql.checkData(0, 6, 11)')
         tdSql.checkData(0, 6, 11)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol2 = 8
         tdLog.info('select * from %s where tgcol2 = 8' % (mt))
@@ -675,42 +675,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 8 then
         tdLog.info('tdSql.checkData(0, 3, 8)')
         tdSql.checkData(0, 3, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 9 then
         tdLog.info('tdSql.checkData(0, 4, 9)')
         tdSql.checkData(0, 4, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 10.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 10.000000000)')
         tdSql.checkData(0, 5, 10.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 11 then
         tdLog.info('tdSql.checkData(0, 6, 11)')
         tdSql.checkData(0, 6, 11)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol4 = '9'
         tdLog.info('select * from %s where tgcol4 = "9"' % (mt))
@@ -721,42 +721,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 8 then
         tdLog.info('tdSql.checkData(0, 3, 8)')
         tdSql.checkData(0, 3, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 9 then
         tdLog.info('tdSql.checkData(0, 4, 9)')
         tdSql.checkData(0, 4, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 10.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 10.000000000)')
         tdSql.checkData(0, 5, 10.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 11 then
         tdLog.info('tdSql.checkData(0, 6, 11)')
         tdSql.checkData(0, 6, 11)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol5 = 10
         tdLog.info('select * from %s where tgcol5 = 10' % (mt))
@@ -767,42 +767,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 8 then
         tdLog.info('tdSql.checkData(0, 3, 8)')
         tdSql.checkData(0, 3, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 9 then
         tdLog.info('tdSql.checkData(0, 4, 9)')
         tdSql.checkData(0, 4, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 10.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 10.000000000)')
         tdSql.checkData(0, 5, 10.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 11 then
         tdLog.info('tdSql.checkData(0, 6, 11)')
         tdSql.checkData(0, 6, 11)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol6 = '11'
         tdLog.info('select * from %s where tgcol6 = "11"' % (mt))
@@ -813,42 +813,42 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data01 != 1 then
         tdLog.info('tdSql.checkData(0, 1, 1)')
         tdSql.checkData(0, 1, 1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data02 != 7 then
         tdLog.info('tdSql.checkData(0, 2, 7)')
         tdSql.checkData(0, 2, 7)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data03 != 8 then
         tdLog.info('tdSql.checkData(0, 3, 8)')
         tdSql.checkData(0, 3, 8)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data04 != 9 then
         tdLog.info('tdSql.checkData(0, 4, 9)')
         tdSql.checkData(0, 4, 9)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data05 != 10.000000000 then
         tdLog.info('tdSql.checkData(0, 5, 10.000000000)')
         tdSql.checkData(0, 5, 10.000000000)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data06 != 11 then
         tdLog.info('tdSql.checkData(0, 6, 11)')
         tdSql.checkData(0, 6, 11)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data07 != NULL then
         tdLog.info('tdSql.checkData(0, 7, NULL)')
         tdSql.checkData(0, 7, None)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -862,7 +862,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/smallint.py b/tests/pytest/tag_lite/smallint.py
index a047b0afee..089af55a34 100644
--- a/tests/pytest/tag_lite/smallint.py
+++ b/tests/pytest/tag_lite/smallint.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -123,7 +123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -155,7 +155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -167,7 +167,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -179,7 +179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -234,7 +234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -242,7 +242,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -250,7 +250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -305,7 +305,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -313,7 +313,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -342,7 +342,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -364,7 +364,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -376,7 +376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -388,7 +388,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -400,7 +400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -413,7 +413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -426,7 +426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -462,7 +462,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -480,7 +480,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -498,7 +498,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -517,7 +517,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -536,7 +536,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -556,7 +556,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -570,7 +570,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/tag_lite/tinyint.py b/tests/pytest/tag_lite/tinyint.py
index 6e1820713c..55e33d013b 100644
--- a/tests/pytest/tag_lite/tinyint.py
+++ b/tests/pytest/tag_lite/tinyint.py
@@ -82,10 +82,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM: while $i < 10
         while (i < 10):
             # TSIM: $tb = $tbPrefix . $i
@@ -108,10 +108,10 @@ class TDTestCase:
                     (tb, ms, x))
                 # TSIM: $x = $x + 1
                 x = x + 1
-                #TSIM: endw
+                # TSIM: endw
             # TSIM: $i = $i + 1
             i = i + 1
-            #TSIM: endw
+            # TSIM: endw
         # TSIM:
         # TSIM: print =============== step2
         tdLog.info('=============== step2')
@@ -123,7 +123,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($rowNum)')
         tdSql.checkRows(rowNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (tb))
         tdSql.query('select * from %s where ts < now + 4m' % (tb))
@@ -131,7 +131,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts <= now + 4m
         tdLog.info('select * from %s where ts <= now + 4m' % (tb))
         tdSql.query('select * from %s where ts <= now + 4m' % (tb))
@@ -139,7 +139,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (tb))
         tdSql.query('select * from %s where ts > now + 4m' % (tb))
@@ -147,7 +147,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts >= now + 4m
         tdLog.info('select * from %s where ts >= now + 4m' % (tb))
         tdSql.query('select * from %s where ts >= now + 4m' % (tb))
@@ -155,7 +155,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(15)')
         tdSql.checkRows(15)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -167,7 +167,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts < now + 4m and ts > now + 5m
         tdLog.info(
             'select * from %s where ts < now + 4m and ts > now + 5m' %
@@ -179,7 +179,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > 100000 and ts < 100000
         tdLog.info('select * from %s where ts > 100000 and ts < 100000' % (tb))
         tdSql.query(
@@ -189,7 +189,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts < now + 3m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 3m' %
@@ -201,7 +201,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $tb where ts > now + 4m and ts > now + 5m and
         # ts < now + 6m
         tdLog.info(
@@ -214,7 +214,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -225,7 +225,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow($totalNum)')
         tdSql.checkRows(totalNum)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where ts < now + 4m
         tdLog.info('select * from %s where ts < now + 4m' % (mt))
@@ -234,7 +234,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(50)')
         tdSql.checkRows(50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m
         tdLog.info('select * from %s where ts > now + 4m' % (mt))
         tdSql.query('select * from %s where ts > now + 4m' % (mt))
@@ -242,7 +242,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(150)')
         tdSql.checkRows(150)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts = now + 4m
         tdLog.info('select * from %s where ts = now + 4m' % (mt))
         tdSql.query('select * from %s where ts = now + 4m' % (mt))
@@ -250,7 +250,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m
         tdLog.info(
             'select * from %s where ts > now + 4m and ts < now + 5m' %
@@ -262,7 +262,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(10)')
         tdSql.checkRows(10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step4
         tdLog.info('=============== step4')
@@ -273,7 +273,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -281,7 +281,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -289,7 +289,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -297,7 +297,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
         tdSql.query('select * from %s where tgcol = 1' % (mt))
@@ -305,7 +305,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 1
         tdLog.info('select * from %s where tgcol <> 1' % (mt))
         tdSql.query('select * from %s where tgcol <> 1' % (mt))
@@ -313,7 +313,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol = 0
         tdLog.info('select * from %s where tgcol = 0' % (mt))
         tdSql.query('select * from %s where tgcol = 0' % (mt))
@@ -321,7 +321,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where tgcol <> 0
         tdLog.info('select * from %s where tgcol <> 0' % (mt))
         tdSql.query('select * from %s where tgcol <> 0' % (mt))
@@ -329,7 +329,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(100)')
         tdSql.checkRows(100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -342,7 +342,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 1
         tdLog.info(
             'select * from %s where ts > now + 4m and tgcol <> 1' %
@@ -354,7 +354,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(75)')
         tdSql.checkRows(75)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol = 0
         tdLog.info('select * from %s where ts < now + 4m and tgcol = 0' % (mt))
         tdSql.query(
@@ -364,7 +364,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts < now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts < now + 4m and tgcol <> 0' %
@@ -376,7 +376,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol = 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol = 0' %
@@ -388,7 +388,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts <= now + 4m and tgcol <> 0
         tdLog.info(
             'select * from %s where ts <= now + 4m and tgcol <> 0' %
@@ -400,7 +400,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(25)')
         tdSql.checkRows(25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and ts < now + 5m and
         # tgcol <> 0
         tdLog.info(
@@ -413,7 +413,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: sql select * from $mt where ts > now + 4m and tgcol <> 0 and ts
         # < now + 5m
         tdLog.info(
@@ -426,7 +426,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(5)')
         tdSql.checkRows(5)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -444,7 +444,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step7
         tdLog.info('=============== step7')
@@ -462,7 +462,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step8
         tdLog.info('=============== step8')
@@ -480,7 +480,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 50)')
         tdSql.checkData(0, 0, 50)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step9
         tdLog.info('=============== step9')
@@ -498,7 +498,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step10
         tdLog.info('=============== step10')
@@ -517,7 +517,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -536,7 +536,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 25)')
         tdSql.checkData(0, 0, 25)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM:
         # TSIM: print =============== step12
@@ -556,7 +556,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 1, 100)')
         tdSql.checkData(0, 1, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -570,7 +570,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end
diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py
index ea178baf93..e9f0dad076 100644
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
@@ -99,6 +99,19 @@ class TDDnode:
     def setValgrind(self, value):
         self.valgrind = value
 
+    def getDataSize(self):
+        totalSize = 0
+
+        if (self.deployed == 1):
+            for dirpath, dirnames, filenames in os.walk(self.dataDir):
+                for f in filenames:
+                    fp = os.path.join(dirpath, f)
+
+                    if not os.path.islink(fp):
+                        totalSize = totalSize + os.path.getsize(fp)
+
+        return totalSize
+
     def deploy(self):
         self.logDir = "%s/pysim/dnode%d/log" % (self.path, self.index)
         self.dataDir = "%s/pysim/dnode%d/data" % (self.path, self.index)
@@ -384,6 +397,10 @@ class TDDnodes:
         self.check(index)
         self.dnodes[index - 1].stop()
 
+    def getDataSize(self, index):
+        self.check(index)
+        return self.dnodes[index - 1].getDataSize()
+
     def forcestop(self, index):
         self.check(index)
         self.dnodes[index - 1].forcestop()

From 3a650da645b6859c164d751bde957f1530436d8b Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Mon, 25 May 2020 17:16:18 +0800
Subject: [PATCH 21/27] TD-407: add config for binary column display width

---
 src/common/src/tglobal.c         |  12 +
 src/kit/shell/inc/shell.h        |  14 +-
 src/kit/shell/src/shellDarwin.c  |  44 +-
 src/kit/shell/src/shellEngine.c  | 680 +++++++++++++++----------------
 src/kit/shell/src/shellLinux.c   |  43 +-
 src/kit/shell/src/shellMain.c    |   1 -
 src/kit/shell/src/shellWindows.c |  42 +-
 7 files changed, 408 insertions(+), 428 deletions(-)

diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index faf15c4215..763b3f5c22 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -202,6 +202,8 @@ char tsTimezone[64] = {0};
 char tsLocale[TSDB_LOCALE_LEN] = {0};
 char tsCharset[TSDB_LOCALE_LEN] = {0};  // default encode string
 
+int32_t tsMaxBinaryDisplayWidth = 30;
+
 static pthread_once_t tsInitGlobalCfgOnce = PTHREAD_ONCE_INIT;
 
 void taosSetAllDebugFlag() {
@@ -1227,6 +1229,16 @@ static void doInitGlobalConfig() {
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
+
+  cfg.option = "maxBinaryDisplayWidth";
+  cfg.ptr = &tsMaxBinaryDisplayWidth;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 1;
+  cfg.maxValue = 0x7fffffff;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
 }
 
 void taosInitGlobalCfg() {
diff --git a/src/kit/shell/inc/shell.h b/src/kit/shell/inc/shell.h
index 549b0ef977..51bd1c1102 100644
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
@@ -29,18 +29,6 @@
 #define MAX_COMMAND_SIZE       65536
 #define HISTORY_FILE           ".taos_history"
 
-#define BOOL_OUTPUT_LENGTH     6
-#define TINYINT_OUTPUT_LENGTH  6
-#define SMALLINT_OUTPUT_LENGTH 7
-#define INT_OUTPUT_LENGTH      11
-#define BIGINT_OUTPUT_LENGTH   21
-#define FLOAT_OUTPUT_LENGTH    20
-#define DOUBLE_OUTPUT_LENGTH   25
-#define BINARY_OUTPUT_LENGTH   20
-
-// dynamic config timestamp width according to maximum time precision
-extern int32_t TIMESTAMP_OUTPUT_LENGTH;
-
 typedef struct SShellHistory {
   char* hist[MAX_HISTORY_SIZE];
   int   hstart;
@@ -80,7 +68,7 @@ void get_history_path(char* history);
 void cleanup_handler(void* arg);
 void exitShell();
 int shellDumpResult(TAOS* con, char* fname, int* error_no, bool printMode);
-void shellPrintNChar(char* str, int width, bool printMode);
+int shellPrintNChar(const char* str, int length, int width);
 void shellGetGrantInfo(void *con);
 int isCommentLine(char *line);
 
diff --git a/src/kit/shell/src/shellDarwin.c b/src/kit/shell/src/shellDarwin.c
index cd2fe6df33..2f5d1f421d 100644
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
@@ -352,37 +352,29 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-void shellPrintNChar(char *str, int width, bool printMode) {
-  int col_left = width;
-  wchar_t wc;
-  while (col_left > 0) {
-    if (*str == '\0') break;
-    char *tstr = str;
-    int byte_width = mbtowc(&wc, tstr, MB_CUR_MAX);
-    if (byte_width <= 0) break;
-    int col_width = wcwidth(wc);
-    if (col_width <= 0) {
-      str += byte_width;
-      continue;
+int shellPrintNChar(const char *str, int length, int width) {
+  int pos = 0, cols = 0;
+  while (pos < length) {
+    wchar_t wc;
+    pos += mbtowc(&wc, str + pos, MB_CUR_MAX);
+    if (pos > length) {
+      break;
+    }
+
+    int w = wcwidth(wc);
+    if (w > 0) {
+      if (width > 0 && cols + w > width) {
+        break;
+      }
+      printf("%lc", wc);
+      cols += w;
     }
-    if (col_left < col_width) break;
-    printf("%lc", wc);
-    str += byte_width;
-    col_left -= col_width;
   }
 
-  while (col_left > 0) {
-    printf(" ");
-    col_left--;
-  }
-
-  if (!printMode) {
-    printf("|");
-  } else {
-    printf("\n");
-  }
+  return cols;
 }
 
+
 int get_old_terminal_mode(struct termios *tio) {
   /* Make sure stdin is a terminal. */
   if (!isatty(STDIN_FILENO)) {
diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c
index dbb05f6a35..b4103ab331 100644
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -35,6 +35,9 @@ int       prompt_size = 6;
 TAOS_RES *result = NULL;
 SShellHistory   history;
 
+#define DEFAULT_MAX_BINARY_DISPLAY_WIDTH 30
+extern int32_t tsMaxBinaryDisplayWidth;
+
 /*
  * FUNCTION: Initialize the shell.
  */
@@ -195,7 +198,15 @@ int32_t shellRunCommand(TAOS *con, char *command) {
   } else if (regex_match(command, "^[\t ]*clear[ \t;]*$", REG_EXTENDED | REG_ICASE)) {
     // If clear the screen.
     system("clear");
-    return 0;
+  } else if (regex_match(command, "^[\t ]*set[ \t]+max_binary_display_width[ \t]+(default|[1-9][0-9]*)[ \t;]*$", REG_EXTENDED | REG_ICASE)) {
+    strtok(command, " \t");
+    strtok(NULL, " \t");
+    char* p = strtok(NULL, " \t");
+    if (strcasecmp(p, "default") == 0) {
+      tsMaxBinaryDisplayWidth = DEFAULT_MAX_BINARY_DISPLAY_WIDTH;
+    } else {
+      tsMaxBinaryDisplayWidth = atoi(p);
+    }
   } else if (regex_match(command, "^[ \t]*source[\t ]+[^ ]+[ \t;]*$", REG_EXTENDED | REG_ICASE)) {
     /* If source file. */
     char *c_ptr = strtok(command, " ;");
@@ -310,360 +321,349 @@ int regex_match(const char *s, const char *reg, int cflags) {
   return 0;
 }
 
-int shellDumpResult(TAOS *con, char *fname, int *error_no, bool printMode) {
-  TAOS_ROW   row = NULL;
-  int        numOfRows = 0;
-  time_t     tt;
-  char       buf[25] = "\0";
-  struct tm *ptm;
-  int        output_bytes = 0;
-  FILE *     fp = NULL;
-  int        num_fields = taos_field_count(con);
-  wordexp_t  full_path;
 
-  assert(num_fields != 0);
+static char* formatTimestamp(char* buf, int64_t val, int precision) {
+  if (args.is_raw_time) {
+    sprintf(buf, "%" PRId64, val);
+    return buf;
+  }
 
-  result = taos_use_result(con);
+  time_t tt;
+  if (precision == TSDB_TIME_PRECISION_MICRO) {
+    tt = (time_t)(val / 1000000);
+  } else {
+    tt = (time_t)(val / 1000);
+  }
+
+  struct tm* ptm = localtime(&tt);
+  size_t pos = strftime(buf, 32, "%Y-%m-%d %H:%M:%S", ptm);
+
+  if (precision == TSDB_TIME_PRECISION_MICRO) {
+    sprintf(buf + pos, ".%06d", (int)(val % 1000000));
+  } else {
+    sprintf(buf + pos, ".%03d", (int)(val % 1000));
+  }
+
+  return buf;
+}
+
+
+static void dumpFieldToFile(FILE* fp, const char* val, TAOS_FIELD* field, int32_t length, int precision) {
+  if (val == NULL) {
+    fprintf(fp, "%s", TSDB_DATA_NULL_STR);
+    return;
+  }
+
+  char buf[TSDB_MAX_BYTES_PER_ROW];
+  switch (field->type) {
+    case TSDB_DATA_TYPE_BOOL:
+      fprintf(fp, "%d", ((((int)(*((char *)val))) == 1) ? 1 : 0));
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      fprintf(fp, "%d", (int)(*((char *)val)));
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      fprintf(fp, "%d", (int)(*((short *)val)));
+      break;
+    case TSDB_DATA_TYPE_INT:
+      fprintf(fp, "%d", *((int *)val));
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      fprintf(fp, "%" PRId64, *((int64_t *)val));
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      fprintf(fp, "%.5f", GET_FLOAT_VAL(val));
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      fprintf(fp, "%.9f", GET_DOUBLE_VAL(val));
+      break;
+    case TSDB_DATA_TYPE_BINARY:
+    case TSDB_DATA_TYPE_NCHAR:
+      memcpy(buf, val, length);
+      buf[length] = 0;
+      fprintf(fp, "\'%s\'", buf);
+      break;
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      formatTimestamp(buf, *(int64_t*)val, precision);
+      fprintf(fp, "'%s'", buf);
+      break;
+    default:
+      break;
+  }
+}
+
+static int dumpResultToFile(const char* fname, TAOS_RES* result) {
+  TAOS_ROW row = taos_fetch_row(result);
+  if (row == NULL) {
+    return 0;
+  }
+
+  wordexp_t full_path;
+
+  if (wordexp(fname, &full_path, 0) != 0) {
+    fprintf(stderr, "ERROR: invalid file name: %s\n", fname);
+    return -1;
+  }
+
+  FILE* fp = fopen(full_path.we_wordv[0], "w");
+  if (fp == NULL) {
+    fprintf(stderr, "ERROR: failed to open file: %s\n", full_path.we_wordv[0]);
+    wordfree(&full_path);
+    return -1;
+  }
+
+  wordfree(&full_path);
+
+  int num_fields = taos_num_fields(result);
+  TAOS_FIELD *fields = taos_fetch_fields(result);
+  int32_t* length = taos_fetch_lengths(result);
+  int precision = taos_result_precision(result);
+
+  for (int col = 0; col < num_fields; col++) {
+    if (col > 0) {
+      fprintf(fp, ",");
+    }
+    fprintf(fp, "%s", fields[col].name);
+  }
+  fputc('\n', fp);
+  
+  int numOfRows = 0;
+  do {
+    for (int i = 0; i < num_fields; i++) {
+      if (i > 0) {
+        fputc(',', fp);
+      }
+      dumpFieldToFile(fp, row[i], fields +i, length[i], precision);
+    }
+    fputc('\n', fp);
+
+    numOfRows++;
+    row = taos_fetch_row(result);
+  } while( row != NULL);
+
+  fclose(fp);
+  return numOfRows;
+}
+
+
+static void printField(const char* val, TAOS_FIELD* field, int width, int32_t length, int precision) {
+  if (val == NULL) {
+    int w = width;
+    if (field->type < TSDB_DATA_TYPE_TINYINT || field->type > TSDB_DATA_TYPE_DOUBLE) {
+      w = 0;
+    }
+    w = printf("%*s", w, TSDB_DATA_NULL_STR);
+    for (; w < width; w++) {
+      putchar(' ');
+    }
+    return;
+  }
+
+  char buf[TSDB_MAX_BYTES_PER_ROW];
+  switch (field->type) {
+    case TSDB_DATA_TYPE_BOOL:
+      printf("%*s", width, ((((int)(*((char *)val))) == 1) ? "true" : "false"));
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      printf("%*d", width, (int)(*((char *)val)));
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      printf("%*d", width, (int)(*((short *)val)));
+      break;
+    case TSDB_DATA_TYPE_INT:
+      printf("%*d", width, *((int *)val));
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      printf("%*" PRId64, width, *((int64_t *)val));
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      printf("%*.5f", width, GET_FLOAT_VAL(val));
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      printf("%*.9f", width, GET_DOUBLE_VAL(val));
+      break;
+    case TSDB_DATA_TYPE_BINARY:
+    case TSDB_DATA_TYPE_NCHAR:
+      for (int w = shellPrintNChar(val, length, width); w < width; w++) {
+        putchar(' ');
+      }
+      break;
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      formatTimestamp(buf, *(int64_t*)val, precision);
+      printf("%s", buf);
+      break;
+    default:
+      break;
+  }
+}
+
+
+static int verticalPrintResult(TAOS_RES* result) {
+  TAOS_ROW row = taos_fetch_row(result);
+  if (row == NULL) {
+    return 0;
+  }
+
+  int num_fields = taos_num_fields(result);
+  TAOS_FIELD *fields = taos_fetch_fields(result);
+  int32_t* length = taos_fetch_lengths(result);
+  int precision = taos_result_precision(result);
+
+  int maxColNameLen = 0;
+  for (int col = 0; col < num_fields; col++) {
+    int len = strlen(fields[col].name);
+    if (len > maxColNameLen) {
+      maxColNameLen = len;
+    }
+  }
+
+  int numOfRows = 0;
+  do {
+    printf("*************************** %d.row ***************************\n", numOfRows + 1);
+    for (int i = 0; i < num_fields; i++) {
+      TAOS_FIELD* field = fields + i;
+
+      int padding = (int)(maxColNameLen - strlen(field->name));
+      printf("%*.s%s: ", padding, " ", field->name);
+
+      printField(row[i], field, 0, length[i], precision);
+      putchar('\n');
+    }
+
+    numOfRows++;
+    row = taos_fetch_row(result);
+  } while(row != NULL);
+
+  return numOfRows;
+}
+
+
+static int calcColWidth(TAOS_FIELD* field, int precision) {
+  int width = strlen(field->name);
+
+  switch (field->type) {
+    case TSDB_DATA_TYPE_BOOL:
+      return MAX(5, width); // 'false'
+
+    case TSDB_DATA_TYPE_TINYINT:
+      return MAX(4, width); // '-127'
+
+    case TSDB_DATA_TYPE_SMALLINT:
+      return MAX(6, width); // '-32767'
+
+    case TSDB_DATA_TYPE_INT:
+      return MAX(11, width); // '-2147483648'
+
+    case TSDB_DATA_TYPE_BIGINT:
+      return MAX(21, width); // '-9223372036854775807'
+
+    case TSDB_DATA_TYPE_FLOAT:
+      return MAX(20, width);
+
+    case TSDB_DATA_TYPE_DOUBLE:
+      return MAX(25, width);
+
+    case TSDB_DATA_TYPE_BINARY:
+    case TSDB_DATA_TYPE_NCHAR:
+      if (field->bytes > tsMaxBinaryDisplayWidth) {
+        return MAX(tsMaxBinaryDisplayWidth, width);
+      } else {
+        return MAX(field->bytes, width);
+      }
+
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      if (args.is_raw_time) {
+        return MAX(14, width);
+      } else if (precision == TSDB_TIME_PRECISION_MICRO) {
+        return MAX(26, width); // '2020-01-01 00:00:00.000000'
+      } else {
+        return MAX(23, width); // '2020-01-01 00:00:00.000'
+      }
+
+    default:
+      assert(false);
+  }
+
+  return 0;
+}
+
+
+static void printHeader(TAOS_FIELD* fields, int* width, int num_fields) {
+  int rowWidth = 0;
+  for (int col = 0; col < num_fields; col++) {
+    TAOS_FIELD* field = fields + col;
+    int padding = (int)(width[col] - strlen(field->name));
+    int left = padding / 2;
+    printf(" %*.s%s%*.s |", left, " ", field->name, padding - left, " ");
+    rowWidth += width[col] + 3;
+  }
+
+  putchar('\n');
+  for (int i = 0; i < rowWidth; i++) {
+    putchar('=');
+  }
+  putchar('\n');
+}
+
+
+static int horizontalPrintResult(TAOS_RES* result) {
+  TAOS_ROW row = taos_fetch_row(result);
+  if (row == NULL) {
+    return 0;
+  }
+
+  int num_fields = taos_num_fields(result);
+  TAOS_FIELD *fields = taos_fetch_fields(result);
+  int32_t* length = taos_fetch_lengths(result);
+  int precision = taos_result_precision(result);
+
+  int width[TSDB_MAX_COLUMNS];
+  for (int col = 0; col < num_fields; col++) {
+    width[col] = calcColWidth(fields + col, precision);
+  }
+
+  printHeader(fields, width, num_fields);
+
+  int numOfRows = 0;
+  do {
+    for (int i = 0; i < num_fields; i++) {
+      putchar(' ');
+      printField(row[i], fields + i, width[i], length[i], precision);
+      putchar(' ');
+      putchar('|');
+    }
+    putchar('\n');
+    numOfRows++;
+    row = taos_fetch_row(result);
+  } while(row != NULL);
+
+  return numOfRows;
+}
+
+
+int shellDumpResult(TAOS *con, char *fname, int *error_no, bool vertical) {
+  int numOfRows = 0;
+
+  TAOS_RES* result = taos_use_result(con);
   if (result == NULL) {
     taos_error(con);
     return -1;
   }
 
   if (fname != NULL) {
-    if (wordexp(fname, &full_path, 0) != 0) {
-      fprintf(stderr, "ERROR: invalid file name: %s\n", fname);
-      return -1;
-    }
-
-    fp = fopen(full_path.we_wordv[0], "w");
-    if (fp == NULL) {
-      fprintf(stderr, "ERROR: failed to open file: %s\n", full_path.we_wordv[0]);
-      wordfree(&full_path);
-      return -1;
-    }
-
-    wordfree(&full_path);
-  }
-
-  TAOS_FIELD *fields = taos_fetch_fields(result);
-
-  row = taos_fetch_row(result);
-  int32_t* length = taos_fetch_lengths(result);
-  
-  char t_str[TSDB_MAX_BYTES_PER_ROW] = "\0";
-  int  l[TSDB_MAX_COLUMNS] = {0};
-  int  maxLenColumnName = 0;
-
-  if (row) {
-    // Print the header indicator
-    if (fname == NULL) {  // print to standard output
-      if (!printMode) {
-        for (int col = 0; col < num_fields; col++) {
-          switch (fields[col].type) {
-            case TSDB_DATA_TYPE_BOOL:
-              l[col] = MAX(BOOL_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_TINYINT:
-              l[col] = MAX(TINYINT_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_SMALLINT:
-              l[col] = MAX(SMALLINT_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_INT:
-              l[col] = MAX(INT_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_BIGINT:
-              l[col] = MAX(BIGINT_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_FLOAT:
-              l[col] = MAX(FLOAT_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_DOUBLE:
-              l[col] = MAX(DOUBLE_OUTPUT_LENGTH, strlen(fields[col].name));
-              break;
-            case TSDB_DATA_TYPE_BINARY:
-            case TSDB_DATA_TYPE_NCHAR:
-              l[col] = MAX(fields[col].bytes, strlen(fields[col].name));
-              /* l[col] = max(BINARY_OUTPUT_LENGTH, strlen(fields[col].name)); */
-              break;
-            case TSDB_DATA_TYPE_TIMESTAMP: {
-              int32_t defaultWidth = TIMESTAMP_OUTPUT_LENGTH;
-              if (args.is_raw_time) {
-                defaultWidth = 14;
-              }
-              if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                defaultWidth += 3;
-              }
-              l[col] = MAX(defaultWidth, strlen(fields[col].name));
-
-              break;
-            }
-            default:
-              break;
-          }
-
-          int spaces = (int)(l[col] - strlen(fields[col].name));
-          int left_space = spaces / 2;
-          int right_space = (spaces % 2 ? left_space + 1 : left_space);
-          printf("%*.s%s%*.s|", left_space, " ", fields[col].name, right_space, " ");
-          output_bytes += (l[col] + 1);
-        }
-        printf("\n");
-        for (int k = 0; k < output_bytes; k++) printf("=");
-        printf("\n");
-      } else {
-        for (int col = 0; col < num_fields; col++) {
-          if (strlen(fields[col].name) > maxLenColumnName) maxLenColumnName = strlen(fields[col].name);
-        }
-      }
-
-      // print the elements
-      do {
-        if (!printMode) {
-          for (int i = 0; i < num_fields; i++) {
-            if (row[i] == NULL) {
-              printf("%*s|", l[i], TSDB_DATA_NULL_STR);
-              continue;
-            }
-
-            switch (fields[i].type) {
-              case TSDB_DATA_TYPE_BOOL:
-                printf("%*s|", l[i], ((((int)(*((char *)row[i]))) == 1) ? "true" : "false"));
-                break;
-              case TSDB_DATA_TYPE_TINYINT:
-                printf("%*d|", l[i], (int)(*((char *)row[i])));
-                break;
-              case TSDB_DATA_TYPE_SMALLINT:
-                printf("%*d|", l[i], (int)(*((short *)row[i])));
-                break;
-              case TSDB_DATA_TYPE_INT:
-                printf("%*d|", l[i], *((int *)row[i]));
-                break;
-              case TSDB_DATA_TYPE_BIGINT:
-                printf("%*" PRId64 "|", l[i], *((int64_t *)row[i]));
-                break;
-              case TSDB_DATA_TYPE_FLOAT: {
-                float fv = 0;
-                fv = GET_FLOAT_VAL(row[i]);
-                printf("%*.5f|", l[i], fv);
-              }              
-                break;
-              case TSDB_DATA_TYPE_DOUBLE: {
-                double dv = 0;
-                dv = GET_DOUBLE_VAL(row[i]);
-                printf("%*.9f|", l[i], dv);
-              }
-                break;
-              case TSDB_DATA_TYPE_BINARY:
-              case TSDB_DATA_TYPE_NCHAR:
-                memset(t_str, 0, TSDB_MAX_BYTES_PER_ROW);
-                memcpy(t_str, row[i], length[i]);
-                /* printf("%-*s|",max(fields[i].bytes, strlen(fields[i].name)),
-                 * t_str); */
-                /* printf("%-*s|", l[i], t_str); */
-                shellPrintNChar(t_str, l[i], printMode);
-                break;
-              case TSDB_DATA_TYPE_TIMESTAMP:
-                if (args.is_raw_time) {
-                  printf(" %" PRId64 "|", *(int64_t *)row[i]);
-                } else {
-                  if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                    tt = (time_t)((*(int64_t *)row[i]) / 1000000);
-                  } else {
-                    tt = (time_t)((*(int64_t *)row[i]) / 1000);
-                  }
-
-                  ptm = localtime(&tt);
-                  strftime(buf, 64, "%y-%m-%d %H:%M:%S", ptm);
-
-                  if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                    printf(" %s.%06d|", buf, (int)(*(int64_t *)row[i] % 1000000));
-                  } else {
-                    printf(" %s.%03d|", buf, (int)(*(int64_t *)row[i] % 1000));
-                  }
-                }
-                break;
-              default:
-                break;
-            }
-          }
-          printf("\n");
-        } else {
-          printf("*************************** %d.row ***************************\n", numOfRows + 1);
-          for (int i = 0; i < num_fields; i++) {
-            // 1. print column name
-            int left_space = (int)(maxLenColumnName - strlen(fields[i].name));
-            printf("%*.s%s: ", left_space, " ", fields[i].name);
-
-            // 2. print column value
-            if (row[i] == NULL) {
-              printf("%s\n", TSDB_DATA_NULL_STR);
-              continue;
-            }
-
-            switch (fields[i].type) {
-              case TSDB_DATA_TYPE_BOOL:
-                printf("%s\n", ((((int)(*((char *)row[i]))) == 1) ? "true" : "false"));
-                break;
-              case TSDB_DATA_TYPE_TINYINT:
-                printf("%d\n", (int)(*((char *)row[i])));
-                break;
-              case TSDB_DATA_TYPE_SMALLINT:
-                printf("%d\n", (int)(*((short *)row[i])));
-                break;
-              case TSDB_DATA_TYPE_INT:
-                printf("%d\n", *((int *)row[i]));
-                break;
-              case TSDB_DATA_TYPE_BIGINT:
-                printf("%" PRId64 "\n", *((int64_t *)row[i]));
-                break;
-              case TSDB_DATA_TYPE_FLOAT: {
-                float fv = 0;
-                fv = GET_FLOAT_VAL(row[i]);
-                printf("%.5f\n", fv);
-              }              
-                break;
-              case TSDB_DATA_TYPE_DOUBLE: {
-                double dv = 0;
-                dv = GET_DOUBLE_VAL(row[i]);
-                printf("%.9f\n", dv);
-              }
-                break;
-              case TSDB_DATA_TYPE_BINARY:
-              case TSDB_DATA_TYPE_NCHAR:
-                memset(t_str, 0, TSDB_MAX_BYTES_PER_ROW);
-                memcpy(t_str, row[i], length[i]);
-                
-                l[i] = MAX(fields[i].bytes, strlen(fields[i].name));
-                shellPrintNChar(t_str, l[i], printMode);
-                break;
-              case TSDB_DATA_TYPE_TIMESTAMP:
-                if (args.is_raw_time) {
-                  printf("%" PRId64 "\n", *(int64_t *)row[i]);
-                } else {
-                  if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                    tt = (time_t)((*(int64_t *)row[i]) / 1000000);
-                  } else {
-                    tt = (time_t)((*(int64_t *)row[i]) / 1000);
-                  }
-
-                  ptm = localtime(&tt);
-                  strftime(buf, 64, "%y-%m-%d %H:%M:%S", ptm);
-
-                  if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                    printf("%s.%06d\n", buf, (int)(*(int64_t *)row[i] % 1000000));
-                  } else {
-                    printf("%s.%03d\n", buf, (int)(*(int64_t *)row[i] % 1000));
-                  }
-                }
-                break;
-              default:
-                break;
-            }
-          }
-        }
-
-        numOfRows++;
-      } while ((row = taos_fetch_row(result)));
-
-    } else {  // dump to file
-      // first write column
-      for (int col = 0; col < num_fields; col++) {
-        fprintf(fp, "%s", fields[col].name);
-        if (col < num_fields - 1) {
-          fprintf(fp, ",");
-        } else {
-          fprintf(fp, "\n");
-        }
-      }
-      
-      do {
-        for (int i = 0; i < num_fields; i++) {
-          if (row[i]) {
-            switch (fields[i].type) {
-              case TSDB_DATA_TYPE_BOOL:
-                fprintf(fp, "%d", ((((int)(*((char *)row[i]))) == 1) ? 1 : 0));
-                break;
-              case TSDB_DATA_TYPE_TINYINT:
-                fprintf(fp, "%d", (int)(*((char *)row[i])));
-                break;
-              case TSDB_DATA_TYPE_SMALLINT:
-                fprintf(fp, "%d", (int)(*((short *)row[i])));
-                break;
-              case TSDB_DATA_TYPE_INT:
-                fprintf(fp, "%d", *((int *)row[i]));
-                break;
-              case TSDB_DATA_TYPE_BIGINT:
-                fprintf(fp, "%" PRId64, *((int64_t *)row[i]));
-                break;
-              case TSDB_DATA_TYPE_FLOAT: {
-                float fv = 0;
-                fv = GET_FLOAT_VAL(row[i]);
-                fprintf(fp, "%.5f", fv);
-              }              
-                break;
-              case TSDB_DATA_TYPE_DOUBLE: {
-                double dv = 0;
-                dv = GET_DOUBLE_VAL(row[i]);
-                fprintf(fp, "%.9f", dv);
-              }
-                break;
-              case TSDB_DATA_TYPE_BINARY:
-              case TSDB_DATA_TYPE_NCHAR:
-                memset(t_str, 0, TSDB_MAX_BYTES_PER_ROW);
-                memcpy(t_str, row[i], length[i]);
-                fprintf(fp, "\'%s\'", t_str);
-                break;
-              case TSDB_DATA_TYPE_TIMESTAMP:
-                if (args.is_raw_time) {
-                  fprintf(fp, "%" PRId64, *(int64_t *)row[i]);
-                } else {
-                  if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                    tt = (time_t)((*(int64_t *)row[i]) / 1000000);
-                  } else {
-                    tt = (time_t)((*(int64_t *)row[i]) / 1000);
-                  }
-
-                  ptm = localtime(&tt);
-                  strftime(buf, 64, "%Y-%m-%d %H:%M:%S", ptm);
-
-                  if (taos_result_precision(result) == TSDB_TIME_PRECISION_MICRO) {
-                    fprintf(fp, "\'%s.%06d\'", buf, (int)(*(int64_t *)row[i] % 1000000));
-                  } else {
-                    fprintf(fp, "\'%s.%03d\'", buf, (int)(*(int64_t *)row[i] % 1000));
-                  }
-                }
-                break;
-              default:
-                break;
-            }
-          } else {
-            fprintf(fp, "%s", TSDB_DATA_NULL_STR);
-          }
-          if (i < num_fields - 1) {
-            fprintf(fp, ",");
-          } else {
-            fprintf(fp, "\n");
-          }
-        }
-
-        numOfRows++;
-      } while ((row = taos_fetch_row(result)));
-    }
+    numOfRows = dumpResultToFile(fname, result);
+  } else if(vertical) {
+    numOfRows = verticalPrintResult(result);
+  } else {
+    numOfRows = horizontalPrintResult(result);
   }
 
   *error_no = taos_errno(con);
-
   taos_free_result(result);
-  result = NULL;
-
-  if (fname != NULL) {
-    fclose(fp);
-  }
-
   return numOfRows;
 }
 
+
 void read_history() {
   // Initialize history
   memset(history.hist, 0, sizeof(char *) * MAX_HISTORY_SIZE);
diff --git a/src/kit/shell/src/shellLinux.c b/src/kit/shell/src/shellLinux.c
index da2bd94814..37c08d7ae9 100644
--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
@@ -329,35 +329,26 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-void shellPrintNChar(char *str, int width, bool printMode) {
-  int col_left = width;
-  wchar_t wc;
-  while (col_left > 0) {
-    if (*str == '\0') break;
-    char *tstr = str;
-    int byte_width = mbtowc(&wc, tstr, MB_CUR_MAX);
-    if (byte_width <= 0) break;
-    int col_width = wcwidth(wc);
-    if (col_width <= 0) {
-      str += byte_width;
-      continue;
+int shellPrintNChar(const char *str, int length, int width) {
+  int pos = 0, cols = 0;
+  while (pos < length) {
+    wchar_t wc;
+    pos += mbtowc(&wc, str + pos, MB_CUR_MAX);
+    if (pos > length) {
+      break;
+    }
+
+    int w = wcwidth(wc);
+    if (w > 0) {
+      if (width > 0 && cols + w > width) {
+        break;
+      }
+      printf("%lc", wc);
+      cols += w;
     }
-    if (col_left < col_width) break;
-    printf("%lc", wc);
-    str += byte_width;
-    col_left -= col_width;
   }
 
-  while (col_left > 0) {
-    printf(" ");
-    col_left--;
-  }
-
-  if (!printMode) {
-    printf("|");
-  } else {
-    printf("\n");
-  }
+  return cols;
 }
 
 int get_old_terminal_mode(struct termios *tio) {
diff --git a/src/kit/shell/src/shellMain.c b/src/kit/shell/src/shellMain.c
index f8010b84cd..3485a964d7 100644
--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
@@ -20,7 +20,6 @@
 
 TAOS*     con;
 pthread_t pid;
-int32_t   TIMESTAMP_OUTPUT_LENGTH = 22;
 
 // TODO: IMPLEMENT INTERRUPT HANDLER.
 void interruptHandler(int signum) {
diff --git a/src/kit/shell/src/shellWindows.c b/src/kit/shell/src/shellWindows.c
index ac04c593fb..8c7f24ef52 100644
--- a/src/kit/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
@@ -217,32 +217,30 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-void shellPrintNChar(char *str, int width, bool printMode) {
-  int     col_left = width;
-  wchar_t wc;
-  while (col_left > 0) {
-    if (*str == '\0') break;
-    char *tstr = str;
-    int   byte_width = mbtowc(&wc, tstr, MB_CUR_MAX);
-    int   col_width = byte_width;
-    if (col_left < col_width) break;
-    printf("%lc", wc);
-    str += byte_width;
-    col_left -= col_width;
+int shellPrintNChar(const char *str, int length, int width) {
+  int pos = 0, cols = 0;
+  while (pos < length) {
+    wchar_t wc;
+    int bytes = mbtowc(&wc, str + pos, MB_CUR_MAX);
+    pos += bytes;
+    if (pos > length) {
+      break;
+    }
+
+    int w = bytes;
+    if (w > 0) {
+      if (width > 0 && cols + w > width) {
+        break;
+      }
+      printf("%lc", wc);
+      cols += w;
+    }
   }
 
-  while (col_left > 0) {
-    printf(" ");
-    col_left--;
-  }
-  
-  if (!printMode) {
-    printf("|");
-  } else {
-    printf("\n");
-  }
+  return cols;
 }
 
+
 void get_history_path(char *history) { sprintf(history, "%s/%s", ".", HISTORY_FILE); }
 
 void exitShell() { exit(EXIT_SUCCESS); }

From d3aaceedb5e8d5010263e9c83a35df82ffb2597d Mon Sep 17 00:00:00 2001
From: sunguofeng <sunguofeng@yuantiaotech.com>
Date: Mon, 25 May 2020 17:25:08 +0800
Subject: [PATCH 22/27] Update TSDBDriver.java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

多数据源下，driver驱动根据acceptsURL判断url使用合适的驱动，增加判断TAOS驱动
---
 .../jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
index c297fb67b0..f4c9ec765a 100755
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
@@ -188,7 +188,7 @@ public class TSDBDriver implements java.sql.Driver {
 	}
 
 	public boolean acceptsURL(String url) throws SQLException {
-		return true;
+		return StringUtils.isNotBlank(url) && url.startsWith(URL_PREFIX);
 	}
 
 	public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException {
@@ -355,4 +355,4 @@ public class TSDBDriver implements java.sql.Driver {
 	public String database(Properties props) {
 		return props.getProperty(PROPERTY_KEY_DBNAME);
 	}
-}
\ No newline at end of file
+}

From 4e3aa5d5d3228ffb193582f2c25a648eea704b30 Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Mon, 25 May 2020 18:45:43 +0800
Subject: [PATCH 23/27] update shellPrintNChar

it padding the output to be exactly  `width` columns now.
---
 src/kit/shell/inc/shell.h        | 2 +-
 src/kit/shell/src/shellDarwin.c  | 6 ++++--
 src/kit/shell/src/shellEngine.c  | 4 +---
 src/kit/shell/src/shellLinux.c   | 6 ++++--
 src/kit/shell/src/shellWindows.c | 6 ++++--
 5 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/kit/shell/inc/shell.h b/src/kit/shell/inc/shell.h
index 51bd1c1102..5400d9c5ba 100644
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
@@ -68,7 +68,7 @@ void get_history_path(char* history);
 void cleanup_handler(void* arg);
 void exitShell();
 int shellDumpResult(TAOS* con, char* fname, int* error_no, bool printMode);
-int shellPrintNChar(const char* str, int length, int width);
+void shellPrintNChar(const char* str, int length, int width);
 void shellGetGrantInfo(void *con);
 int isCommentLine(char *line);
 
diff --git a/src/kit/shell/src/shellDarwin.c b/src/kit/shell/src/shellDarwin.c
index 2f5d1f421d..e4ef06c403 100644
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
@@ -352,7 +352,7 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-int shellPrintNChar(const char *str, int length, int width) {
+void shellPrintNChar(const char *str, int length, int width) {
   int pos = 0, cols = 0;
   while (pos < length) {
     wchar_t wc;
@@ -371,7 +371,9 @@ int shellPrintNChar(const char *str, int length, int width) {
     }
   }
 
-  return cols;
+  for (; cols < width; cols++) {
+    putchar(' ');
+  }
 }
 
 
diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c
index b4103ab331..ba5909923b 100644
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -484,9 +484,7 @@ static void printField(const char* val, TAOS_FIELD* field, int width, int32_t le
       break;
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
-      for (int w = shellPrintNChar(val, length, width); w < width; w++) {
-        putchar(' ');
-      }
+      shellPrintNChar(val, length, width);
       break;
     case TSDB_DATA_TYPE_TIMESTAMP:
       formatTimestamp(buf, *(int64_t*)val, precision);
diff --git a/src/kit/shell/src/shellLinux.c b/src/kit/shell/src/shellLinux.c
index 37c08d7ae9..856e011a78 100644
--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
@@ -329,7 +329,7 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-int shellPrintNChar(const char *str, int length, int width) {
+void shellPrintNChar(const char *str, int length, int width) {
   int pos = 0, cols = 0;
   while (pos < length) {
     wchar_t wc;
@@ -348,7 +348,9 @@ int shellPrintNChar(const char *str, int length, int width) {
     }
   }
 
-  return cols;
+  for (; cols < width; cols++) {
+    putchar(' ');
+  }
 }
 
 int get_old_terminal_mode(struct termios *tio) {
diff --git a/src/kit/shell/src/shellWindows.c b/src/kit/shell/src/shellWindows.c
index 8c7f24ef52..c446677276 100644
--- a/src/kit/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
@@ -217,7 +217,7 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-int shellPrintNChar(const char *str, int length, int width) {
+void shellPrintNChar(const char *str, int length, int width) {
   int pos = 0, cols = 0;
   while (pos < length) {
     wchar_t wc;
@@ -237,7 +237,9 @@ int shellPrintNChar(const char *str, int length, int width) {
     }
   }
 
-  return cols;
+  for (; cols < width; cols++) {
+    putchar(' ');
+  }
 }
 
 

From 316e807c5151db17fd546f13135966f5ba03e411 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Mon, 25 May 2020 18:46:14 +0800
Subject: [PATCH 24/27] [modify script for arbitrator function]

---
 tests/script/sh/deploy.sh                     |   1 +
 tests/script/sh/exec_tarbitrator.sh           |  64 +++++
 tests/script/sh/stop_dnodes.sh                |   9 +
 tests/script/test.sh                          |   8 +
 .../replica_changeWithArbitrator.sim          | 242 ++++++++++++++++++
 tests/tsim/src/simExe.c                       |   5 +
 tests/tsim/src/simSystem.c                    |   6 +
 7 files changed, 335 insertions(+)
 create mode 100755 tests/script/sh/exec_tarbitrator.sh
 create mode 100644 tests/script/unique/arbitrator/replica_changeWithArbitrator.sim

diff --git a/tests/script/sh/deploy.sh b/tests/script/sh/deploy.sh
index 83ecea555a..b3134938cb 100755
--- a/tests/script/sh/deploy.sh
+++ b/tests/script/sh/deploy.sh
@@ -96,6 +96,7 @@ echo "second              ${HOSTNAME}:7200" >> $TAOS_CFG
 echo "serverPort          ${NODE}"          >> $TAOS_CFG
 echo "dataDir             $DATA_DIR"      >> $TAOS_CFG
 echo "logDir              $LOG_DIR"       >> $TAOS_CFG
+echo "debugFlag           135"            >> $TAOS_CFG
 echo "dDebugFlag          135"            >> $TAOS_CFG
 echo "mDebugFlag          135"            >> $TAOS_CFG
 echo "sdbDebugFlag        135"            >> $TAOS_CFG
diff --git a/tests/script/sh/exec_tarbitrator.sh b/tests/script/sh/exec_tarbitrator.sh
new file mode 100755
index 0000000000..cb0a8858cb
--- /dev/null
+++ b/tests/script/sh/exec_tarbitrator.sh
@@ -0,0 +1,64 @@
+#!/bin/sh
+
+# if [ $# != 2 || $# != 3 ]; then 
+  # echo "argument list need input : "
+  # echo "  -s start/stop"
+  # exit 1
+# fi
+
+EXEC_OPTON=
+while getopts "n:s:u:x:ct" arg 
+do
+  case $arg in
+    n)
+      NODE_NAME=$OPTARG
+      ;;
+    s)
+      EXEC_OPTON=$OPTARG
+      ;;
+    c)
+      CLEAR_OPTION="clear"
+      ;;
+    t)
+      SHELL_OPTION="true"
+      ;;
+    u)
+      USERS=$OPTARG
+      ;;
+    x)
+      SIGNAL=$OPTARG
+      ;;
+    ?)
+      echo "unkown argument"
+      ;;
+  esac
+done
+
+
+SCRIPT_DIR=`dirname $0`
+cd $SCRIPT_DIR/../
+SCRIPT_DIR=`pwd`
+
+cd ../../
+TAOS_DIR=`pwd`
+
+BUILD_DIR=$TAOS_DIR/../debug/build
+SIM_DIR=$TAOS_DIR/sim
+NODE_DIR=$SIM_DIR/arbitrator
+EXE_DIR=$BUILD_DIR/bin
+LOG_DIR=$NODE_DIR/log
+
+echo "------------ $EXEC_OPTON tarbitrator"
+
+if [ "$EXEC_OPTON" = "start" ]; then 
+  echo "------------ log path: $LOG_DIR"
+  nohup $EXE_DIR/tarbitrator -p 8000 -d 135 -g $LOG_DIR > /dev/null 2>&1 & 
+else
+  #relative path
+  PID=`ps -ef|grep tarbitrator | grep -v grep | awk '{print $2}'`
+  if [ -n "$PID" ]; then   
+  	sudo kill -9 $PID
+	  sudo pkill -9 tarbitrator
+  fi 
+fi
+
diff --git a/tests/script/sh/stop_dnodes.sh b/tests/script/sh/stop_dnodes.sh
index 2364dff9b3..1a6e7153c3 100755
--- a/tests/script/sh/stop_dnodes.sh
+++ b/tests/script/sh/stop_dnodes.sh
@@ -13,3 +13,12 @@ while [ -n "$PID" ]; do
   fuser -k -n tcp 6030
   PID=`ps -ef|grep -w taosd | grep -v grep | awk '{print $2}'`
 done
+
+PID=`ps -ef|grep -w tarbitrator | grep -v grep | awk '{print $2}'`
+while [ -n "$PID" ]; do
+	echo kill -9 $PID 
+	pkill -9 tarbitrator
+  fuser -k -n tcp 6040
+  PID=`ps -ef|grep -w tarbitrator | grep -v grep | awk '{print $2}'`
+done
+
diff --git a/tests/script/test.sh b/tests/script/test.sh
index 96ab3c5808..984eb13c4c 100755
--- a/tests/script/test.sh
+++ b/tests/script/test.sh
@@ -62,6 +62,11 @@ CFG_DIR=$PRG_DIR/cfg
 LOG_DIR=$PRG_DIR/log
 DATA_DIR=$PRG_DIR/data
 
+
+ARBITRATOR_PRG_DIR=$SIM_DIR/arbitrator
+ARBITRATOR_LOG_DIR=$ARBITRATOR_PRG_DIR/log
+
+
 chmod -R 777 $PRG_DIR
 echo "------------------------------------------------------------------------"
 echo "Start TDengine Testing Case ..."
@@ -72,9 +77,12 @@ echo "CFG_DIR  : $CFG_DIR"
 
 rm -rf $LOG_DIR
 rm -rf $CFG_DIR
+rm -rf $ARBITRATOR_LOG_DIR
+
 mkdir -p $PRG_DIR
 mkdir -p $LOG_DIR
 mkdir -p $CFG_DIR
+mkdir -p $ARBITRATOR_LOG_DIR
 
 TAOS_CFG=$PRG_DIR/cfg/taos.cfg
 touch -f $TAOS_CFG
diff --git a/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim b/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim
new file mode 100644
index 0000000000..9a04d187fa
--- /dev/null
+++ b/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim
@@ -0,0 +1,242 @@
+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/cfg.sh -n dnode1 -c numOfMPeers -v 2
+system sh/cfg.sh -n dnode2 -c numOfMPeers -v 2
+system sh/cfg.sh -n dnode3 -c numOfMPeers -v 2
+
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode2 -c walLevel -v 1
+system sh/cfg.sh -n dnode3 -c walLevel -v 1
+
+system sh/cfg.sh -n dnode1 -c balanceInterval -v 10
+system sh/cfg.sh -n dnode2 -c balanceInterval -v 10
+system sh/cfg.sh -n dnode3 -c balanceInterval -v 10
+
+system sh/cfg.sh -n dnode1 -c arbitrator -v $arbitrator
+system sh/cfg.sh -n dnode2 -c arbitrator -v $arbitrator
+system sh/cfg.sh -n dnode3 -c arbitrator -v $arbitrator
+
+print ============== step0: start tarbitrator
+system sh/exec_tarbitrator.sh -s start
+
+
+print ============== step1: replica is 1, and start 1 dnode
+system sh/exec_up.sh -n dnode1 -s start
+sleep 3000
+sql connect
+
+$db = replica_db1
+sql create database $db replica 1 maxTables 4
+sql use $db
+
+# create table , insert data
+$stb = repl_stb
+sql create table $stb (ts timestamp, c1 int) tags(t1 int)
+$rowNum = 10
+$tblNum = 12
+
+$ts0 = 1420041600000
+$ts = $ts0
+$delta = 1
+
+$i = 0
+while $i < $tblNum
+  $tb = tb . $i
+  sql create table $tb using $stb tags( $i )
+ 
+  $x = 0
+  while $x < $rowNum
+    $xs = $x * $delta
+    $ts = $ts0 + $xs
+    sql insert into $tb values ( $ts , $x ) 
+    $x = $x + 1
+  endw 
+  $i = $i + 1
+endw 
+
+print ============== step2: add 1 new dnode, expect balanced
+system sh/exec_up.sh -n dnode2 -s start
+sql create dnode $hostname2
+
+# expect after balanced, 2 vondes in dnode1, 1 vonde in dnode2
+$x = 0
+show2: 
+	$x = $x + 1
+	sleep 2000
+	if $x == 10 then
+		return -1
+	endi
+	
+sql show dnodes
+print dnode1 openVnodes $data2_1
+print dnode2 openVnodes $data2_2
+if $data2_1 != 2 then
+	goto show2
+endi
+if $data2_2 != 1 then
+	goto show2
+endi
+
+#print ============== step3: start tarbitrator
+#system sh/exec_tarbitrator.sh -s start
+
+return 1
+
+print ============== step4: stop dnode1, and wait dnode2 master
+system sh/exec_up.sh -n dnode1 -s stop
+
+$x = 0
+loop_wait:
+	$x = $x + 1
+	sleep 2000
+	if $x == 10 then
+	  print ERROR: after dnode1 stop, dnode2 didn't become a master! 
+		return -1
+	endi
+sql show mnodes
+$dnodeRole = $data2_1
+print dnodeRole ==> $dnodeRole
+print dnodeEp ==> $data1_1
+print hostname1 ==> $hostname1
+print arbitrator ==> $arbitrator
+
+if $dnodeRole != master then
+  goto loop_wait
+endi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# alter replica to 2
+#print ============== step3: alter replica to 2
+#sql alter database $db replica 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#$x = 0
+#show2: 
+#	$x = $x + 1
+#	sleep 2000
+#	if $x == 10 then 
+#		return -1
+#	endi
+#	
+#sql show mnodes
+#print dnode1 ==> $data2_1
+#print dnode2 ==> $data2_2
+#if $data2_1 != master then
+#	goto show2
+#endi
+#if $data2_2 != slave then
+#	goto show2
+#endi
+#
+#print ============== step3
+#sql_error drop dnode $hostname1 -x error1
+#print should not drop master
+#
+#print ============== step4
+#system sh/exec_up.sh -n dnode1 -s stop -x SIGINT
+#sql_error show mnodes
+#print error of no master
+#
+#print ============== step5
+#sql_error drop dnode $hostname1
+#print error of no master
+#
+#print ============== step6
+#system sh/exec_up.sh -n dnode1 -s start
+#sleep 2000
+#sql close
+#sql connect
+#
+#$x = 0
+#show6: 
+#	$x = $x + 1
+#	sleep 2000
+#	if $x == 10 then 
+#		return -1
+#	endi
+#	
+#sql show mnodes -x show6
+#print dnode1 ==> $data2_1
+#print dnode2 ==> $data2_2
+#if $data2_1 != master then
+#	goto show6
+#endi
+#if $data2_2 != slave then
+#	goto show6
+#endi
+#
+#print ============== step7
+#system sh/exec_up.sh -n dnode3 -s start
+#sql create dnode $hostname3
+#sleep 5000
+#
+#$x = 0
+#show7: 
+#	$x = $x + 1
+#	sleep 2000
+#	if $x == 10 then 
+#		return -1
+#	endi
+#	
+#sql show mnodes
+#print dnode1 ==> $data2_1
+#print dnode2 ==> $data2_2
+#print dnode3 ==> $data2_3
+#if $data2_1 != master then
+#	goto show7
+#endi
+#if $data2_2 != slave then
+#	goto show7
+#endi
+#if $data3_3 != null then
+#	goto show7
+#endi
+#
+#system sh/exec_up.sh -n dnode1 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode2 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode3 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode4 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode5 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode6 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode7 -s stop  -x SIGINT
+#system sh/exec_up.sh -n dnode8 -s stop  -x SIGINT
\ No newline at end of file
diff --git a/tests/tsim/src/simExe.c b/tests/tsim/src/simExe.c
index 5ea1cb4a1a..0c35e3668c 100644
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
@@ -36,12 +36,17 @@ void simLogSql(char *sql) {
   fflush(fp);
 }
 
+char *simParseArbitratorName(char *varName);
 char *simParseHostName(char *varName);
 char *simGetVariable(SScript *script, char *varName, int varLen) {
   if (strncmp(varName, "hostname", 8) == 0) {
     return simParseHostName(varName);
   }
 
+  if (strncmp(varName, "arbitrator", 10) == 0) {
+      return simParseArbitratorName(varName);
+  }
+
   if (strncmp(varName, "error", varLen) == 0) return script->error;
 
   if (strncmp(varName, "rows", varLen) == 0) return script->rows;
diff --git a/tests/tsim/src/simSystem.c b/tests/tsim/src/simSystem.c
index bac68c22d3..3acfebb9bd 100644
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c
@@ -29,6 +29,12 @@ int simDebugFlag = 135;
 void simCloseTaosdConnect(SScript *script);
 char simHostName[128];
 
+char *simParseArbitratorName(char *varName) {
+  static char hostName[140];
+  sprintf(hostName, "%s:%d", simHostName, 8000);
+  return hostName;
+}
+
 char *simParseHostName(char *varName) {
   static char hostName[140];
 

From 41556c085bde0a5d34209db33ab0c7e151b32fb1 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Mon, 25 May 2020 18:56:24 +0800
Subject: [PATCH 25/27] [modify script for arbitrator function]

---
 .../replica_changeWithArbitrator.sim          | 142 ------------------
 1 file changed, 142 deletions(-)

diff --git a/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim b/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim
index 9a04d187fa..d1b4a2ec72 100644
--- a/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim
+++ b/tests/script/unique/arbitrator/replica_changeWithArbitrator.sim
@@ -80,11 +80,6 @@ if $data2_2 != 1 then
 	goto show2
 endi
 
-#print ============== step3: start tarbitrator
-#system sh/exec_tarbitrator.sh -s start
-
-return 1
-
 print ============== step4: stop dnode1, and wait dnode2 master
 system sh/exec_up.sh -n dnode1 -s stop
 
@@ -99,144 +94,7 @@ loop_wait:
 sql show mnodes
 $dnodeRole = $data2_1
 print dnodeRole ==> $dnodeRole
-print dnodeEp ==> $data1_1
-print hostname1 ==> $hostname1
-print arbitrator ==> $arbitrator
 
 if $dnodeRole != master then
   goto loop_wait
 endi
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# alter replica to 2
-#print ============== step3: alter replica to 2
-#sql alter database $db replica 2
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#$x = 0
-#show2: 
-#	$x = $x + 1
-#	sleep 2000
-#	if $x == 10 then 
-#		return -1
-#	endi
-#	
-#sql show mnodes
-#print dnode1 ==> $data2_1
-#print dnode2 ==> $data2_2
-#if $data2_1 != master then
-#	goto show2
-#endi
-#if $data2_2 != slave then
-#	goto show2
-#endi
-#
-#print ============== step3
-#sql_error drop dnode $hostname1 -x error1
-#print should not drop master
-#
-#print ============== step4
-#system sh/exec_up.sh -n dnode1 -s stop -x SIGINT
-#sql_error show mnodes
-#print error of no master
-#
-#print ============== step5
-#sql_error drop dnode $hostname1
-#print error of no master
-#
-#print ============== step6
-#system sh/exec_up.sh -n dnode1 -s start
-#sleep 2000
-#sql close
-#sql connect
-#
-#$x = 0
-#show6: 
-#	$x = $x + 1
-#	sleep 2000
-#	if $x == 10 then 
-#		return -1
-#	endi
-#	
-#sql show mnodes -x show6
-#print dnode1 ==> $data2_1
-#print dnode2 ==> $data2_2
-#if $data2_1 != master then
-#	goto show6
-#endi
-#if $data2_2 != slave then
-#	goto show6
-#endi
-#
-#print ============== step7
-#system sh/exec_up.sh -n dnode3 -s start
-#sql create dnode $hostname3
-#sleep 5000
-#
-#$x = 0
-#show7: 
-#	$x = $x + 1
-#	sleep 2000
-#	if $x == 10 then 
-#		return -1
-#	endi
-#	
-#sql show mnodes
-#print dnode1 ==> $data2_1
-#print dnode2 ==> $data2_2
-#print dnode3 ==> $data2_3
-#if $data2_1 != master then
-#	goto show7
-#endi
-#if $data2_2 != slave then
-#	goto show7
-#endi
-#if $data3_3 != null then
-#	goto show7
-#endi
-#
-#system sh/exec_up.sh -n dnode1 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode2 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode3 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode4 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode5 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode6 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode7 -s stop  -x SIGINT
-#system sh/exec_up.sh -n dnode8 -s stop  -x SIGINT
\ No newline at end of file

From e1a34a1bf7a815771614b694d910c99a32df3a6e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 25 May 2020 19:13:15 +0800
Subject: [PATCH 26/27] [td-225]fix bugs in fill for super table query

---
 src/client/inc/tsclient.h                    |   2 +-
 src/client/src/tscFunctionImpl.c             |  39 ++++-
 src/client/src/tscParseInsert.c              |   6 +-
 src/client/src/tscSQLParser.c                |  20 ++-
 src/client/src/tscSecondaryMerge.c           |   5 +-
 src/client/src/tscServer.c                   |   4 +-
 src/client/src/tscStream.c                   |   2 +-
 src/client/src/tscUtil.c                     |  10 +-
 src/common/src/ttypes.c                      |  14 +-
 src/inc/taosdef.h                            |   1 +
 src/inc/taosmsg.h                            |   2 +-
 src/query/inc/qExecutor.h                    |   2 +-
 src/query/inc/qfill.h                        |   8 +-
 src/query/src/qExecutor.c                    | 160 ++++++++++++-------
 src/query/src/qfill.c                        | 102 +++++++-----
 src/query/src/tvariant.c                     |   9 +-
 src/tsdb/src/tsdbRead.c                      |  11 +-
 tests/script/general/parser/limit2_query.sim |   1 +
 18 files changed, 248 insertions(+), 150 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 13f5ebc86e..08536a505d 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -210,7 +210,7 @@ typedef struct SQueryInfo {
   int16_t          numOfTables;
   STableMetaInfo **pTableMetaInfo;
   struct STSBuf *  tsBuf;
-  int64_t *        defaultVal;   // default value for interpolation
+  int64_t *        fillVal;      // default value for interpolation
   char *           msg;          // pointer to the pCmd->payload to keep error message temporarily
   int64_t          clauseLimit;  // limit for current sub clause
 
diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index 52d904d314..a265243ce9 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -390,7 +390,11 @@ static void function_finalizer(SQLFunctionCtx *pCtx) {
   
   if (pResInfo->hasResult != DATA_SET_FLAG) {
     tscTrace("no result generated, result is set to NULL");
-    setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+      setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+    } else {
+      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    }
   }
   
   doFinalizer(pCtx);
@@ -1864,12 +1868,22 @@ static void last_row_finalizer(SQLFunctionCtx *pCtx) {
   SResultInfo *pResInfo = GET_RES_INFO(pCtx);
   if (pCtx->currentStage == SECONDARY_STAGE_MERGE) {
     if (pResInfo->hasResult != DATA_SET_FLAG) {
-      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+        setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+      } else {
+        setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      }
+      
       return;
     }
   } else {
     if (pResInfo->hasResult != DATA_SET_FLAG) {
-      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+        setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+      } else {
+        setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      }
+      
       return;
     }
   }
@@ -2885,7 +2899,12 @@ static void leastsquares_finalizer(SQLFunctionCtx *pCtx) {
   SLeastsquareInfo *pInfo = pResInfo->interResultBuf;
   
   if (pInfo->num == 0) {
-    setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+      setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+    } else {
+      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    }
+    
     return;
   }
   
@@ -3862,7 +3881,11 @@ static void interp_function(SQLFunctionCtx *pCtx) {
       *(TSKEY *)pCtx->aOutputBuf = pInfoDetail->ts;
     } else {
       if (pInfoDetail->type == TSDB_FILL_NULL) {
-        setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+        if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+        } else {
+          setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+        }
       } else if (pInfoDetail->type == TSDB_FILL_SET_VALUE) {
         tVariantDump(&pCtx->param[1], pCtx->aOutputBuf, pCtx->inputType);
       } else if (pInfoDetail->type == TSDB_FILL_PREV) {
@@ -3914,7 +3937,11 @@ static void interp_function(SQLFunctionCtx *pCtx) {
           }
           
         } else {
-          setNull(pCtx->aOutputBuf, srcType, pCtx->inputBytes);
+          if (srcType == TSDB_DATA_TYPE_BINARY || srcType == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(pCtx->aOutputBuf, pCtx->inputBytes);
+          } else {
+            setNull(pCtx->aOutputBuf, srcType, pCtx->inputBytes);
+          }
         }
       }
     }
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 3e1f0787c3..9202203fac 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -312,8 +312,7 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
     case TSDB_DATA_TYPE_BINARY:
       // binary data cannot be null-terminated char string, otherwise the last char of the string is lost
       if (pToken->type == TK_NULL) {
-        varDataSetLen(payload, sizeof(int8_t));
-        *(uint8_t*) varDataVal(payload) = TSDB_DATA_BINARY_NULL;
+        setVardataNull(payload, TSDB_DATA_TYPE_BINARY);
       } else { // too long values will return invalid sql, not be truncated automatically
         if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) { //todo refactor
           return tscInvalidSQLErrMsg(msg, "string data overflow", pToken->z);
@@ -326,8 +325,7 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
 
     case TSDB_DATA_TYPE_NCHAR:
       if (pToken->type == TK_NULL) {
-        varDataSetLen(payload, sizeof(int32_t));
-        *(uint32_t*) varDataVal(payload) = TSDB_DATA_NCHAR_NULL;
+        setVardataNull(payload, TSDB_DATA_TYPE_NCHAR);
       } else {
         // if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long'
         size_t output = 0;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index d23d0e1860..35a4937fd7 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -4015,9 +4015,9 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
   
   size_t size = tscSqlExprNumOfExprs(pQueryInfo);
   
-  if (pQueryInfo->defaultVal == NULL) {
-    pQueryInfo->defaultVal = calloc(size, sizeof(int64_t));
-    if (pQueryInfo->defaultVal == NULL) {
+  if (pQueryInfo->fillVal == NULL) {
+    pQueryInfo->fillVal = calloc(size, sizeof(int64_t));
+    if (pQueryInfo->fillVal == NULL) {
       return TSDB_CODE_CLI_OUT_OF_MEMORY;
     }
   }
@@ -4028,7 +4028,11 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
     pQueryInfo->fillType = TSDB_FILL_NULL;
     for (int32_t i = START_INTERPO_COL_IDX; i < size; ++i) {
       TAOS_FIELD* pFields = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
-      setNull((char*)&pQueryInfo->defaultVal[i], pFields->type, pFields->bytes);
+      if (pFields->type == TSDB_DATA_TYPE_BINARY || pFields->type == TSDB_DATA_TYPE_NCHAR) {
+        setVardataNull((char*) &pQueryInfo->fillVal[i], pFields->type);
+      } else {
+        setNull((char*)&pQueryInfo->fillVal[i], pFields->type, pFields->bytes);
+      };
     }
   } else if (strncasecmp(pItem->pVar.pz, "prev", 4) == 0 && pItem->pVar.nLen == 4) {
     pQueryInfo->fillType = TSDB_FILL_PREV;
@@ -4061,11 +4065,11 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
       TAOS_FIELD* pFields = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
 
       if (pFields->type == TSDB_DATA_TYPE_BINARY || pFields->type == TSDB_DATA_TYPE_NCHAR) {
-        setNull((char*)(&pQueryInfo->defaultVal[i]), pFields->type, pFields->bytes);
+        setVardataNull((char*) &pQueryInfo->fillVal[i], pFields->type);
         continue;
       }
 
-      int32_t ret = tVariantDump(&pFillToken->a[j].pVar, (char*)&pQueryInfo->defaultVal[i], pFields->type);
+      int32_t ret = tVariantDump(&pFillToken->a[j].pVar, (char*)&pQueryInfo->fillVal[i], pFields->type);
       if (ret != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg);
       }
@@ -4079,9 +4083,9 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
         TAOS_FIELD* pFields = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
 
         if (pFields->type == TSDB_DATA_TYPE_BINARY || pFields->type == TSDB_DATA_TYPE_NCHAR) {
-          setNull((char*)(&pQueryInfo->defaultVal[i]), pFields->type, pFields->bytes);
+          setVardataNull((char*) &pQueryInfo->fillVal[i], pFields->type);
         } else {
-          tVariantDump(&lastItem->pVar, (char*)&pQueryInfo->defaultVal[i], pFields->type);
+          tVariantDump(&lastItem->pVar, (char*)&pQueryInfo->fillVal[i], pFields->type);
         }
       }
     }
diff --git a/src/client/src/tscSecondaryMerge.c b/src/client/src/tscSecondaryMerge.c
index 35658d1867..7617621e5f 100644
--- a/src/client/src/tscSecondaryMerge.c
+++ b/src/client/src/tscSecondaryMerge.c
@@ -145,7 +145,7 @@ static SFillColInfo* createFillColInfo(SQueryInfo* pQueryInfo) {
     pFillCol[i].flag       = pExpr->colInfo.flag;
     pFillCol[i].col.offset = offset;
     pFillCol[i].functionId = pExpr->functionId;
-    pFillCol[i].defaultVal.i = pQueryInfo->defaultVal[i];
+    pFillCol[i].fillVal.i  = pQueryInfo->fillVal[i];
     offset += pExpr->resBytes;
   }
   
@@ -946,8 +946,7 @@ static void doInterpolateResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, boo
   }
   
   while (1) {
-    int64_t newRows = -1;
-    taosGenerateDataBlock(pFillInfo, pResPages, &newRows, pLocalReducer->resColModel->capacity);
+    int64_t newRows = taosGenerateDataBlock(pFillInfo, pResPages, pLocalReducer->resColModel->capacity);
 
     if (pQueryInfo->limit.offset < newRows) {
       newRows -= pQueryInfo->limit.offset;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 0aac5daa2e..7d0ac09e66 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -781,8 +781,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
     for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-      *((int64_t *)pMsg) = htobe64(pQueryInfo->defaultVal[i]);
-      pMsg += sizeof(pQueryInfo->defaultVal[0]);
+      *((int64_t *)pMsg) = htobe64(pQueryInfo->fillVal[i]);
+      pMsg += sizeof(pQueryInfo->fillVal[0]);
     }
   }
   
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index fd84a2b759..1b1aaa54c9 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -223,7 +223,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
           int16_t     offset = tscFieldInfoGetOffset(pQueryInfo, i);
           TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
 
-          assignVal(pSql->res.data + offset, (char *)(&pQueryInfo->defaultVal[i]), pField->bytes, pField->type);
+          assignVal(pSql->res.data + offset, (char *)(&pQueryInfo->fillVal[i]), pField->bytes, pField->type);
           row[i] = pSql->res.data + offset;
         }
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 296ffe3333..ec9908ae96 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -281,7 +281,7 @@ void tscClearInterpInfo(SQueryInfo* pQueryInfo) {
   }
 
   pQueryInfo->fillType = TSDB_FILL_NONE;
-  tfree(pQueryInfo->defaultVal);
+  tfree(pQueryInfo->fillVal);
 }
 
 int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
@@ -1616,7 +1616,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
   
   pQueryInfo->tsBuf = tsBufDestory(pQueryInfo->tsBuf);
 
-  tfree(pQueryInfo->defaultVal);
+  tfree(pQueryInfo->fillVal);
 }
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
@@ -1768,7 +1768,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   pNewQueryInfo->order  = pQueryInfo->order;
   pNewQueryInfo->clauseLimit = pQueryInfo->clauseLimit;
   pNewQueryInfo->pTableMetaInfo = NULL;
-  pNewQueryInfo->defaultVal  = NULL;
+  pNewQueryInfo->fillVal  = NULL;
   pNewQueryInfo->numOfTables = 0;
   pNewQueryInfo->tsBuf = NULL;
   
@@ -1780,8 +1780,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   tscTagCondCopy(&pNewQueryInfo->tagCond, &pQueryInfo->tagCond);
 
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-    pNewQueryInfo->defaultVal = malloc(pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
-    memcpy(pNewQueryInfo->defaultVal, pQueryInfo->defaultVal, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
+    pNewQueryInfo->fillVal = malloc(pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
+    memcpy(pNewQueryInfo->fillVal, pQueryInfo->fillVal, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
   }
 
   if (tscAllocPayload(pnCmd, TSDB_DEFAULT_PAYLOAD_SIZE) != TSDB_CODE_SUCCESS) {
diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index 654cb65ec3..f97a146a1e 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -381,6 +381,18 @@ bool isNull(const char *val, int32_t type) {
   };
 }
 
+void setVardataNull(char* val, int32_t type) {
+  if (type == TSDB_DATA_TYPE_BINARY) {
+    varDataSetLen(val, sizeof(int8_t));
+    *(uint8_t*) varDataVal(val) = TSDB_DATA_BINARY_NULL;
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    varDataSetLen(val, sizeof(int32_t));
+    *(uint32_t*) varDataVal(val) = TSDB_DATA_NCHAR_NULL;
+  } else {
+    assert(0);
+  }
+}
+
 void setNull(char *val, int32_t type, int32_t bytes) { setNullN(val, type, bytes, 1); }
 
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
@@ -483,7 +495,7 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
       break;
     };
     case TSDB_DATA_TYPE_NCHAR: {
-      wcsncpy((wchar_t*)val, (wchar_t*)src, len / TSDB_NCHAR_SIZE);
+      varDataCopy(val, src);
       break;
     };
     default: {
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index cbb83d1028..b87a6b3118 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -157,6 +157,7 @@ extern tDataTypeDescriptor tDataTypeDesc[11];
 bool isValidDataType(int32_t type, int32_t length);
 bool isNull(const char *val, int32_t type);
 
+void setVardataNull(char* val, int32_t type);
 void setNull(char *val, int32_t type, int32_t bytes);
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems);
 
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index f550b1660f..17b975c193 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -443,7 +443,7 @@ typedef struct {
   int16_t     numOfOutput;  // final output columns numbers
   int16_t     tagNameRelType;   // relation of tag criteria and tbname criteria
   int16_t     fillType;      // interpolate type
-  uint64_t    defaultVal;       // default value array list
+  uint64_t    fillVal;       // default value array list
   int32_t     tsOffset;       // offset value in current msg body, NOTE: ts list is compressed
   int32_t     tsLen;          // total length of ts comp block
   int32_t     tsNumOfBlocks;  // ts comp block numbers
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 3f4618bf1c..0996b643d1 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -138,7 +138,7 @@ typedef struct SQuery {
   SColumnInfo*      colList;
   SColumnInfo*      tagColList;
   int32_t           numOfFilterCols;
-  int64_t*          defaultVal;
+  int64_t*          fillVal;
   uint32_t          status;  // query status
   SResultRec        rec;
   int32_t           pos;
diff --git a/src/query/inc/qfill.h b/src/query/inc/qfill.h
index d0ba8941b2..323ff7a812 100644
--- a/src/query/inc/qfill.h
+++ b/src/query/inc/qfill.h
@@ -28,7 +28,7 @@ typedef struct {
   STColumn col;             // column info
   int16_t  functionId;      // sql function id
   int16_t  flag;            // column flag: TAG COLUMN|NORMAL COLUMN
-  union {int64_t i; double d;} defaultVal;
+  union {int64_t i; double d;} fillVal;
 } SFillColInfo;
   
 typedef struct SFillInfo {
@@ -75,15 +75,13 @@ void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, tFilePage* pInpu
 
 TSKEY taosGetRevisedEndKey(TSKEY ekey, int32_t order, int64_t timeInterval, int8_t slidingTimeUnit, int8_t precision);
 
-int32_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows);
+int64_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows);
 
 int32_t taosNumOfRemainRows(SFillInfo *pFillInfo);
 
-int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numOfRows, int32_t outputRows, char** srcData);
-  
 int taosDoLinearInterpolation(int32_t type, SPoint *point1, SPoint *point2, SPoint *point);
 
-void taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int64_t* outputRows, int32_t capacity);
+int64_t taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int32_t capacity);
 
 #ifdef __cplusplus
 }
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 0bd6f2ab34..47ad633e34 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -376,11 +376,16 @@ bool isSelectivityWithTagsQuery(SQuery *pQuery) {
 
 bool isTSCompQuery(SQuery *pQuery) { return pQuery->pSelectExpr[0].base.functionId == TSDB_FUNC_TS_COMP; }
 
-static bool limitResults(SQuery *pQuery) {
+static bool limitResults(SQueryRuntimeEnv* pRuntimeEnv) {
+  SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+  
   if ((pQuery->limit.limit > 0) && (pQuery->rec.total + pQuery->rec.rows > pQuery->limit.limit)) {
     pQuery->rec.rows = pQuery->limit.limit - pQuery->rec.total;
-    assert(pQuery->rec.rows > 0);
-
+    
+    qTrace("QInfo:%p discard remain data due to result limitation, limit:%"PRId64", current return:%d, total:%"PRId64,
+        pQInfo, pQuery->limit.limit, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
+    assert(pQuery->rec.rows >= 0);
     setQueryStatus(pQuery, QUERY_COMPLETED);
     return true;
   }
@@ -624,15 +629,17 @@ static int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t sea
 /**
  * NOTE: the query status only set for the first scan of master scan.
  */
-static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey, SWindowResInfo *pWindowResInfo) {
+static int32_t doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey, SWindowResInfo *pWindowResInfo) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
   if (pRuntimeEnv->scanFlag != MASTER_SCAN || (!isIntervalQuery(pQuery))) {
-    return;
+    return pWindowResInfo->size;
   }
 
   // no qualified results exist, abort check
+  int32_t numOfClosed = 0;
+  
   if (pWindowResInfo->size == 0) {
-    return;
+    return pWindowResInfo->size;
   }
 
   // query completed
@@ -646,10 +653,10 @@ static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey,
     int32_t i = 0;
     int64_t skey = TSKEY_INITIAL_VAL;
 
-    // TODO opt performance: get the closed time window here
     for (i = 0; i < pWindowResInfo->size; ++i) {
       SWindowResult *pResult = &pWindowResInfo->pResult[i];
       if (pResult->status.closed) {
+        numOfClosed += 1;
         continue;
       }
 
@@ -672,16 +679,26 @@ static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey,
 
     pWindowResInfo->prevSKey = pWindowResInfo->pResult[pWindowResInfo->curIndex].window.skey;
 
-    // the number of completed slots are larger than the threshold, dump to client immediately.
-    int32_t n = numOfClosedTimeWindow(pWindowResInfo);
-    if (n > pWindowResInfo->threshold) {
+    // the number of completed slots are larger than the threshold, return current generated results to client.
+    if (numOfClosed > pWindowResInfo->threshold) {
+      qTrace("QInfo:%p total result window:%d closed:%d, reached the output threshold %d, return",
+          GET_QINFO_ADDR(pRuntimeEnv), pWindowResInfo->size, numOfClosed, pQuery->rec.threshold);
+      
       setQueryStatus(pQuery, QUERY_RESBUF_FULL);
+    } else {
+      qTrace("QInfo:%p total result window:%d already closed:%d", GET_QINFO_ADDR(pRuntimeEnv), pWindowResInfo->size,
+             numOfClosed);
     }
-
-    qTrace("QInfo:%p total window:%d, closed:%d", GET_QINFO_ADDR(pRuntimeEnv), pWindowResInfo->size, n);
   }
-
+  
+  // output has reached the limitation, set query completed
+  if (pQuery->limit.limit > 0 && (pQuery->limit.limit + pQuery->limit.offset) <= numOfClosed &&
+      pRuntimeEnv->scanFlag == MASTER_SCAN) {
+    setQueryStatus(pQuery, QUERY_COMPLETED);
+  }
+  
   assert(pWindowResInfo->prevSKey != TSKEY_INITIAL_VAL);
+  return numOfClosed;
 }
 
 static int32_t getNumOfRowsInTimeWindow(SQuery *pQuery, SDataBlockInfo *pDataBlockInfo, TSKEY *pPrimaryColumn,
@@ -1309,28 +1326,27 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
   TSKEY lastKey = QUERY_IS_ASC_QUERY(pQuery) ? pDataBlockInfo->window.ekey : pDataBlockInfo->window.skey;
   pTableQInfo->lastKey = lastKey + GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
 
-  doCheckQueryCompleted(pRuntimeEnv, lastKey, pWindowResInfo);
 
   // interval query with limit applied
-  if (isIntervalQuery(pQuery) && pQuery->limit.limit > 0 &&
-      (pQuery->limit.limit + pQuery->limit.offset) <= numOfClosedTimeWindow(pWindowResInfo) &&
-      pRuntimeEnv->scanFlag == MASTER_SCAN) {
-    setQueryStatus(pQuery, QUERY_COMPLETED);
-  }
+  int32_t numOfRes = 0;
+  
+  if (isIntervalQuery(pQuery)) {
+    numOfRes = doCheckQueryCompleted(pRuntimeEnv, lastKey, pWindowResInfo);
+  } else {
+    numOfRes = getNumOfResult(pRuntimeEnv);
 
-  int32_t numOfRes = getNumOfResult(pRuntimeEnv);
+    // update the number of output result
+    if (numOfRes > 0 && pQuery->checkBuffer == 1) {
+      assert(numOfRes >= pQuery->rec.rows);
+      pQuery->rec.rows = numOfRes;
 
-  // update the number of output result
-  if (numOfRes > 0 && pQuery->checkBuffer == 1) {
-    assert(numOfRes >= pQuery->rec.rows);
-    pQuery->rec.rows = numOfRes;
+      if (numOfRes >= pQuery->rec.threshold) {
+        setQueryStatus(pQuery, QUERY_RESBUF_FULL);
+      }
 
-    if (numOfRes >= pQuery->rec.threshold) {
-      setQueryStatus(pQuery, QUERY_RESBUF_FULL);
-    }
-    
-    if ((pQuery->limit.limit >= 0) && numOfRes >= (pQuery->limit.limit + pQuery->limit.offset)) {
-      setQueryStatus(pQuery, QUERY_COMPLETED);
+      if ((pQuery->limit.limit >= 0) && (pQuery->limit.limit + pQuery->limit.offset) <= numOfRes) {
+        setQueryStatus(pQuery, QUERY_COMPLETED);
+      }
     }
   }
 
@@ -2026,10 +2042,10 @@ void pointInterpSupporterSetData(SQInfo *pQInfo, SPointInterpoSupporter *pPointI
 
         tVariantCreateFromBinary(&pCtx->param[3], (char *)&count, sizeof(count), TSDB_DATA_TYPE_INT);
 
-        if (isNull((char *)&pQuery->defaultVal[i], pCtx->inputType)) {
+        if (isNull((char *)&pQuery->fillVal[i], pCtx->inputType)) {
           pCtx->param[1].nType = TSDB_DATA_TYPE_NULL;
         } else {
-          tVariantCreateFromBinary(&pCtx->param[1], (char *)&pQuery->defaultVal[i], pCtx->inputBytes, pCtx->inputType);
+          tVariantCreateFromBinary(&pCtx->param[1], (char *)&pQuery->fillVal[i], pCtx->inputBytes, pCtx->inputType);
         }
 
         pInterpDetail->ts = pQuery->window.skey;
@@ -2471,8 +2487,8 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, pQueryHandle, &blockInfo, &pStatis);
     int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, pStatis, binarySearchForKey, pDataBlock);
 
-    qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d", GET_QINFO_ADDR(pRuntimeEnv),
-           blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes);
+    qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%"PRId64, GET_QINFO_ADDR(pRuntimeEnv),
+           blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes, pQuery->current->lastKey);
 
     // while the output buffer is full or limit/offset is applied, query may be paused here
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL | QUERY_COMPLETED)) {
@@ -3374,7 +3390,9 @@ static void clearEnvAfterReverseScan(SQueryRuntimeEnv *pRuntimeEnv, SQueryStatus
   // during reverse scan
   pTableQueryInfo->lastKey = pStatus->lastKey;
   pQuery->status = pStatus->status;
+  
   pTableQueryInfo->win = pStatus->w;
+  pQuery->window = pTableQueryInfo->win;
 }
 
 void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
@@ -3396,6 +3414,7 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
     if (pRuntimeEnv->scanFlag == MASTER_SCAN) {
       qstatus.status = pQuery->status;
       qstatus.curWindow.ekey = pTableQueryInfo->lastKey - step;
+      qstatus.lastKey = pTableQueryInfo->lastKey;
     }
 
     if (!needScanDataBlocksAgain(pRuntimeEnv)) {
@@ -3423,6 +3442,9 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
 
     setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
     pRuntimeEnv->scanFlag = REPEAT_SCAN;
+    
+    qTrace("QInfo:%p start to repeat scan data blocks due to query func required, qrange:%"PRId64"-%"PRId64, pQInfo,
+        cond.twindow.skey, cond.twindow.ekey);
 
     // check if query is killed or not
     if (isQueryKilled(pQInfo)) {
@@ -3707,7 +3729,7 @@ static int32_t doCopyToSData(SQInfo *pQInfo, SWindowResult *result, int32_t orde
   int32_t startIdx = 0;
   int32_t step = -1;
 
-  qTrace("QInfo:%p start to copy data from windowResInfo to query buf", GET_QINFO_ADDR(pQuery));
+  qTrace("QInfo:%p start to copy data from windowResInfo to query buf", pQInfo);
   int32_t totalSubset = getNumOfSubset(pQInfo);
 
   if (orderType == TSDB_ORDER_ASC) {
@@ -3836,7 +3858,7 @@ bool queryHasRemainResults(SQueryRuntimeEnv* pRuntimeEnv) {
   }
   
   /*
-   * There are no results returned to client now.
+   * While the code reaches here, there are no results returned to client now.
    * If query is not completed yet, the gaps between two results blocks need to be handled after next data block
    * is retrieved from TSDB.
    *
@@ -3890,18 +3912,24 @@ static void doCopyQueryResultToMsg(SQInfo *pQInfo, int32_t numOfRows, char *data
 }
 
 int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int32_t numOfRows, int32_t *numOfInterpo) {
+  SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
   SQuery *pQuery = pRuntimeEnv->pQuery;
+  SFillInfo* pFillInfo = pRuntimeEnv->pFillInfo;
+  
   while (1) {
-    taosGenerateDataBlock(pRuntimeEnv->pFillInfo, (tFilePage**) pQuery->sdata, &pQuery->rec.rows, pQuery->rec.capacity);
-    int32_t ret = pQuery->rec.rows;
+    int32_t ret = taosGenerateDataBlock(pFillInfo, (tFilePage**) pQuery->sdata, pQuery->rec.capacity);
     
     // todo apply limit output function
     /* reached the start position of according to offset value, return immediately */
     if (pQuery->limit.offset == 0) {
+      qTrace("QInfo:%p initial numOfRows:%d, generate filled result:%d rows", pQInfo, pFillInfo->numOfRows, ret);
       return ret;
     }
 
     if (pQuery->limit.offset < ret) {
+      qTrace("QInfo:%p initial numOfRows:%d, generate filled result:%d rows, offset:%d. Discard due to offset, remain:%d, new offset:%d",
+             pQInfo, pFillInfo->numOfRows, ret, pQuery->limit.offset, ret - pQuery->limit.offset, 0);
+      
       ret -= pQuery->limit.offset;
       // todo !!!!there exactly number of interpo is not valid.
       // todo refactor move to the beginning of buffer
@@ -3909,10 +3937,16 @@ int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int
         memmove(pDst[i]->data, pDst[i]->data + pQuery->pSelectExpr[i].bytes * pQuery->limit.offset,
                 ret * pQuery->pSelectExpr[i].bytes);
       }
+      
       pQuery->limit.offset = 0;
       return ret;
     } else {
+      qTrace("QInfo:%p initial numOfRows:%d, generate filled result:%d rows, offset:%d. Discard due to offset, "
+             "remain:%d, new offset:%d", pQInfo, pFillInfo->numOfRows, ret, pQuery->limit.offset, 0,
+          pQuery->limit.offset - ret);
+      
       pQuery->limit.offset -= ret;
+      pQuery->rec.rows = 0;
       ret = 0;
     }
 
@@ -3920,8 +3954,6 @@ int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int
       return ret;
     }
   }
-  
-  return 0;
 }
 
 void vnodePrintQueryStatistics(SQInfo *pQInfo) {
@@ -4002,8 +4034,8 @@ static void updateOffsetVal(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBloc
 
   int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock);
 
-  qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d", GET_QINFO_ADDR(pRuntimeEnv),
-         pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes);
+  qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%"PRId64, GET_QINFO_ADDR(pRuntimeEnv),
+         pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes, pQuery->current->lastKey);
 }
 
 void skipBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
@@ -4120,8 +4152,9 @@ static bool skipTimeInterval(SQueryRuntimeEnv *pRuntimeEnv, TSKEY* start) {
           int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, NULL, binarySearchForKey, pDataBlock);
           pRuntimeEnv->windowResInfo.curIndex = index;  // restore the window index
           
-          qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d",
-                 GET_QINFO_ADDR(pRuntimeEnv), blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes);
+          qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%"PRId64,
+                 GET_QINFO_ADDR(pRuntimeEnv), blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes, pQuery->current->lastKey);
+          
           return true;
         } else { // do nothing
           *start = tw.skey;
@@ -4215,7 +4248,7 @@ static SFillColInfo* taosCreateFillColInfo(SQuery* pQuery) {
     pFillCol[i].col.offset = offset;
     pFillCol[i].flag       = TSDB_COL_NORMAL;    // always be ta normal column for table query
     pFillCol[i].functionId = pExprInfo->base.functionId;
-    pFillCol[i].defaultVal.i = pQuery->defaultVal[i];
+    pFillCol[i].fillVal.i = pQuery->fillVal[i];
     
     offset += pExprInfo->bytes;
   }
@@ -4591,7 +4624,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       skipResults(pRuntimeEnv);
 
       // the limitation of output result is reached, set the query completed
-      if (limitResults(pQuery)) {
+      if (limitResults(pRuntimeEnv)) {
         pQInfo->tableIndex = pQInfo->groupInfo.numOfTables;
         break;
       }
@@ -4846,7 +4879,7 @@ static void tableFixedOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
   pQuery->rec.rows = getNumOfResult(pRuntimeEnv);
 
   skipResults(pRuntimeEnv);
-  limitResults(pQuery);
+  limitResults(pRuntimeEnv);
 }
 
 static void tableMultiOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
@@ -4894,7 +4927,7 @@ static void tableMultiOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
     resetCtxOutputBuf(pRuntimeEnv);
   }
 
-  limitResults(pQuery);
+  limitResults(pRuntimeEnv);
   if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
     qTrace("QInfo:%p query paused due to output limitation, next qrange:%" PRId64 "-%" PRId64, pQInfo,
         pQuery->current->lastKey, pQuery->window.ekey);
@@ -4972,7 +5005,7 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
 
     // the offset is handled at prepare stage if no interpolation involved
     if (pQuery->fillType == TSDB_FILL_NONE || pQuery->rec.rows == 0) {
-      limitResults(pQuery);
+      limitResults(pRuntimeEnv);
       break;
     } else {
       TSKEY ekey = taosGetRevisedEndKey(pQuery->window.ekey, pQuery->order.order, pQuery->slidingTime,
@@ -4980,11 +5013,10 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
       taosFillSetStartInfo(pRuntimeEnv->pFillInfo, pQuery->rec.rows, ekey);
       taosFillCopyInputDataFromFilePage(pRuntimeEnv->pFillInfo, (tFilePage**) pQuery->sdata);
       numOfInterpo = 0;
+      
       pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata, pQuery->rec.rows, &numOfInterpo);
-
-      qTrace("QInfo: %p fill results completed, final:%d", pQInfo, pQuery->rec.rows);
       if (pQuery->rec.rows > 0 || Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
-        limitResults(pQuery);
+        limitResults(pRuntimeEnv);
         break;
       }
 
@@ -5017,9 +5049,8 @@ static void tableQueryImpl(SQInfo *pQInfo) {
     int32_t remain = taosNumOfRemainRows(pRuntimeEnv->pFillInfo);
     pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata, remain, &numOfInterpo);
   
-    qTrace("QInfo: %p fill results completed, final:%d", pQInfo, pQuery->rec.rows);
     if (pQuery->rec.rows > 0) {
-      limitResults(pQuery);
+      limitResults(pRuntimeEnv);
     }
     
     qTrace("QInfo:%p current:%d returned, total:%d", pQInfo, pQuery->rec.rows, pQuery->rec.total);
@@ -5351,7 +5382,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
 
   pQueryMsg->fillType = htons(pQueryMsg->fillType);
   if (pQueryMsg->fillType != TSDB_FILL_NONE) {
-    pQueryMsg->defaultVal = (uint64_t)(pMsg);
+    pQueryMsg->fillVal = (uint64_t)(pMsg);
 
     int64_t *v = (int64_t *)pMsg;
     for (int32_t i = 0; i < pQueryMsg->numOfOutput; ++i) {
@@ -5722,13 +5753,13 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SArray* pTableIdList,
   }
 
   if (pQuery->fillType != TSDB_FILL_NONE) {
-    pQuery->defaultVal = malloc(sizeof(int64_t) * pQuery->numOfOutput);
-    if (pQuery->defaultVal == NULL) {
+    pQuery->fillVal = malloc(sizeof(int64_t) * pQuery->numOfOutput);
+    if (pQuery->fillVal == NULL) {
       goto _cleanup;
     }
 
     // the first column is the timestamp
-    memcpy(pQuery->defaultVal, (char *)pQueryMsg->defaultVal, pQuery->numOfOutput * sizeof(int64_t));
+    memcpy(pQuery->fillVal, (char *)pQueryMsg->fillVal, pQuery->numOfOutput * sizeof(int64_t));
   }
 
   // to make sure third party won't overwrite this structure
@@ -5785,7 +5816,7 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SArray* pTableIdList,
   return pQInfo;
 
 _cleanup:
-  tfree(pQuery->defaultVal);
+  tfree(pQuery->fillVal);
 
   if (pQuery->sdata != NULL) {
     for (int16_t col = 0; col < pQuery->numOfOutput; ++col) {
@@ -5893,8 +5924,8 @@ static void freeQInfo(SQInfo *pQInfo) {
     tfree(pQuery->pSelectExpr);
   }
 
-  if (pQuery->defaultVal != NULL) {
-    tfree(pQuery->defaultVal);
+  if (pQuery->fillVal != NULL) {
+    tfree(pQuery->fillVal);
   }
 
   // todo refactor, extract method to destroytableDataInfo
@@ -5997,8 +6028,13 @@ static int32_t doDumpQueryResult(SQInfo *pQInfo, char *data) {
   }
 
   pQuery->rec.total += pQuery->rec.rows;
-  qTrace("QInfo:%p current:%d, total:%d", pQInfo, pQuery->rec.rows, pQuery->rec.total);
+  qTrace("QInfo:%p current numOfRes rows:%d, total:%d", pQInfo, pQuery->rec.rows, pQuery->rec.total);
 
+  if (pQuery->limit.limit > 0 && pQuery->limit.limit == pQuery->rec.total) {
+    qTrace("QInfo:%p results limitation reached, limitation:%"PRId64, pQInfo, pQuery->limit.limit);
+    setQueryStatus(pQuery, QUERY_OVER);
+  }
+  
   return TSDB_CODE_SUCCESS;
 
   // todo if interpolation exists, the result may be dump to client by several rounds
diff --git a/src/query/src/qfill.c b/src/query/src/qfill.c
index 4f69c44940..36ffc433ce 100644
--- a/src/query/src/qfill.c
+++ b/src/query/src/qfill.c
@@ -34,7 +34,7 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, ch
      * here we revised the start time of day according to the local time zone,
      * but in case of DST, the start time of one day need to be dynamically decided.
      *
-     * TODO dynamically decide the start time of a day
+     * TODO dynamically decide the start time of a day, move to common module
      */
 
     // todo refactor to extract function that is available for Linux/Windows/Mac platform
@@ -116,10 +116,9 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
     return;
   }
 
-  pFillInfo->rowIdx = 0;
+  pFillInfo->rowIdx    = 0;
+  pFillInfo->endKey    = endKey;
   pFillInfo->numOfRows = numOfRows;
-  
-  pFillInfo->endKey = endKey;
 }
 
 void taosFillCopyInputDataFromFilePage(SFillInfo* pFillInfo, tFilePage** pInput) {
@@ -131,6 +130,8 @@ void taosFillCopyInputDataFromFilePage(SFillInfo* pFillInfo, tFilePage** pInput)
 
 void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, tFilePage* pInput) {
   assert(pFillInfo->numOfRows == pInput->num);
+  int32_t t = 0;
+  
   for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
     
@@ -138,7 +139,7 @@ void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, tFilePage* pInpu
     memcpy(pFillInfo->pData[i], s, pInput->num * pCol->col.bytes);
     
     if (pCol->flag == TSDB_COL_TAG) {  // copy the tag value
-      memcpy(pFillInfo->pTags[i], pFillInfo->pData[i], pCol->col.bytes);
+      memcpy(pFillInfo->pTags[t++], pFillInfo->pData[i], pCol->col.bytes);
     }
   }
 }
@@ -170,7 +171,7 @@ static int32_t taosGetTotalNumOfFilledRes(SFillInfo* pFillInfo, const TSKEY* tsA
   }
 }
 
-int32_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows) {
+int64_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows) {
   int32_t numOfRes = taosGetTotalNumOfFilledRes(pFillInfo, (int64_t*) pFillInfo->pData[0], numOfRows,
                                                 pFillInfo->slidingTime, ekey);
   return (numOfRes > maxNumOfRows) ? maxNumOfRows : numOfRes;
@@ -193,7 +194,7 @@ static double linearInterpolationImpl(double v1, double v2, double k1, double k2
 int taosDoLinearInterpolation(int32_t type, SPoint* point1, SPoint* point2, SPoint* point) {
   switch (type) {
     case TSDB_DATA_TYPE_INT: {
-      *(int32_t*)point->val = linearInterpolationImpl(*(int32_t*)point1->val, *(int32_t*)point2->val, point1->key,
+      *(int32_t*)point->val = (int32_t) linearInterpolationImpl(*(int32_t*)point1->val, *(int32_t*)point2->val, point1->key,
                                                         point2->key, point->key);
       break;
     }
@@ -209,17 +210,17 @@ int taosDoLinearInterpolation(int32_t type, SPoint* point1, SPoint* point2, SPoi
     };
     case TSDB_DATA_TYPE_TIMESTAMP:
     case TSDB_DATA_TYPE_BIGINT: {
-      *(int64_t*)point->val = linearInterpolationImpl(*(int64_t*)point1->val, *(int64_t*)point2->val, point1->key,
+      *(int64_t*)point->val = (int64_t) linearInterpolationImpl(*(int64_t*)point1->val, *(int64_t*)point2->val, point1->key,
                                                         point2->key, point->key);
       break;
     };
     case TSDB_DATA_TYPE_SMALLINT: {
-      *(int16_t*)point->val = linearInterpolationImpl(*(int16_t*)point1->val, *(int16_t*)point2->val, point1->key,
+      *(int16_t*)point->val = (int16_t) linearInterpolationImpl(*(int16_t*)point1->val, *(int16_t*)point2->val, point1->key,
                                                         point2->key, point->key);
       break;
     };
     case TSDB_DATA_TYPE_TINYINT: {
-      *(int8_t*)point->val =
+      *(int8_t*) point->val = (int8_t)
           linearInterpolationImpl(*(int8_t*)point1->val, *(int8_t*)point2->val, point1->key, point2->key, point->key);
       break;
     };
@@ -243,8 +244,8 @@ static void setTagsValue(SFillInfo* pColInfo, tFilePage** data, char** pTags, in
 
 static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t* num, char** srcData,
                                 int64_t ts, char** pTags, bool outOfBound) {
-  char** prevValues = &pFillInfo->prevValues;
-  char** nextValues = &pFillInfo->nextValues;
+  char* prevValues = pFillInfo->prevValues;
+  char* nextValues = pFillInfo->nextValues;
 
   SPoint point1, point2, point;
 
@@ -257,16 +258,21 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
 
   // set the other values
   if (pFillInfo->fillType == TSDB_FILL_PREV) {
-    char* pInterpolationData = FILL_IS_ASC_FILL(pFillInfo) ? *prevValues : *nextValues;
-    if (pInterpolationData != NULL) {
+    char* p = FILL_IS_ASC_FILL(pFillInfo) ? prevValues : nextValues;
+    
+    if (p != NULL) {
       for (int32_t i = 1; i < numOfValCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
         
         char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        if (isNull(pInterpolationData + pCol->col.offset, pCol->col.type)) {
-          setNull(val1, pCol->col.type, pCol->col.bytes);
+        if (isNull(p + pCol->col.offset, pCol->col.type)) {
+          if (pCol->col.type == TSDB_DATA_TYPE_BINARY || pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(val1, pCol->col.type);
+          } else {
+            setNull(val1, pCol->col.type, pCol->col.bytes);
+          }
         } else {
-          assignVal(val1, pInterpolationData + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+          assignVal(val1, p + pCol->col.offset, pCol->col.bytes, pCol->col.type);
         }
       }
     } else { // no prev value yet, set the value for NULL
@@ -274,14 +280,18 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
 
         char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        setNull(val1, pCol->col.type, pCol->col.bytes);
+        if (pCol->col.type == TSDB_DATA_TYPE_BINARY||pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(val1, pCol->col.type);
+        } else {
+          setNull(val1, pCol->col.type, pCol->col.bytes);
+        }
       }
     }
 
     setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
   } else if (pFillInfo->fillType == TSDB_FILL_LINEAR) {
     // TODO : linear interpolation supports NULL value
-    if (*prevValues != NULL && !outOfBound) {
+    if (prevValues != NULL && !outOfBound) {
       for (int32_t i = 1; i < numOfValCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
         
@@ -289,14 +299,17 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
         int16_t bytes = pCol->col.bytes;
         
         char *val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BOOL) {
+        if (type == TSDB_DATA_TYPE_BINARY|| type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(val1, pCol->col.type);
+          continue;
+        } else if (type == TSDB_DATA_TYPE_BOOL) {
           setNull(val1, pCol->col.type, bytes);
           continue;
         }
 
-        point1 = (SPoint){.key = *(TSKEY*)(*prevValues), .val = *prevValues + pCol->col.offset};
+        point1 = (SPoint){.key = *(TSKEY*)(prevValues), .val = prevValues + pCol->col.offset};
         point2 = (SPoint){.key = ts, .val = srcData[i] + pFillInfo->rowIdx * bytes};
-        point = (SPoint){.key = pFillInfo->start, .val = val1};
+        point  = (SPoint){.key = pFillInfo->start, .val = val1};
         taosDoLinearInterpolation(type, &point1, &point2, &point);
       }
 
@@ -307,7 +320,12 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
   
         char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        setNull(val1, pCol->col.type, pCol->col.bytes);
+  
+        if (pCol->col.type == TSDB_DATA_TYPE_BINARY || pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(val1, pCol->col.type);
+        } else {
+          setNull(val1, pCol->col.type, pCol->col.bytes);
+        }
       }
 
       setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
@@ -318,7 +336,7 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
       
       char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-      assignVal(val1, (char*)&pCol->defaultVal.i, pCol->col.bytes, pCol->col.type);
+      assignVal(val1, (char*)&pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
     }
 
     setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
@@ -338,11 +356,16 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo, char** nextValues) {
   *nextValues = calloc(1, pFillInfo->rowSize);
   for (int i = 1; i < pFillInfo->numOfCols; i++) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-    setNull(*nextValues + pCol->col.offset, pCol->col.type, pCol->col.bytes);
+  
+    if (pCol->col.type == TSDB_DATA_TYPE_BINARY||pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+      setVardataNull(*nextValues + pCol->col.offset, pCol->col.type);
+    } else {
+      setNull(*nextValues + pCol->col.offset, pCol->col.type, pCol->col.bytes);
+    }
   }
 }
 
-int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numOfRows, int32_t outputRows, char** srcData) {
+int32_t generateDataBlockImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t numOfRows, int32_t outputRows, char** srcData) {
   int32_t num = 0;
   pFillInfo->numOfCurrent = 0;
 
@@ -356,8 +379,8 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
 
   if (numOfRows == 0) {
     /*
-     * we need to rebuild whole result set
-     * NOTE:we need to keep the last saved data, to generated the filled data
+     * These data are generated according to fill strategy, since the current timestamp is out of time window of
+     * real result set. Note that we need to keep the direct previous result rows, to generated the filled data.
      */
     while (num < outputRows) {
       doInterpoResultImpl(pFillInfo, data, &num, srcData, pFillInfo->start, pTags, true);
@@ -387,7 +410,7 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
         
         while (((pFillInfo->start < ts && FILL_IS_ASC_FILL(pFillInfo)) ||
                 (pFillInfo->start > ts && !FILL_IS_ASC_FILL(pFillInfo))) && num < outputRows) {
-          doInterpoResultImpl(pFillInfo, data, &num, srcData, pFillInfo->start, pTags, false);
+          doInterpoResultImpl(pFillInfo, data, &num, srcData, ts, pTags, false);
         }
 
         /* output buffer is full, abort */
@@ -420,7 +443,7 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
               assignVal(val1, src, pCol->col.bytes, pCol->col.type);
               memcpy(*prevValues + pCol->col.offset, src, pCol->col.bytes);
             } else {
-              assignVal(val1, (char*) &pCol->defaultVal.i, pCol->col.bytes, pCol->col.type);
+              assignVal(val1, (char*) &pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
             }
           }
         }
@@ -450,21 +473,12 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
   }
 }
 
-void taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int64_t* outputRows, int32_t capacity) {
+int64_t taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int32_t capacity) {
     int32_t remain = taosNumOfRemainRows(pFillInfo);  // todo use iterator?
-    
-//    TSKEY ekey = taosGetRevisedEndKey(pQuery->window.ekey, pQuery->order.order, pQuery->slidingTime,
-//                                      pQuery->slidingTimeUnit, pQuery->precision);
-//    if (QUERY_IS_ASC_QUERY(pQuery)) {
-//      assert(ekey >= pQuery->window.ekey);
-//    } else {
-//      assert(ekey <= pQuery->window.ekey);
-//    }
-    
-    int32_t rows = taosGetNumOfResultWithFill(pFillInfo, remain, pFillInfo->endKey, capacity);
+    int32_t rows   = taosGetNumOfResultWithFill(pFillInfo, remain, pFillInfo->endKey, capacity);
   
-    int32_t numOfRes = taosDoInterpoResult(pFillInfo, output, remain, rows, pFillInfo->pData);
-    *outputRows = rows;
-    
+    int32_t numOfRes = generateDataBlockImpl(pFillInfo, output, remain, rows, pFillInfo->pData);
     assert(numOfRes == rows);
+    
+    return numOfRes;
 }
diff --git a/src/query/src/tvariant.c b/src/query/src/tvariant.c
index 6f8d579936..c89e9dc5f2 100644
--- a/src/query/src/tvariant.c
+++ b/src/query/src/tvariant.c
@@ -101,11 +101,12 @@ void tVariantCreateFromBinary(tVariant *pVar, const char *pz, size_t len, uint32
       break;
     }
     case TSDB_DATA_TYPE_NCHAR: { // here we get the nchar length from raw binary bits length
-      pVar->nLen = len / TSDB_NCHAR_SIZE;
-      pVar->wpz = calloc(1, (pVar->nLen + 1) * TSDB_NCHAR_SIZE);
+      int32_t lenInwchar = len / TSDB_NCHAR_SIZE;
+      pVar->wpz = calloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
       
-      wcsncpy(pVar->wpz, (wchar_t *)pz, pVar->nLen);
-      pVar->wpz[pVar->nLen] = 0;
+      wcsncpy(pVar->wpz, (wchar_t *)pz, lenInwchar);
+      pVar->wpz[lenInwchar] = 0;
+      pVar->nLen = len;
       
       break;
     }
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 0e70ab2d7e..595217debb 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -1539,14 +1539,21 @@ int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT* pQueryHandle, SDataSta
   tsdbLoadCompData(&pHandle->rhelper, pBlockInfo->compBlock, NULL);
   
   size_t numOfCols = QH_GET_NUM_OF_COLS(pHandle);
-  memset(pHandle->statis, 0, sizeof(SDataStatis) * numOfCols);
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    SDataStatis* st = &pHandle->statis[i];
+    int32_t colId = st->colId;
+    
+    memset(st, 0, sizeof(SDataStatis));
+    st->colId = colId;
+  }
+  
   tsdbGetDataStatis(&pHandle->rhelper, pHandle->statis, numOfCols);
   
   *pBlockStatis = pHandle->statis;
   
   //update the number of NULL data rows
   for(int32_t i = 0; i < numOfCols; ++i) {
-    if (pHandle->statis[i].numOfNull == -1) {
+    if (pHandle->statis[i].numOfNull == -1) { // set the column data are all NULL
       pHandle->statis[i].numOfNull = pBlockInfo->compBlock->numOfRows;
     }
   }
diff --git a/tests/script/general/parser/limit2_query.sim b/tests/script/general/parser/limit2_query.sim
index 57cd13abee..cbff2e946c 100644
--- a/tests/script/general/parser/limit2_query.sim
+++ b/tests/script/general/parser/limit2_query.sim
@@ -36,6 +36,7 @@ if $data01 != 2 then
   return -1
 endi
 if $data02 != tb2 then
+  print expect tb2, actual: $data02
   return -1
 endi
 if $data03 != tb2 then

From 6f524d20ac3ec3e4bf9a9c4f1e431c35467166a4 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 25 May 2020 19:27:19 +0800
Subject: [PATCH 27/27] [td-225]fix bugs in diff

---
 src/client/src/tscFunctionImpl.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index a265243ce9..81602d17f4 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -3158,7 +3158,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pCtx->param[1].i64Key;
+          *pOutput = pData[i] - pCtx->param[1].dKey;
           *pTimestamp = pCtx->ptsList[i];
           pOutput += 1;
           pTimestamp += 1;
@@ -3189,7 +3189,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pCtx->param[1].i64Key;
+          *pOutput = pData[i] - pCtx->param[1].dKey;
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;