Merge remote-tracking branch 'origin/develop' into feature/python-test-no-sudo

.travis.yml

@@ -46,10 +46,10 @@ matrix:
           pip3 install --user ${TRAVIS_BUILD_DIR}/src/connector/python/linux/python3/
 
           cd ${TRAVIS_BUILD_DIR}/tests
-          ./test-all.sh || travis_terminate $?
+          ./test-all.sh $TRAVIS_EVENT_TYPE || travis_terminate $?
 
           cd ${TRAVIS_BUILD_DIR}/tests/pytest
-          ./simpletest.sh -g 2>&1 | tee mem-error-out.txt
+          ./smoketest.sh -g 2>&1 | tee mem-error-out.txt
           sleep 1
 
           # Color setting
@@ -86,13 +86,12 @@ matrix:
 
     addons:
       coverity_scan:
-
         # GitHub project metadata
         # ** specific to your project **
         project:
           name: TDengine
           version: 2.x
-          description: taosdata/TDengine
+          description: TDengine
 
         # Where email notification of build analysis results will be sent
         notification_email: sdsang@taosdata.com

src/client/inc/tscUtil.h

@@ -25,6 +25,7 @@ extern "C" {
  */
 #include "os.h"
 #include "tbuffer.h"
+#include "exception.h"
 #include "qextbuffer.h"
 #include "taosdef.h"
 #include "tscSecondaryMerge.h"
@@ -177,7 +178,7 @@ bool tscValidateColumnId(STableMetaInfo* pTableMetaInfo, int32_t colId);
 
 // get starter position of metric query condition (query on tags) in SSqlCmd.payload
 SCond* tsGetSTableQueryCond(STagCond* pCond, uint64_t uid);
-void   tsSetSTableQueryCond(STagCond* pTagCond, uint64_t uid, SBuffer* pBuf);
+void   tsSetSTableQueryCond(STagCond* pTagCond, uint64_t uid, SBufferWriter* bw);
 
 void tscTagCondCopy(STagCond* dest, const STagCond* src);
 void tscTagCondRelease(STagCond* pCond);

src/client/src/tscSQLParser.c

@@ -1185,10 +1185,18 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel
           return invalidSqlErrMsg(pQueryInfo->msg, "invalid arithmetic expression in select clause");
         }
         
-        SBuffer buf = exprTreeToBinary(pNode);
+        SBufferWriter bw = tbufInitWriter(NULL, false);
+
+        TRY(0) {
+          exprTreeToBinary(&bw, pNode);
+        } CATCH(code) {
+          tbufCloseWriter(&bw);
+          UNUSED(code);
+          // TODO: other error handling
+        } END_TRY
         
-        size_t len = tbufTell(&buf);
-        char* c = tbufGetData(&buf, true);
+        size_t len = tbufTell(&bw);
+        char* c = tbufGetData(&bw, true);
         
         // set the serialized binary string as the parameter of arithmetic expression
         addExprParams(pExpr, c, TSDB_DATA_TYPE_BINARY, len, index.tableIndex);
@@ -3751,7 +3759,15 @@ static int32_t getTagQueryCondExpr(SQueryInfo* pQueryInfo, SCondExpr* pCondExpr,
   
     SArray* colList = taosArrayInit(10, sizeof(SColIndex));
     ret = exprTreeFromSqlExpr(&p, p1, NULL, pQueryInfo, colList);
-    SBuffer buf = exprTreeToBinary(p);
+    SBufferWriter bw = tbufInitWriter(NULL, false);
+
+    TRY(0) {
+      exprTreeToBinary(&bw, p);
+    } CATCH(code) {
+      tbufCloseWriter(&bw);
+      UNUSED(code);
+      // TODO: more error handling
+    } END_TRY
     
     // add to source column list
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
@@ -3765,7 +3781,7 @@ static int32_t getTagQueryCondExpr(SQueryInfo* pQueryInfo, SCondExpr* pCondExpr,
       addRequiredTagColumn(pTableMetaInfo, &index);
     }
     
-    tsSetSTableQueryCond(&pQueryInfo->tagCond, uid, &buf);
+    tsSetSTableQueryCond(&pQueryInfo->tagCond, uid, &bw);
     doCompactQueryExpr(pExpr);
     
     tSQLExprDestroy(p1);

src/client/src/tscUtil.c

@@ -47,18 +47,18 @@ SCond* tsGetSTableQueryCond(STagCond* pTagCond, uint64_t uid) {
   return NULL;
 }
 
-void tsSetSTableQueryCond(STagCond* pTagCond, uint64_t uid, SBuffer* pBuf) {
-  if (tbufTell(pBuf) == 0) {
+void tsSetSTableQueryCond(STagCond* pTagCond, uint64_t uid, SBufferWriter* bw) {
+  if (tbufTell(bw) == 0) {
     return;
   }
   
   SCond cond = {
     .uid = uid,
-    .len = tbufTell(pBuf),
+    .len = tbufTell(bw),
     .cond = NULL,
   };
   
-  cond.cond = tbufGetData(pBuf, true);
+  cond.cond = tbufGetData(bw, true);
   
   if (pTagCond->pCond == NULL) {
     pTagCond->pCond = taosArrayInit(3, sizeof(SCond));

src/mnode/src/mgmtBalance.c

@@ -17,6 +17,7 @@
 #include "os.h"
 #include "trpc.h"
 #include "tbalance.h"
+#include "tglobal.h"
 #include "mgmtDef.h"
 #include "mgmtLog.h"
 #include "mgmtMnode.h"
@@ -41,7 +42,10 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) {
     if (pDnode == NULL) break;
 
     if (pDnode->totalVnodes > 0 && pDnode->openVnodes < pDnode->totalVnodes) {
-      float usage = (float)pDnode->openVnodes / pDnode->totalVnodes;
+      float openVnodes = pDnode->openVnodes;
+      if (pDnode->isMgmt) openVnodes += tsMgmtEqualVnodeNum;
+
+      float usage = openVnodes / pDnode->totalVnodes;
       if (usage <= vnodeUsage) {
         pSelDnode = pDnode;
         vnodeUsage = usage;

src/query/inc/qast.h

@@ -90,9 +90,10 @@ void tSQLBinaryExprTrv(tExprNode *pExprs, SArray* res);
 
 uint8_t getBinaryExprOptr(SSQLToken *pToken);
 
-SBuffer exprTreeToBinary(tExprNode* pExprTree);
+void       tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *));
+void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
 
-tExprNode* exprTreeFromBinary(const void* pBuf, size_t size);
+tExprNode* exprTreeFromBinary(const void* data, size_t size);
 tExprNode* exprTreeFromTableName(const char* tbnameCond);
 
 #ifdef __cplusplus

src/query/src/qast.c

@@ -31,6 +31,7 @@
 #include "tskiplist.h"
 #include "queryLog.h"
 #include "tsdbMain.h"
+#include "exception.h"
 
 /*
  *
@@ -44,7 +45,6 @@
  *
  */
 static tExprNode *tExprNodeCreate(SSchema *pSchema, int32_t numOfCols, SSQLToken *pToken);
-static void       tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *));
 
 static tExprNode *createSyntaxTree(SSchema *pSchema, int32_t numOfCols, char *str, int32_t *i);
 static void       destroySyntaxTree(tExprNode *);
@@ -428,7 +428,7 @@ void tSQLBinaryExprToString(tExprNode *pExpr, char *dst, int32_t *len) {
 
 static void UNUSED_FUNC destroySyntaxTree(tExprNode *pNode) { tExprNodeDestroy(pNode, NULL); }
 
-static void tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *)) {
+void tExprNodeDestroy(tExprNode *pNode, void (*fp)(void *)) {
   if (pNode == NULL) {
     return;
   }
@@ -1023,104 +1023,116 @@ void tSQLBinaryExprTrv(tExprNode *pExprs, SArray* res) {
   }
 }
 
-static void exprTreeToBinaryImpl(tExprNode* pExprTree, SBuffer* pBuf) {
-  tbufWrite(pBuf, &pExprTree->nodeType, sizeof(pExprTree->nodeType));
+static void exprTreeToBinaryImpl(SBufferWriter* bw, tExprNode* expr) {
+  tbufWriteUint8(bw, expr->nodeType);
   
-  if (pExprTree->nodeType == TSQL_NODE_VALUE) {
-    tVariant* pVal = pExprTree->pVal;
+  if (expr->nodeType == TSQL_NODE_VALUE) {
+    tVariant* pVal = expr->pVal;
     
-    tbufWrite(pBuf, &pVal->nType, sizeof(pVal->nType));
+    tbufWriteUint32(bw, pVal->nType);
     if (pVal->nType == TSDB_DATA_TYPE_BINARY) {
-      tbufWrite(pBuf, &pVal->nLen, sizeof(pVal->nLen));
-      tbufWrite(pBuf, pVal->pz, pVal->nLen);
+      tbufWriteInt32(bw, pVal->nLen);
+      tbufWrite(bw, pVal->pz, pVal->nLen);
     } else {
-      tbufWrite(pBuf, &pVal->pz, sizeof(pVal->i64Key));
+      tbufWriteInt64(bw, pVal->i64Key);
     }
     
-  } else if (pExprTree->nodeType == TSQL_NODE_COL) {
-    SSchema* pSchema = pExprTree->pSchema;
-    tbufWrite(pBuf, &pSchema->colId, sizeof(pSchema->colId));
-    tbufWrite(pBuf, &pSchema->bytes, sizeof(pSchema->bytes));
-    tbufWrite(pBuf, &pSchema->type, sizeof(pSchema->type));
+  } else if (expr->nodeType == TSQL_NODE_COL) {
+    SSchema* pSchema = expr->pSchema;
+    tbufWriteInt16(bw, pSchema->colId);
+    tbufWriteInt16(bw, pSchema->bytes);
+    tbufWriteUint8(bw, pSchema->type);
+    tbufWriteString(bw, pSchema->name);
     
-    int32_t len = strlen(pSchema->name);
-    tbufWriteStringLen(pBuf, pSchema->name, len);
-    
-  } else if (pExprTree->nodeType == TSQL_NODE_EXPR) {
-    tbufWrite(pBuf, &pExprTree->_node.optr, sizeof(pExprTree->_node.optr));
-    tbufWrite(pBuf, &pExprTree->_node.hasPK, sizeof(pExprTree->_node.hasPK));
-  
-    exprTreeToBinaryImpl(pExprTree->_node.pLeft, pBuf);
-    exprTreeToBinaryImpl(pExprTree->_node.pRight, pBuf);
+  } else if (expr->nodeType == TSQL_NODE_EXPR) {
+    tbufWriteUint8(bw, expr->_node.optr);
+    tbufWriteUint8(bw, expr->_node.hasPK);
+    exprTreeToBinaryImpl(bw, expr->_node.pLeft);
+    exprTreeToBinaryImpl(bw, expr->_node.pRight);
   }
 }
 
-SBuffer exprTreeToBinary(tExprNode* pExprTree) {
-  SBuffer buf = {0};
-  if (pExprTree == NULL) {
-    return buf;
+void exprTreeToBinary(SBufferWriter* bw, tExprNode* expr) {
+  if (expr != NULL) {
+    exprTreeToBinaryImpl(bw, expr);
   }
-  
-  int32_t code = tbufBeginWrite(&buf);
-  if (code != 0) {
-    return buf;
+}
+
+// TODO: these three functions should be made global
+static void* exception_calloc(size_t nmemb, size_t size) {
+  void* p = calloc(nmemb, size);
+  if (p == NULL) {
+    THROW(TSDB_CODE_SERV_OUT_OF_MEMORY);
   }
-  
-  exprTreeToBinaryImpl(pExprTree, &buf);
-  return buf;
+  return p;
+}
+
+static void* exception_malloc(size_t size) {
+  void* p = malloc(size);
+  if (p == NULL) {
+    THROW(TSDB_CODE_SERV_OUT_OF_MEMORY);
+  }
+  return p;
 }
 
-static tExprNode* exprTreeFromBinaryImpl(SBuffer* pBuf) {
-  tExprNode* pExpr = calloc(1, sizeof(tExprNode));
-  pExpr->nodeType = tbufReadUint8(pBuf);
+static char* exception_strdup(const char* str) {
+  char* p = strdup(str);
+  if (p == NULL) {
+    THROW(TSDB_CODE_SERV_OUT_OF_MEMORY);
+  }
+  return p;
+}
+
+
+static tExprNode* exprTreeFromBinaryImpl(SBufferReader* br) {
+  int32_t anchor = CLEANUP_GET_ANCHOR();
+
+  tExprNode* pExpr = exception_calloc(1, sizeof(tExprNode));
+  CLEANUP_PUSH_VOID_PTR_PTR(true, tExprNodeDestroy, pExpr, NULL);
+
+  pExpr->nodeType = tbufReadUint8(br);
   
   if (pExpr->nodeType == TSQL_NODE_VALUE) {
-    tVariant* pVal = calloc(1, sizeof(tVariant));
-    if (pVal == NULL) {
-      // TODO:
-    }
+    tVariant* pVal = exception_calloc(1, sizeof(tVariant));
     pExpr->pVal = pVal;
   
-    pVal->nType = tbufReadUint32(pBuf);
+    pVal->nType = tbufReadUint32(br);
     if (pVal->nType == TSDB_DATA_TYPE_BINARY) {
-      tbufReadToBuffer(pBuf, &pVal->nLen, sizeof(pVal->nLen));
+      tbufReadToBuffer(br, &pVal->nLen, sizeof(pVal->nLen));
       pVal->pz = calloc(1, pVal->nLen + 1);
-      tbufReadToBuffer(pBuf, pVal->pz, pVal->nLen);
+      tbufReadToBuffer(br, pVal->pz, pVal->nLen);
     } else {
-      pVal->i64Key = tbufReadInt64(pBuf);
+      pVal->i64Key = tbufReadInt64(br);
     }
     
   } else if (pExpr->nodeType == TSQL_NODE_COL) {
-    SSchema* pSchema = calloc(1, sizeof(SSchema));
-    if (pSchema == NULL) {
-      // TODO:
-    }
+    SSchema* pSchema = exception_calloc(1, sizeof(SSchema));
     pExpr->pSchema = pSchema;
 
-    pSchema->colId = tbufReadInt16(pBuf);
-    pSchema->bytes = tbufReadInt16(pBuf);
-    pSchema->type = tbufReadUint8(pBuf);
-    tbufReadToString(pBuf, pSchema->name, TSDB_COL_NAME_LEN);
+    pSchema->colId = tbufReadInt16(br);
+    pSchema->bytes = tbufReadInt16(br);
+    pSchema->type = tbufReadUint8(br);
+    tbufReadToString(br, pSchema->name, TSDB_COL_NAME_LEN);
     
   } else if (pExpr->nodeType == TSQL_NODE_EXPR) {
-    pExpr->_node.optr = tbufReadUint8(pBuf);
-    pExpr->_node.hasPK = tbufReadUint8(pBuf);
-    pExpr->_node.pLeft = exprTreeFromBinaryImpl(pBuf);
-    pExpr->_node.pRight = exprTreeFromBinaryImpl(pBuf);
+    pExpr->_node.optr = tbufReadUint8(br);
+    pExpr->_node.hasPK = tbufReadUint8(br);
+    pExpr->_node.pLeft = exprTreeFromBinaryImpl(br);
+    pExpr->_node.pRight = exprTreeFromBinaryImpl(br);
     
     assert(pExpr->_node.pLeft != NULL && pExpr->_node.pRight != NULL);
   }
   
+  CLEANUP_EXECUTE_TO(anchor, false);
   return pExpr;
 }
 
-tExprNode* exprTreeFromBinary(const void* pBuf, size_t size) {
+tExprNode* exprTreeFromBinary(const void* data, size_t size) {
   if (size == 0) {
     return NULL;
   }
-  SBuffer rbuf = {0};
-  tbufBeginRead(&rbuf, pBuf, size);
-  return exprTreeFromBinaryImpl(&rbuf);
+  SBufferReader br = tbufInitReader(data, size, false);
+  return exprTreeFromBinaryImpl(&br);
 }
 
 tExprNode* exprTreeFromTableName(const char* tbnameCond) {
@@ -1128,23 +1140,18 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
     return NULL;
   }
 
-  tExprNode* expr = calloc(1, sizeof(tExprNode));
-  if (expr == NULL) {
-    // TODO:
-  }
+  int32_t anchor = CLEANUP_GET_ANCHOR();
+
+  tExprNode* expr = exception_calloc(1, sizeof(tExprNode));
+  CLEANUP_PUSH_VOID_PTR_PTR(true, tExprNodeDestroy, expr, NULL);
+
   expr->nodeType = TSQL_NODE_EXPR;
 
-  tExprNode* left = calloc(1, sizeof(tExprNode));
-  if (left == NULL) {
-    // TODO:
-  }
+  tExprNode* left = exception_calloc(1, sizeof(tExprNode));
   expr->_node.pLeft = left;
 
   left->nodeType = TSQL_NODE_COL;
-  SSchema* pSchema = calloc(1, sizeof(SSchema));
-  if (pSchema == NULL) {
-    // TODO:
-  }
+  SSchema* pSchema = exception_calloc(1, sizeof(SSchema));
   left->pSchema = pSchema;
 
   pSchema->type = TSDB_DATA_TYPE_BINARY;
@@ -1152,36 +1159,24 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
   strcpy(pSchema->name, TSQL_TBNAME_L);
   pSchema->colId = -1;
 
-  tExprNode* right = calloc(1, sizeof(tExprNode));
-  if (right == NULL) {
-    // TODO
-  }
+  tExprNode* right = exception_calloc(1, sizeof(tExprNode));
   expr->_node.pRight = right;
 
   if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_LIKE, QUERY_COND_REL_PREFIX_LIKE_LEN) == 0) {
     right->nodeType = TSQL_NODE_VALUE;
     expr->_node.optr = TSDB_RELATION_LIKE;
-    tVariant* pVal = calloc(1, sizeof(tVariant));
-    if (pVal == NULL) {
-      // TODO:
-    }
+    tVariant* pVal = exception_calloc(1, sizeof(tVariant));
     right->pVal = pVal;
-    pVal->nType = TSDB_DATA_TYPE_BINARY;
     size_t len = strlen(tbnameCond + QUERY_COND_REL_PREFIX_LIKE_LEN) + 1;
-    pVal->pz = malloc(len);
-    if (pVal->pz == NULL) {
-      // TODO:
-    }
+    pVal->pz = exception_malloc(len);
     memcpy(pVal->pz, tbnameCond + QUERY_COND_REL_PREFIX_LIKE_LEN, len);
+    pVal->nType = TSDB_DATA_TYPE_BINARY;
     pVal->nLen = (int32_t)len;
 
   } else if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN) == 0) {
     right->nodeType = TSQL_NODE_VALUE;
     expr->_node.optr = TSDB_RELATION_IN;
-    tVariant* pVal = calloc(1, sizeof(tVariant));
-    if (pVal == NULL) {
-      // TODO:
-    }
+    tVariant* pVal = exception_calloc(1, sizeof(tVariant));
     right->pVal = pVal;
     pVal->nType = TSDB_DATA_TYPE_ARRAY;
     pVal->arr = taosArrayInit(2, sizeof(char*));
@@ -1192,7 +1187,7 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
         cond = e + 1;
       } else if (*e == ',') {
         size_t len = e - cond + 1;
-        char* p = malloc( len );
+        char* p = exception_malloc( len );
         memcpy(p, cond, len);
         p[len - 1] = 0;
         cond += len;
@@ -1201,12 +1196,13 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
     }
 
     if (*cond != 0) {
-        char* p = strdup( cond );
+        char* p = exception_strdup( cond );
         taosArrayPush(pVal->arr, &p);
     }
 
     taosArraySortString(pVal->arr);
   }
 
+  CLEANUP_EXECUTE_TO(anchor, false);
   return expr;
 }
\ No newline at end of file

src/query/tests/astTest.cpp

@@ -550,11 +550,12 @@ tExprNode* createExpr2() {
 
 void exprSerializeTest1() {
   tExprNode* p1 = createExpr1();
-  SBuffer buf = exprTreeToBinary(p1);
+  SBufferWriter bw = tbufInitWriter(NULL, false);
+  exprTreeToBinary(&bw, p1);
   
-  size_t size = tbufTell(&buf);
+  size_t size = tbufTell(&bw);
   ASSERT_TRUE(size > 0);
-  char* b = tbufGetData(&buf, false);
+  char* b = tbufGetData(&bw, false);
   
   tExprNode* p2 = exprTreeFromBinary(b, size);
   ASSERT_EQ(p1->nodeType, p2->nodeType);
@@ -581,16 +582,17 @@ void exprSerializeTest1() {
   tExprTreeDestroy(&p1, nullptr);
   tExprTreeDestroy(&p2, nullptr);
   
-  tbufClose(&buf, false);
+  tbufClose(&bw);
 }
 
 void exprSerializeTest2() {
   tExprNode* p1 = createExpr2();
-  SBuffer buf = exprTreeToBinary(p1);
+  SBufferWriter bw = tbufInitWriter(NULL, false);
+  exprTreeToBinary(&bw, p1);
   
-  size_t size = tbufTell(&buf);
+  size_t size = tbufTell(&bw);
   ASSERT_TRUE(size > 0);
-  char* b = tbufGetData(&buf, false);
+  char* b = tbufGetData(&bw, false);
   
   tExprNode* p2 = exprTreeFromBinary(b, size);
   ASSERT_EQ(p1->nodeType, p2->nodeType);
@@ -625,7 +627,7 @@ void exprSerializeTest2() {
   tExprTreeDestroy(&p1, nullptr);
   tExprTreeDestroy(&p2, nullptr);
 
-  tbufClose(&buf, false);
+  tbufClose(&bw);
 }
 }  // namespace
 TEST(testCase, astTest) {

src/tsdb/src/tsdbRead.c

@@ -18,6 +18,7 @@
 #include "talgo.h"
 #include "tutil.h"
 #include "tcompare.h"
+#include "exception.h"
 
 #include "../../../query/inc/qast.h"  // todo move to common module
 #include "../../../query/inc/tlosertree.h"  // todo move to util module
@@ -1473,21 +1474,35 @@ int32_t tsdbQueryByTagsCond(
   }
 
   int32_t    ret = TSDB_CODE_SUCCESS;
+  tExprNode* expr = NULL;
 
-  tExprNode* expr = exprTreeFromTableName(tbnameCond);
-  tExprNode* tagExpr = exprTreeFromBinary(pTagCond, len);
-  if (tagExpr != NULL) {
+  TRY(32) {
+    expr = exprTreeFromTableName(tbnameCond);
     if (expr == NULL) {
-      expr = tagExpr;
+      expr = exprTreeFromBinary(pTagCond, len);
     } else {
-      tExprNode* tbnameExpr = expr;
-      expr = calloc(1, sizeof(tExprNode));
-      expr->nodeType = TSQL_NODE_EXPR;
-      expr->_node.optr = tagNameRelType;
-      expr->_node.pLeft = tagExpr;
-      expr->_node.pRight = tbnameExpr;
+      CLEANUP_PUSH_VOID_PTR_PTR(true, tExprNodeDestroy, expr, NULL);
+      tExprNode* tagExpr = exprTreeFromBinary(pTagCond, len);
+      if (tagExpr != NULL) {
+        CLEANUP_PUSH_VOID_PTR_PTR(true, tExprNodeDestroy, tagExpr, NULL);
+        tExprNode* tbnameExpr = expr;
+        expr = calloc(1, sizeof(tExprNode));
+        if (expr == NULL) {
+          THROW( TSDB_CODE_SERV_OUT_OF_MEMORY );
+        }
+        expr->nodeType = TSQL_NODE_EXPR;
+        expr->_node.optr = tagNameRelType;
+        expr->_node.pLeft = tagExpr;
+        expr->_node.pRight = tbnameExpr;
+      }
     }
-  }
+    CLEANUP_EXECUTE();
+
+  } CATCH( code ) {
+    CLEANUP_EXECUTE();
+    ret = code;
+    // TODO: more error handling
+  } END_TRY
 
   doQueryTableList(pSTable, res, expr);
   pGroupInfo->numOfTables = taosArrayGetSize(res);

src/util/inc/exception.h

+/*
+ * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_EXCEPTION_H
+#define TDENGINE_EXCEPTION_H
+
+#include <setjmp.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * cleanup actions
+ */
+typedef struct SCleanupAction {
+    bool failOnly;
+    uint8_t wrapper;
+    uint16_t reserved;
+    void* func;
+    union {
+        void* Ptr;
+        bool Bool;
+        char Char;
+        int8_t Int8;
+        uint8_t Uint8;
+        int16_t Int16;
+        uint16_t Uint16;
+        int Int;
+        unsigned int Uint;
+        int32_t Int32;
+        uint32_t Uint32;
+        int64_t Int64;
+        uint64_t Uint64;
+        float Float;
+        double Double;
+    } arg1, arg2;
+} SCleanupAction;
+
+
+/*
+ * exception hander registration
+ */
+typedef struct SExceptionNode {
+   struct SExceptionNode* prev;
+   jmp_buf jb;
+   int32_t code;
+   int32_t maxCleanupAction;
+   int32_t numCleanupAction;
+   SCleanupAction* cleanupActions;
+} SExceptionNode;
+
+////////////////////////////////////////////////////////////////////////////////
+// functions & macros for auto-cleanup
+
+void cleanupPush_void_ptr_ptr   ( bool failOnly, void* func, void* arg1, void* arg2 );
+void cleanupPush_void_ptr_bool  ( bool failOnly, void* func, void* arg1, bool arg2 );
+void cleanupPush_void_ptr       ( bool failOnly, void* func, void* arg );
+void cleanupPush_int_int        ( bool failOnly, void* func, int arg );
+void cleanupPush_void           ( bool failOnly, void* func );
+
+int32_t cleanupGetActionCount();
+void cleanupExecuteTo( int32_t anchor, bool failed );
+void cleanupExecute( SExceptionNode* node, bool failed );
+
+#define CLEANUP_PUSH_VOID_PTR_PTR( failOnly, func, arg1, arg2 )  cleanupPush_void_ptr_ptr( (failOnly), (void*)(func), (void*)(arg1), (void*)(arg2) )
+#define CLEANUP_PUSH_VOID_PTR_BOOL( failOnly, func, arg1, arg2 ) cleanupPush_void_ptr_bool( (failOnly), (void*)(func), (void*)(arg1), (bool)(arg2) )
+#define CLEANUP_PUSH_VOID_PTR( failOnly, func, arg )             cleanupPush_void_ptr( (failOnly), (void*)(func), (void*)(arg) )
+#define CLEANUP_PUSH_INT_INT( failOnly, func, arg )              cleanupPush_void_ptr( (failOnly), (void*)(func), (int)(arg) )
+#define CLEANUP_PUSH_VOID( failOnly, func )                      cleanupPush_void( (failOnly), (void*)(func) )
+#define CLEANUP_PUSH_FREE( failOnly, arg )                       cleanupPush_void_ptr( (failOnly), free, (void*)(arg) )
+#define CLEANUP_PUSH_CLOSE( failOnly, arg )                      cleanupPush_int_int( (failOnly), close, (int)(arg) )
+
+#define CLEANUP_GET_ANCHOR()          cleanupGetActionCount()
+#define CLEANUP_EXECUTE_TO( anchor, failed )  cleanupExecuteTo( (anchor), (failed) )
+
+
+////////////////////////////////////////////////////////////////////////////////
+// functions & macros for exception handling
+
+void exceptionPushNode( SExceptionNode* node );
+int32_t exceptionPopNode();
+void exceptionThrow( int code );
+
+#define TRY(maxCleanupActions) do { \
+    SExceptionNode exceptionNode = { 0 }; \
+    SCleanupAction cleanupActions[(maxCleanupActions) > 0 ? (maxCleanupActions) : 1]; \
+    exceptionNode.maxCleanupAction = (maxCleanupActions) > 0 ? (maxCleanupActions) : 1; \
+    exceptionNode.cleanupActions = cleanupActions; \
+    exceptionPushNode( &exceptionNode ); \
+    int caughtException = setjmp( exceptionNode.jb ); \
+    if( caughtException == 0 )
+
+#define CATCH( code ) int code = exceptionPopNode(); \
+    if( caughtException == 1 )
+
+#define FINALLY( code ) int code = exceptionPopNode();
+
+#define END_TRY } while( 0 );
+
+#define THROW( x )          exceptionThrow( (x) )
+#define CAUGHT_EXCEPTION()  ((bool)(caughtException == 1))
+#define CLEANUP_EXECUTE()   cleanupExecute( &exceptionNode, CAUGHT_EXCEPTION() )
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/util/inc/tbuffer.h

@@ -16,122 +16,163 @@
 #ifndef TDENGINE_TBUFFER_H
 #define TDENGINE_TBUFFER_H
 
-#include "setjmp.h"
-#include "os.h"
+#include <stdint.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// usage example
 /*
-SBuffer can be used to read or write a buffer, but cannot be used for both
-read & write at a same time. Below is an example:
-
-int main(int argc, char** argv) {
-  //--------------------- write ------------------------
-  SBuffer wbuf;
-  int32_t code = tbufBeginWrite(&wbuf);
-  if (code != 0) {
-    // handle errors
-    return 0;
-  }
-
-  // reserve 1024 bytes for the buffer to improve performance
-  tbufEnsureCapacity(&wbuf, 1024);
-
-  // write 5 integers to the buffer
-  for (int i = 0; i < 5; i++) {
-    tbufWriteInt32(&wbuf, i);
-  }
-
-  // write a string to the buffer
-  tbufWriteString(&wbuf, "this is a string.\n");
-
-  // acquire the result and close the write buffer
-  size_t size = tbufTell(&wbuf);
-  char*  data = tbufGetData(&wbuf, true);
-  tbufClose(&wbuf, true);
-
-
-  //------------------------ read -----------------------
-  SBuffer rbuf;
-  code = tbufBeginRead(&rbuf, data, size);
-  if (code != 0) {
-    printf("you will see this message after print out 5 integers and a string.\n");
-    tbufClose(&rbuf, false);
-    return 0;
-  }
-
-  // read & print out 5 integers
-  for (int i = 0; i < 5; i++) {
-    printf("%d\n", tbufReadInt32(&rbuf));
-  }
-
-  // read & print out a string
-  printf(tbufReadString(&rbuf, NULL));
-
-  // try read another integer, this result in an error as there no this integer
-  tbufReadInt32(&rbuf);
-
-  printf("you should not see this message.\n");
-  tbufClose(&rbuf, false);
-
+#include <stdio.h>
+#include "exception.h"
+
+int main( int argc, char** argv ) {
+  SBufferWriter bw = tbufInitWriter( NULL, false );
+
+  TRY( 1 ) {
+    //--------------------- write ------------------------
+    // reserve 1024 bytes for the buffer to improve performance
+    tbufEnsureCapacity( &bw, 1024 );
+
+    // reserve space for the interger count
+    size_t pos = tbufReserve( &bw, sizeof(int32_t) );
+    // write 5 integers to the buffer
+    for( int i = 0; i < 5; i++) {
+      tbufWriteInt32( &bw, i );
+    }
+    // write the integer count to buffer at reserved position
+    tbufWriteInt32At( &bw, pos, 5 );
+
+    // write a string to the buffer
+    tbufWriteString( &bw, "this is a string.\n" );
+    // acquire the result and close the write buffer
+    size_t size = tbufTell( &bw );
+    char*  data = tbufGetData( &bw, false );
+
+    //------------------------ read -----------------------
+    SBufferReader br = tbufInitReader( data, size, false );
+    // read & print out all integers
+    int32_t count = tbufReadInt32( &br );
+    for( int i = 0; i < count; i++ ) {
+      printf( "%d\n", tbufReadInt32(&br) );
+    }
+    // read & print out a string
+    puts( tbufReadString(&br, NULL) );
+    // try read another integer, this result in an error as there no this integer
+    tbufReadInt32( &br );
+    printf( "you should not see this message.\n" );
+  } CATCH( code ) {
+    printf( "exception code is: %d, you will see this message after print out 5 integers and a string.\n", code );
+  } END_TRY
+
+  tbufCloseWriter( &bw );
   return 0;
 }
 */
+
 typedef struct {
-  jmp_buf jb;
-  char*   data;
-  size_t  pos;
-  size_t  size;
-} SBuffer;
-
-// common functions can be used in both read & write
-#define tbufThrowError(buf, code) longjmp((buf)->jb, (code))
-size_t tbufTell(SBuffer* buf);
-size_t tbufSeekTo(SBuffer* buf, size_t pos);
-size_t tbufSkip(SBuffer* buf, size_t size);
-void   tbufClose(SBuffer* buf, bool keepData);
-
-// basic read functions
-#define tbufBeginRead(buf, _data, len) ((buf)->data = (char*)(_data), ((buf)->pos = 0), ((buf)->size = ((_data) == NULL) ? 0 : (len)), setjmp((buf)->jb))
-char*       tbufRead(SBuffer* buf, size_t size);
-void        tbufReadToBuffer(SBuffer* buf, void* dst, size_t size);
-const char* tbufReadString(SBuffer* buf, size_t* len);
-size_t      tbufReadToString(SBuffer* buf, char* dst, size_t size);
-
-// basic write functions
-#define tbufBeginWrite(buf) ((buf)->data = NULL, ((buf)->pos = 0), ((buf)->size = 0), setjmp((buf)->jb))
-void  tbufEnsureCapacity(SBuffer* buf, size_t size);
-char* tbufGetData(SBuffer* buf, bool takeOver);
-void  tbufWrite(SBuffer* buf, const void* data, size_t size);
-void  tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size);
-void  tbufWriteStringLen(SBuffer* buf, const char* str, size_t len);
-void  tbufWriteString(SBuffer* buf, const char* str);
-
-// read & write function for primitive types
-#ifndef TBUFFER_DEFINE_FUNCTION
-#define TBUFFER_DEFINE_FUNCTION(type, name) \
-  type tbufRead##name(SBuffer* buf); \
-  void tbufWrite##name(SBuffer* buf, type data); \
-  void tbufWrite##name##At(SBuffer* buf, size_t pos, type data);
-#endif
+  bool endian;
+  const char* data;
+  size_t pos;
+  size_t size;
+} SBufferReader;
 
-TBUFFER_DEFINE_FUNCTION(bool, Bool)
-TBUFFER_DEFINE_FUNCTION(char, Char)
-TBUFFER_DEFINE_FUNCTION(int8_t, Int8)
-TBUFFER_DEFINE_FUNCTION(uint8_t, Uint8)
-TBUFFER_DEFINE_FUNCTION(int16_t, Int16)
-TBUFFER_DEFINE_FUNCTION(uint16_t, Uint16)
-TBUFFER_DEFINE_FUNCTION(int32_t, Int32)
-TBUFFER_DEFINE_FUNCTION(uint32_t, Uint32)
-TBUFFER_DEFINE_FUNCTION(int64_t, Int64)
-TBUFFER_DEFINE_FUNCTION(uint64_t, Uint64)
-TBUFFER_DEFINE_FUNCTION(float, Float)
-TBUFFER_DEFINE_FUNCTION(double, Double)
+typedef struct {
+  bool endian;
+  char* data;
+  size_t pos;
+  size_t size;
+  void* (*allocator)( void*, size_t );
+} SBufferWriter;
+
+////////////////////////////////////////////////////////////////////////////////
+// common functions & macros for both reader & writer
+
+#define tbufTell( buf ) ((buf)->pos)
+
+
+////////////////////////////////////////////////////////////////////////////////
+// reader functions & macros
+
+// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
+#define tbufInitReader( Data, Size, Endian ) {.endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 :(Size))}
+
+size_t      tbufSkip( SBufferReader* buf, size_t size );
+
+const char* tbufRead( SBufferReader* buf, size_t size );
+void        tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size );
+const char* tbufReadString( SBufferReader* buf, size_t* len );
+size_t      tbufReadToString( SBufferReader* buf, char* dst, size_t size );
+const char* tbufReadBinary( SBufferReader* buf, size_t *len );
+size_t      tbufReadToBinary( SBufferReader* buf, void* dst, size_t size );
+
+bool     tbufReadBool( SBufferReader* buf );
+char     tbufReadChar( SBufferReader* buf );
+int8_t   tbufReadInt8( SBufferReader* buf );
+uint8_t  tbufReadUint8( SBufferReader* buf );
+int16_t  tbufReadInt16( SBufferReader* buf );
+uint16_t tbufReadUint16( SBufferReader* buf );
+int32_t  tbufReadInt32( SBufferReader* buf );
+uint32_t tbufReadUint32( SBufferReader* buf );
+int64_t  tbufReadInt64( SBufferReader* buf );
+uint64_t tbufReadUint64( SBufferReader* buf );
+float    tbufReadFloat( SBufferReader* buf );
+double   tbufReadDouble( SBufferReader* buf );
+
+
+////////////////////////////////////////////////////////////////////////////////
+// writer functions & macros
+
+// *Allocator*, function to allocate memory, will use 'realloc' if NULL
+// *Endian*, if true, writer functions of primitive types will do 'hton' automatically
+#define tbufInitWriter( Allocator, Endian ) {.endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator))}
+void   tbufCloseWriter( SBufferWriter* buf );
+
+void   tbufEnsureCapacity( SBufferWriter* buf, size_t size );
+size_t tbufReserve( SBufferWriter* buf, size_t size );
+char*  tbufGetData( SBufferWriter* buf, bool takeOver );
+
+void   tbufWrite( SBufferWriter* buf, const void* data, size_t size );
+void   tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size );
+void   tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len );
+void   tbufWriteString( SBufferWriter* buf, const char* str );
+// the prototype of tbufWriteBinary and tbufWrite are identical
+// the difference is: tbufWriteBinary writes the length of the data to the buffer
+// first, then the actual data, which means the reader don't need to know data
+// size before read. Write only write the data itself, which means the reader
+// need to know data size before read.
+void   tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len );
+
+void tbufWriteBool( SBufferWriter* buf, bool data );
+void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data );
+void tbufWriteChar( SBufferWriter* buf, char data );
+void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data );
+void tbufWriteInt8( SBufferWriter* buf, int8_t data );
+void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data );
+void tbufWriteUint8( SBufferWriter* buf, uint8_t data );
+void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data );
+void tbufWriteInt16( SBufferWriter* buf, int16_t data );
+void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data );
+void tbufWriteUint16( SBufferWriter* buf, uint16_t data );
+void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data );
+void tbufWriteInt32( SBufferWriter* buf, int32_t data );
+void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data );
+void tbufWriteUint32( SBufferWriter* buf, uint32_t data );
+void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data );
+void tbufWriteInt64( SBufferWriter* buf, int64_t data );
+void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data );
+void tbufWriteUint64( SBufferWriter* buf, uint64_t data );
+void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data );
+void tbufWriteFloat( SBufferWriter* buf, float data );
+void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data );
+void tbufWriteDouble( SBufferWriter* buf, double data );
+void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data );
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif
\ No newline at end of file

src/util/src/exception.c

+#include "exception.h"
+
+
+static _Thread_local SExceptionNode* expList;
+
+void exceptionPushNode( SExceptionNode* node ) {
+    node->prev = expList;
+    expList = node;
+}
+
+int32_t exceptionPopNode() {
+    SExceptionNode* node = expList;
+    expList = node->prev;
+    return node->code;
+}
+
+void exceptionThrow( int code ) {
+    expList->code = code;
+    longjmp( expList->jb, 1 );
+}
+
+
+
+static void cleanupWrapper_void_ptr_ptr( SCleanupAction* ca ) {
+    void (*func)( void*, void* ) = ca->func;
+    func( ca->arg1.Ptr, ca->arg2.Ptr );
+}
+
+static void cleanupWrapper_void_ptr_bool( SCleanupAction* ca ) {
+    void (*func)( void*, bool ) = ca->func;
+    func( ca->arg1.Ptr, ca->arg2.Bool );
+}
+
+static void cleanupWrapper_void_ptr( SCleanupAction* ca ) {
+    void (*func)( void* ) = ca->func;
+    func( ca->arg1.Ptr );
+}
+
+static void cleanupWrapper_int_int( SCleanupAction* ca ) {
+    int (*func)( int ) = ca->func;
+    func( (int)(intptr_t)(ca->arg1.Int) );
+}
+
+static void cleanupWrapper_void_void( SCleanupAction* ca ) {
+    void (*func)() = ca->func;
+    func();
+}
+
+typedef void (*wrapper)(SCleanupAction*);
+static wrapper wrappers[] = {
+    cleanupWrapper_void_ptr_ptr,
+    cleanupWrapper_void_ptr_bool,
+    cleanupWrapper_void_ptr,
+    cleanupWrapper_int_int,
+    cleanupWrapper_void_void,
+};
+
+
+void cleanupPush_void_ptr_ptr( bool failOnly, void* func, void* arg1, void* arg2 ) {
+    assert( expList->numCleanupAction < expList->maxCleanupAction );
+
+    SCleanupAction *ca = expList->cleanupActions + expList->numCleanupAction++;
+    ca->wrapper = 0;
+    ca->failOnly = failOnly;
+    ca->func = func;
+    ca->arg1.Ptr = arg1;
+    ca->arg2.Ptr = arg2;
+}
+
+void cleanupPush_void_ptr_bool( bool failOnly, void* func, void* arg1, bool arg2 ) {
+    assert( expList->numCleanupAction < expList->maxCleanupAction );
+
+    SCleanupAction *ca = expList->cleanupActions + expList->numCleanupAction++;
+    ca->wrapper = 1;
+    ca->failOnly = failOnly;
+    ca->func = func;
+    ca->arg1.Ptr = arg1;
+    ca->arg2.Bool = arg2;
+}
+
+void cleanupPush_void_ptr( bool failOnly, void* func, void* arg ) {
+    assert( expList->numCleanupAction < expList->maxCleanupAction );
+
+    SCleanupAction *ca = expList->cleanupActions + expList->numCleanupAction++;
+    ca->wrapper = 2;
+    ca->failOnly = failOnly;
+    ca->func = func;
+    ca->arg1.Ptr = arg;
+}
+
+void cleanupPush_int_int( bool failOnly, void* func, int arg ) {
+    assert( expList->numCleanupAction < expList->maxCleanupAction );
+
+    SCleanupAction *ca = expList->cleanupActions + expList->numCleanupAction++;
+    ca->wrapper = 3;
+    ca->failOnly = failOnly;
+    ca->func = func;
+    ca->arg1.Int = arg;
+}
+
+void cleanupPush_void( bool failOnly, void* func ) {
+    assert( expList->numCleanupAction < expList->maxCleanupAction );
+
+    SCleanupAction *ca = expList->cleanupActions + expList->numCleanupAction++;
+    ca->wrapper = 4;
+    ca->failOnly = failOnly;
+    ca->func = func;
+}
+
+
+
+int32_t cleanupGetActionCount() {
+    return expList->numCleanupAction;
+}
+
+
+static void doExecuteCleanup( SExceptionNode* node, int32_t anchor, bool failed ) {
+    while( node->numCleanupAction > anchor ) {
+        --node->numCleanupAction;
+        SCleanupAction *ca = node->cleanupActions + node->numCleanupAction;
+        if( failed || !(ca->failOnly) )
+            wrappers[ca->wrapper]( ca );
+    }
+}
+
+void cleanupExecuteTo( int32_t anchor, bool failed ) {
+    doExecuteCleanup( expList, anchor, failed );
+}
+
+void cleanupExecute( SExceptionNode* node, bool failed ) {
+    doExecuteCleanup( node, 0, failed );
+}
\ No newline at end of file

src/util/src/tbuffer.c

@@ -16,150 +16,384 @@
 #include <stdlib.h>
 #include <memory.h>
 #include <assert.h>
+#include <arpa/inet.h>
+#include "tbuffer.h"
+#include "exception.h"
+#include <taoserror.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// reader functions
 
-#define TBUFFER_DEFINE_FUNCTION(type, name) \
-  type tbufRead##name(SBuffer* buf) {            \
-    type ret;                                    \
-    tbufReadToBuffer(buf, &ret, sizeof(type));   \
-    return ret;                                  \
-  }\
-  void tbufWrite##name(SBuffer* buf, type data) {\
-    tbufWrite(buf, &data, sizeof(data));\
-  }\
-  void tbufWrite##name##At(SBuffer* buf, size_t pos, type data) {\
-    tbufWriteAt(buf, pos, &data, sizeof(data));\
+size_t tbufSkip(SBufferReader* buf, size_t size) {
+  if( (buf->pos + size) > buf->size ) {
+    THROW( TSDB_CODE_MEMORY_CORRUPTED );
   }
+  size_t old = buf->pos;
+  buf->pos += size;
+  return old;
+}
 
-#include "tbuffer.h"
+const char* tbufRead( SBufferReader* buf, size_t size ) {
+  const char* ret = buf->data + buf->pos;
+  tbufSkip( buf, size );
+  return ret;
+}
 
+void tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size ) {
+  assert( dst != NULL );
+  // always using memcpy, leave optimization to compiler
+  memcpy( dst, tbufRead(buf, size), size );
+}
 
-////////////////////////////////////////////////////////////////////////////////
-// common functions
+static size_t tbufReadLength( SBufferReader* buf ) {
+  // maximum length is 65535, if larger length is required
+  // this function and the corresponding write function need to be
+  // revised.
+  uint16_t l = tbufReadUint16( buf );
+  return l;
+}
 
-size_t tbufTell(SBuffer* buf) {
-  return buf->pos;
+const char* tbufReadString( SBufferReader* buf, size_t* len ) {
+  size_t l = tbufReadLength( buf );
+  const char* ret = buf->data + buf->pos;
+  tbufSkip( buf, l + 1 );
+  if( ret[l] != 0 ) {
+    THROW( TSDB_CODE_MEMORY_CORRUPTED );
+  }
+  if( len != NULL ) {
+    *len = l;
+  }
+  return ret;
 }
 
-size_t tbufSeekTo(SBuffer* buf, size_t pos) {
-  if (pos > buf->size) {
-    // TODO: update error code, other tbufThrowError need to be changed too
-    tbufThrowError(buf, 1);
+size_t tbufReadToString( SBufferReader* buf, char* dst, size_t size ) {
+  assert( dst != NULL );
+  size_t len;
+  const char* str = tbufReadString( buf, &len );
+  if (len >= size) {
+    len = size - 1;
   }
-  size_t old = buf->pos;
-  buf->pos = pos;
-  return old;
+  memcpy( dst, str, len );
+  dst[len] = 0;
+  return len;
 }
 
-size_t tbufSkip(SBuffer* buf, size_t size) {
-  return tbufSeekTo(buf, buf->pos + size);
+const char* tbufReadBinary( SBufferReader* buf, size_t *len ) {
+  size_t l = tbufReadLength( buf );
+  const char* ret = buf->data + buf->pos;
+  tbufSkip( buf, l );
+  if( len != NULL ) {
+    *len = l;
+  }
+  return ret;
 }
 
-void tbufClose(SBuffer* buf, bool keepData) {
-  if (!keepData) {
-    free(buf->data);
+size_t tbufReadToBinary( SBufferReader* buf, void* dst, size_t size ) {
+  assert( dst != NULL );
+  size_t len;
+  const char* data = tbufReadBinary( buf, &len );
+  if( len >= size ) {
+    len = size;
   }
-  buf->data = NULL;
-  buf->pos = 0;
-  buf->size = 0;
+  memcpy( dst, data, len );
+  return len;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// read functions
+bool tbufReadBool( SBufferReader* buf ) {
+  bool ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
+}
 
-char* tbufRead(SBuffer* buf, size_t size) {
-  char* ret = buf->data + buf->pos;
-  tbufSkip(buf, size);
+char tbufReadChar( SBufferReader* buf ) {
+  char ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
   return ret;
 }
 
-void tbufReadToBuffer(SBuffer* buf, void* dst, size_t size) {
-  assert(dst != NULL);
-  // always using memcpy, leave optimization to compiler
-  memcpy(dst, tbufRead(buf, size), size);
+int8_t tbufReadInt8( SBufferReader* buf ) {
+  int8_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
 }
 
-const char* tbufReadString(SBuffer* buf, size_t* len) {
-  uint16_t l = tbufReadUint16(buf);
-  char*    ret = buf->data + buf->pos;
-  tbufSkip(buf, l + 1);
-  ret[l] = 0;  // ensure the string end with '\0'
-  if (len != NULL) {
-    *len = l;
+uint8_t tbufReadUint8( SBufferReader* buf ) {
+  uint8_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
+}
+
+int16_t tbufReadInt16( SBufferReader* buf ) {
+  int16_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return (int16_t)ntohs( ret );
   }
   return ret;
 }
 
-size_t tbufReadToString(SBuffer* buf, char* dst, size_t size) {
-  assert(dst != NULL);
-  size_t      len;
-  const char* str = tbufReadString(buf, &len);
-  if (len >= size) {
-    len = size - 1;
+uint16_t tbufReadUint16( SBufferReader* buf ) {
+  uint16_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return ntohs( ret );
   }
-  memcpy(dst, str, len);
-  dst[len] = 0;
-  return len;
+  return ret;
+}
+
+int32_t tbufReadInt32( SBufferReader* buf ) {
+  int32_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return (int32_t)ntohl( ret );
+  }
+  return ret;
+}
+
+uint32_t tbufReadUint32( SBufferReader* buf ) {
+  uint32_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return ntohl( ret );
+  }
+  return ret;
+}
+
+int64_t tbufReadInt64( SBufferReader* buf ) {
+  int64_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return (int64_t)htobe64( ret ); // TODO: ntohll
+  }
+  return ret;
+}
+
+uint64_t tbufReadUint64( SBufferReader* buf ) {
+  uint64_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return htobe64( ret ); // TODO: ntohll
+  }
+  return ret;
+}
+
+float tbufReadFloat( SBufferReader* buf ) {
+  uint32_t ret = tbufReadUint32( buf );
+  return *(float*)( &ret );
 }
 
+double tbufReadDouble(SBufferReader* buf) {
+  uint64_t ret = tbufReadUint64( buf );
+  return *(double*)( &ret );
+}
 
 ////////////////////////////////////////////////////////////////////////////////
-// write functions
+// writer functions
 
-void tbufEnsureCapacity(SBuffer* buf, size_t size) {
+void tbufCloseWriter( SBufferWriter* buf ) {
+  (*buf->allocator)( buf->data, 0 );
+  buf->data = NULL;
+  buf->pos = 0;
+  buf->size = 0;
+}
+
+void tbufEnsureCapacity( SBufferWriter* buf, size_t size ) {
   size += buf->pos;
-  if (size > buf->size) {
+  if( size > buf->size ) {
     size_t nsize = size + buf->size;
-    char* data = realloc(buf->data, nsize);
-    if (data == NULL) {
-      tbufThrowError(buf, 2);
+    char* data = (*buf->allocator)( buf->data, nsize );
+    // TODO: the exception should be thrown by the allocator function
+    if( data == NULL ) {
+      THROW( TSDB_CODE_SERV_OUT_OF_MEMORY );
     }
     buf->data = data;
     buf->size = nsize;
   }
 }
 
-char* tbufGetData(SBuffer* buf, bool takeOver) {
+size_t tbufReserve( SBufferWriter* buf, size_t size ) {
+  tbufEnsureCapacity( buf, size );
+  size_t old = buf->pos;
+  buf->pos += size;
+  return old;
+}
+
+char* tbufGetData( SBufferWriter* buf, bool takeOver ) {
   char* ret = buf->data;
-  if (takeOver) {
+  if( takeOver ) {
     buf->pos = 0;
     buf->size = 0;
     buf->data = NULL;
   }
-
   return ret;
 }
 
-void tbufEndWrite(SBuffer* buf) {
-    free(buf->data);
-    buf->data = NULL;
-    buf->pos = 0;
-    buf->size = 0;
-}
-
-void tbufWrite(SBuffer* buf, const void* data, size_t size) {
-  assert(data != NULL);
-  tbufEnsureCapacity(buf, size);
-  memcpy(buf->data + buf->pos, data, size);
+void tbufWrite( SBufferWriter* buf, const void* data, size_t size ) {
+  assert( data != NULL );
+  tbufEnsureCapacity( buf, size );
+  memcpy( buf->data + buf->pos, data, size );
   buf->pos += size;
 }
 
-void tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size) {
-  assert(data != NULL);
+void tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size ) {
+  assert( data != NULL );
   // this function can only be called to fill the gap on previous writes,
   // so 'pos + size <= buf->pos' must be true
-  assert(pos + size <= buf->pos);
-  memcpy(buf->data + pos, data, size);
+  assert( pos + size <= buf->pos );
+  memcpy( buf->data + pos, data, size );
 }
 
-void tbufWriteStringLen(SBuffer* buf, const char* str, size_t len) {
-  // maximum string length is 65535, if longer string is required
+static void tbufWriteLength( SBufferWriter* buf, size_t len ) {
+  // maximum length is 65535, if larger length is required
   // this function and the corresponding read function need to be
   // revised.
-  assert(len <= 0xffff);
-  tbufWriteUint16(buf, (uint16_t)len);
-  tbufWrite(buf, str, len + 1);
+  assert( len <= 0xffff );
+  tbufWriteUint16( buf, (uint16_t)len );
+}
+
+void tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len ) {
+  tbufWriteLength( buf, len );
+  tbufWrite( buf, str, len );
+  tbufWriteChar( buf, '\0' );
+}
+
+void tbufWriteString( SBufferWriter* buf, const char* str ) {
+  tbufWriteStringLen( buf, str, strlen(str) );
+}
+
+void tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len ) {
+  tbufWriteLength( buf, len );
+  tbufWrite( buf, data, len );
+}
+
+void tbufWriteBool( SBufferWriter* buf, bool data ) {
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteChar( SBufferWriter* buf, char data ) {
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteInt8( SBufferWriter* buf, int8_t data ) {
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteUint8( SBufferWriter* buf, uint8_t data ) {
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteInt16( SBufferWriter* buf, int16_t data ) {
+  if( buf->endian ) {
+    data = (int16_t)htons( data );
+  }
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data ) {
+  if( buf->endian ) {
+    data = (int16_t)htons( data );
+  }
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteUint16( SBufferWriter* buf, uint16_t data ) {
+  if( buf->endian ) {
+    data = htons( data );
+  }
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data ) {
+  if( buf->endian ) {
+    data = htons( data );
+  }
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteInt32( SBufferWriter* buf, int32_t data ) {
+  if( buf->endian ) {
+    data = (int32_t)htonl( data );
+  }
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data ) {
+  if( buf->endian ) {
+    data = (int32_t)htonl( data );
+  }
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteUint32( SBufferWriter* buf, uint32_t data ) {
+  if( buf->endian ) {
+    data = htonl( data );
+  }
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data ) {
+  if( buf->endian ) {
+    data = htonl( data );
+  }
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteInt64( SBufferWriter* buf, int64_t data ) {
+  if( buf->endian ) {
+    data = (int64_t)htobe64( data );
+  }
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data ) {
+  if( buf->endian ) {
+    data = (int64_t)htobe64( data );
+  }
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteUint64( SBufferWriter* buf, uint64_t data ) {
+  if( buf->endian ) {
+    data = htobe64( data );
+  }
+  tbufWrite( buf, &data, sizeof(data) );
+}
+
+void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data ) {
+  if( buf->endian ) {
+    data = htobe64( data );
+  }
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
+}
+
+void tbufWriteFloat( SBufferWriter* buf, float data ) {
+  tbufWriteUint32( buf, *(uint32_t*)(&data) );
+}
+
+void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data ) {
+  tbufWriteUint32At( buf, pos, *(uint32_t*)(&data) );
+}
+
+void tbufWriteDouble( SBufferWriter* buf, double data ) {
+  tbufWriteUint64( buf, *(uint64_t*)(&data) );
 }
 
-void tbufWriteString(SBuffer* buf, const char* str) {
-  tbufWriteStringLen(buf, str, strlen(str));
+void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data ) {
+  tbufWriteUint64At( buf, pos, *(uint64_t*)(&data) );
 }

src/vnode/src/vnodeMain.c

@@ -197,7 +197,7 @@ int32_t vnodeOpen(int32_t vnode, char *rootDir) {
   syncInfo.vgId = pVnode->vgId;
   syncInfo.version = pVnode->version;
   syncInfo.syncCfg = pVnode->syncCfg;
-  sprintf(syncInfo.path, "%s/tsdb/", rootDir);
+  sprintf(syncInfo.path, "%s", rootDir);
   syncInfo.ahandle = pVnode;
   syncInfo.getWalInfo = vnodeGetWalInfo;
   syncInfo.getFileInfo = vnodeGetFileInfo;
@@ -286,7 +286,7 @@ void *vnodeGetVnode(int32_t vgId) {
   SVnodeObj **ppVnode = (SVnodeObj **)taosGetIntHashData(tsDnodeVnodesHash, vgId);
   if (ppVnode == NULL || *ppVnode == NULL) {
     terrno = TSDB_CODE_INVALID_VGROUP_ID;
-    dError("vgId:%d not exist", vgId);
+    dPrint("vgId:%d not exist", vgId);
     return NULL;
   }
 

src/vnode/src/vnodeWrite.c

@@ -58,7 +58,7 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) {
       return TSDB_CODE_NOT_ACTIVE_VNODE;
 
     if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER)
-      return TSDB_CODE_NO_MASTER;
+      return TSDB_CODE_NOT_READY;
 
     // assign version
     pVnode->version++;
@@ -74,15 +74,15 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) {
 
   // write into WAL
   code = walWrite(pVnode->wal, pHead);
-  if ( code < 0) return code;
- 
-  code = (*vnodeProcessWriteMsgFp[pHead->msgType])(pVnode, pHead->cont, item);
   if (code < 0) return code;
 
-  if (pVnode->syncCfg.replica > 1) 
-    code = syncForwardToPeer(pVnode->sync, pHead, item);
+  int32_t syncCode = syncForwardToPeer(pVnode->sync, pHead, item);
+  if (syncCode < 0) return syncCode;
 
-  return code;
+  code = (*vnodeProcessWriteMsgFp[pHead->msgType])(pVnode, pHead->cont, item);
+  if (code < 0) return code;
+
+  return syncCode;
 }
 
 static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) {

src/wal/src/walMain.c

@@ -269,7 +269,7 @@ int walGetWalFile(void *handle, char *name, uint32_t *index) {
   if (*index < first && *index > pWal->id) {
     code = -1;  // index out of range
   } else { 
-    sprintf(name, "%s/%s%d", pWal->path, walPrefix, *index);
+    sprintf(name, "wal/%s%d", walPrefix, *index);
     code = (*index == pWal->id) ? 0:1;
   }
 

tests/pytest/fulltest.sh

+#!/bin/bash
+python3 ./test.py $1 -f insert/basic.py
+python3 ./test.py $1 -f insert/int.py
+python3 ./test.py $1 -f insert/float.py
+python3 ./test.py $1 -f insert/bigint.py
+python3 ./test.py $1 -f insert/bool.py
+python3 ./test.py $1 -f insert/double.py
+python3 ./test.py $1 -f insert/smallint.py
+python3 ./test.py $1 -f insert/tinyint.py
+python3 ./test.py $1 -f insert/date.py
+python3 ./test.py $1 -f insert/binary.py
+python3 ./test.py $1 -f import_merge/importBlock1HO.py
+python3 ./test.py $1 -f import_merge/importBlock1HPO.py
+python3 ./test.py $1 -f import_merge/importBlock1H.py
+python3 ./test.py $1 -f import_merge/importBlock1S.py
+python3 ./test.py $1 -f import_merge/importBlock1Sub.py
+python3 ./test.py $1 -f import_merge/importBlock1TO.py
+python3 ./test.py $1 -f import_merge/importBlock1TPO.py
+python3 ./test.py $1 -f import_merge/importBlock1T.py
+python3 ./test.py $1 -f import_merge/importBlock2HO.py
+python3 ./test.py $1 -f import_merge/importBlock2HPO.py
+python3 ./test.py $1 -f import_merge/importBlock2H.py
+python3 ./test.py $1 -f import_merge/importBlock2S.py
+python3 ./test.py $1 -f import_merge/importBlock2Sub.py
+python3 ./test.py $1 -f import_merge/importBlock2TO.py
+python3 ./test.py $1 -f import_merge/importBlock2TPO.py
+python3 ./test.py $1 -f import_merge/importBlock2T.py
+python3 ./test.py $1 -f import_merge/importBlockbetween.py
+python3 ./test.py $1 -f import_merge/importCacheFileHO.py
+python3 ./test.py $1 -f import_merge/importCacheFileHPO.py
+python3 ./test.py $1 -f import_merge/importCacheFileH.py
+python3 ./test.py $1 -f import_merge/importCacheFileS.py
+python3 ./test.py $1 -f import_merge/importCacheFileSub.py
+python3 ./test.py $1 -f import_merge/importCacheFileTO.py
+python3 ./test.py $1 -f import_merge/importCacheFileTPO.py
+python3 ./test.py $1 -f import_merge/importCacheFileT.py
+python3 ./test.py $1 -f import_merge/importDataH2.py
+python3 ./test.py $1 -f import_merge/importDataHO2.py
+python3 ./test.py $1 -f import_merge/importDataHO.py
+python3 ./test.py $1 -f import_merge/importDataHPO.py
+python3 ./test.py $1 -f import_merge/importDataLastHO.py
+python3 ./test.py $1 -f import_merge/importDataLastHPO.py
+python3 ./test.py $1 -f import_merge/importDataLastH.py
+python3 ./test.py $1 -f import_merge/importDataLastS.py
+python3 ./test.py $1 -f import_merge/importDataLastSub.py
+python3 ./test.py $1 -f import_merge/importDataLastTO.py
+python3 ./test.py $1 -f import_merge/importDataLastTPO.py
+python3 ./test.py $1 -f import_merge/importDataLastT.py
+python3 ./test.py $1 -f import_merge/importDataS.py
+python3 ./test.py $1 -f import_merge/importDataSub.py
+python3 ./test.py $1 -f import_merge/importDataTO.py
+python3 ./test.py $1 -f import_merge/importDataTPO.py
+python3 ./test.py $1 -f import_merge/importDataT.py
+python3 ./test.py $1 -f import_merge/importHeadOverlap.py
+python3 ./test.py $1 -f import_merge/importHeadPartOverlap.py
+python3 ./test.py $1 -f import_merge/importHead.py
+python3 ./test.py $1 -f import_merge/importHORestart.py
+python3 ./test.py $1 -f import_merge/importHPORestart.py
+python3 ./test.py $1 -f import_merge/importHRestart.py
+python3 ./test.py $1 -f import_merge/importLastHO.py
+python3 ./test.py $1 -f import_merge/importLastHPO.py
+python3 ./test.py $1 -f import_merge/importLastH.py
+python3 ./test.py $1 -f import_merge/importLastS.py
+python3 ./test.py $1 -f import_merge/importLastSub.py
+python3 ./test.py $1 -f import_merge/importLastTO.py
+python3 ./test.py $1 -f import_merge/importLastTPO.py
+python3 ./test.py $1 -f import_merge/importLastT.py
+python3 ./test.py $1 -f import_merge/importSpan.py
+python3 ./test.py $1 -f import_merge/importSRestart.py
+python3 ./test.py $1 -f import_merge/importSubRestart.py
+python3 ./test.py $1 -f import_merge/importTailOverlap.py
+python3 ./test.py $1 -f import_merge/importTailPartOverlap.py
+python3 ./test.py $1 -f import_merge/importTail.py
+python3 ./test.py $1 -f import_merge/importToCommit.py
+python3 ./test.py $1 -f import_merge/importTORestart.py
+python3 ./test.py $1 -f import_merge/importTPORestart.py
+python3 ./test.py $1 -f import_merge/importTRestart.py

tests/pytest/import_merge/importBlock1H.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(39)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1HO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data before with overlap")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(43)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1HPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(15, 43):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 20 data before with partly overlap")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(47)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1S.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 50 data covering existing data")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 51):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(50)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1Sub.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data totally repetitive")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1T.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data after")
+        startTime = self.startTime + 38
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(39)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1TO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data later with overlap")
+        startTime = self.startTime + 30
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(40)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock1TPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 38 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 31):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(35, 43):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(38)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 30 data later with partly overlap")
+        startTime = self.startTime + 25
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 31):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(55)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2H.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 77):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(77)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2HO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 77):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data before with overlap")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(81)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2HPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(15, 81):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 20 data before with partly overlap")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(85)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2S.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 77):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 90 data covering existing data")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 91):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(90)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2Sub.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 77):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data totally repetitive")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2T.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 77):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data after")
+        startTime = self.startTime + 76
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(77)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2TO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 77):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data later with overlap")
+        startTime = self.startTime + 70
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(80)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlock2TPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 61):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(65, 81):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 30 data later with partly overlap")
+        startTime = self.startTime + 55
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 31):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(85)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importBlockbetween.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("one block can import 38 records")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 76 sequential data with gap between 2 blocks")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 39):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+        for rid in range(40, 78):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(76)
+
+        tdLog.info("================= step4")
+        tdLog.info("import data into the gap between 2 blocks")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(39, 40):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(77)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileH.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data again")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(21)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileHO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data again")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 10 data before with overlap")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(25)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileHPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 9 sequential data with gap")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            if (rid == 5):
+                continue
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(9)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 9 data again with gap")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            if (rid == 5):
+                continue
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(18)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 20 data before with partly overlap")
+        startTime = self.startTime - 3
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(23)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileS.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data again")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 30 data covering existing data")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 31):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(30)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileSub.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data again")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 10 data totally repetitive")
+        startTime = self.startTime + 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileT.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data again")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 1 data later")
+        startTime = self.startTime + 20
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, rid))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(21)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileTO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data again")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 10 data later with overlap")
+        startTime = self.startTime + 15
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(25)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importCacheFileTPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 9 sequential data with gap")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            if (rid == 7):
+                continue
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(9)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 9 data again with gap")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            if (rid == 7):
+                continue
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(18)
+
+        tdLog.info("================= step7")
+        tdLog.info("import 20 data later with partly overlap")
+        startTime = self.startTime + 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step8")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(25)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataH2.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import %d sequential data" % (self.rows / 2))
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, self.rows / 2 + 1):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(self.rows / 2)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
+
+        tdLog.info("================= step7")
+        tdSql.execute('reset query cache')
+        tdSql.query('select * from tb1 order by ts desc')
+        tdSql.checkRows(self.rows / 2 + 1)
+
+        tdLog.info("================= step8")
+        tdLog.info("import 10 data in batch before")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime - rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step9")
+        tdSql.execute('reset query cache')
+        tdSql.query('select * from tb1 order by ts desc')
+        tdSql.checkRows(self.rows / 2 + 11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataHO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+        self.rowsPerTable = 20
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import %d sequential data" % self.rowsPerTable)
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, self.rowsPerTable + 1):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select count(*) from tb1')
+        tdSql.checkData(0, 0, self.rowsPerTable)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 6 data before with overlap")
+        startTime = self.startTime - 3
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 7):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1 order by ts desc')
+        tdSql.checkRows(self.rowsPerTable + 3)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataHO2.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+        self.rowsPerTable = 100
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import %d sequential data" % self.rowsPerTable)
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, self.rowsPerTable + 1):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select count(*) from tb1')
+        tdSql.checkData(0, 0, self.rowsPerTable)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 6 data before with overlap")
+        startTime = self.startTime - 3
+        sqlcmd = ['import into tb1 values']
+        for rid in range(6, 0, -1):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1 order by ts desc')
+        tdSql.checkRows(self.rowsPerTable + 3)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataHPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+        self.rowsPerTable = 20
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import %d sequential data" % self.rowsPerTable)
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 10):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(14, self.rowsPerTable + 5):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select count(*) from tb1')
+        tdSql.checkData(0, 0, self.rowsPerTable)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 20 data before with partly overlap")
+        startTime = self.startTime - 4
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(self.rowsPerTable + 8)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastH.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 206):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(206)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastHO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 206):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 5 data before with overlap")
+        startTime = self.startTime - 2
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(207)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastHPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(14, 209):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 20 data before with partly overlap")
+        startTime = self.startTime - 2
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(210)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastS.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 206):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 250 data covering the existing data")
+        startTime = self.startTime - 15
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 251):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(250)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastSub.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 206):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data totally repetitive")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastT.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 206):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data later")
+        startTime = self.startTime + 205
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(206)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastTO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 206):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 5 data later with overlap")
+        startTime = self.startTime + 203
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(208)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataLastTPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than %d rows less than %d rows will go to data and last file" %
+            (self.rows, 10 + self.rows))
+
+        tdLog.info("================= step2")
+        tdLog.info("import 205 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 196):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(200, 210):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(205)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 20 data later with partly overlap")
+        startTime = self.startTime + 192
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(212)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataS.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import 20 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 30 data covering the existing data")
+        startTime = self.startTime - 5
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 31):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(30)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataSub.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import %d sequential data" % (self.rows / 2))
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, self.rows / 2 + 1):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(self.rows / 2)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 10 data totally repetitive")
+        startTime = self.startTime + 10
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 11):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step9")
+        tdSql.execute('reset query cache')
+        tdSql.query('select * from tb1 order by ts desc')
+        tdSql.checkRows(self.rows / 2)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataT.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import 20 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data later")
+        startTime = self.startTime + 20
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(21)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataTO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import 20 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 6 data later with overlap")
+        startTime = self.startTime + 18
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 7):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(24)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importDataTPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info(
+            "More than 10 rows less than %d rows will go to data file" %
+            self.rows)
+
+        tdLog.info("================= step2")
+        tdLog.info("import 20 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 18):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(22, 25):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+        tdLog.sleep(5)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 20 data later with partly overlap")
+        startTime = self.startTime + 15
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(35)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importHORestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdSql.prepare()
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 5 data before with overlap")
+        startTime = self.startTime - 2
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(12)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importHPORestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdSql.prepare()
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 8 sequential data with gap")
+        startTime = self.startTime
+        for rid in range(1, 4):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+        for rid in range(6, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+            startTime += 1
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(8)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 8 data before with partly overlap")
+        startTime = self.startTime - 2
+        for rid in range(1, 9):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(12)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importHRestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdSql.prepare()
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importHead.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importHeadOverlap.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdSql.prepare()
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 5 data before with overlap")
+        startTime = self.startTime - 2
+        for rid in range(1, 11):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(12)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importHeadPartOverlap.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdSql.prepare()
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 8 sequential data with gap")
+        startTime = self.startTime
+        for rid in range(1, 4):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+        startTime += 2
+        for rid in range(6, 11):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(8)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 8 data before with partly overlap")
+        startTime = self.startTime - 2
+        for rid in range(1, 9):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(12)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastH.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 5 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data before")
+        startTime = self.startTime - 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(6)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastHO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 5 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 4 data before with overlap")
+        startTime = self.startTime - 2
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 5):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(7)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastHPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 6 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 4):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(6, 9):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(6)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 8 data before with partly overlap")
+        startTime = self.startTime - 2
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 9):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastS.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 5 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 20 data covering existing data")
+        startTime = self.startTime - 10
+        for rid in range(1, 21):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastSub.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 5 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 3 data totally repetitive")
+        startTime = self.startTime + 1
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 4):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastT.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 5 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data later")
+        startTime = self.startTime + 5
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(6)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastTO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 5 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 6):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(5)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 4 data later with overlap")
+        startTime = self.startTime + 3
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 5):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(7)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importLastTPO.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+        self.rows = 200
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db rows %d' % self.rows)
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+        tdLog.info("less than 10 rows will go to last file")
+
+        tdLog.info("================= step2")
+        tdLog.info("import 6 sequential data")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(1, 4):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        for rid in range(6, 9):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(6)
+
+        tdLog.info("================= step4")
+        tdDnodes.stop(1)
+        tdLog.sleep(5)
+        tdDnodes.start(1)
+
+        tdLog.info("================= step5")
+        tdLog.info("import 8 data later with partly overlap")
+        startTime = self.startTime + 2
+        for rid in range(1, 9):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importSRestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 20 data cover existing data")
+        startTime = self.startTime - 5
+        for rid in range(1, 21):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importSpan.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 20 data cover existing data")
+        startTime = self.startTime - 5
+        for rid in range(1, 21):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importSubRestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 20 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 21):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 10 data totally repetitive")
+        startTime = self.startTime + 5
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(20)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importTORestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 6 data after with overlap")
+        startTime = self.startTime + 8
+        for rid in range(1, 7):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(14)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importTPORestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 8 sequential data with gap")
+        startTime = self.startTime
+        for rid in range(1, 6):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+        for rid in range(8, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(8)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 8 data after with partly overlap")
+        startTime = self.startTime + 3
+        for rid in range(1, 9):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importTRestart.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data after")
+        startTime = self.startTime + 11
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step5")
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+        tdLog.sleep(10)
+
+        tdLog.info("================= step6")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importTail.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 1 data after")
+        startTime += 1
+        tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importTailOverlap.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 10 sequential data")
+        startTime = self.startTime
+        for rid in range(1, 11):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(10)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 6 data after with overlap")
+        startTime = self.startTime + 8
+        for rid in range(1, 7):
+            tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
+            startTime += 1
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(14)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importTailPartOverlap.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, speed int)')
+
+        tdLog.info("================= step2")
+        tdLog.info("import 8 sequential data with gap")
+        startTime = self.startTime
+        for rid in range(1, 6):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+        for rid in range(8, 11):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step3")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(8)
+
+        tdLog.info("================= step4")
+        tdLog.info("import 8 data after with partly overlap")
+        startTime = self.startTime + 3
+        for rid in range(1, 9):
+            tdSql.execute(
+                'import into tb1 values(%ld, %d)' %
+                (startTime + rid, rid))
+
+        tdLog.info("================= step5")
+        tdSql.query('select * from tb1')
+        tdSql.checkRows(11)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/import_merge/importToCommit.py

+###################################################################
+#       Copyright (c) 2016 by TAOS Technologies, Inc.
+#             All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        self.ntables = 1
+        self.startTime = 1520000010000
+
+        tdDnodes.stop(1)
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+        tdSql.execute('reset query cache')
+        tdSql.execute('drop database if exists db')
+        tdSql.execute('create database db cache 512 tables 10')
+        tdSql.execute('use db')
+
+        tdLog.info("================= step1")
+        tdLog.info("create 1 table")
+        tdSql.execute('create table tb1 (ts timestamp, i int)')
+        tdLog.info(
+            "one block can import 38 records and totally there are 40 blocks")
+
+        tdLog.info("================= step2")
+        tdLog.info('insert data until the first commit')
+        dnodesDir = tdDnodes.getDnodesRootDir()
+        dataDir = dnodesDir + '/dnode1/data/data'
+        startTime = self.startTime
+        rid0 = 1
+        while (True):
+            sqlcmd = 'insert into tb1 values(%ld, %d)' % (
+                startTime + rid0 * 2, rid0)
+            tdSql.execute(sqlcmd)
+            rid0 += 1
+            vnodes = os.listdir(dataDir)
+            if (len(vnodes) > 0):
+                tdLog.info("data is committed, stop inserting")
+                break
+
+        tdLog.info("================= step5")
+        tdLog.info("import 1 data before ")
+        startTime = self.startTime
+        sqlcmd = ['import into tb1 values']
+        for rid in range(3, 4):
+            sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
+        tdSql.execute(" ".join(sqlcmd))
+
+        tdLog.info("================= step6")
+        tdSql.execute('reset query cache')
+        tdSql.query('select * from tb1 order by ts desc')
+        tdSql.checkRows(rid0 - 1 + 1)
+
+        tdLog.info("================= step7")
+        tdSql.execute('reset query cache')
+        tdSql.query('select count(*) from tb1')
+        tdSql.checkData(0, 0, rid0 - 1 + 1)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/insert/binary.py

+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        tdSql.prepare()
+
+
+        tdLog.info('=============== step1')
+        tdLog.info('create table tb (ts timestamp, speed binary(5))')
+        tdSql.execute('create table tb (ts timestamp, speed binary(5))')
+        tdLog.info("insert into tb values (now, ) -x step1")
+        tdSql.error("insert into tb values (now, )")
+        tdLog.info('=============== step2')
+        tdLog.info("insert into tb values (now+1a, '1234')")
+        tdSql.execute("insert into tb values (now+1a, '1234')")
+        tdLog.info('select speed from tb order by ts desc')
+        tdSql.query('select speed from tb order by ts desc')
+        tdLog.info('tdSql.checkRow(1)')
+        tdSql.checkRows(1)
+        tdLog.info('tdSql.checkData(0, 0, 1234)')
+        tdSql.checkData(0, 0, 1234)
+        tdLog.info('=============== step3')
+        tdLog.info("insert into tb values (now+2a, '23456')")
+        tdSql.execute("insert into tb values (now+2a, '23456')")
+        tdLog.info('select speed from tb order by ts desc')
+        tdSql.query('select speed from tb order by ts desc')
+        tdLog.info('tdSql.checkRow(2)')
+        tdSql.checkRows(2)
+        tdLog.info('==> $data00')
+        tdLog.info('tdSql.checkData(0, 0, 23456)')
+        tdSql.checkData(0, 0, 23456)
+        tdLog.info('=============== step4')
+        tdLog.info("insert into tb values (now+3a, '345678')")
+        tdSql.error("insert into tb values (now+3a, '345678')")
+        tdLog.info("insert into tb values (now+3a, '34567')")
+        tdSql.execute("insert into tb values (now+3a, '34567')")
+        tdLog.info('select speed from tb order by ts desc')
+        tdSql.query('select speed from tb order by ts desc')
+        tdLog.info('tdSql.checkRow(3)')
+        tdSql.checkRows(3)
+        tdLog.info('==> $data00')
+        tdLog.info('tdSql.checkData(0, 0, 34567)')
+        tdSql.checkData(0, 0, 34567)
+        tdLog.info('drop database db')
+        tdSql.execute('drop database db')
+        tdLog.info('show databases')
+        tdSql.query('show databases')
+        tdLog.info('tdSql.checkRow(0)')
+        tdSql.checkRows(0)
+# convert end
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/insert/date.py

+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+
+class TDTestCase:
+    def init(self, conn):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        tdSql.prepare()
+
+        # TSIM: system sh/stop_dnodes.sh
+        # TSIM:
+        # TSIM: system sh/ip.sh -i 1 -s up
+        # TSIM: system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
+        # TSIM: system sh/cfg.sh -n dnode1 -c commitLog -v 0
+        # TSIM: system sh/exec.sh -n dnode1 -s start
+        # TSIM:
+        # TSIM: sleep 3000
+        # TSIM: sql connect
+        # TSIM:
+        # TSIM: $i = 0
+        # TSIM: $dbPrefix = lm_da_db
+        # TSIM: $tbPrefix = lm_da_tb
+        # TSIM: $db = $dbPrefix . $i
+        # TSIM: $tb = $tbPrefix . $i
+        # TSIM:
+        # TSIM: print =============== step1
+        tdLog.info('=============== step1')
+        # TSIM: sql create database $db
+        # TSIM: sql use $db
+        # TSIM:
+        # TSIM: sql create table $tb (ts timestamp, speed int)
+        tdLog.info("create table tb0 (ts timestamp, speed int)")
+        tdSql.execute('create table tb0 (ts timestamp, speed int)')
+        # TSIM: sql insert into $tb values ('2017-01-01 08:00:00.001', 1)
+        tdLog.info("insert into tb0 values ('2017-01-01 08:00:00.001', 1)")
+        tdSql.execute("insert into tb0 values ('2017-01-01 08:00:00.001', 1)")
+        # TSIM: sql select ts from $tb
+        tdLog.info('select ts from tb0')
+        tdSql.query('select ts from tb0')
+        # TSIM: if $rows != 1 then
+        tdLog.info('tdSql.checkRow(1)')
+        tdSql.checkRows(1)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM: if $data00 != @17-01-01 08:00:00.001@ then
+        tdLog.info("tdSql.checkData(0, 0, 17-01-01 08:00:00.001)")
+        expectedData = datetime.datetime.strptime(
+            "17-01-01 08:00:00.001", "%y-%m-%d %H:%M:%S.%f")
+        tdSql.checkData(0, 0, expectedData)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM:
+        # TSIM: print =============== step2
+        tdLog.info('=============== step2')
+        # TSIM: sql insert into $tb values ('2017-08-28 00:23:46.429+ 1a', 2)
+        tdLog.info("insert into tb0 values ('2017-08-28 00:23:46.429+ 1a', 2)")
+        tdSql.execute(
+            "insert into tb0 values ('2017-08-28 00:23:46.429+ 1a', 2)")
+        # TSIM: #sql insert into $tb values ('2017-08-28 00:23:46cd .429', 2)
+        # TSIM: sql select ts from $tb
+        tdLog.info('select ts from tb0')
+        tdSql.query('select ts from tb0')
+        # TSIM: if $rows != 2 then
+        tdLog.info('tdSql.checkRow(2)')
+        tdSql.checkRows(2)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM:
+        # TSIM: print =============== step3
+        tdLog.info('=============== step3')
+        # TSIM: #sql insert into $tb values ('1970-01-01 08:00:00.000', 3)
+        # TSIM: #sql insert into $tb values ('1970-01-01 08:00:00.000', 3)
+        # TSIM: sql select ts from $tb
+        tdLog.info('select ts from tb0')
+        tdSql.query('select ts from tb0')
+        # TSIM: if $rows != 2 then
+        tdLog.info('tdSql.checkRow(2)')
+        tdSql.checkRows(2)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM:
+        # TSIM: print =============== step4
+        tdLog.info('=============== step4')
+        # TSIM: sql insert into $tb values(now, 4);
+        tdLog.info("insert into tb0 values(now, 4);")
+        tdSql.execute("insert into tb0 values(now, 4);")
+        # TSIM: sql insert into $tb values(now+1a, 5);
+        tdLog.info("insert into tb0 values(now+1a, 5);")
+        tdSql.execute("insert into tb0 values(now+1a, 5);")
+        # TSIM: sql insert into $tb values(now+1s, 6);
+        tdLog.info("insert into tb0 values(now+1s, 6);")
+        tdSql.execute("insert into tb0 values(now+1s, 6);")
+        # TSIM: sql insert into $tb values(now+1m, 7);
+        tdLog.info("insert into tb0 values(now+1m, 7);")
+        tdSql.execute("insert into tb0 values(now+1m, 7);")
+        # TSIM: sql insert into $tb values(now+1h, 8);
+        tdLog.info("insert into tb0 values(now+1h, 8);")
+        tdSql.execute("insert into tb0 values(now+1h, 8);")
+        # TSIM: sql insert into $tb values(now+1d, 9);
+        tdLog.info("insert into tb0 values(now+1d, 9);")
+        tdSql.execute("insert into tb0 values(now+1d, 9);")
+        # TSIM: sql_error insert into $tb values(now+3w, 10);
+        tdLog.info("insert into tb0 values(now+3w, 10);")
+        tdSql.error("insert into tb0 values(now+3w, 10);")
+        # TSIM: sql_error insert into $tb values(now+1n, 11);
+        tdLog.info("insert into tb0 values(now+1n, 11);")
+        tdSql.error("insert into tb0 values(now+1n, 11);")
+        # TSIM: sql_error insert into $tb values(now+1y, 12);
+        tdLog.info("insert into tb0 values(now+1y, 12);")
+        tdSql.error("insert into tb0 values(now+1y, 12);")
+        # TSIM:
+        # TSIM: print =============== step5
+        tdLog.info('=============== step5')
+        # TSIM: sql_error insert into $tb values ('9999-12-31 213:59:59.999',
+        # 13)
+        tdLog.info("insert into tb0 values ('9999-12-31 213:59:59.999', 13)")
+        tdSql.error("insert into tb0 values ('9999-12-31 213:59:59.999', 13)")
+        # TSIM: sql select ts from $tb
+        tdLog.info('select ts from tb0')
+        tdSql.query('select ts from tb0')
+        # TSIM: print $rows
+        tdLog.info('$rows')
+        # TSIM: if $rows != 8 then
+        tdLog.info('tdSql.checkRow(8)')
+        tdSql.checkRows(8)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM:
+        # TSIM: print =============== step6
+        tdLog.info('=============== step6')
+        # TSIM: sql_error insert into $tb values ('9999-12-99 23:59:59.999',
+        # 13)
+        tdLog.info("insert into tb0 values ('9999-12-99 23:59:59.999', 13)")
+        tdSql.error("insert into tb0 values ('9999-12-99 23:59:59.999', 13)")
+        # TSIM:
+        # TSIM: sql select ts from $tb
+        tdLog.info('select ts from tb0')
+        tdSql.query('select ts from tb0')
+        # TSIM: if $rows != 8 then
+        tdLog.info('tdSql.checkRow(8)')
+        tdSql.checkRows(8)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM:
+        # TSIM: print =============== step7
+        tdLog.info('=============== step7')
+        # TSIM: $i = 1
+        # TSIM: $tb = $tbPrefix . $i
+        # TSIM: sql create table $tb (ts timestamp, ts2 timestamp)
+        tdLog.info("create table tb1 (ts timestamp, ts2 timestamp)")
+        tdSql.execute('create table tb1 (ts timestamp, ts2 timestamp)')
+        # TSIM:
+        # TSIM: print =============== step8
+        tdLog.info('=============== step8')
+        # TSIM: sql insert into $tb values (now, now)
+        tdLog.info("insert into tb1 values (now, now)")
+        tdSql.execute("insert into tb1 values (now, now)")
+        # TSIM: sql select * from $tb
+        tdLog.info('select * from tb1')
+        tdSql.query('select * from tb1')
+        # TSIM: if $rows != 1 then
+        tdLog.info('tdSql.checkRow(1)')
+        tdSql.checkRows(1)
+        # TSIM: return -1
+        # TSIM: endi
+        # TSIM:
+        # TSIM: sql drop database $db
+        tdLog.info('drop database db')
+        tdSql.execute('drop database db')
+        # TSIM: sql show databases
+        tdLog.info('show databases')
+        tdSql.query('show databases')
+        # TSIM: if $rows != 0 then
+        tdLog.info('tdSql.checkRow(0)')
+        tdSql.checkRows(0)
+        # TSIM: return -1
+        # TSIM: endi
+# convert end
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/tbname.py

@@ -26,12 +26,14 @@ class TDTestCase:
     def run(self):
         tdSql.prepare()
 
-        tdSql.execute('create table cars (ts timestamp, speed int) tags(id int)')
+        tdSql.execute(
+            'create table cars (ts timestamp, speed int) tags(id int)')
         tdSql.execute("create table carzero using cars tags(0)")
         tdSql.execute("create table carone using cars tags(1)")
         tdSql.execute("create table cartwo using cars tags(2)")
 
-        tdSql.execute("insert into carzero values(now, 100) carone values(now, 110)")
+        tdSql.execute(
+            "insert into carzero values(now, 100) carone values(now, 110)")
 
         tdSql.query("select * from cars where tbname in ('carzero', 'carone')")
         tdSql.checkRows(2)
@@ -39,13 +41,16 @@ class TDTestCase:
         tdSql.query("select * from cars where tbname in ('carzero', 'cartwo')")
         tdSql.checkRows(1)
 
-        tdSql.query("select * from cars where id=1 or tbname in ('carzero', 'cartwo')")
+        tdSql.query(
+            "select * from cars where id=1 or tbname in ('carzero', 'cartwo')")
         tdSql.checkRows(2)
 
-        tdSql.query("select * from cars where id=1 and tbname in ('carzero', 'cartwo')")
+        tdSql.query(
+            "select * from cars where id=1 and tbname in ('carzero', 'cartwo')")
         tdSql.checkRows(0)
 
-        tdSql.query("select * from cars where id=0 and tbname in ('carzero', 'cartwo')")
+        tdSql.query(
+            "select * from cars where id=0 and tbname in ('carzero', 'cartwo')")
         tdSql.checkRows(1)
 
         """

tests/pytest/simpletest.sh → tests/pytest/smoketest.sh

@@ -23,3 +23,33 @@ sleep 1
 python3 ./test.py $1 -f insert/tinyint.py
 python3 ./test.py -s $1
 sleep 1
+python3 ./test.py $1 -f import_merge/importDataLastTO.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importDataLastT.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importDataTO.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importDataT.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importHeadOverlap.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importHeadPartOverlap.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importHORestart.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importHPORestart.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importHRestart.py 
+python3 ./test.py -s $1
+sleep 1
+python3 ./test.py $1 -f import_merge/importLastSub.py 
+python3 ./test.py -s $1
+sleep 1

tests/pytest/util/sql.py

@@ -44,7 +44,7 @@ class TDSql:
         except BaseException:
             expectErrNotOccured = False
         if expectErrNotOccured:
-            tdLog.exit("sql:%.40s, expect error not occured" % (sql))
+            tdLog.exit("failed: sql:%.40s, expect error not occured" % (sql))
         else:
             tdLog.info("sql:%.40s, expect error occured" % (sql))
 
@@ -71,48 +71,51 @@ class TDSql:
     def checkData(self, row, col, data):
         if row < 0:
             tdLog.exit(
-                "sql:%.40s, row:%d is smaller than zero" %
+                "failed: sql:%.40s, row:%d is smaller than zero" %
                 (self.sql, row))
         if col < 0:
             tdLog.exit(
-                "sql:%.40s, col:%d is smaller than zero" %
+                "failed: sql:%.40s, col:%d is smaller than zero" %
                 (self.sql, col))
         if row >= self.queryRows:
             tdLog.exit(
-                "sql:%.40s, row:%d is larger than queryRows:%d" %
+                "failed: sql:%.40s, row:%d is larger than queryRows:%d" %
                 (self.sql, row, self.queryRows))
         if col >= self.queryCols:
             tdLog.exit(
-                "sql:%.40s, col:%d is larger than queryRows:%d" %
+                "failed: sql:%.40s, col:%d is larger than queryRows:%d" %
                 (self.sql, col, self.queryCols))
         if self.queryResult[row][col] != data:
             tdLog.exit(
-                "sql:%.40s row:%d col:%d data:%s != expect:%s" %
+                "failed: sql:%.40s row:%d col:%d data:%s != expect:%s" %
                 (self.sql, row, col, self.queryResult[row][col], data))
 
         if data is None:
             tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%s" %
-                   (self.sql, row, col, self.queryResult[row][col], data))
+                       (self.sql, row, col, self.queryResult[row][col], data))
+        elif isinstance(data, datetime.date):
+            tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%s" %
+                       (self.sql, row, col, self.queryResult[row][col], data))
         else:
             tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%d" %
-                   (self.sql, row, col, self.queryResult[row][col], data))
+                       (self.sql, row, col, self.queryResult[row][col], data))
 
     def getData(self, row, col):
         if row < 0:
             tdLog.exit(
-                "sql:%.40s, row:%d is smaller than zero" %
+                "failed: sql:%.40s, row:%d is smaller than zero" %
                 (self.sql, row))
         if col < 0:
             tdLog.exit(
-                "sql:%.40s, col:%d is smaller than zero" %
+                "failed: sql:%.40s, col:%d is smaller than zero" %
                 (self.sql, col))
         if row >= self.queryRows:
             tdLog.exit(
-                "sql:%.40s, row:%d is larger than queryRows:%d" %
+                "failed: sql:%.40s, row:%d is larger than queryRows:%d" %
                 (self.sql, row, self.queryRows))
         if col >= self.queryCols:
             tdLog.exit(
-                "sql:%.40s, col:%d is larger than queryRows:%d" %
+                "failed: sql:%.40s, col:%d is larger than queryRows:%d" %
                 (self.sql, col, self.queryCols))
         return self.queryResult[row][col]
 
@@ -131,7 +134,7 @@ class TDSql:
 
     def checkAffectedRows(self, expectAffectedRows):
         if self.affectedRows != expectAffectedRows:
-            tdLog.exit("sql:%.40s, affectedRows:%d != expect:%d" %
+            tdLog.exit("failed: sql:%.40s, affectedRows:%d != expect:%d" %
                        (self.sql, self.affectedRows, expectAffectedRows))
         tdLog.info("sql:%.40s, affectedRows:%d == expect:%d" %
                    (self.sql, self.affectedRows, expectAffectedRows))

tests/script/sh/deploy.sh

@@ -93,7 +93,7 @@ echo "privateIp           $NODE_IP"       >> $TAOS_CFG
 echo "dDebugFlag          199"            >> $TAOS_CFG
 echo "mDebugFlag          199"            >> $TAOS_CFG
 echo "sdbDebugFlag        199"            >> $TAOS_CFG
-echo "rpcDebugFlag        131"            >> $TAOS_CFG
+echo "rpcDebugFlag        135"            >> $TAOS_CFG
 echo "tmrDebugFlag        131"            >> $TAOS_CFG
 echo "cDebugFlag          135"            >> $TAOS_CFG
 echo "httpDebugFlag       135"            >> $TAOS_CFG
@@ -101,6 +101,7 @@ echo "monitorDebugFlag    131"            >> $TAOS_CFG
 echo "udebugFlag          131"            >> $TAOS_CFG
 echo "jnidebugFlag        131"            >> $TAOS_CFG
 echo "monitor             0"              >> $TAOS_CFG
+echo "http                0"              >> $TAOS_CFG
 echo "numOfThreadsPerCore 2.0"            >> $TAOS_CFG
 echo "defaultPass         taosdata"       >> $TAOS_CFG
 echo "numOfLogLines       100000000"      >> $TAOS_CFG

tests/script/tmp/prepare.sim

 system sh/stop_dnodes.sh
+system sh/ip.sh -i 1 -s up
+system sh/ip.sh -i 2 -s up
+system sh/ip.sh -i 3 -s up
+system sh/ip.sh -i 4 -s up
+
 system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
-system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
+system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
\ No newline at end of file
+system sh/deploy.sh -n dnode4 -m 192.168.0.1 -i 192.168.0.4
+
+system sh/cfg.sh -n dnode1 -c commitLog -v 2
+system sh/cfg.sh -n dnode2 -c commitLog -v 2
+system sh/cfg.sh -n dnode3 -c commitLog -v 2
+system sh/cfg.sh -n dnode4 -c commitLog -v 2
+
+system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
+system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
+system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
+system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
+
+system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+
+system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
+system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4
+system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4
+system sh/cfg.sh -n dnode4 -c numOfTotalVnodes -v 4
\ No newline at end of file

tests/script/unique/db/commit.sim

@@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 0
-system sh/cfg.sh -n dnode2 -c commitLog -v 0
-system sh/cfg.sh -n dnode3 -c commitLog -v 0
+system sh/cfg.sh -n dnode1 -c commitLog -v 2
+system sh/cfg.sh -n dnode2 -c commitLog -v 2
+system sh/cfg.sh -n dnode3 -c commitLog -v 2
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1

tests/script/unique/db/delete.sim

@@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 
-system sh/cfg.sh -n dnode1 -c clog -v 0
-system sh/cfg.sh -n dnode2 -c clog -v 0
-system sh/cfg.sh -n dnode3 -c clog -v 0
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 3
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 3
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 3

tests/script/unique/db/delete_part.sim

@@ -9,10 +9,10 @@ system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 system sh/deploy.sh -n dnode4 -m 192.168.0.1 -i 192.168.0.4
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 0
-system sh/cfg.sh -n dnode2 -c commitLog -v 0
-system sh/cfg.sh -n dnode3 -c commitLog -v 0
-system sh/cfg.sh -n dnode4 -c commitLog -v 0
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
+system sh/cfg.sh -n dnode4 -c clog -v 2
 
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1

tests/script/unique/db/replica_add12.sim

@@ -9,10 +9,10 @@ system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 system sh/deploy.sh -n dnode4 -m 192.168.0.1 -i 192.168.0.4
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 1
-system sh/cfg.sh -n dnode2 -c commitLog -v 1
-system sh/cfg.sh -n dnode3 -c commitLog -v 1
-system sh/cfg.sh -n dnode4 -c commitLog -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
+system sh/cfg.sh -n dnode4 -c clog -v 2
 
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
@@ -30,12 +30,12 @@ system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode4 -c numOfTotalVnodes -v 4
 
 print ========= start dnodes
-system sh/exec.sh -n dnode1 -s start
+system sh/exec_up.sh -n dnode1 -s start
 sql connect
 sql create dnode 192.168.0.2
-system sh/exec.sh -n dnode2 -s start
+system sh/exec_up.sh -n dnode2 -s start
 sql create dnode 192.168.0.3
-system sh/exec.sh -n dnode3 -s start
+system sh/exec_up.sh -n dnode3 -s start
 sleep 3000
 
 print ======== step1 
@@ -76,41 +76,47 @@ endi
 
 sleep 2000
 
+sql show dnodes
+print dnode192.168.0.1 ==> openVnodes: $data3_1
+print dnode192.168.0.2 ==> openVnodes: $data3_2
+print dnode192.168.0.3 ==> openVnodes: $data3_3
+
+if $data3_1 != 0 then
+   return -1
+endi
+
+if $data3_2 != 2 then
+   return -1
+endi
+
+if $data3_3 != 2 then
+   return -1
+endi
+
 print ======== step2
 sql alter database d1 replica 2
 sql alter database d2 replica 2
 sql alter database d3 replica 2
 sql alter database d4 replica 2
-sleep 22000
+sleep 10000
 
 print ======== step3
-$x = 0
-show3: 
-	$x = $x + 1
-	sleep 2000
-	if $x == 10 then 
-		return -1
-	endi
 	
 sql show dnodes
-print dnode192.168.0.1 ==> openVnodes: $data2_192.168.0.1  freeVnodes: $data3_192.168.0.1
-print dnode192.168.0.2 ==> openVnodes: $data2_192.168.0.2  freeVnodes: $data3_192.168.0.2
-print dnode192.168.0.3 ==> openVnodes: $data2_192.168.0.3  freeVnodes: $data3_192.168.0.3
+print dnode192.168.0.1 ==> openVnodes: $data3_1
+print dnode192.168.0.2 ==> openVnodes: $data3_2
+print dnode192.168.0.3 ==> openVnodes: $data3_3
 
-if $data2_192.168.0.1 != 0 then
-   goto show3
+if $data3_1 != 0 then
+   return -1
 endi
 
-if $data3_192.168.0.1 != 4 then
-  goto show3
+if $data3_2 != 4 then
+  return -1
 endi
 
-if $data3_192.168.0.2 != 0 then
-  goto show3
-endi
-
-if $data3_192.168.0.3 != 0 then
-  goto show3
+if $data3_3 != 4 then
+  return -1
 endi
 
 print ======== step4
@@ -139,11 +145,34 @@ if $rows != 2 then
 	return -1
 endi
 
-sleep 20000
+sleep 2000
 print ========= step5 
-system sh/exec.sh -n dnode2 -s stop -x SIGINT
+system sh/exec_up.sh -n dnode2 -s stop -x SIGINT
 sleep 5000
 
+sql select * from d1.t1
+if $rows != 2 then
+	return -1
+endi
+
+sql select * from d2.t2
+if $rows != 2 then
+	return -1
+endi
+
+sql select * from d3.t3
+if $rows != 2 then
+	return -1
+endi
+
+sql select * from d4.t4
+if $rows != 2 then
+	return -1
+endi
+
+print ===== insert data
+
+
 sql insert into d1.t1 values(now, 3)
 sql insert into d2.t2 values(now, 3)
 sql insert into d3.t3 values(now, 3)
@@ -170,9 +199,9 @@ if $rows != 3 then
 endi
 
 print ========= step6
-system sh/exec.sh -n dnode2 -s start
+system sh/exec_up.sh -n dnode2 -s start
 sleep 10000
-system sh/exec.sh -n dnode3 -s stop -x SIGINT
+system sh/exec_up.sh -n dnode3 -s stop -x SIGINT
 sleep 10000
 
 sql insert into d1.t1 values(now, 4)
@@ -201,9 +230,9 @@ if $rows != 4 then
 endi
 
 print ========= step7
-system sh/exec.sh -n dnode3 -s start
+system sh/exec_up.sh -n dnode3 -s start
 sleep 10000
-system sh/exec.sh -n dnode2 -s stop -x SIGINT
+system sh/exec_up.sh -n dnode2 -s stop -x SIGINT
 sleep 10000
 
 sql insert into d1.t1 values(now, 5)

tests/script/unique/db/replica_add13.sim

@@ -9,10 +9,10 @@ system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 system sh/deploy.sh -n dnode4 -m 192.168.0.1 -i 192.168.0.4
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 1
-system sh/cfg.sh -n dnode2 -c commitLog -v 1
-system sh/cfg.sh -n dnode3 -c commitLog -v 1
-system sh/cfg.sh -n dnode4 -c commitLog -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
+system sh/cfg.sh -n dnode4 -c clog -v 2
 
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1

tests/script/unique/db/replica_add23.sim

@@ -9,10 +9,10 @@ system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 system sh/deploy.sh -n dnode4 -m 192.168.0.1 -i 192.168.0.4
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 1
-system sh/cfg.sh -n dnode2 -c commitLog -v 1
-system sh/cfg.sh -n dnode3 -c commitLog -v 1
-system sh/cfg.sh -n dnode4 -c commitLog -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
+system sh/cfg.sh -n dnode4 -c clog -v 2
 
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1

tests/script/unique/db/replica_part.sim

@@ -6,12 +6,12 @@ system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 0
-system sh/cfg.sh -n dnode2 -c commitLog -v 0
-system sh/cfg.sh -n dnode3 -c commitLog -v 0
-system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
-system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
-system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
+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 mgmtEqualVnodeNum -v 4
 system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
 system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4

tests/script/unique/db/replica_reduce21.sim

@@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 1
-system sh/cfg.sh -n dnode2 -c commitLog -v 1
-system sh/cfg.sh -n dnode3 -c commitLog -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1

tests/script/unique/db/replica_reduce31.sim

@@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 1
-system sh/cfg.sh -n dnode2 -c commitLog -v 1
-system sh/cfg.sh -n dnode3 -c commitLog -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1

tests/script/unique/db/replica_reduce32.sim

@@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
 system sh/deploy.sh -n dnode2 -m 192.168.0.1 -i 192.168.0.2
 system sh/deploy.sh -n dnode3 -m 192.168.0.1 -i 192.168.0.3
 
-system sh/cfg.sh -n dnode1 -c commitLog -v 1
-system sh/cfg.sh -n dnode2 -c commitLog -v 1
-system sh/cfg.sh -n dnode3 -c commitLog -v 1
+system sh/cfg.sh -n dnode1 -c clog -v 2
+system sh/cfg.sh -n dnode2 -c clog -v 2
+system sh/cfg.sh -n dnode3 -c clog -v 2
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1

tests/test-all.sh

@@ -25,7 +25,12 @@ if [ "$totalFailed" -ne "0" ]; then
 fi
 
 cd ../pytest
-./simpletest.sh 2>&1 | tee pytest-out.txt
+
+if [ "$1" == "cron" ]; then
+  ./fulltest.sh 2>&1 | tee pytest-out.txt
+else
+  ./smoketest.sh 2>&1 | tee pytest-out.txt
+fi
 totalPySuccess=`grep 'successfully executed' pytest-out.txt | wc -l`
 
 if [ "$totalPySuccess" -gt "0" ]; then