Merge branch 'develop' into hotfix/mgmt

documentation/webdocs/markdowndocs/Connector.md

@@ -2,6 +2,8 @@
 
 TDengine provides many connectors for development, including C/C++, JAVA, Python, RESTful, Go, Node.JS, etc.
 
+NOTE: All APIs which require a SQL string as parameter, including but not limit to `taos_query`, `taos_query_a`, `taos_subscribe` in the C/C++ Connector and their counterparts in other connectors, can ONLY process one SQL statement at a time. If more than one SQL statements are provided, their behaviors are undefined.
+
 ## C/C++ API
 
 C/C++ APIs are similar to the MySQL APIs. Applications should include TDengine head file _taos.h_ to use C/C++ APIs by adding the following line in code:

documentation/webdocs/markdowndocs/connector-ch.md

@@ -2,6 +2,8 @@
 
 TDengine提供了丰富的应用程序开发接口，其中包括C/C++、JAVA、Python、RESTful、Go等，便于用户快速开发应用。
 
+注意：所以执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
+
 ## C/C++ Connector
 
 C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine头文件 _taos.h_（安装后，位于 _/usr/local/taos/include_）：

src/client/inc/tscLog.h

@@ -24,24 +24,11 @@ extern "C" {
 
 extern int32_t cDebugFlag;
 
-#define tscError(...)                        \
-  if (cDebugFlag & DEBUG_ERROR) {            \
-    taosPrintLog("ERROR TSC ", 255, __VA_ARGS__); \
-  }
-#define tscWarn(...)                                \
-  if (cDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN TSC ", cDebugFlag, __VA_ARGS__); \
-  }
-#define tscTrace(...)                         \
-  if (cDebugFlag & DEBUG_TRACE) {             \
-    taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); \
-  }
-#define tscPrint(...) \
-  { taosPrintLog("TSC ", 255, __VA_ARGS__); }
-#define tscDump(...)                                      \
-  if (cDebugFlag & DEBUG_TRACE) {                         \
-    taosPrintLongString("TSC ", cDebugFlag, __VA_ARGS__); \
-  }
+#define tscError(...)  { if (cDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscWarn(...)   { if (cDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscTrace(...)  { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscDump(...)   { if (cDebugFlag & DEBUG_TRACE) { taosPrintLongString("TSC ", cDebugFlag, __VA_ARGS__); }}
+#define tscPrint(...)  { taosPrintLog("TSC ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
 
 #ifdef __cplusplus
 }

src/client/inc/tsclient.h

@@ -210,7 +210,7 @@ typedef struct SQueryInfo {
   int16_t          numOfTables;
   STableMetaInfo **pTableMetaInfo;
   struct STSBuf *  tsBuf;
-  int64_t *        defaultVal;   // default value for interpolation
+  int64_t *        fillVal;      // default value for interpolation
   char *           msg;          // pointer to the pCmd->payload to keep error message temporarily
   int64_t          clauseLimit;  // limit for current sub clause
 

src/client/src/TSDBJNIConnector.c

@@ -22,20 +22,10 @@
 #include "tlog.h"
 #include "ttime.h"
 
-#define jniError(...)                                 \
-  if (jniDebugFlag & DEBUG_ERROR) {                   \
-    taosPrintLog("ERROR JNI ", jniDebugFlag, __VA_ARGS__); \
-  }
-#define jniWarn(...)                                  \
-  if (jniDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN  JNI ", jniDebugFlag, __VA_ARGS__); \
-  }
-#define jniTrace(...)                           \
-  if (jniDebugFlag & DEBUG_TRACE) {             \
-    taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); \
-  }
-#define jniPrint(...) \
-  { taosPrintLog("JNI ", 255, __VA_ARGS__); }
+#define jniError(...)  { if (jniDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR JNI ", jniDebugFlag, __VA_ARGS__); }}
+#define jniWarn(...)   { if (jniDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  JNI ", jniDebugFlag, __VA_ARGS__); }}
+#define jniTrace(...)  { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); }}
+#define jniPrint(...)  { taosPrintLog("JNI ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
 
 int __init = 0;
 

src/client/src/tscFunctionImpl.c

@@ -390,7 +390,11 @@ static void function_finalizer(SQLFunctionCtx *pCtx) {
   
   if (pResInfo->hasResult != DATA_SET_FLAG) {
     tscTrace("no result generated, result is set to NULL");
-    setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+      setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+    } else {
+      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    }
   }
   
   doFinalizer(pCtx);
@@ -1864,12 +1868,22 @@ static void last_row_finalizer(SQLFunctionCtx *pCtx) {
   SResultInfo *pResInfo = GET_RES_INFO(pCtx);
   if (pCtx->currentStage == SECONDARY_STAGE_MERGE) {
     if (pResInfo->hasResult != DATA_SET_FLAG) {
-      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+        setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+      } else {
+        setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      }
+      
       return;
     }
   } else {
     if (pResInfo->hasResult != DATA_SET_FLAG) {
-      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+        setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+      } else {
+        setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+      }
+      
       return;
     }
   }
@@ -2885,7 +2899,12 @@ static void leastsquares_finalizer(SQLFunctionCtx *pCtx) {
   SLeastsquareInfo *pInfo = pResInfo->interResultBuf;
   
   if (pInfo->num == 0) {
-    setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+      setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+    } else {
+      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+    }
+    
     return;
   }
   
@@ -3139,7 +3158,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pCtx->param[1].i64Key;
+          *pOutput = pData[i] - pCtx->param[1].dKey;
           *pTimestamp = pCtx->ptsList[i];
           pOutput += 1;
           pTimestamp += 1;
@@ -3170,7 +3189,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
           pOutput += 1;
           pTimestamp += 1;
         } else {
-          *pOutput = pData[i] - pCtx->param[1].i64Key;
+          *pOutput = pData[i] - pCtx->param[1].dKey;
           *pTimestamp = pCtx->ptsList[i];
           
           pOutput += 1;
@@ -3862,7 +3881,11 @@ static void interp_function(SQLFunctionCtx *pCtx) {
       *(TSKEY *)pCtx->aOutputBuf = pInfoDetail->ts;
     } else {
       if (pInfoDetail->type == TSDB_FILL_NULL) {
-        setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+        if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
+        } else {
+          setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
+        }
       } else if (pInfoDetail->type == TSDB_FILL_SET_VALUE) {
         tVariantDump(&pCtx->param[1], pCtx->aOutputBuf, pCtx->inputType);
       } else if (pInfoDetail->type == TSDB_FILL_PREV) {
@@ -3914,7 +3937,11 @@ static void interp_function(SQLFunctionCtx *pCtx) {
           }
           
         } else {
-          setNull(pCtx->aOutputBuf, srcType, pCtx->inputBytes);
+          if (srcType == TSDB_DATA_TYPE_BINARY || srcType == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(pCtx->aOutputBuf, pCtx->inputBytes);
+          } else {
+            setNull(pCtx->aOutputBuf, srcType, pCtx->inputBytes);
+          }
         }
       }
     }

src/client/src/tscParseInsert.c

@@ -312,8 +312,7 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
     case TSDB_DATA_TYPE_BINARY:
       // binary data cannot be null-terminated char string, otherwise the last char of the string is lost
       if (pToken->type == TK_NULL) {
-        varDataSetLen(payload, sizeof(int8_t));
-        *(uint8_t*) varDataVal(payload) = TSDB_DATA_BINARY_NULL;
+        setVardataNull(payload, TSDB_DATA_TYPE_BINARY);
       } else { // too long values will return invalid sql, not be truncated automatically
         if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) { //todo refactor
           return tscInvalidSQLErrMsg(msg, "string data overflow", pToken->z);
@@ -326,8 +325,7 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
 
     case TSDB_DATA_TYPE_NCHAR:
       if (pToken->type == TK_NULL) {
-        varDataSetLen(payload, sizeof(int32_t));
-        *(uint32_t*) varDataVal(payload) = TSDB_DATA_NCHAR_NULL;
+        setVardataNull(payload, TSDB_DATA_TYPE_NCHAR);
       } else {
         // if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long'
         size_t output = 0;

src/client/src/tscSQLParser.c

@@ -13,7 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define _XOPEN_SOURCE
+#define _BSD_SOURCE
+#define _XOPEN_SOURCE 500
 #define _DEFAULT_SOURCE
 
 #include "os.h"
@@ -4015,9 +4016,9 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
   
   size_t size = tscSqlExprNumOfExprs(pQueryInfo);
   
-  if (pQueryInfo->defaultVal == NULL) {
-    pQueryInfo->defaultVal = calloc(size, sizeof(int64_t));
-    if (pQueryInfo->defaultVal == NULL) {
+  if (pQueryInfo->fillVal == NULL) {
+    pQueryInfo->fillVal = calloc(size, sizeof(int64_t));
+    if (pQueryInfo->fillVal == NULL) {
       return TSDB_CODE_CLI_OUT_OF_MEMORY;
     }
   }
@@ -4028,7 +4029,11 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
     pQueryInfo->fillType = TSDB_FILL_NULL;
     for (int32_t i = START_INTERPO_COL_IDX; i < size; ++i) {
       TAOS_FIELD* pFields = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
-      setNull((char*)&pQueryInfo->defaultVal[i], pFields->type, pFields->bytes);
+      if (pFields->type == TSDB_DATA_TYPE_BINARY || pFields->type == TSDB_DATA_TYPE_NCHAR) {
+        setVardataNull((char*) &pQueryInfo->fillVal[i], pFields->type);
+      } else {
+        setNull((char*)&pQueryInfo->fillVal[i], pFields->type, pFields->bytes);
+      };
     }
   } else if (strncasecmp(pItem->pVar.pz, "prev", 4) == 0 && pItem->pVar.nLen == 4) {
     pQueryInfo->fillType = TSDB_FILL_PREV;
@@ -4061,11 +4066,11 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
       TAOS_FIELD* pFields = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
 
       if (pFields->type == TSDB_DATA_TYPE_BINARY || pFields->type == TSDB_DATA_TYPE_NCHAR) {
-        setNull((char*)(&pQueryInfo->defaultVal[i]), pFields->type, pFields->bytes);
+        setVardataNull((char*) &pQueryInfo->fillVal[i], pFields->type);
         continue;
       }
 
-      int32_t ret = tVariantDump(&pFillToken->a[j].pVar, (char*)&pQueryInfo->defaultVal[i], pFields->type);
+      int32_t ret = tVariantDump(&pFillToken->a[j].pVar, (char*)&pQueryInfo->fillVal[i], pFields->type);
       if (ret != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg);
       }
@@ -4079,9 +4084,9 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
         TAOS_FIELD* pFields = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
 
         if (pFields->type == TSDB_DATA_TYPE_BINARY || pFields->type == TSDB_DATA_TYPE_NCHAR) {
-          setNull((char*)(&pQueryInfo->defaultVal[i]), pFields->type, pFields->bytes);
+          setVardataNull((char*) &pQueryInfo->fillVal[i], pFields->type);
         } else {
-          tVariantDump(&lastItem->pVar, (char*)&pQueryInfo->defaultVal[i], pFields->type);
+          tVariantDump(&lastItem->pVar, (char*)&pQueryInfo->fillVal[i], pFields->type);
         }
       }
     }

src/client/src/tscSecondaryMerge.c

@@ -145,7 +145,7 @@ static SFillColInfo* createFillColInfo(SQueryInfo* pQueryInfo) {
     pFillCol[i].flag       = pExpr->colInfo.flag;
     pFillCol[i].col.offset = offset;
     pFillCol[i].functionId = pExpr->functionId;
-    pFillCol[i].defaultVal.i = pQueryInfo->defaultVal[i];
+    pFillCol[i].fillVal.i  = pQueryInfo->fillVal[i];
     offset += pExpr->resBytes;
   }
   
@@ -946,8 +946,7 @@ static void doInterpolateResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, boo
   }
   
   while (1) {
-    int64_t newRows = -1;
-    taosGenerateDataBlock(pFillInfo, pResPages, &newRows, pLocalReducer->resColModel->capacity);
+    int64_t newRows = taosGenerateDataBlock(pFillInfo, pResPages, pLocalReducer->resColModel->capacity);
 
     if (pQueryInfo->limit.offset < newRows) {
       newRows -= pQueryInfo->limit.offset;

src/client/src/tscServer.c

@@ -217,10 +217,12 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
   STscObj *pObj = pSql->pTscObj;
   // tscTrace("%p msg:%s is received from server", pSql, taosMsg[rpcMsg->msgType]);
 
-  if (pSql->freed || pObj->signature != pObj) {
+  if (pObj->signature != pObj) {
     tscTrace("%p sql is already released or DB connection is closed, freed:%d pObj:%p signature:%p", pSql, pSql->freed,
              pObj, pObj->signature);
-    tscFreeSqlObj(pSql);
+    if (pSql != pObj->pSql) {
+      tscFreeSqlObj(pSql);
+    }
     rpcFreeCont(rpcMsg->pCont);
     return;
   }
@@ -781,8 +783,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
     for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-      *((int64_t *)pMsg) = htobe64(pQueryInfo->defaultVal[i]);
-      pMsg += sizeof(pQueryInfo->defaultVal[0]);
+      *((int64_t *)pMsg) = htobe64(pQueryInfo->fillVal[i]);
+      pMsg += sizeof(pQueryInfo->fillVal[0]);
     }
   }
   
@@ -1867,8 +1869,8 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
     return TSDB_CODE_CLI_OUT_OF_MEMORY;
   }
 
-  free(pTableMeta);
   tscTrace("%p recv table meta: %"PRId64 ", tid:%d, name:%s", pSql, pTableMeta->uid, pTableMeta->sid, pTableMetaInfo->name);
+  free(pTableMeta);
   
   return TSDB_CODE_SUCCESS;
 }

src/client/src/tscSql.c

@@ -576,26 +576,22 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) {
    *         for each subquery. Because the failure of execution tsProcessSql may trigger the callback function
    *         be executed, and the retry efforts may result in double free the resources, e.g.,SRetrieveSupport
    */
-  if ((pCmd->command == TSDB_SQL_SELECT || pCmd->command == TSDB_SQL_SHOW || pCmd->command == TSDB_SQL_RETRIEVE ||
-      pCmd->command == TSDB_SQL_FETCH) &&
-      (pRes->code != TSDB_CODE_QUERY_CANCELLED && ((pRes->numOfRows > 0 && pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) ||
-       (pRes->code == TSDB_CODE_SUCCESS && pRes->numOfRows == 0 && pCmd->command == TSDB_SQL_SELECT &&
-        pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)))) {
+  if ((pCmd->command == TSDB_SQL_SELECT ||
+       pCmd->command == TSDB_SQL_SHOW ||
+       pCmd->command == TSDB_SQL_RETRIEVE ||
+       pCmd->command == TSDB_SQL_FETCH) &&
+       (pRes->code != TSDB_CODE_QUERY_CANCELLED && ((pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) ||
+       (pRes->code == TSDB_CODE_SUCCESS && pCmd->command == TSDB_SQL_SELECT && pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)))) {
     pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
 
-    tscTrace("%p code:%d, numOfRows:%d, command:%d", pSql, pRes->code, pRes->numOfRows, pCmd->command);
+    tscTrace("%p send msg to free qhandle in vnode, code:%d, numOfRows:%d, command:%s", pSql, pRes->code, pRes->numOfRows,
+        sqlCmd[pCmd->command]);
 
     pSql->freed = 1;
     tscProcessSql(pSql);
-
-    /*
-     *  If release connection msg is sent to vnode, the corresponding SqlObj for async query can not be freed instantly,
-     *  since its free operation is delegated to callback function, which is tscProcessMsgFromServer.
-     */
-    STscObj* pObj = pSql->pTscObj;
-    if (pObj->pSql == pSql) {
-      pObj->pSql = NULL;
-    }
+  
+    // waits for response and then goes on
+    sem_wait(&pSql->rspSem);
   } else { // if no free resource msg is sent to vnode, we free this object immediately.
     STscObj* pTscObj = pSql->pTscObj;
     

src/client/src/tscStream.c

@@ -223,7 +223,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
           int16_t     offset = tscFieldInfoGetOffset(pQueryInfo, i);
           TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
 
-          assignVal(pSql->res.data + offset, (char *)(&pQueryInfo->defaultVal[i]), pField->bytes, pField->type);
+          assignVal(pSql->res.data + offset, (char *)(&pQueryInfo->fillVal[i]), pField->bytes, pField->type);
           row[i] = pSql->res.data + offset;
         }
 

src/client/src/tscUtil.c

@@ -281,7 +281,7 @@ void tscClearInterpInfo(SQueryInfo* pQueryInfo) {
   }
 
   pQueryInfo->fillType = TSDB_FILL_NONE;
-  tfree(pQueryInfo->defaultVal);
+  tfree(pQueryInfo->fillVal);
 }
 
 int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
@@ -423,6 +423,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
   tfree(pCmd->payload);
 
   pCmd->allocSize = 0;
+  
+  tfree(pSql->sqlstr);
   free(pSql);
 }
 
@@ -1616,7 +1618,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
   
   pQueryInfo->tsBuf = tsBufDestory(pQueryInfo->tsBuf);
 
-  tfree(pQueryInfo->defaultVal);
+  tfree(pQueryInfo->fillVal);
 }
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
@@ -1768,7 +1770,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   pNewQueryInfo->order  = pQueryInfo->order;
   pNewQueryInfo->clauseLimit = pQueryInfo->clauseLimit;
   pNewQueryInfo->pTableMetaInfo = NULL;
-  pNewQueryInfo->defaultVal  = NULL;
+  pNewQueryInfo->fillVal  = NULL;
   pNewQueryInfo->numOfTables = 0;
   pNewQueryInfo->tsBuf = NULL;
   
@@ -1780,8 +1782,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   tscTagCondCopy(&pNewQueryInfo->tagCond, &pQueryInfo->tagCond);
 
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-    pNewQueryInfo->defaultVal = malloc(pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
-    memcpy(pNewQueryInfo->defaultVal, pQueryInfo->defaultVal, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
+    pNewQueryInfo->fillVal = malloc(pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
+    memcpy(pNewQueryInfo->fillVal, pQueryInfo->fillVal, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
   }
 
   if (tscAllocPayload(pnCmd, TSDB_DEFAULT_PAYLOAD_SIZE) != TSDB_CODE_SUCCESS) {

src/common/inc/tdataformat.h

@@ -217,6 +217,59 @@ void       tdPopDataColsPoints(SDataCols *pCols, int pointsToPop); //!!!!
 int        tdMergeDataCols(SDataCols *target, SDataCols *src, int rowsToMerge);
 void       tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SDataCols *src2, int *iter2, int tRows);
 
+
+// ----------------- Tag row structure
+
+/* A tag row, the format is like below:
++----------+----------------------------------------------------------------+
+| STagRow  | STagCol | STagCol | STagCol | STagCol | ...| STagCol | STagCol | 
++----------+----------------------------------------------------------------+
+
+pData
++----------+----------------------------------------------------------------+
+| value 1     | value 2 |  value 3     | value 4       | ....|value n       |
++----------+----------------------------------------------------------------+
+
+ */
+
+
+#define TD_TAG_ROW_HEAD_SIZE sizeof(int16_t)
+
+#define tagRowNum(r) (*(int16_t *)(r))
+#define tagRowArray(r) POINTER_SHIFT(r, TD_TAG_ROW_HEAD_SIZE)
+//#define dataRowKey(r) (*(TSKEY *)(dataRowTuple(r)))
+//#define dataRowSetLen(r, l) (dataRowLen(r) = (l))
+//#define dataRowCpy(dst, r) memcpy((dst), (r), dataRowLen(r))
+//#define dataRowMaxBytesFromSchema(s) (schemaTLen(s) + TD_DATA_ROW_HEAD_SIZE)
+
+typedef struct {
+  int16_t colId;   // column ID
+  int16_t colType;
+  uint16_t offset;  //to store value for numeric col or offset for binary/Nchar
+} STagCol;
+
+typedef struct {
+  int32_t    len;    
+  void *     pData;  // Space to store the tag value   
+  uint16_t   dataLen;
+  int16_t    ncols;  // Total columns allocated
+  STagCol    tagCols[];
+} STagRow;
+
+
+#define tagColSize(r) (sizeof(STagCol) + r.colLen)
+
+int tdSetTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId);  //insert tag value and update all the information
+int tdDeleteTagCol(SDataRow row, int16_t colId);  // delete tag value and update all the information
+void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type);   //if find tag, 0, else return -1;
+int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId);  
+SDataRow tdTagRowDup(SDataRow row);
+void tdFreeTagRow(SDataRow row); 
+SDataRow tdTagRowDecode(SDataRow row);
+int tdTagRowCpy(SDataRow dst, SDataRow src);
+void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags);
+STSchema *tdGetSchemaFromData(SDataRow *row);
+
 #ifdef __cplusplus
 }
 #endif

src/common/inc/tulog.h

@@ -25,31 +25,15 @@ extern "C" {
 extern int32_t uDebugFlag;
 extern int32_t tscEmbedded;
 
-#define uError(...)                                      \
-  if (uDebugFlag & DEBUG_ERROR) {                        \
-    taosPrintLog("ERROR UTL ", uDebugFlag, __VA_ARGS__); \
-  }
-#define uWarn(...)                                       \
-  if (uDebugFlag & DEBUG_WARN) {                         \
-    taosPrintLog("WARN  UTL ", uDebugFlag, __VA_ARGS__); \
-  }
-#define uTrace(...)                                \
-  if (uDebugFlag & DEBUG_TRACE) {                  \
-    taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); \
-  }
-#define uDump(x, y)              \
-  if (uDebugFlag & DEBUG_DUMP) { \
-    taosDumpData(x, y);          \
-  }
-#define uPrint(...) \
-  { taosPrintLog("UTL ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
-#define uForcePrint(...) \
-  { taosPrintLog("ERROR UTL ", 255, __VA_ARGS__); }
-
-#define pError(...) \
-  { taosPrintLog("ERROR APP ", 255, __VA_ARGS__); }  
-#define pPrint(...) \
-  { taosPrintLog("APP ", 255, __VA_ARGS__); }  
+#define uError(...)       { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR UTL ", uDebugFlag, __VA_ARGS__); }}
+#define uWarn(...)        { if (uDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  UTL ", uDebugFlag, __VA_ARGS__); }}
+#define uTrace(...)       { if (uDebugFlag & DEBUG_TRACE) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }}
+#define uDump(x, y)       { if (uDebugFlag & DEBUG_DUMP)  { taosDumpData(x, y); }}
+#define uPrint(...)       { taosPrintLog("UTL ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
+#define uForcePrint(...)  { taosPrintLog("ERROR UTL ", 255, __VA_ARGS__); }
+
+#define pError(...) { taosPrintLog("ERROR APP ", 255, __VA_ARGS__); }  
+#define pPrint(...) { taosPrintLog("APP ", 255, __VA_ARGS__); }  
 
 #ifdef __cplusplus
 }

src/common/src/tdataformat.c

@@ -14,6 +14,7 @@
  */
 #include "tdataformat.h"
 #include "wchar.h"
+#include "talgo.h"
 
 /**
  * Create a SSchema object with nCols columns
@@ -151,6 +152,151 @@ SDataRow tdNewDataRowFromSchema(STSchema *pSchema) {
   return row;
 }
 
+int tdSetTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId){ //insert/update tag value and update all the information
+  ASSERT(((STagRow *)row)->pData != NULL);
+  //STagCol * stCol = tdQueryTagColByID()
+
+  return 0;
+};  
+
+int tdDeleteTagCol(SDataRow row, int16_t colId){   // delete tag value and update all the information
+  //todo
+  return 0;
+};  
+
+static int compTagId(const void *key1, const void *key2) {
+  if (((STagCol *)key1)->colId > ((STagCol *)key2)->colId) {
+    return 1;
+  } else if (((STagCol *)key1)->colId == ((STagCol *)key2)->colId) {
+    return 0;
+  } else {
+    return -1;
+  }
+}
+
+/**
+ * Find tag structure by colId, if find, return tag structure, else return NULL;
+ */
+STagCol * tdQueryTagColByID(SDataRow row, int16_t colId, int flags) {  //if find tag, 0, else return -1; 
+  ASSERT(((STagRow *)row)->pData != NULL);
+  STagCol *pBase = ((STagRow *)row)->tagCols;
+  int16_t nCols = ((STagRow *)row)->ncols;
+  STagCol key = {colId,0,0};
+  STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, flags);
+  return stCol;
+};   
+
+/**
+* Find tag value by colId, if find, return tag value, else return NULL;
+*/
+void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) {
+  ASSERT(((STagRow *)row)->pData != NULL);
+  STagCol *pBase = ((STagRow *)row)->tagCols;
+  int16_t nCols = ((STagRow *)row)->ncols;
+  STagCol key = {colId,0,0};
+  STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, TD_EQ);
+  if (NULL == stCol) {
+    return NULL;
+  }
+  
+  void * pData = ((STagRow *)row)->pData;
+  *type = stCol->colType;
+
+  return pData + stCol->offset;
+};   
+
+int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId){
+  ASSERT(value != NULL);
+  //ASSERT(bytes-2 == varDataTLen(value));
+  ASSERT(row != NULL);
+  STagRow *pTagrow = row;
+  pTagrow->tagCols[pTagrow->ncols].colId = colId;
+  pTagrow->tagCols[pTagrow->ncols].colType = type;
+  pTagrow->tagCols[pTagrow->ncols].offset = pTagrow->dataLen;
+  
+  switch (type) {
+    case TSDB_DATA_TYPE_BINARY:
+    case TSDB_DATA_TYPE_NCHAR:
+      memcpy((char *)pTagrow->pData + pTagrow->dataLen, value, varDataTLen(value));
+      pTagrow->dataLen += varDataTLen(value);
+      break;
+    default:
+      memcpy((char *)pTagrow->pData + pTagrow->dataLen, value, TYPE_BYTES[type]);
+      pTagrow->dataLen += TYPE_BYTES[type];
+      break;
+  } 
+  
+  pTagrow->ncols++;   
+
+  return 0;
+};  
+
+void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags) {
+  int32_t size = sizeof(STagRow) + numofTags * sizeof(STagCol);
+
+  STagRow *row = malloc(size);
+  if (row == NULL) return NULL;
+
+  int32_t datasize = pSchema->tlen;
+  row->pData = malloc(datasize);
+  if (NULL == row->pData) {
+    free(row);
+    return NULL;
+  }
+
+  row->len = size;
+  row->dataLen = 0; 
+  row->ncols = 0; 
+  return row;   
+}
+/**
+ * free tag row 
+ */
+ 
+void tdFreeTagRow(SDataRow row) {
+  if (row) {
+    free(((STagRow *)row)->pData);
+    free(row);
+  }  
+}
+
+SDataRow tdTagRowDup(SDataRow row) {
+  STagRow *trow = malloc(dataRowLen(row));
+  if (trow == NULL) return NULL;
+  
+  dataRowCpy(trow, row);
+  trow->pData = malloc(trow->dataLen);
+  if (NULL == trow->pData) {
+    free(trow);
+    return NULL;
+  }
+  memcpy(trow->pData, ((STagRow *)row)->pData, trow->dataLen);
+  return trow;
+}
+
+SDataRow tdTagRowDecode(SDataRow row) {
+  STagRow *trow = malloc(dataRowLen(row));
+  if (trow == NULL) return NULL;
+  
+  dataRowCpy(trow, row);
+  trow->pData = malloc(trow->dataLen);
+  if (NULL == trow->pData) {
+    free(trow);
+    return NULL;
+  }
+  char * pData = (char *)row + dataRowLen(row);
+  memcpy(trow->pData, pData, trow->dataLen);
+  return trow;
+}
+
+int tdTagRowCpy(SDataRow dst, SDataRow src) {
+  if (src == NULL) return -1;
+  
+  dataRowCpy(dst, src);
+  void * pData = dst + dataRowLen(src);
+  memcpy(pData, ((STagRow *)src)->pData, ((STagRow *)src)->dataLen);
+  return 0;
+}
 /**
  * Free the SDataRow object
  */

src/common/src/tglobal.c

@@ -202,6 +202,8 @@ char tsTimezone[64] = {0};
 char tsLocale[TSDB_LOCALE_LEN] = {0};
 char tsCharset[TSDB_LOCALE_LEN] = {0};  // default encode string
 
+int32_t tsMaxBinaryDisplayWidth = 30;
+
 static pthread_once_t tsInitGlobalCfgOnce = PTHREAD_ONCE_INIT;
 
 void taosSetAllDebugFlag() {
@@ -605,7 +607,7 @@ static void doInitGlobalConfig() {
   cfg.minValue = TSDB_MIN_CACHE_BLOCK_SIZE;
   cfg.maxValue = TSDB_MAX_CACHE_BLOCK_SIZE;
   cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_BYTE;
+  cfg.unitType = TAOS_CFG_UTYPE_Mb;
   taosInitConfigOption(cfg);
 
   cfg.option = "blocks";
@@ -615,7 +617,7 @@ static void doInitGlobalConfig() {
   cfg.minValue = TSDB_MIN_TOTAL_BLOCKS;
   cfg.maxValue = TSDB_MAX_TOTAL_BLOCKS;
   cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_BYTE;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
   cfg.option = "days";
@@ -1227,6 +1229,16 @@ static void doInitGlobalConfig() {
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
+
+  cfg.option = "maxBinaryDisplayWidth";
+  cfg.ptr = &tsMaxBinaryDisplayWidth;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 1;
+  cfg.maxValue = 0x7fffffff;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
 }
 
 void taosInitGlobalCfg() {

src/common/src/tlocale.c

@@ -31,16 +31,16 @@ void tsSetLocale() {
 
   // default locale or user specified locale is not valid, abort launch
   if (locale == NULL) {
-    uForcePrint("Invalid locale:%s, please set the valid locale in config file", tsLocale);
+    uError("Invalid locale:%s, please set the valid locale in config file", tsLocale);
   }
 
   if (strlen(tsCharset) == 0) {
-    uForcePrint("failed to get charset, please set the valid charset in config file");
+    uError("failed to get charset, please set the valid charset in config file");
     exit(-1);
   }
 
   if (!taosValidateEncodec(tsCharset)) {
-    uForcePrint("Invalid charset:%s, please set the valid charset in config file", tsCharset);
+    uError("Invalid charset:%s, please set the valid charset in config file", tsCharset);
     exit(-1);
   }
 }
\ No newline at end of file

src/common/src/ttypes.c

@@ -381,6 +381,18 @@ bool isNull(const char *val, int32_t type) {
   };
 }
 
+void setVardataNull(char* val, int32_t type) {
+  if (type == TSDB_DATA_TYPE_BINARY) {
+    varDataSetLen(val, sizeof(int8_t));
+    *(uint8_t*) varDataVal(val) = TSDB_DATA_BINARY_NULL;
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    varDataSetLen(val, sizeof(int32_t));
+    *(uint32_t*) varDataVal(val) = TSDB_DATA_NCHAR_NULL;
+  } else {
+    assert(0);
+  }
+}
+
 void setNull(char *val, int32_t type, int32_t bytes) { setNullN(val, type, bytes, 1); }
 
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
@@ -483,7 +495,7 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
       break;
     };
     case TSDB_DATA_TYPE_NCHAR: {
-      wcsncpy((wchar_t*)val, (wchar_t*)src, len / TSDB_NCHAR_SIZE);
+      varDataCopy(val, src);
       break;
     };
     default: {

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java

@@ -188,7 +188,7 @@ public class TSDBDriver implements java.sql.Driver {
 	}
 
 	public boolean acceptsURL(String url) throws SQLException {
-		return true;
+		return StringUtils.isNotBlank(url) && url.startsWith(URL_PREFIX);
 	}
 
 	public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException {
@@ -355,4 +355,4 @@ public class TSDBDriver implements java.sql.Driver {
 	public String database(Properties props) {
 		return props.getProperty(PROPERTY_KEY_DBNAME);
 	}
-}
+}
\ No newline at end of file

src/cq/src/cqMain.c

@@ -27,10 +27,10 @@
 #include "tcq.h"
 #include "taos.h"
 
-#define cError(...) if (cqDebugFlag & DEBUG_ERROR) {taosPrintLog("ERROR CQ  ", cqDebugFlag, __VA_ARGS__);}
-#define cWarn(...) if (cqDebugFlag & DEBUG_WARN) {taosPrintLog("WARN CQ  ", cqDebugFlag, __VA_ARGS__);}
-#define cTrace(...) if (cqDebugFlag & DEBUG_TRACE) {taosPrintLog("CQ  ", cqDebugFlag, __VA_ARGS__);}
-#define cPrint(...) {taosPrintLog("CQ  ", 255, __VA_ARGS__);}
+#define cError(...) { if (cqDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR CQ  ", cqDebugFlag, __VA_ARGS__); }}
+#define cWarn(...)  { if (cqDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN CQ  ", cqDebugFlag, __VA_ARGS__); }}
+#define cTrace(...) { if (cqDebugFlag & DEBUG_TRACE) { taosPrintLog("CQ  ", cqDebugFlag, __VA_ARGS__); }}
+#define cPrint(...) { taosPrintLog("CQ  ", 255, __VA_ARGS__); }
 
 typedef struct {
   int      vgId;

src/dnode/inc/dnodeInt.h

@@ -24,10 +24,10 @@ extern "C" {
 
 extern int32_t dDebugFlag;
 
-#define dError(...) if (dDebugFlag & DEBUG_ERROR) {taosPrintLog("ERROR DND ", 255, __VA_ARGS__); }
-#define dWarn(...) if (dDebugFlag & DEBUG_WARN) {taosPrintLog("WARN  DND ", dDebugFlag, __VA_ARGS__); }
-#define dTrace(...) if (dDebugFlag & DEBUG_TRACE) {taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }
-#define dPrint(...) {taosPrintLog("DND ", 255, __VA_ARGS__); }
+#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR DND ", 255, __VA_ARGS__); }}
+#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  DND ", dDebugFlag, __VA_ARGS__); }}
+#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
+#define dPrint(...) { taosPrintLog("DND ", 255, __VA_ARGS__); }
 
 #ifdef __cplusplus
 }

src/inc/taosdef.h

@@ -157,6 +157,7 @@ extern tDataTypeDescriptor tDataTypeDesc[11];
 bool isValidDataType(int32_t type, int32_t length);
 bool isNull(const char *val, int32_t type);
 
+void setVardataNull(char* val, int32_t type);
 void setNull(char *val, int32_t type, int32_t bytes);
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems);
 

src/inc/taoserror.h

@@ -46,145 +46,144 @@ static STaosError errors[] = {
 #endif
 
 // rpc
-TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_IN_PROGRESS,         0, 1, "action in progress")
-TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_NEED_REPROCESSED,    0, 3, "action need to be reprocessed")
-TAOS_DEFINE_ERROR(TSDB_CODE_MSG_NOT_PROCESSED,          0, 4, "message not processed")
-TAOS_DEFINE_ERROR(TSDB_CODE_ALREADY_PROCESSED,          0, 5, "message already processed")
-TAOS_DEFINE_ERROR(TSDB_CODE_REDIRECT,                   0, 6, "redirect")
-TAOS_DEFINE_ERROR(TSDB_CODE_LAST_SESSION_NOT_FINISHED,  0, 7, "last session not finished")
-TAOS_DEFINE_ERROR(TSDB_CODE_MAX_SESSIONS,               0, 8, "max sessions")    // too many sessions
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_SESSION_ID,         0, 9, "invalid session id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TRAN_ID,            0, 10, "invalid transaction id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_TYPE,           0, 11, "invalid message type")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_LEN,            0, 12, "invalid message length")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_CONTENT,        0, 13, "invalid message content")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_VERSION,        0, 14, "invalid message version")
-TAOS_DEFINE_ERROR(TSDB_CODE_UNEXPECTED_RESPONSE,        0, 15, "unexpected response")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_RESPONSE_TYPE,      0, 16, "invalid response type")
-TAOS_DEFINE_ERROR(TSDB_CODE_MISMATCHED_METER_ID,        0, 17, "mismatched meter id")
-TAOS_DEFINE_ERROR(TSDB_CODE_DISCONNECTED,               0, 18, "disconnected")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_READY,                  0, 19, "not ready")    // peer is not ready to process data
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_SLOW,                   0, 20, "too slow")
-TAOS_DEFINE_ERROR(TSDB_CODE_OTHERS,                     0, 21, "others")
-TAOS_DEFINE_ERROR(TSDB_CODE_APP_ERROR,                  0, 22, "app error")
-TAOS_DEFINE_ERROR(TSDB_CODE_ALREADY_THERE,              0, 23, "already there")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_RESOURCE,                0, 14, "no resource")
-TAOS_DEFINE_ERROR(TSDB_CODE_OPS_NOT_SUPPORT,            0, 25, "operations not support")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_OPTION,             0, 26, "invalid option")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_CONFIGURED,             0, 27, "not configured")
-TAOS_DEFINE_ERROR(TSDB_CODE_NODE_OFFLINE,               0, 28, "node offline")
-TAOS_DEFINE_ERROR(TSDB_CODE_NETWORK_UNAVAIL,            0, 29, "network unavailable")
-TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_REQUIRED,              0, 30, "auth required")
+TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_IN_PROGRESS,         0, 0x0001, "action in progress")
+TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_NEED_REPROCESSED,    0, 0x0003, "action need to be reprocessed")
+TAOS_DEFINE_ERROR(TSDB_CODE_MSG_NOT_PROCESSED,          0, 0x0004, "message not processed")
+TAOS_DEFINE_ERROR(TSDB_CODE_ALREADY_PROCESSED,          0, 0x0005, "message already processed")
+TAOS_DEFINE_ERROR(TSDB_CODE_REDIRECT,                   0, 0x0006, "redirect")
+TAOS_DEFINE_ERROR(TSDB_CODE_LAST_SESSION_NOT_FINISHED,  0, 0x0007, "last session not finished")
+TAOS_DEFINE_ERROR(TSDB_CODE_MAX_SESSIONS,               0, 0x0008, "max sessions")    // too many sessions
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_SESSION_ID,         0, 0x0009, "invalid session id")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TRAN_ID,            0, 0x000A, "invalid transaction id")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_TYPE,           0, 0x000B, "invalid message type")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_LEN,            0, 0x000C, "invalid message length")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_CONTENT,        0, 0x000D, "invalid message content")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_VERSION,        0, 0x000E, "invalid message version")
+TAOS_DEFINE_ERROR(TSDB_CODE_UNEXPECTED_RESPONSE,        0, 0x000F, "unexpected response")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_RESPONSE_TYPE,      0, 0x0010, "invalid response type")
+TAOS_DEFINE_ERROR(TSDB_CODE_MISMATCHED_METER_ID,        0, 0x0011, "mismatched meter id")
+TAOS_DEFINE_ERROR(TSDB_CODE_DISCONNECTED,               0, 0x0012, "disconnected")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_READY,                  0, 0x0013, "not ready")    // peer is not ready to process data
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_SLOW,                   0, 0x0014, "too slow")
+TAOS_DEFINE_ERROR(TSDB_CODE_OTHERS,                     0, 0x0015, "others")
+TAOS_DEFINE_ERROR(TSDB_CODE_APP_ERROR,                  0, 0x0016, "app error")
+TAOS_DEFINE_ERROR(TSDB_CODE_ALREADY_THERE,              0, 0x0017, "already there")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_RESOURCE,                0, 0x0018, "no resource")
+TAOS_DEFINE_ERROR(TSDB_CODE_OPS_NOT_SUPPORT,            0, 0x0019, "operations not support")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_OPTION,             0, 0x001A, "invalid option")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_CONFIGURED,             0, 0x001B, "not configured")
+TAOS_DEFINE_ERROR(TSDB_CODE_NODE_OFFLINE,               0, 0x001C, "node offline")
+TAOS_DEFINE_ERROR(TSDB_CODE_NETWORK_UNAVAIL,            0, 0x001D, "network unavailable")
+TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_REQUIRED,              0, 0x001E, "auth required")
 
 // db
-TAOS_DEFINE_ERROR(TSDB_CODE_DB_NOT_SELECTED,            0, 100, "db not selected")
-TAOS_DEFINE_ERROR(TSDB_CODE_DB_ALREADY_EXIST,           0, 101, "database aleady exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_DB,                 0, 102, "invalid database")
-TAOS_DEFINE_ERROR(TSDB_CODE_MONITOR_DB_FORBIDDEN,       0, 103, "monitor db forbidden")
+TAOS_DEFINE_ERROR(TSDB_CODE_DB_NOT_SELECTED,            0, 0x0100, "db not selected")
+TAOS_DEFINE_ERROR(TSDB_CODE_DB_ALREADY_EXIST,           0, 0x0101, "database aleady exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_DB,                 0, 0x0102, "invalid database")
+TAOS_DEFINE_ERROR(TSDB_CODE_MONITOR_DB_FORBIDDEN,       0, 0x0103, "monitor db forbidden")
 
 // user
-TAOS_DEFINE_ERROR(TSDB_CODE_USER_ALREADY_EXIST,         0, 150, "user already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_USER,               0, 151, "invalid user")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PASS,               0, 152, "invalid password")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_USER_FORMAT,        0, 153, "invalid user format")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PASS_FORMAT,        0, 154, "invalid password format")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_USER_FROM_CONN,          0, 155, "can not get user from conn")
+TAOS_DEFINE_ERROR(TSDB_CODE_USER_ALREADY_EXIST,         0, 0x0180, "user already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_USER,               0, 0x0181, "invalid user")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PASS,               0, 0x0182, "invalid password")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_USER_FORMAT,        0, 0x0183, "invalid user format")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PASS_FORMAT,        0, 0x0184, "invalid password format")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_USER_FROM_CONN,          0, 0x0185, "can not get user from conn")
 
 // table
-TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ALREADY_EXIST,        0, 200, "table already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_ID,           0, 201, "invalid table id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_TYPE,         0, 202, "invalid table typee")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE,              0, 203, "invalid table name")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUPER_TABLE,            0, 204, "no super table")           // operation only available for super table
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_ACTIVE_TABLE,           0, 205, "not active table")
-TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ID_MISMATCH,          0, 206, "table id mismatch")
-TAOS_DEFINE_ERROR(TSDB_CODE_TAG_ALREAY_EXIST,           0, 207, "tag already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_TAG_NOT_EXIST,              0, 208, "tag not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_ALREAY_EXIST,         0, 209, "field already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_NOT_EXIST,            0, 210, "field not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG,          0, 211, "column name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TAGS,              0, 211, "too many tags")
+TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ALREADY_EXIST,        0, 0x0200, "table already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_ID,           0, 0x0201, "invalid table id")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_TYPE,         0, 0x0202, "invalid table typee")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE,              0, 0x0203, "invalid table name")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUPER_TABLE,            0, 0x0204, "no super table")           // operation only available for super table
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_ACTIVE_TABLE,           0, 0x0205, "not active table")
+TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ID_MISMATCH,          0, 0x0206, "table id mismatch")
+TAOS_DEFINE_ERROR(TSDB_CODE_TAG_ALREAY_EXIST,           0, 0x0207, "tag already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_TAG_NOT_EXIST,              0, 0x0208, "tag not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_ALREAY_EXIST,         0, 0x0209, "field already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_NOT_EXIST,            0, 0x020A, "field not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG,          0, 0x020B, "column name too long")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TAGS,              0, 0x020C, "too many tags")
 
 
 // dnode & mnode
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_ENOUGH_DNODES,           0, 250, "no enough dnodes")
-TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_ALREADY_EXIST,        0, 251, "dnode already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_NOT_EXIST,            0, 252, "dnode not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_MASTER,                  0, 253, "no master")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_REMOVE_MASTER,           0, 254, "no remove master")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QUERY_ID,           0, 255, "invalid query id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_STREAM_ID,          0, 256, "invalid stream id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONNECTION,         0, 257, "invalid connection")
-TAOS_DEFINE_ERROR(TSDB_CODE_SDB_ERROR,                  0, 258, "sdb error")
-TAOS_DEFINE_ERROR(TSDB_CODE_TIMESTAMP_OUT_OF_RANGE,     0, 259, "timestamp is out of range")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_ENOUGH_DNODES,           0, 0x0280, "no enough dnodes")
+TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_ALREADY_EXIST,        0, 0x0281, "dnode already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_NOT_EXIST,            0, 0x0282, "dnode not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_MASTER,                  0, 0x0283, "no master")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_REMOVE_MASTER,           0, 0x0284, "no remove master")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QUERY_ID,           0, 0x0285, "invalid query id")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_STREAM_ID,          0, 0x0286, "invalid stream id")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONNECTION,         0, 0x0287, "invalid connection")
+TAOS_DEFINE_ERROR(TSDB_CODE_SDB_ERROR,                  0, 0x0288, "sdb error")
+TAOS_DEFINE_ERROR(TSDB_CODE_TIMESTAMP_OUT_OF_RANGE,     0, 0x0289, "timestamp is out of range")
 
 // acct
-TAOS_DEFINE_ERROR(TSDB_CODE_ACCT_ALREADY_EXIST,         0, 300, "accounts already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_ACCT,               0, 301, "invalid account")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_ACCT_PARAMETER,     0, 302, "invalid account parameter")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_ACCTS,             0, 303, "too many accounts")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_USERS,             0, 304, "too many users")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TABLES,            0, 305, "too many tables")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_DATABASES,         0, 306, "too many databases")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TIME_SERIES,       0, 307, "not enough time series")
+TAOS_DEFINE_ERROR(TSDB_CODE_ACCT_ALREADY_EXIST,         0, 0x0300, "accounts already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_ACCT,               0, 0x0301, "invalid account")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_ACCT_PARAMETER,     0, 0x0302, "invalid account parameter")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_ACCTS,             0, 0x0303, "too many accounts")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_USERS,             0, 0x0304, "too many users")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TABLES,            0, 0x0305, "too many tables")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_DATABASES,         0, 0x0306, "too many databases")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TIME_SERIES,       0, 0x0307, "not enough time series")
 
 // grant
-TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_FAILURE,               0, 350, "auth failure")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_RIGHTS,                  0, 351, "no rights")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_WRITE_ACCESS,            0, 352, "no write access")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_READ_ACCESS,             0, 353, "no read access")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED,              0, 354, "grant expired")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DNODE_LIMITED,        0, 355, "grant dnode limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_ACCT_LIMITED,         0, 356, "grant account limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_TIMESERIES_LIMITED,   0, 357, "grant timeseries limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DB_LIMITED,           0, 358, "grant db limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_USER_LIMITED,         0, 359, "grant user limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CONN_LIMITED,         0, 360, "grant conn limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STREAM_LIMITED,       0, 361, "grant stream limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_SPEED_LIMITED,        0, 362, "grant speed limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STORAGE_LIMITED,      0, 363, "grant storage limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_QUERYTIME_LIMITED,    0, 364, "grant query time limited")
-TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CPU_LIMITED,          0, 365, "grant cpu limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_FAILURE,               0, 0x0380, "auth failure")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_RIGHTS,                  0, 0x0381, "no rights")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_WRITE_ACCESS,            0, 0x0382, "no write access")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_READ_ACCESS,             0, 0x0383, "no read access")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED,              0, 0x0384, "grant expired")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DNODE_LIMITED,        0, 0x0385, "grant dnode limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_ACCT_LIMITED,         0, 0x0386, "grant account limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_TIMESERIES_LIMITED,   0, 0x0387, "grant timeseries limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DB_LIMITED,           0, 0x0388, "grant db limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_USER_LIMITED,         0, 0x0389, "grant user limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CONN_LIMITED,         0, 0x038A, "grant conn limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STREAM_LIMITED,       0, 0x038B, "grant stream limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_SPEED_LIMITED,        0, 0x038C, "grant speed limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STORAGE_LIMITED,      0, 0x038D, "grant storage limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_QUERYTIME_LIMITED,    0, 0x038E, "grant query time limited")
+TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CPU_LIMITED,          0, 0x038F, "grant cpu limited")
 
 // server
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VGROUP_ID,          0, 400, "invalid vgroup id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VNODE_ID,           0, 401, "invalid vnode id")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_ACTIVE_VNODE,           0, 402, "not active vnode")
-TAOS_DEFINE_ERROR(TSDB_CODE_VG_INIT_FAILED,             0, 403, "vg init failed")
-TAOS_DEFINE_ERROR(TSDB_CODE_SERV_NO_DISKSPACE,          0, 404, "server no diskspace")
-TAOS_DEFINE_ERROR(TSDB_CODE_SERV_OUT_OF_MEMORY,         0, 405, "server out of memory")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISK_PERMISSIONS,        0, 406, "no disk permissions")
-TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED,             0, 407, "file corrupted")
-TAOS_DEFINE_ERROR(TSDB_CODE_MEMORY_CORRUPTED,           0, 408, "memory corrupted")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUCH_FILE_OR_DIR,       0, 409, "no such file or directory")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VGROUP_ID,          0, 0x0400, "invalid vgroup id")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VNODE_ID,           0, 0x0401, "invalid vnode id")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_ACTIVE_VNODE,           0, 0x0402, "not active vnode")
+TAOS_DEFINE_ERROR(TSDB_CODE_VG_INIT_FAILED,             0, 0x0403, "vg init failed")
+TAOS_DEFINE_ERROR(TSDB_CODE_SERV_NO_DISKSPACE,          0, 0x0404, "server no diskspace")
+TAOS_DEFINE_ERROR(TSDB_CODE_SERV_OUT_OF_MEMORY,         0, 0x0405, "server out of memory")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISK_PERMISSIONS,        0, 0x0406, "no disk permissions")
+TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED,             0, 0x0407, "file corrupted")
+TAOS_DEFINE_ERROR(TSDB_CODE_MEMORY_CORRUPTED,           0, 0x0408, "memory corrupted")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUCH_FILE_OR_DIR,       0, 0x0409, "no such file or directory")
 
 // client
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CLIENT_VERSION,     0, 451, "invalid client version")
-TAOS_DEFINE_ERROR(TSDB_CODE_CLI_OUT_OF_MEMORY,          0, 452, "client out of memory")
-TAOS_DEFINE_ERROR(TSDB_CODE_CLI_NO_DISKSPACE,           0, 453, "client no disk space")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TIME_STAMP,         0, 454, "invalid timestamp")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_SQL,                0, 455, "invalid sql")
-TAOS_DEFINE_ERROR(TSDB_CODE_QUERY_CACHE_ERASED,         0, 456, "query cache erased")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QUERY_MSG,          0, 457, "invalid query message")    // failed to validate the sql expression msg by vnode
-TAOS_DEFINE_ERROR(TSDB_CODE_SORTED_RES_TOO_MANY,        0, 458, "sorted res too many")      // too many result for ordered super table projection query
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QHANDLE,            0, 459, "invalid handle")
-TAOS_DEFINE_ERROR(TSDB_CODE_QUERY_CANCELLED,            0, 460, "query cancelled")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_IE,                 0, 461, "invalid ie")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VALUE,              0, 462, "invalid value")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FQDN,               0, 463, "invalid FQDN")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CLIENT_VERSION,     0, 0x0481, "invalid client version")
+TAOS_DEFINE_ERROR(TSDB_CODE_CLI_OUT_OF_MEMORY,          0, 0x0482, "client out of memory")
+TAOS_DEFINE_ERROR(TSDB_CODE_CLI_NO_DISKSPACE,           0, 0x0483, "client no disk space")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TIME_STAMP,         0, 0x0484, "invalid timestamp")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_SQL,                0, 0x0485, "invalid sql")
+TAOS_DEFINE_ERROR(TSDB_CODE_QUERY_CACHE_ERASED,         0, 0x0486, "query cache erased")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QUERY_MSG,          0, 0x0487, "invalid query message")    // failed to validate the sql expression msg by vnode
+TAOS_DEFINE_ERROR(TSDB_CODE_SORTED_RES_TOO_MANY,        0, 0x0488, "sorted res too many")      // too many result for ordered super table projection query
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QHANDLE,            0, 0x0489, "invalid handle")
+TAOS_DEFINE_ERROR(TSDB_CODE_QUERY_CANCELLED,            0, 0x048A, "query cancelled")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_IE,                 0, 0x048B, "invalid ie")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VALUE,              0, 0x048C, "invalid value")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FQDN,               0, 0x048D, "invalid FQDN")
 
 // others
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FILE_FORMAT,        0, 500, "invalid file format")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FILE_FORMAT,        0, 0x0500, "invalid file format")
 
 // TSDB
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONFIG,             0, 550, "invalid TSDB configuration")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONFIG,             0, 0x0580, "invalid TSDB configuration")
 
 
 #ifdef TAOS_ERROR_C
 };
 #endif
 
-#define TSDB_CODE_MAX_ERROR_CODE             120
 
 #ifdef __cplusplus
 }

src/inc/taosmsg.h

@@ -443,7 +443,7 @@ typedef struct {
   int16_t     numOfOutput;  // final output columns numbers
   int16_t     tagNameRelType;   // relation of tag criteria and tbname criteria
   int16_t     fillType;      // interpolate type
-  uint64_t    defaultVal;       // default value array list
+  uint64_t    fillVal;       // default value array list
   int32_t     tsOffset;       // offset value in current msg body, NOTE: ts list is compressed
   int32_t     tsLen;          // total length of ts comp block
   int32_t     tsNumOfBlocks;  // ts comp block numbers

src/inc/tsdb.h

@@ -92,6 +92,7 @@ typedef struct {
   STSchema * schema;
   STSchema * tagSchema;
   SDataRow   tagValues;
+  char *     sql;
 } STableCfg;
 
 int  tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t tid);
@@ -101,6 +102,7 @@ int  tsdbTableSetTagSchema(STableCfg *config, STSchema *pSchema, bool dup);
 int  tsdbTableSetTagValue(STableCfg *config, SDataRow row, bool dup);
 int  tsdbTableSetName(STableCfg *config, char *name, bool dup);
 int  tsdbTableSetSName(STableCfg *config, char *sname, bool dup);
+int  tsdbTableSetStreamSql(STableCfg *config, char *sql, bool dup);
 void tsdbClearTableCfg(STableCfg *config);
 
 int32_t tsdbGetTableTagVal(TsdbRepoT *repo, STableId* id, int32_t colId, int16_t *type, int16_t *bytes, char **val);

src/kit/shell/inc/shell.h

@@ -29,18 +29,6 @@
 #define MAX_COMMAND_SIZE       65536
 #define HISTORY_FILE           ".taos_history"
 
-#define BOOL_OUTPUT_LENGTH     6
-#define TINYINT_OUTPUT_LENGTH  6
-#define SMALLINT_OUTPUT_LENGTH 7
-#define INT_OUTPUT_LENGTH      11
-#define BIGINT_OUTPUT_LENGTH   21
-#define FLOAT_OUTPUT_LENGTH    20
-#define DOUBLE_OUTPUT_LENGTH   25
-#define BINARY_OUTPUT_LENGTH   20
-
-// dynamic config timestamp width according to maximum time precision
-extern int32_t TIMESTAMP_OUTPUT_LENGTH;
-
 typedef struct SShellHistory {
   char* hist[MAX_HISTORY_SIZE];
   int   hstart;
@@ -80,7 +68,7 @@ void get_history_path(char* history);
 void cleanup_handler(void* arg);
 void exitShell();
 int shellDumpResult(TAOS* con, char* fname, int* error_no, bool printMode);
-void shellPrintNChar(char* str, int width, bool printMode);
+void shellPrintNChar(const char* str, int length, int width);
 void shellGetGrantInfo(void *con);
 int isCommentLine(char *line);
 

src/kit/shell/src/shellDarwin.c

@@ -335,54 +335,45 @@ void *shellLoopQuery(void *arg) {
       tscError("failed to malloc command");
       return NULL;
     }
-    while (1) {
-      // Read command from shell.
 
+    do {
+      // Read command from shell.
       memset(command, 0, MAX_COMMAND_SIZE);
       set_terminal_mode();
       shellReadCommand(con, command);
       reset_terminal_mode();
-
-      // Run the command
-      shellRunCommand(con, command);
-    }
+    } while (shellRunCommand(con, command) == 0);
 
   pthread_cleanup_pop(1);
 
   return NULL;
 }
 
-void shellPrintNChar(char *str, int width, bool printMode) {
-  int col_left = width;
-  wchar_t wc;
-  while (col_left > 0) {
-    if (*str == '\0') break;
-    char *tstr = str;
-    int byte_width = mbtowc(&wc, tstr, MB_CUR_MAX);
-    if (byte_width <= 0) break;
-    int col_width = wcwidth(wc);
-    if (col_width <= 0) {
-      str += byte_width;
-      continue;
+void shellPrintNChar(const char *str, int length, int width) {
+  int pos = 0, cols = 0;
+  while (pos < length) {
+    wchar_t wc;
+    pos += mbtowc(&wc, str + pos, MB_CUR_MAX);
+    if (pos > length) {
+      break;
     }
-    if (col_left < col_width) break;
-    printf("%lc", wc);
-    str += byte_width;
-    col_left -= col_width;
-  }
 
-  while (col_left > 0) {
-    printf(" ");
-    col_left--;
+    int w = wcwidth(wc);
+    if (w > 0) {
+      if (width > 0 && cols + w > width) {
+        break;
+      }
+      printf("%lc", wc);
+      cols += w;
+    }
   }
 
-  if (!printMode) {
-    printf("|");
-  } else {
-    printf("\n");
+  for (; cols < width; cols++) {
+    putchar(' ');
   }
 }
 
+
 int get_old_terminal_mode(struct termios *tio) {
   /* Make sure stdin is a terminal. */
   if (!isatty(STDIN_FILENO)) {

src/kit/shell/src/shellImport.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define _GNU_SOURCE
 #define _XOPEN_SOURCE
 #define _DEFAULT_SOURCE
 

src/kit/shell/src/shellLinux.c

@@ -307,19 +307,13 @@ void *shellLoopQuery(void *arg) {
     return NULL;
   }
   
-  while (1) {
+  do {
     // Read command from shell.
-
     memset(command, 0, MAX_COMMAND_SIZE);
     set_terminal_mode();
     shellReadCommand(con, command);
     reset_terminal_mode();
-
-    // Run the command
-    if (shellRunCommand(con, command) != 0) {
-      break;
-    }
-  }
+  } while (shellRunCommand(con, command) == 0);
   
   tfree(command);
   exitShell();
@@ -329,34 +323,27 @@ void *shellLoopQuery(void *arg) {
   return NULL;
 }
 
-void shellPrintNChar(char *str, int width, bool printMode) {
-  int col_left = width;
-  wchar_t wc;
-  while (col_left > 0) {
-    if (*str == '\0') break;
-    char *tstr = str;
-    int byte_width = mbtowc(&wc, tstr, MB_CUR_MAX);
-    if (byte_width <= 0) break;
-    int col_width = wcwidth(wc);
-    if (col_width <= 0) {
-      str += byte_width;
-      continue;
+void shellPrintNChar(const char *str, int length, int width) {
+  int pos = 0, cols = 0;
+  while (pos < length) {
+    wchar_t wc;
+    pos += mbtowc(&wc, str + pos, MB_CUR_MAX);
+    if (pos > length) {
+      break;
     }
-    if (col_left < col_width) break;
-    printf("%lc", wc);
-    str += byte_width;
-    col_left -= col_width;
-  }
 
-  while (col_left > 0) {
-    printf(" ");
-    col_left--;
+    int w = wcwidth(wc);
+    if (w > 0) {
+      if (width > 0 && cols + w > width) {
+        break;
+      }
+      printf("%lc", wc);
+      cols += w;
+    }
   }
 
-  if (!printMode) {
-    printf("|");
-  } else {
-    printf("\n");
+  for (; cols < width; cols++) {
+    putchar(' ');
   }
 }
 

src/kit/shell/src/shellMain.c

@@ -20,7 +20,6 @@
 
 TAOS*     con;
 pthread_t pid;
-int32_t   TIMESTAMP_OUTPUT_LENGTH = 22;
 
 // TODO: IMPLEMENT INTERRUPT HANDLER.
 void interruptHandler(int signum) {

src/kit/shell/src/shellWindows.c

@@ -203,46 +203,43 @@ void *shellLoopQuery(void *arg) {
   char *command = malloc(MAX_COMMAND_SIZE);
   if (command == NULL) return NULL;
 
-  while (1) {
+  do {
     memset(command, 0, MAX_COMMAND_SIZE);
     shellPrintPrompt();
 
     // Read command from shell.
     shellReadCommand(con, command);
-
-    // Run the command
-    shellRunCommand(con, command);
-  }
+  } while (shellRunCommand(con, command) == 0);
 
   return NULL;
 }
 
-void shellPrintNChar(char *str, int width, bool printMode) {
-  int     col_left = width;
-  wchar_t wc;
-  while (col_left > 0) {
-    if (*str == '\0') break;
-    char *tstr = str;
-    int   byte_width = mbtowc(&wc, tstr, MB_CUR_MAX);
-    int   col_width = byte_width;
-    if (col_left < col_width) break;
-    printf("%lc", wc);
-    str += byte_width;
-    col_left -= col_width;
-  }
+void shellPrintNChar(const char *str, int length, int width) {
+  int pos = 0, cols = 0;
+  while (pos < length) {
+    wchar_t wc;
+    int bytes = mbtowc(&wc, str + pos, MB_CUR_MAX);
+    pos += bytes;
+    if (pos > length) {
+      break;
+    }
 
-  while (col_left > 0) {
-    printf(" ");
-    col_left--;
+    int w = bytes;
+    if (w > 0) {
+      if (width > 0 && cols + w > width) {
+        break;
+      }
+      printf("%lc", wc);
+      cols += w;
+    }
   }
-  
-  if (!printMode) {
-    printf("|");
-  } else {
-    printf("\n");
+
+  for (; cols < width; cols++) {
+    putchar(' ');
   }
 }
 
+
 void get_history_path(char *history) { sprintf(history, "%s/%s", ".", HISTORY_FILE); }
 
 void exitShell() { exit(EXIT_SUCCESS); }

src/mnode/inc/mnodeInt.h

@@ -27,23 +27,23 @@ extern int32_t mDebugFlag;
 extern int32_t sdbDebugFlag;
 
 // mnode log function
-#define mError(...) if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND ", 255, __VA_ARGS__); }
-#define mWarn(...)  if (mDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MND ", mDebugFlag, __VA_ARGS__); }
-#define mTrace(...) if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }
-#define mPrint(...)                               { taosPrintLog("MND ", 255, __VA_ARGS__); }
-
-#define mLError(...) monitorSaveLog(2, __VA_ARGS__); mError(__VA_ARGS__)
-#define mLWarn(...)  monitorSaveLog(1, __VA_ARGS__); mWarn(__VA_ARGS__)
-#define mLPrint(...) monitorSaveLog(0, __VA_ARGS__); mPrint(__VA_ARGS__)
-
-#define sdbError(...) if (sdbDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND-SDB ", 255, __VA_ARGS__); }
-#define sdbWarn(...)  if (sdbDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MND-SDB ", sdbDebugFlag, __VA_ARGS__); }
-#define sdbTrace(...) if (sdbDebugFlag & DEBUG_TRACE) { taosPrintLog("MND-SDB ", sdbDebugFlag, __VA_ARGS__);}
-#define sdbPrint(...)                                 { taosPrintLog("MND-SDB ", 255, __VA_ARGS__); }
-
-#define sdbLError(...) monitorSaveLog(2, __VA_ARGS__); sdbError(__VA_ARGS__)
-#define sdbLWarn(...)  monitorSaveLog(1, __VA_ARGS__); sdbWarn(__VA_ARGS__)
-#define sdbLPrint(...) monitorSaveLog(0, __VA_ARGS__); sdbPrint(__VA_ARGS__)
+#define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND ", 255, __VA_ARGS__); }}
+#define mWarn(...)  { if (mDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MND ", mDebugFlag, __VA_ARGS__); }}
+#define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
+#define mPrint(...) { taosPrintLog("MND ", 255, __VA_ARGS__); }
+
+#define mLError(...) { monitorSaveLog(2, __VA_ARGS__); mError(__VA_ARGS__) }
+#define mLWarn(...)  { monitorSaveLog(1, __VA_ARGS__); mWarn(__VA_ARGS__)  }
+#define mLPrint(...) { monitorSaveLog(0, __VA_ARGS__); mPrint(__VA_ARGS__) }
+
+#define sdbError(...) { if (sdbDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND-SDB ", 255, __VA_ARGS__); }}
+#define sdbWarn(...)  { if (sdbDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MND-SDB ", sdbDebugFlag, __VA_ARGS__); }}
+#define sdbTrace(...) { if (sdbDebugFlag & DEBUG_TRACE) { taosPrintLog("MND-SDB ", sdbDebugFlag, __VA_ARGS__);}}
+#define sdbPrint(...) { taosPrintLog("MND-SDB ", 255, __VA_ARGS__); }
+
+#define sdbLError(...) { monitorSaveLog(2, __VA_ARGS__); sdbError(__VA_ARGS__) }
+#define sdbLWarn(...)  { monitorSaveLog(1, __VA_ARGS__); sdbWarn(__VA_ARGS__)  }
+#define sdbLPrint(...) { monitorSaveLog(0, __VA_ARGS__); sdbPrint(__VA_ARGS__) }
 
 #ifdef __cplusplus
 }

src/os/linux/src/linuxSysPara.c

@@ -226,11 +226,11 @@ static void taosGetSystemLocale() {  // get and set default locale
   if (cfg_locale && cfg_locale->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
     locale = setlocale(LC_CTYPE, "");
     if (locale == NULL) {
-      uForcePrint("can't get locale from system, set it to en_US.UTF-8");
+      uError("can't get locale from system, set it to en_US.UTF-8");
       strcpy(tsLocale, "en_US.UTF-8");
     } else {
       strncpy(tsLocale, locale, tListLen(tsLocale));
-      uForcePrint("locale not configured, set to system default:%s", tsLocale);
+      uError("locale not configured, set to system default:%s", tsLocale);
     }
   }
 
@@ -245,10 +245,10 @@ static void taosGetSystemLocale() {  // get and set default locale
       strncpy(tsCharset, revisedCharset, tListLen(tsCharset));
 
       free(revisedCharset);
-      uForcePrint("charset not configured, set to system default:%s", tsCharset);
+      uError("charset not configured, set to system default:%s", tsCharset);
     } else {
       strcpy(tsCharset, "UTF-8");
-      uForcePrint("can't get locale and charset from system, set it to UTF-8");
+      uError("can't get locale and charset from system, set it to UTF-8");
     }
   }
 }

src/plugins/http/inc/httpLog.h

@@ -20,23 +20,10 @@
 
 extern int32_t httpDebugFlag;
 
-#define httpError(...)                       \
-  if (httpDebugFlag & DEBUG_ERROR) {         \
-    taosPrintLog("ERROR HTP ", 255, __VA_ARGS__); \
-  }
-#define httpWarn(...)                                  \
-  if (httpDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN  HTP ", httpDebugFlag, __VA_ARGS__); \
-  }
-#define httpTrace(...)                           \
-  if (httpDebugFlag & DEBUG_TRACE) {             \
-    taosPrintLog("HTP ", httpDebugFlag, __VA_ARGS__); \
-  }
-#define httpDump(...)                                        \
-  if (httpDebugFlag & DEBUG_TRACE) {                         \
-    taosPrintLongString("HTP ", httpDebugFlag, __VA_ARGS__); \
-  }
-#define httpPrint(...) \
-  { taosPrintLog("HTP ", 255, __VA_ARGS__); }
+#define httpError(...) { if (httpDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR HTP ", 255, __VA_ARGS__); }}
+#define httpWarn(...)  { if (httpDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  HTP ", httpDebugFlag, __VA_ARGS__); }}
+#define httpTrace(...) { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLog("HTP ", httpDebugFlag, __VA_ARGS__); }}
+#define httpDump(...)  { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLongString("HTP ", httpDebugFlag, __VA_ARGS__); }}
+#define httpPrint(...) { taosPrintLog("HTP ", 255, __VA_ARGS__); }
 
 #endif

src/plugins/monitor/src/monitorMain.c

@@ -27,20 +27,10 @@
 #include "dnode.h"
 #include "monitor.h"
 
-#define monitorError(...)                         \
-  if (monitorDebugFlag & DEBUG_ERROR) {           \
-    taosPrintLog("ERROR MON ", 255, __VA_ARGS__); \
-  }
-#define monitorWarn(...)                                       \
-  if (monitorDebugFlag & DEBUG_WARN) {                         \
-    taosPrintLog("WARN  MON ", monitorDebugFlag, __VA_ARGS__); \
-  }
-#define monitorTrace(...)                                \
-  if (monitorDebugFlag & DEBUG_TRACE) {                  \
-    taosPrintLog("MON ", monitorDebugFlag, __VA_ARGS__); \
-  }
-#define monitorPrint(...) \
-  { taosPrintLog("MON ", 255, __VA_ARGS__); }
+#define monitorError(...) { if (monitorDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MON ", 255, __VA_ARGS__); }}
+#define monitorWarn(...)  { if (monitorDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MON ", monitorDebugFlag, __VA_ARGS__); }}
+#define monitorTrace(...) { if (monitorDebugFlag & DEBUG_TRACE) { taosPrintLog("MON ", monitorDebugFlag, __VA_ARGS__); }}
+#define monitorPrint(...) { taosPrintLog("MON ", 255, __VA_ARGS__); }
 
 #define SQL_LENGTH     1024
 #define LOG_LEN_STR    100

src/query/inc/qExecutor.h

@@ -138,7 +138,7 @@ typedef struct SQuery {
   SColumnInfo*      colList;
   SColumnInfo*      tagColList;
   int32_t           numOfFilterCols;
-  int64_t*          defaultVal;
+  int64_t*          fillVal;
   uint32_t          status;  // query status
   SResultRec        rec;
   int32_t           pos;

src/query/inc/qfill.h

@@ -28,7 +28,7 @@ typedef struct {
   STColumn col;             // column info
   int16_t  functionId;      // sql function id
   int16_t  flag;            // column flag: TAG COLUMN|NORMAL COLUMN
-  union {int64_t i; double d;} defaultVal;
+  union {int64_t i; double d;} fillVal;
 } SFillColInfo;
   
 typedef struct SFillInfo {
@@ -75,15 +75,13 @@ void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, tFilePage* pInpu
 
 TSKEY taosGetRevisedEndKey(TSKEY ekey, int32_t order, int64_t timeInterval, int8_t slidingTimeUnit, int8_t precision);
 
-int32_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows);
+int64_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows);
 
 int32_t taosNumOfRemainRows(SFillInfo *pFillInfo);
 
-int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numOfRows, int32_t outputRows, char** srcData);
-  
 int taosDoLinearInterpolation(int32_t type, SPoint *point1, SPoint *point2, SPoint *point);
 
-void taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int64_t* outputRows, int32_t capacity);
+int64_t taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int32_t capacity);
 
 #ifdef __cplusplus
 }

src/query/inc/queryLog.h

@@ -24,23 +24,12 @@ extern "C" {
 
 extern int32_t qDebugFlag;
 
-#define qTrace(...)                                \
-  if (qDebugFlag & DEBUG_TRACE) {                  \
-    taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); \
-  }
-
-#define qError(...)                                      \
-  if (qDebugFlag & DEBUG_ERROR) {                        \
-    taosPrintLog("ERROR QRY ", qDebugFlag, __VA_ARGS__); \
-  }
-
-#define qWarn(...)                                      \
-  if (qDebugFlag & DEBUG_WARN) {                        \
-    taosPrintLog("WARN QRY ", qDebugFlag, __VA_ARGS__); \
-  }
+#define qTrace(...) { if (qDebugFlag & DEBUG_TRACE) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }}
+#define qError(...) { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR QRY ", qDebugFlag, __VA_ARGS__); }}
+#define qWarn(...)  { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN QRY ", qDebugFlag, __VA_ARGS__); }}
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_QUERY_CACHE_H
+#endif  // TDENGINE_QUERY_LOG_H

src/query/src/qExecutor.c

@@ -376,11 +376,16 @@ bool isSelectivityWithTagsQuery(SQuery *pQuery) {
 
 bool isTSCompQuery(SQuery *pQuery) { return pQuery->pSelectExpr[0].base.functionId == TSDB_FUNC_TS_COMP; }
 
-static bool limitResults(SQuery *pQuery) {
+static bool limitResults(SQueryRuntimeEnv* pRuntimeEnv) {
+  SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+  
   if ((pQuery->limit.limit > 0) && (pQuery->rec.total + pQuery->rec.rows > pQuery->limit.limit)) {
     pQuery->rec.rows = pQuery->limit.limit - pQuery->rec.total;
-    assert(pQuery->rec.rows > 0);
-
+    
+    qTrace("QInfo:%p discard remain data due to result limitation, limit:%"PRId64", current return:%d, total:%"PRId64,
+        pQInfo, pQuery->limit.limit, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
+    assert(pQuery->rec.rows >= 0);
     setQueryStatus(pQuery, QUERY_COMPLETED);
     return true;
   }
@@ -624,15 +629,17 @@ static int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t sea
 /**
  * NOTE: the query status only set for the first scan of master scan.
  */
-static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey, SWindowResInfo *pWindowResInfo) {
+static int32_t doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey, SWindowResInfo *pWindowResInfo) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
   if (pRuntimeEnv->scanFlag != MASTER_SCAN || (!isIntervalQuery(pQuery))) {
-    return;
+    return pWindowResInfo->size;
   }
 
   // no qualified results exist, abort check
+  int32_t numOfClosed = 0;
+  
   if (pWindowResInfo->size == 0) {
-    return;
+    return pWindowResInfo->size;
   }
 
   // query completed
@@ -646,10 +653,10 @@ static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey,
     int32_t i = 0;
     int64_t skey = TSKEY_INITIAL_VAL;
 
-    // TODO opt performance: get the closed time window here
     for (i = 0; i < pWindowResInfo->size; ++i) {
       SWindowResult *pResult = &pWindowResInfo->pResult[i];
       if (pResult->status.closed) {
+        numOfClosed += 1;
         continue;
       }
 
@@ -672,16 +679,26 @@ static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey,
 
     pWindowResInfo->prevSKey = pWindowResInfo->pResult[pWindowResInfo->curIndex].window.skey;
 
-    // the number of completed slots are larger than the threshold, dump to client immediately.
-    int32_t n = numOfClosedTimeWindow(pWindowResInfo);
-    if (n > pWindowResInfo->threshold) {
+    // the number of completed slots are larger than the threshold, return current generated results to client.
+    if (numOfClosed > pWindowResInfo->threshold) {
+      qTrace("QInfo:%p total result window:%d closed:%d, reached the output threshold %d, return",
+          GET_QINFO_ADDR(pRuntimeEnv), pWindowResInfo->size, numOfClosed, pQuery->rec.threshold);
+      
       setQueryStatus(pQuery, QUERY_RESBUF_FULL);
+    } else {
+      qTrace("QInfo:%p total result window:%d already closed:%d", GET_QINFO_ADDR(pRuntimeEnv), pWindowResInfo->size,
+             numOfClosed);
     }
-
-    qTrace("QInfo:%p total window:%d, closed:%d", GET_QINFO_ADDR(pRuntimeEnv), pWindowResInfo->size, n);
   }
-
+  
+  // output has reached the limitation, set query completed
+  if (pQuery->limit.limit > 0 && (pQuery->limit.limit + pQuery->limit.offset) <= numOfClosed &&
+      pRuntimeEnv->scanFlag == MASTER_SCAN) {
+    setQueryStatus(pQuery, QUERY_COMPLETED);
+  }
+  
   assert(pWindowResInfo->prevSKey != TSKEY_INITIAL_VAL);
+  return numOfClosed;
 }
 
 static int32_t getNumOfRowsInTimeWindow(SQuery *pQuery, SDataBlockInfo *pDataBlockInfo, TSKEY *pPrimaryColumn,
@@ -1309,28 +1326,27 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
   TSKEY lastKey = QUERY_IS_ASC_QUERY(pQuery) ? pDataBlockInfo->window.ekey : pDataBlockInfo->window.skey;
   pTableQInfo->lastKey = lastKey + GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
 
-  doCheckQueryCompleted(pRuntimeEnv, lastKey, pWindowResInfo);
 
   // interval query with limit applied
-  if (isIntervalQuery(pQuery) && pQuery->limit.limit > 0 &&
-      (pQuery->limit.limit + pQuery->limit.offset) <= numOfClosedTimeWindow(pWindowResInfo) &&
-      pRuntimeEnv->scanFlag == MASTER_SCAN) {
-    setQueryStatus(pQuery, QUERY_COMPLETED);
-  }
+  int32_t numOfRes = 0;
+  
+  if (isIntervalQuery(pQuery)) {
+    numOfRes = doCheckQueryCompleted(pRuntimeEnv, lastKey, pWindowResInfo);
+  } else {
+    numOfRes = getNumOfResult(pRuntimeEnv);
 
-  int32_t numOfRes = getNumOfResult(pRuntimeEnv);
+    // update the number of output result
+    if (numOfRes > 0 && pQuery->checkBuffer == 1) {
+      assert(numOfRes >= pQuery->rec.rows);
+      pQuery->rec.rows = numOfRes;
 
-  // update the number of output result
-  if (numOfRes > 0 && pQuery->checkBuffer == 1) {
-    assert(numOfRes >= pQuery->rec.rows);
-    pQuery->rec.rows = numOfRes;
+      if (numOfRes >= pQuery->rec.threshold) {
+        setQueryStatus(pQuery, QUERY_RESBUF_FULL);
+      }
 
-    if (numOfRes >= pQuery->rec.threshold) {
-      setQueryStatus(pQuery, QUERY_RESBUF_FULL);
-    }
-    
-    if ((pQuery->limit.limit >= 0) && numOfRes >= (pQuery->limit.limit + pQuery->limit.offset)) {
-      setQueryStatus(pQuery, QUERY_COMPLETED);
+      if ((pQuery->limit.limit >= 0) && (pQuery->limit.limit + pQuery->limit.offset) <= numOfRes) {
+        setQueryStatus(pQuery, QUERY_COMPLETED);
+      }
     }
   }
 
@@ -2026,10 +2042,10 @@ void pointInterpSupporterSetData(SQInfo *pQInfo, SPointInterpoSupporter *pPointI
 
         tVariantCreateFromBinary(&pCtx->param[3], (char *)&count, sizeof(count), TSDB_DATA_TYPE_INT);
 
-        if (isNull((char *)&pQuery->defaultVal[i], pCtx->inputType)) {
+        if (isNull((char *)&pQuery->fillVal[i], pCtx->inputType)) {
           pCtx->param[1].nType = TSDB_DATA_TYPE_NULL;
         } else {
-          tVariantCreateFromBinary(&pCtx->param[1], (char *)&pQuery->defaultVal[i], pCtx->inputBytes, pCtx->inputType);
+          tVariantCreateFromBinary(&pCtx->param[1], (char *)&pQuery->fillVal[i], pCtx->inputBytes, pCtx->inputType);
         }
 
         pInterpDetail->ts = pQuery->window.skey;
@@ -2471,8 +2487,8 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, pQueryHandle, &blockInfo, &pStatis);
     int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, pStatis, binarySearchForKey, pDataBlock);
 
-    qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d", GET_QINFO_ADDR(pRuntimeEnv),
-           blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes);
+    qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%"PRId64, GET_QINFO_ADDR(pRuntimeEnv),
+           blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes, pQuery->current->lastKey);
 
     // while the output buffer is full or limit/offset is applied, query may be paused here
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL | QUERY_COMPLETED)) {
@@ -3374,7 +3390,9 @@ static void clearEnvAfterReverseScan(SQueryRuntimeEnv *pRuntimeEnv, SQueryStatus
   // during reverse scan
   pTableQueryInfo->lastKey = pStatus->lastKey;
   pQuery->status = pStatus->status;
+  
   pTableQueryInfo->win = pStatus->w;
+  pQuery->window = pTableQueryInfo->win;
 }
 
 void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
@@ -3396,6 +3414,7 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
     if (pRuntimeEnv->scanFlag == MASTER_SCAN) {
       qstatus.status = pQuery->status;
       qstatus.curWindow.ekey = pTableQueryInfo->lastKey - step;
+      qstatus.lastKey = pTableQueryInfo->lastKey;
     }
 
     if (!needScanDataBlocksAgain(pRuntimeEnv)) {
@@ -3423,6 +3442,9 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
 
     setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
     pRuntimeEnv->scanFlag = REPEAT_SCAN;
+    
+    qTrace("QInfo:%p start to repeat scan data blocks due to query func required, qrange:%"PRId64"-%"PRId64, pQInfo,
+        cond.twindow.skey, cond.twindow.ekey);
 
     // check if query is killed or not
     if (isQueryKilled(pQInfo)) {
@@ -3707,7 +3729,7 @@ static int32_t doCopyToSData(SQInfo *pQInfo, SWindowResult *result, int32_t orde
   int32_t startIdx = 0;
   int32_t step = -1;
 
-  qTrace("QInfo:%p start to copy data from windowResInfo to query buf", GET_QINFO_ADDR(pQuery));
+  qTrace("QInfo:%p start to copy data from windowResInfo to query buf", pQInfo);
   int32_t totalSubset = getNumOfSubset(pQInfo);
 
   if (orderType == TSDB_ORDER_ASC) {
@@ -3836,7 +3858,7 @@ bool queryHasRemainResults(SQueryRuntimeEnv* pRuntimeEnv) {
   }
   
   /*
-   * There are no results returned to client now.
+   * While the code reaches here, there are no results returned to client now.
    * If query is not completed yet, the gaps between two results blocks need to be handled after next data block
    * is retrieved from TSDB.
    *
@@ -3890,18 +3912,24 @@ static void doCopyQueryResultToMsg(SQInfo *pQInfo, int32_t numOfRows, char *data
 }
 
 int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int32_t numOfRows, int32_t *numOfInterpo) {
+  SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
   SQuery *pQuery = pRuntimeEnv->pQuery;
+  SFillInfo* pFillInfo = pRuntimeEnv->pFillInfo;
+  
   while (1) {
-    taosGenerateDataBlock(pRuntimeEnv->pFillInfo, (tFilePage**) pQuery->sdata, &pQuery->rec.rows, pQuery->rec.capacity);
-    int32_t ret = pQuery->rec.rows;
+    int32_t ret = taosGenerateDataBlock(pFillInfo, (tFilePage**) pQuery->sdata, pQuery->rec.capacity);
     
     // todo apply limit output function
     /* reached the start position of according to offset value, return immediately */
     if (pQuery->limit.offset == 0) {
+      qTrace("QInfo:%p initial numOfRows:%d, generate filled result:%d rows", pQInfo, pFillInfo->numOfRows, ret);
       return ret;
     }
 
     if (pQuery->limit.offset < ret) {
+      qTrace("QInfo:%p initial numOfRows:%d, generate filled result:%d rows, offset:%d. Discard due to offset, remain:%d, new offset:%d",
+             pQInfo, pFillInfo->numOfRows, ret, pQuery->limit.offset, ret - pQuery->limit.offset, 0);
+      
       ret -= pQuery->limit.offset;
       // todo !!!!there exactly number of interpo is not valid.
       // todo refactor move to the beginning of buffer
@@ -3909,10 +3937,16 @@ int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int
         memmove(pDst[i]->data, pDst[i]->data + pQuery->pSelectExpr[i].bytes * pQuery->limit.offset,
                 ret * pQuery->pSelectExpr[i].bytes);
       }
+      
       pQuery->limit.offset = 0;
       return ret;
     } else {
+      qTrace("QInfo:%p initial numOfRows:%d, generate filled result:%d rows, offset:%d. Discard due to offset, "
+             "remain:%d, new offset:%d", pQInfo, pFillInfo->numOfRows, ret, pQuery->limit.offset, 0,
+          pQuery->limit.offset - ret);
+      
       pQuery->limit.offset -= ret;
+      pQuery->rec.rows = 0;
       ret = 0;
     }
 
@@ -3920,8 +3954,6 @@ int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int
       return ret;
     }
   }
-  
-  return 0;
 }
 
 void vnodePrintQueryStatistics(SQInfo *pQInfo) {
@@ -4002,8 +4034,8 @@ static void updateOffsetVal(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBloc
 
   int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock);
 
-  qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d", GET_QINFO_ADDR(pRuntimeEnv),
-         pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes);
+  qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%"PRId64, GET_QINFO_ADDR(pRuntimeEnv),
+         pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes, pQuery->current->lastKey);
 }
 
 void skipBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
@@ -4120,8 +4152,9 @@ static bool skipTimeInterval(SQueryRuntimeEnv *pRuntimeEnv, TSKEY* start) {
           int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, NULL, binarySearchForKey, pDataBlock);
           pRuntimeEnv->windowResInfo.curIndex = index;  // restore the window index
           
-          qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, numOfRes:%d",
-                 GET_QINFO_ADDR(pRuntimeEnv), blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes);
+          qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%"PRId64,
+                 GET_QINFO_ADDR(pRuntimeEnv), blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes, pQuery->current->lastKey);
+          
           return true;
         } else { // do nothing
           *start = tw.skey;
@@ -4215,7 +4248,7 @@ static SFillColInfo* taosCreateFillColInfo(SQuery* pQuery) {
     pFillCol[i].col.offset = offset;
     pFillCol[i].flag       = TSDB_COL_NORMAL;    // always be ta normal column for table query
     pFillCol[i].functionId = pExprInfo->base.functionId;
-    pFillCol[i].defaultVal.i = pQuery->defaultVal[i];
+    pFillCol[i].fillVal.i = pQuery->fillVal[i];
     
     offset += pExprInfo->bytes;
   }
@@ -4591,7 +4624,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       skipResults(pRuntimeEnv);
 
       // the limitation of output result is reached, set the query completed
-      if (limitResults(pQuery)) {
+      if (limitResults(pRuntimeEnv)) {
         pQInfo->tableIndex = pQInfo->groupInfo.numOfTables;
         break;
       }
@@ -4846,7 +4879,7 @@ static void tableFixedOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
   pQuery->rec.rows = getNumOfResult(pRuntimeEnv);
 
   skipResults(pRuntimeEnv);
-  limitResults(pQuery);
+  limitResults(pRuntimeEnv);
 }
 
 static void tableMultiOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
@@ -4894,7 +4927,7 @@ static void tableMultiOutputProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
     resetCtxOutputBuf(pRuntimeEnv);
   }
 
-  limitResults(pQuery);
+  limitResults(pRuntimeEnv);
   if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
     qTrace("QInfo:%p query paused due to output limitation, next qrange:%" PRId64 "-%" PRId64, pQInfo,
         pQuery->current->lastKey, pQuery->window.ekey);
@@ -4972,7 +5005,7 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
 
     // the offset is handled at prepare stage if no interpolation involved
     if (pQuery->fillType == TSDB_FILL_NONE || pQuery->rec.rows == 0) {
-      limitResults(pQuery);
+      limitResults(pRuntimeEnv);
       break;
     } else {
       TSKEY ekey = taosGetRevisedEndKey(pQuery->window.ekey, pQuery->order.order, pQuery->slidingTime,
@@ -4980,11 +5013,10 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
       taosFillSetStartInfo(pRuntimeEnv->pFillInfo, pQuery->rec.rows, ekey);
       taosFillCopyInputDataFromFilePage(pRuntimeEnv->pFillInfo, (tFilePage**) pQuery->sdata);
       numOfInterpo = 0;
+      
       pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata, pQuery->rec.rows, &numOfInterpo);
-
-      qTrace("QInfo: %p fill results completed, final:%d", pQInfo, pQuery->rec.rows);
       if (pQuery->rec.rows > 0 || Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
-        limitResults(pQuery);
+        limitResults(pRuntimeEnv);
         break;
       }
 
@@ -5017,9 +5049,8 @@ static void tableQueryImpl(SQInfo *pQInfo) {
     int32_t remain = taosNumOfRemainRows(pRuntimeEnv->pFillInfo);
     pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata, remain, &numOfInterpo);
   
-    qTrace("QInfo: %p fill results completed, final:%d", pQInfo, pQuery->rec.rows);
     if (pQuery->rec.rows > 0) {
-      limitResults(pQuery);
+      limitResults(pRuntimeEnv);
     }
     
     qTrace("QInfo:%p current:%d returned, total:%d", pQInfo, pQuery->rec.rows, pQuery->rec.total);
@@ -5267,7 +5298,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
       if (pColFilter->filterstr) {
         pColFilter->len = htobe64(pFilterMsg->len);
 
-        pColFilter->pz = (int64_t) calloc(1, pColFilter->len);
+        pColFilter->pz = (int64_t) calloc(1, pColFilter->len + 1 * TSDB_NCHAR_SIZE); // note: null-terminator
         memcpy((void *)pColFilter->pz, pMsg, pColFilter->len);
         pMsg += (pColFilter->len + 1);
       } else {
@@ -5351,7 +5382,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
 
   pQueryMsg->fillType = htons(pQueryMsg->fillType);
   if (pQueryMsg->fillType != TSDB_FILL_NONE) {
-    pQueryMsg->defaultVal = (uint64_t)(pMsg);
+    pQueryMsg->fillVal = (uint64_t)(pMsg);
 
     int64_t *v = (int64_t *)pMsg;
     for (int32_t i = 0; i < pQueryMsg->numOfOutput; ++i) {
@@ -5722,13 +5753,13 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SArray* pTableIdList,
   }
 
   if (pQuery->fillType != TSDB_FILL_NONE) {
-    pQuery->defaultVal = malloc(sizeof(int64_t) * pQuery->numOfOutput);
-    if (pQuery->defaultVal == NULL) {
+    pQuery->fillVal = malloc(sizeof(int64_t) * pQuery->numOfOutput);
+    if (pQuery->fillVal == NULL) {
       goto _cleanup;
     }
 
     // the first column is the timestamp
-    memcpy(pQuery->defaultVal, (char *)pQueryMsg->defaultVal, pQuery->numOfOutput * sizeof(int64_t));
+    memcpy(pQuery->fillVal, (char *)pQueryMsg->fillVal, pQuery->numOfOutput * sizeof(int64_t));
   }
 
   // to make sure third party won't overwrite this structure
@@ -5785,7 +5816,7 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SArray* pTableIdList,
   return pQInfo;
 
 _cleanup:
-  tfree(pQuery->defaultVal);
+  tfree(pQuery->fillVal);
 
   if (pQuery->sdata != NULL) {
     for (int16_t col = 0; col < pQuery->numOfOutput; ++col) {
@@ -5893,8 +5924,8 @@ static void freeQInfo(SQInfo *pQInfo) {
     tfree(pQuery->pSelectExpr);
   }
 
-  if (pQuery->defaultVal != NULL) {
-    tfree(pQuery->defaultVal);
+  if (pQuery->fillVal != NULL) {
+    tfree(pQuery->fillVal);
   }
 
   // todo refactor, extract method to destroytableDataInfo
@@ -5997,8 +6028,13 @@ static int32_t doDumpQueryResult(SQInfo *pQInfo, char *data) {
   }
 
   pQuery->rec.total += pQuery->rec.rows;
-  qTrace("QInfo:%p current:%d, total:%d", pQInfo, pQuery->rec.rows, pQuery->rec.total);
+  qTrace("QInfo:%p current numOfRes rows:%d, total:%d", pQInfo, pQuery->rec.rows, pQuery->rec.total);
 
+  if (pQuery->limit.limit > 0 && pQuery->limit.limit == pQuery->rec.total) {
+    qTrace("QInfo:%p results limitation reached, limitation:%"PRId64, pQInfo, pQuery->limit.limit);
+    setQueryStatus(pQuery, QUERY_OVER);
+  }
+  
   return TSDB_CODE_SUCCESS;
 
   // todo if interpolation exists, the result may be dump to client by several rounds

src/query/src/qfill.c

@@ -34,7 +34,7 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, ch
      * here we revised the start time of day according to the local time zone,
      * but in case of DST, the start time of one day need to be dynamically decided.
      *
-     * TODO dynamically decide the start time of a day
+     * TODO dynamically decide the start time of a day, move to common module
      */
 
     // todo refactor to extract function that is available for Linux/Windows/Mac platform
@@ -116,10 +116,9 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
     return;
   }
 
-  pFillInfo->rowIdx = 0;
+  pFillInfo->rowIdx    = 0;
+  pFillInfo->endKey    = endKey;
   pFillInfo->numOfRows = numOfRows;
-  
-  pFillInfo->endKey = endKey;
 }
 
 void taosFillCopyInputDataFromFilePage(SFillInfo* pFillInfo, tFilePage** pInput) {
@@ -131,6 +130,8 @@ void taosFillCopyInputDataFromFilePage(SFillInfo* pFillInfo, tFilePage** pInput)
 
 void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, tFilePage* pInput) {
   assert(pFillInfo->numOfRows == pInput->num);
+  int32_t t = 0;
+  
   for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
     
@@ -138,7 +139,7 @@ void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, tFilePage* pInpu
     memcpy(pFillInfo->pData[i], s, pInput->num * pCol->col.bytes);
     
     if (pCol->flag == TSDB_COL_TAG) {  // copy the tag value
-      memcpy(pFillInfo->pTags[i], pFillInfo->pData[i], pCol->col.bytes);
+      memcpy(pFillInfo->pTags[t++], pFillInfo->pData[i], pCol->col.bytes);
     }
   }
 }
@@ -170,7 +171,7 @@ static int32_t taosGetTotalNumOfFilledRes(SFillInfo* pFillInfo, const TSKEY* tsA
   }
 }
 
-int32_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows) {
+int64_t taosGetNumOfResultWithFill(SFillInfo* pFillInfo, int32_t numOfRows, int64_t ekey, int32_t maxNumOfRows) {
   int32_t numOfRes = taosGetTotalNumOfFilledRes(pFillInfo, (int64_t*) pFillInfo->pData[0], numOfRows,
                                                 pFillInfo->slidingTime, ekey);
   return (numOfRes > maxNumOfRows) ? maxNumOfRows : numOfRes;
@@ -193,7 +194,7 @@ static double linearInterpolationImpl(double v1, double v2, double k1, double k2
 int taosDoLinearInterpolation(int32_t type, SPoint* point1, SPoint* point2, SPoint* point) {
   switch (type) {
     case TSDB_DATA_TYPE_INT: {
-      *(int32_t*)point->val = linearInterpolationImpl(*(int32_t*)point1->val, *(int32_t*)point2->val, point1->key,
+      *(int32_t*)point->val = (int32_t) linearInterpolationImpl(*(int32_t*)point1->val, *(int32_t*)point2->val, point1->key,
                                                         point2->key, point->key);
       break;
     }
@@ -209,17 +210,17 @@ int taosDoLinearInterpolation(int32_t type, SPoint* point1, SPoint* point2, SPoi
     };
     case TSDB_DATA_TYPE_TIMESTAMP:
     case TSDB_DATA_TYPE_BIGINT: {
-      *(int64_t*)point->val = linearInterpolationImpl(*(int64_t*)point1->val, *(int64_t*)point2->val, point1->key,
+      *(int64_t*)point->val = (int64_t) linearInterpolationImpl(*(int64_t*)point1->val, *(int64_t*)point2->val, point1->key,
                                                         point2->key, point->key);
       break;
     };
     case TSDB_DATA_TYPE_SMALLINT: {
-      *(int16_t*)point->val = linearInterpolationImpl(*(int16_t*)point1->val, *(int16_t*)point2->val, point1->key,
+      *(int16_t*)point->val = (int16_t) linearInterpolationImpl(*(int16_t*)point1->val, *(int16_t*)point2->val, point1->key,
                                                         point2->key, point->key);
       break;
     };
     case TSDB_DATA_TYPE_TINYINT: {
-      *(int8_t*)point->val =
+      *(int8_t*) point->val = (int8_t)
           linearInterpolationImpl(*(int8_t*)point1->val, *(int8_t*)point2->val, point1->key, point2->key, point->key);
       break;
     };
@@ -243,8 +244,8 @@ static void setTagsValue(SFillInfo* pColInfo, tFilePage** data, char** pTags, in
 
 static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t* num, char** srcData,
                                 int64_t ts, char** pTags, bool outOfBound) {
-  char** prevValues = &pFillInfo->prevValues;
-  char** nextValues = &pFillInfo->nextValues;
+  char* prevValues = pFillInfo->prevValues;
+  char* nextValues = pFillInfo->nextValues;
 
   SPoint point1, point2, point;
 
@@ -257,16 +258,21 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
 
   // set the other values
   if (pFillInfo->fillType == TSDB_FILL_PREV) {
-    char* pInterpolationData = FILL_IS_ASC_FILL(pFillInfo) ? *prevValues : *nextValues;
-    if (pInterpolationData != NULL) {
+    char* p = FILL_IS_ASC_FILL(pFillInfo) ? prevValues : nextValues;
+    
+    if (p != NULL) {
       for (int32_t i = 1; i < numOfValCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
         
         char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        if (isNull(pInterpolationData + pCol->col.offset, pCol->col.type)) {
-          setNull(val1, pCol->col.type, pCol->col.bytes);
+        if (isNull(p + pCol->col.offset, pCol->col.type)) {
+          if (pCol->col.type == TSDB_DATA_TYPE_BINARY || pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(val1, pCol->col.type);
+          } else {
+            setNull(val1, pCol->col.type, pCol->col.bytes);
+          }
         } else {
-          assignVal(val1, pInterpolationData + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+          assignVal(val1, p + pCol->col.offset, pCol->col.bytes, pCol->col.type);
         }
       }
     } else { // no prev value yet, set the value for NULL
@@ -274,14 +280,18 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
 
         char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        setNull(val1, pCol->col.type, pCol->col.bytes);
+        if (pCol->col.type == TSDB_DATA_TYPE_BINARY||pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(val1, pCol->col.type);
+        } else {
+          setNull(val1, pCol->col.type, pCol->col.bytes);
+        }
       }
     }
 
     setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
   } else if (pFillInfo->fillType == TSDB_FILL_LINEAR) {
     // TODO : linear interpolation supports NULL value
-    if (*prevValues != NULL && !outOfBound) {
+    if (prevValues != NULL && !outOfBound) {
       for (int32_t i = 1; i < numOfValCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
         
@@ -289,14 +299,17 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
         int16_t bytes = pCol->col.bytes;
         
         char *val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BOOL) {
+        if (type == TSDB_DATA_TYPE_BINARY|| type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(val1, pCol->col.type);
+          continue;
+        } else if (type == TSDB_DATA_TYPE_BOOL) {
           setNull(val1, pCol->col.type, bytes);
           continue;
         }
 
-        point1 = (SPoint){.key = *(TSKEY*)(*prevValues), .val = *prevValues + pCol->col.offset};
+        point1 = (SPoint){.key = *(TSKEY*)(prevValues), .val = prevValues + pCol->col.offset};
         point2 = (SPoint){.key = ts, .val = srcData[i] + pFillInfo->rowIdx * bytes};
-        point = (SPoint){.key = pFillInfo->start, .val = val1};
+        point  = (SPoint){.key = pFillInfo->start, .val = val1};
         taosDoLinearInterpolation(type, &point1, &point2, &point);
       }
 
@@ -307,7 +320,12 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
   
         char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-        setNull(val1, pCol->col.type, pCol->col.bytes);
+  
+        if (pCol->col.type == TSDB_DATA_TYPE_BINARY || pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(val1, pCol->col.type);
+        } else {
+          setNull(val1, pCol->col.type, pCol->col.bytes);
+        }
       }
 
       setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
@@ -318,7 +336,7 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
       
       char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, *num);
-      assignVal(val1, (char*)&pCol->defaultVal.i, pCol->col.bytes, pCol->col.type);
+      assignVal(val1, (char*)&pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
     }
 
     setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
@@ -338,11 +356,16 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo, char** nextValues) {
   *nextValues = calloc(1, pFillInfo->rowSize);
   for (int i = 1; i < pFillInfo->numOfCols; i++) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-    setNull(*nextValues + pCol->col.offset, pCol->col.type, pCol->col.bytes);
+  
+    if (pCol->col.type == TSDB_DATA_TYPE_BINARY||pCol->col.type == TSDB_DATA_TYPE_NCHAR) {
+      setVardataNull(*nextValues + pCol->col.offset, pCol->col.type);
+    } else {
+      setNull(*nextValues + pCol->col.offset, pCol->col.type, pCol->col.bytes);
+    }
   }
 }
 
-int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numOfRows, int32_t outputRows, char** srcData) {
+int32_t generateDataBlockImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t numOfRows, int32_t outputRows, char** srcData) {
   int32_t num = 0;
   pFillInfo->numOfCurrent = 0;
 
@@ -356,8 +379,8 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
 
   if (numOfRows == 0) {
     /*
-     * we need to rebuild whole result set
-     * NOTE:we need to keep the last saved data, to generated the filled data
+     * These data are generated according to fill strategy, since the current timestamp is out of time window of
+     * real result set. Note that we need to keep the direct previous result rows, to generated the filled data.
      */
     while (num < outputRows) {
       doInterpoResultImpl(pFillInfo, data, &num, srcData, pFillInfo->start, pTags, true);
@@ -387,7 +410,7 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
         
         while (((pFillInfo->start < ts && FILL_IS_ASC_FILL(pFillInfo)) ||
                 (pFillInfo->start > ts && !FILL_IS_ASC_FILL(pFillInfo))) && num < outputRows) {
-          doInterpoResultImpl(pFillInfo, data, &num, srcData, pFillInfo->start, pTags, false);
+          doInterpoResultImpl(pFillInfo, data, &num, srcData, ts, pTags, false);
         }
 
         /* output buffer is full, abort */
@@ -420,7 +443,7 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
               assignVal(val1, src, pCol->col.bytes, pCol->col.type);
               memcpy(*prevValues + pCol->col.offset, src, pCol->col.bytes);
             } else {
-              assignVal(val1, (char*) &pCol->defaultVal.i, pCol->col.bytes, pCol->col.type);
+              assignVal(val1, (char*) &pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
             }
           }
         }
@@ -450,21 +473,12 @@ int32_t taosDoInterpoResult(SFillInfo* pFillInfo, tFilePage** data, int32_t numO
   }
 }
 
-void taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int64_t* outputRows, int32_t capacity) {
+int64_t taosGenerateDataBlock(SFillInfo* pFillInfo, tFilePage** output, int32_t capacity) {
     int32_t remain = taosNumOfRemainRows(pFillInfo);  // todo use iterator?
-    
-//    TSKEY ekey = taosGetRevisedEndKey(pQuery->window.ekey, pQuery->order.order, pQuery->slidingTime,
-//                                      pQuery->slidingTimeUnit, pQuery->precision);
-//    if (QUERY_IS_ASC_QUERY(pQuery)) {
-//      assert(ekey >= pQuery->window.ekey);
-//    } else {
-//      assert(ekey <= pQuery->window.ekey);
-//    }
-    
-    int32_t rows = taosGetNumOfResultWithFill(pFillInfo, remain, pFillInfo->endKey, capacity);
+    int32_t rows   = taosGetNumOfResultWithFill(pFillInfo, remain, pFillInfo->endKey, capacity);
   
-    int32_t numOfRes = taosDoInterpoResult(pFillInfo, output, remain, rows, pFillInfo->pData);
-    *outputRows = rows;
-    
+    int32_t numOfRes = generateDataBlockImpl(pFillInfo, output, remain, rows, pFillInfo->pData);
     assert(numOfRes == rows);
+    
+    return numOfRes;
 }

src/query/src/tvariant.c

@@ -101,11 +101,12 @@ void tVariantCreateFromBinary(tVariant *pVar, const char *pz, size_t len, uint32
       break;
     }
     case TSDB_DATA_TYPE_NCHAR: { // here we get the nchar length from raw binary bits length
-      pVar->nLen = len / TSDB_NCHAR_SIZE;
-      pVar->wpz = calloc(1, (pVar->nLen + 1) * TSDB_NCHAR_SIZE);
+      int32_t lenInwchar = len / TSDB_NCHAR_SIZE;
+      pVar->wpz = calloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
       
-      wcsncpy(pVar->wpz, (wchar_t *)pz, pVar->nLen);
-      pVar->wpz[pVar->nLen] = 0;
+      wcsncpy(pVar->wpz, (wchar_t *)pz, lenInwchar);
+      pVar->wpz[lenInwchar] = 0;
+      pVar->nLen = len;
       
       break;
     }

src/rpc/inc/rpcLog.h

@@ -24,27 +24,14 @@ extern "C" {
 
 extern int32_t rpcDebugFlag;
 
-#define tError(...)                                   \
-  if (rpcDebugFlag & DEBUG_ERROR) {                   \
-    taosPrintLog("ERROR RPC ", rpcDebugFlag, __VA_ARGS__); \
-  }
-#define tWarn(...)                                    \
-  if (rpcDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN  RPC ", rpcDebugFlag, __VA_ARGS__); \
-  }
-#define tTrace(...)                             \
-  if (rpcDebugFlag & DEBUG_TRACE) {             \
-    taosPrintLog("RPC ", rpcDebugFlag, __VA_ARGS__); \
-  }
-#define tPrint(...) \
-  { taosPrintLog("RPC ", 255, __VA_ARGS__); }
-#define tDump(x, y)                      \
-  if (rpcDebugFlag & DEBUG_DUMP) {       \
-    taosDumpData((unsigned char *)x, y); \
-  }
+#define tError(...) { if (rpcDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR RPC ", rpcDebugFlag, __VA_ARGS__); }}
+#define tWarn(...)  { if (rpcDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  RPC ", rpcDebugFlag, __VA_ARGS__); }}
+#define tTrace(...) { if (rpcDebugFlag & DEBUG_TRACE) { taosPrintLog("RPC ", rpcDebugFlag, __VA_ARGS__); }}
+#define tDump(x, y) { if (rpcDebugFlag & DEBUG_DUMP)  { taosDumpData((unsigned char *)x, y); }}
+#define tPrint(...) { taosPrintLog("RPC ", 255, __VA_ARGS__); }
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_RPC_CACHE_H
+#endif  // TDENGINE_RPC_LOG_H

src/rpc/src/rpcMain.c

@@ -594,7 +594,10 @@ static SRpcConn *rpcAllocateServerConn(SRpcInfo *pRpc, SRecvInfo *pRecv) {
   // check if it is already allocated
   SRpcConn **ppConn = (SRpcConn **)(taosHashGet(pRpc->hash, hashstr, size));
   if (ppConn) pConn = *ppConn;
-  if (pConn) return pConn;
+  if (pConn) {
+    pConn->secured = 0;
+    return pConn;
+  }
 
   int sid = taosAllocateId(pRpc->idPool);
   if (sid <= 0) {

src/tsdb/inc/tsdbMain.h

@@ -29,20 +29,10 @@ extern "C" {
 
 extern int tsdbDebugFlag;
 
-#define tsdbError(...)                                      \
-  if (tsdbDebugFlag & DEBUG_ERROR) {                        \
-    taosPrintLog("ERROR TDB ", tsdbDebugFlag, __VA_ARGS__); \
-  }
-#define tsdbWarn(...)                                      \
-  if (tsdbDebugFlag & DEBUG_WARN) {                        \
-    taosPrintLog("WARN TDB ", tsdbDebugFlag, __VA_ARGS__); \
-  }
-#define tsdbTrace(...)                                \
-  if (tsdbDebugFlag & DEBUG_TRACE) {                  \
-    taosPrintLog("TDB ", tsdbDebugFlag, __VA_ARGS__); \
-  }
-#define tsdbPrint(...) \
-  { taosPrintLog("TDB ", 255, __VA_ARGS__); }
+#define tsdbError(...) { if (tsdbDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR TDB ", tsdbDebugFlag, __VA_ARGS__); }}
+#define tsdbWarn(...)  { if (tsdbDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN TDB ", tsdbDebugFlag, __VA_ARGS__); }}
+#define tsdbTrace(...) { if (tsdbDebugFlag & DEBUG_TRACE) { taosPrintLog("TDB ", tsdbDebugFlag, __VA_ARGS__); }}
+#define tsdbPrint(...) { taosPrintLog("TDB ", 255, __VA_ARGS__); }
 
 // ------------------------------ TSDB META FILE INTERFACES ------------------------------
 #define TSDB_META_FILE_NAME "meta"
@@ -95,12 +85,13 @@ typedef struct STable {
   TSKEY          lastKey;        // lastkey inserted in this table, initialized as 0, TODO: make a structure
   struct STable *next;           // TODO: remove the next
   struct STable *prev;
-  tstr *         name;           // NOTE: there a flexible string here
+  tstr *         name;  // NOTE: there a flexible string here
+  char *         sql;
 } STable;
 
 #define TSDB_GET_TABLE_LAST_KEY(tb) ((tb)->lastKey)
 
-void *  tsdbEncodeTable(STable *pTable, int *contLen);
+void    tsdbEncodeTable(STable *pTable, char *buf, int *contLen);
 STable *tsdbDecodeTable(void *cont, int contLen);
 void    tsdbFreeEncode(void *cont);
 

src/tsdb/src/tsdbMain.c

@@ -446,7 +446,7 @@ int32_t tsdbInsertData(TsdbRepoT *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg * p
  */
 int tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t tid) {
   if (config == NULL) return -1;
-  if (type != TSDB_NORMAL_TABLE && type != TSDB_CHILD_TABLE) return -1;
+  if (type != TSDB_CHILD_TABLE && type != TSDB_NORMAL_TABLE && type != TSDB_STREAM_TABLE) return -1;
 
   memset((void *)config, 0, sizeof(STableCfg));
 
@@ -455,6 +455,7 @@ int tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t t
   config->tableId.uid = uid;
   config->tableId.tid = tid;
   config->name = NULL;
+  config->sql = NULL;
   return 0;
 }
 
@@ -540,12 +541,26 @@ int tsdbTableSetSName(STableCfg *config, char *sname, bool dup) {
   return 0;
 }
 
+int tsdbTableSetStreamSql(STableCfg *config, char *sql, bool dup) {
+  if (config->type != TSDB_STREAM_TABLE) return -1;
+  
+  if (dup) {
+    config->sql = strdup(sql);
+    if (config->sql == NULL) return -1;
+  } else {
+    config->sql = sql;
+  }
+
+  return 0;
+}
+
 void tsdbClearTableCfg(STableCfg *config) {
   if (config->schema) tdFreeSchema(config->schema);
   if (config->tagSchema) tdFreeSchema(config->tagSchema);
   if (config->tagValues) tdFreeDataRow(config->tagValues);
   tfree(config->name);
   tfree(config->sname);
+  tfree(config->sql);
 }
 
 int tsdbInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter) {
@@ -936,7 +951,7 @@ static SSkipListIterator **tsdbCreateTableIters(STsdbMeta *pMeta, int maxTables)
 
   for (int tid = 1; tid < maxTables; tid++) {
     STable *pTable = pMeta->tables[tid];
-    if (pTable == NULL || pTable->imem == NULL) continue;
+    if (pTable == NULL || pTable->imem == NULL || pTable->imem->numOfRows == 0) continue;
 
     iters[tid] = tSkipListCreateIter(pTable->imem->pData);
     if (iters[tid] == NULL) goto _err;
@@ -968,12 +983,12 @@ static void *tsdbCommitData(void *arg) {
   SRWHelper   whelper = {{0}};
   if (pCache->imem == NULL) return NULL;
 
-  tsdbPrint("vgId: %d, starting to commit....", pRepo->config.tsdbId);
+  tsdbPrint("vgId:%d, starting to commit....", pRepo->config.tsdbId);
 
   // Create the iterator to read from cache
   SSkipListIterator **iters = tsdbCreateTableIters(pMeta, pCfg->maxTables);
   if (iters == NULL) {
-    // TODO: deal with the error
+    ASSERT(0);
     return NULL;
   }
 
@@ -1015,6 +1030,7 @@ _exit:
     }
   }
   tsdbUnLockRepo(arg);
+  tsdbPrint("vgId:%d, commit over....", pRepo->config.tsdbId);
 
   return NULL;
 }

src/tsdb/src/tsdbMeta.c

@@ -15,7 +15,6 @@ static int32_t tsdbCheckTableCfg(STableCfg *pCfg);
 static int     tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable, bool addIdx);
 static int     tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable);
 static int     tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable);
-static int     tsdbEstimateTableEncodeSize(STable *pTable);
 static int     tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rmFromIdx);
 
 /**
@@ -28,16 +27,10 @@ static int     tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rm
  * @return binary content for success
  *         NULL fro failure
  */
-void *tsdbEncodeTable(STable *pTable, int *contLen) {
-  if (pTable == NULL) return NULL;
-
-  *contLen = tsdbEstimateTableEncodeSize(pTable);
-  if (*contLen < 0) return NULL;
-
-  void *ret = calloc(1, *contLen);
-  if (ret == NULL) return NULL;
+void tsdbEncodeTable(STable *pTable, char *buf, int *contLen) {
+  if (pTable == NULL) return;
 
-  void *ptr = ret;
+  void *ptr = buf;
   T_APPEND_MEMBER(ptr, pTable, STable, type);
   // Encode name, todo refactor
   *(int *)ptr = varDataLen(pTable->name);
@@ -54,12 +47,17 @@ void *tsdbEncodeTable(STable *pTable, int *contLen) {
     ptr = tdEncodeSchema(ptr, pTable->schema);
     ptr = tdEncodeSchema(ptr, pTable->tagSchema);
   } else if (pTable->type == TSDB_CHILD_TABLE) {
-    dataRowCpy(ptr, pTable->tagVal);
+    tdTagRowCpy(ptr, pTable->tagVal);
+    ptr = POINTER_SHIFT(ptr, dataRowLen(pTable->tagVal) + ((STagRow *)pTable->tagVal)->dataLen);
   } else {
     ptr = tdEncodeSchema(ptr, pTable->schema);
   }
 
-  return ret;
+  if (pTable->type == TSDB_STREAM_TABLE) {
+    ptr = taosEncodeString(ptr, pTable->sql);
+  }
+
+  *contLen = (char *)ptr - buf;
 }
 
 /**
@@ -96,11 +94,16 @@ STable *tsdbDecodeTable(void *cont, int contLen) {
     pTable->schema = tdDecodeSchema(&ptr);
     pTable->tagSchema = tdDecodeSchema(&ptr);
   } else if (pTable->type == TSDB_CHILD_TABLE) {
-    pTable->tagVal = tdDataRowDup(ptr);
+    pTable->tagVal = tdTagRowDecode(ptr);
+    ptr = POINTER_SHIFT(ptr, dataRowLen(pTable->tagVal) + ((STagRow *)pTable->tagVal)->dataLen);
   } else {
     pTable->schema = tdDecodeSchema(&ptr);
   }
 
+  if (pTable->type == TSDB_STREAM_TABLE) {
+    ptr = taosDecodeString(ptr, &(pTable->sql));
+  }
+
   return pTable;
 }
 
@@ -114,8 +117,10 @@ static char* getTagIndexKey(const void* pData) {
   SDataRow row = elem->pTable->tagVal;
   STSchema* pSchema = tsdbGetTableTagSchema(elem->pMeta, elem->pTable);
   STColumn* pCol = &pSchema->columns[DEFAULT_TAG_INDEX_COLUMN];
-  
-  return tdGetRowDataOfCol(row, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
+  int16_t type = 0;
+  void * res = tdQueryTagByID(row, pCol->colId,&type);
+  ASSERT(type == pCol->type);
+  return res;
 }
 
 int tsdbRestoreTable(void *pHandle, void *cont, int contLen) {
@@ -211,7 +216,7 @@ int32_t tsdbFreeMeta(STsdbMeta *pMeta) {
 }
 
 STSchema *tsdbGetTableSchema(STsdbMeta *pMeta, STable *pTable) {
-  if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE) {
+  if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE || pTable->type == TSDB_STREAM_TABLE) {
     return pTable->schema;
   } else if (pTable->type == TSDB_CHILD_TABLE) {
     STable *pSuper = tsdbGetTableByUid(pMeta, pTable->superUid);
@@ -255,8 +260,9 @@ int32_t tsdbGetTableTagVal(TsdbRepoT* repo, STableId* id, int32_t colId, int16_t
   }
   
   SDataRow row = (SDataRow)pTable->tagVal;
-  char* d = tdGetRowDataOfCol(row, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
-  
+  int16_t tagtype = 0;
+  char* d = tdQueryTagByID(row, pCol->colId, &tagtype);
+  //ASSERT((int8_t)tagtype == pCol->type)
   *val = d;
   *type  = pCol->type;
   *bytes = pCol->bytes;
@@ -283,6 +289,76 @@ char* tsdbGetTableName(TsdbRepoT *repo, const STableId* id, int16_t* bytes) {
   }
 }
 
+static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) {
+  STable *pTable = NULL;
+  size_t  tsize = 0;
+
+  pTable = (STable *)calloc(1, sizeof(STable));
+  if (pTable == NULL) {
+    terrno = TSDB_CODE_SERV_OUT_OF_MEMORY;
+    goto _err;
+  }
+
+  pTable->type = pCfg->type;
+
+  if (isSuper) {
+    pTable->type = TSDB_SUPER_TABLE;
+    pTable->tableId.uid = pCfg->superUid;
+    pTable->tableId.tid = -1;
+    pTable->superUid = TSDB_INVALID_SUPER_TABLE_ID;
+    pTable->schema = tdDupSchema(pCfg->schema);
+    pTable->tagSchema = tdDupSchema(pCfg->tagSchema);
+
+    tsize = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN);
+    pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1);
+    if (pTable->name == NULL) {
+      terrno = TSDB_CODE_SERV_OUT_OF_MEMORY;
+      goto _err;
+    }
+    STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->sname, tsize);
+
+    STColumn *pColSchema = schemaColAt(pTable->tagSchema, 0);
+    pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes, 1, 0, 0,
+                                     getTagIndexKey);  // Allow duplicate key, no lock
+    if (pTable->pIndex == NULL) {
+      terrno = TSDB_CODE_SERV_OUT_OF_MEMORY;
+      goto _err;
+    }
+  } else {
+    pTable->type = pCfg->type;
+    pTable->tableId.uid = pCfg->tableId.uid;
+    pTable->tableId.tid = pCfg->tableId.tid;
+    pTable->lastKey = TSKEY_INITIAL_VAL;
+
+    tsize = strnlen(pCfg->name, TSDB_TABLE_NAME_LEN);
+    pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1);
+    if (pTable->name == NULL) {
+      terrno = TSDB_CODE_SERV_OUT_OF_MEMORY;
+      goto _err;
+    }
+    STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->name, tsize);
+
+    if (pCfg->type == TSDB_CHILD_TABLE) {
+      pTable->superUid = pCfg->superUid;
+      pTable->tagVal = tdDataRowDup(pCfg->tagValues);
+    } else if (pCfg->type == TSDB_NORMAL_TABLE) {
+      pTable->superUid = -1;
+      pTable->schema = tdDupSchema(pCfg->schema);
+    } else {
+      ASSERT(pCfg->type == TSDB_STREAM_TABLE);
+      pTable->superUid = -1;
+      pTable->schema = tdDupSchema(pCfg->schema);
+      pTable->sql = strdup(pCfg->sql);
+    }
+  }
+
+  return pTable;
+
+_err:
+  tsdbFreeTable(pTable);
+  return NULL;
+}
+
 int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) {
   STsdbRepo *pRepo = (STsdbRepo *)repo;
   STsdbMeta *pMeta = pRepo->tsdbMeta;
@@ -303,61 +379,19 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) {
     super = tsdbGetTableByUid(pMeta, pCfg->superUid);
     if (super == NULL) {  // super table not exists, try to create it
       newSuper = 1;
-      // TODO: use function to implement create table object
-      super = (STable *)calloc(1, sizeof(STable));
+      super = tsdbNewTable(pCfg, true);
       if (super == NULL) return -1;
-
-      super->type = TSDB_SUPER_TABLE;
-      super->tableId.uid = pCfg->superUid;
-      super->tableId.tid = -1;
-      super->superUid = TSDB_INVALID_SUPER_TABLE_ID;
-      super->schema = tdDupSchema(pCfg->schema);
-      super->tagSchema = tdDupSchema(pCfg->tagSchema);
-      super->tagVal = NULL;
-      
-      // todo refactor extract method
-      size_t size = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN);
-      super->name = calloc(1, size + VARSTR_HEADER_SIZE + 1);
-      STR_WITH_SIZE_TO_VARSTR(super->name, pCfg->sname, size);
-
-      // index the first tag column
-      STColumn* pColSchema = schemaColAt(super->tagSchema, 0);
-      super->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes,
-          1, 0, 1, getTagIndexKey);  // Allow duplicate key, no lock
-
-      if (super->pIndex == NULL) {
-        tdFreeSchema(super->schema);
-        tdFreeSchema(super->tagSchema);
-        tdFreeDataRow(super->tagVal);
-        free(super);
-        return -1;
-      }
     } else {
       if (super->type != TSDB_SUPER_TABLE) return -1;
     }
   }
 
-  STable *table = (STable *)calloc(1, sizeof(STable));
+  STable *table = tsdbNewTable(pCfg, false);
   if (table == NULL) {
-    if (newSuper) tsdbFreeTable(super);
-    return -1;
-  }
-
-  table->tableId = pCfg->tableId;
-  
-  size_t size = strnlen(pCfg->name, TSDB_TABLE_NAME_LEN);
-  table->name = calloc(1, size + VARSTR_HEADER_SIZE + 1);
-  STR_WITH_SIZE_TO_VARSTR(table->name, pCfg->name, size);
-  
-  table->lastKey = 0;
-  if (IS_CREATE_STABLE(pCfg)) { // TSDB_CHILD_TABLE
-    table->type = TSDB_CHILD_TABLE;
-    table->superUid = pCfg->superUid;
-    table->tagVal = tdDataRowDup(pCfg->tagValues);
-  } else { // TSDB_NORMAL_TABLE
-    table->type = TSDB_NORMAL_TABLE;
-    table->superUid = -1;
-    table->schema = tdDupSchema(pCfg->schema);
+    if (newSuper) {
+      tsdbFreeTable(super);
+      return -1;
+    }
   }
 
   // Register to meta
@@ -372,15 +406,15 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) {
 
   // Write to meta file
   int bufLen = 0;
+  char *buf = malloc(1024*1024);
   if (newSuper) {
-    void *buf = tsdbEncodeTable(super, &bufLen);
+    tsdbEncodeTable(super, buf, &bufLen);
     tsdbInsertMetaRecord(pMeta->mfh, super->tableId.uid, buf, bufLen);
-    tsdbFreeEncode(buf);
   }
 
-  void *buf = tsdbEncodeTable(table, &bufLen);
+  tsdbEncodeTable(table, buf, &bufLen);
   tsdbInsertMetaRecord(pMeta->mfh, table->tableId.uid, buf, bufLen);
-  tsdbFreeEncode(buf);
+  tfree(buf);
 
   return 0;
 }
@@ -438,13 +472,18 @@ static void tsdbFreeMemTable(SMemTable *pMemTable) {
 }
 
 static int tsdbFreeTable(STable *pTable) {
-  // TODO: finish this function
+  if (pTable == NULL) return 0;
+
   if (pTable->type == TSDB_CHILD_TABLE) {
-    tdFreeDataRow(pTable->tagVal);
+    tdFreeTagRow(pTable->tagVal);
   } else {
     tdFreeSchema(pTable->schema);
   }
 
+  if (pTable->type == TSDB_STREAM_TABLE) {
+    tfree(pTable->sql);
+  }
+
   // Free content
   if (TSDB_TABLE_IS_SUPER_TABLE(pTable)) {
     tdFreeSchema(pTable->tagSchema);
@@ -491,6 +530,9 @@ static int tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable, bool addIdx) {
     if (pTable->type == TSDB_CHILD_TABLE && addIdx) { // add STABLE to the index
       tsdbAddTableIntoIndex(pMeta, pTable);
     }
+    if (pTable->type == TSDB_STREAM_TABLE && addIdx) {
+      // TODO
+    }
     
     pMeta->nTables++;
   }
@@ -522,7 +564,6 @@ static int tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rmFrom
 
     tSkipListDestroyIter(pIter);
 
-    // TODO: Remove the table from the list
     if (pTable->prev != NULL) {
       pTable->prev->next = pTable->next;
       if (pTable->next != NULL) {
@@ -536,6 +577,9 @@ static int tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rmFrom
     if (pTable->type == TSDB_CHILD_TABLE && rmFromIdx) {
       tsdbRemoveTableFromIndex(pMeta, pTable);
     }
+    if (pTable->type == TSDB_STREAM_TABLE && rmFromIdx) {
+      // TODO
+    }
 
     pMeta->nTables--;
   }
@@ -579,7 +623,9 @@ static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable) {
   STSchema* pSchema = tsdbGetTableTagSchema(pMeta, pTable);
   STColumn* pCol = &pSchema->columns[DEFAULT_TAG_INDEX_COLUMN];
   
-  char* key = tdGetRowDataOfCol(pTable->tagVal, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
+  int16_t tagtype = 0;
+  char* key = tdQueryTagByID(pTable->tagVal, pCol->colId, &tagtype);
+  ASSERT(pCol->type == tagtype);
   SArray* res = tSkipListGet(pSTable->pIndex, key);
   
   size_t size = taosArrayGetSize(res);
@@ -598,25 +644,6 @@ static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable) {
   return 0;
 }
 
-static int tsdbEstimateTableEncodeSize(STable *pTable) {
-  int size = 0;
-  size += T_MEMBER_SIZE(STable, type);
-  size += sizeof(int) + varDataLen(pTable->name);
-  size += T_MEMBER_SIZE(STable, tableId);
-  size += T_MEMBER_SIZE(STable, superUid);
-  size += T_MEMBER_SIZE(STable, sversion);
-
-  if (pTable->type == TSDB_SUPER_TABLE) {
-    size += tdGetSchemaEncodeSize(pTable->schema);
-    size += tdGetSchemaEncodeSize(pTable->tagSchema);
-  } else if (pTable->type == TSDB_CHILD_TABLE) {
-    size += dataRowLen(pTable->tagVal);
-  } else {
-    size += tdGetSchemaEncodeSize(pTable->schema);
-  }
-
-  return size;
-}
 
 char *getTSTupleKey(const void * data) {
   SDataRow row = (SDataRow)data;

src/tsdb/src/tsdbRead.c

@@ -1539,14 +1539,21 @@ int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT* pQueryHandle, SDataSta
   tsdbLoadCompData(&pHandle->rhelper, pBlockInfo->compBlock, NULL);
   
   size_t numOfCols = QH_GET_NUM_OF_COLS(pHandle);
-  memset(pHandle->statis, 0, sizeof(SDataStatis) * numOfCols);
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    SDataStatis* st = &pHandle->statis[i];
+    int32_t colId = st->colId;
+    
+    memset(st, 0, sizeof(SDataStatis));
+    st->colId = colId;
+  }
+  
   tsdbGetDataStatis(&pHandle->rhelper, pHandle->statis, numOfCols);
   
   *pBlockStatis = pHandle->statis;
   
   //update the number of NULL data rows
   for(int32_t i = 0; i < numOfCols; ++i) {
-    if (pHandle->statis[i].numOfNull == -1) {
+    if (pHandle->statis[i].numOfNull == -1) { // set the column data are all NULL
       pHandle->statis[i].numOfNull = pBlockInfo->compBlock->numOfRows;
     }
   }
@@ -1746,9 +1753,9 @@ int32_t tableGroupComparFn(const void *p1, const void *p2, const void *param) {
       STColumn* pCol = schemaColAt(pTableGroupSupp->pTagSchema, colIndex);
       bytes = pCol->bytes;
       type = pCol->type;
-      
-      f1 = tdGetRowDataOfCol(pTable1->tagVal, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
-      f2 = tdGetRowDataOfCol(pTable2->tagVal, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
+      int16_t tgtype1, tgtype2 = 0;
+      f1 = tdQueryTagByID(pTable1->tagVal, pCol->colId, &tgtype1);
+      f2 = tdQueryTagByID(pTable2->tagVal, pCol->colId, &tgtype2);
     }
     
     int32_t ret = doCompare(f1, f2, type, bytes);
@@ -1836,12 +1843,14 @@ bool indexedNodeFilterFp(const void* pNode, void* param) {
     val = (char*) elem->pTable->name;
     type = TSDB_DATA_TYPE_BINARY;
   } else {
-    STSchema* pTSchema = (STSchema*) pInfo->param; // todo table schema is identical to stable schema??
-    
-    int32_t offset = pTSchema->columns[pInfo->colIndex].offset;
-    val = tdGetRowDataOfCol(elem->pTable->tagVal, pInfo->sch.type, TD_DATA_ROW_HEAD_SIZE + offset);
-  }
-
+//    STSchema* pTSchema = (STSchema*) pInfo->param; // todo table schema is identical to stable schema??
+    int16_t type;
+  //  int32_t offset = pTSchema->columns[pInfo->colIndex].offset;
+  //  val = tdGetRowDataOfCol(elem->pTable->tagVal, pInfo->sch.type, TD_DATA_ROW_HEAD_SIZE + offset);
+    val = tdQueryTagByID(elem->pTable->tagVal, pInfo->sch.colId, &type);
+  //  ASSERT(pInfo->sch.type == type);    
+  }
+  //todo :the val is possible to be null, so check it out carefully
   int32_t ret = 0;
   if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
     if (pInfo->optr == TSDB_RELATION_IN) {

src/util/inc/tcoding.h

@@ -217,6 +217,28 @@ static FORCE_INLINE void *taosDecodeVariant64(void *buf, uint64_t *value) {
   return NULL;  // error happened
 }
 
+static FORCE_INLINE void *taosEncodeString(void *buf, char *value) {
+  size_t size = strlen(value);
+
+  buf = taosEncodeVariant64(buf, size);
+  memcpy(buf, value, size);
+
+  return POINTER_SHIFT(buf, size);
+}
+
+static FORCE_INLINE void *taosDecodeString(void *buf, char **value) {
+  uint64_t size = 0;
+
+  buf = taosDecodeVariant64(buf, &size);
+  *value = (char *)malloc(size + 1);
+  if (*value == NULL) return NULL;
+  memcpy(*value, buf, size);
+
+  (*value)[size] = '\0';
+
+  return POINTER_SHIFT(buf, size);
+}
+
 #ifdef __cplusplus
 }
 #endif

src/util/src/ttime.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define _BSD_SOURCE
 #define _XOPEN_SOURCE
 #define _DEFAULT_SOURCE
 

src/vnode/src/vnodeWrite.c

@@ -106,6 +106,7 @@ static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pR
 static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) {
   SMDCreateTableMsg *pTable = pCont;
   int32_t code = 0;
+  char sql[1024] = "\0";
 
   vTrace("vgId:%d, table:%s, start to create", pVnode->vgId, pTable->tableId);
   int16_t   numOfColumns = htons(pTable->numOfColumns);
@@ -139,16 +140,23 @@ static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRe
     
     char *pTagData = pTable->data + totalCols * sizeof(SSchema);
     int accumBytes = 0;
-    dataRow = tdNewDataRowFromSchema(pDestTagSchema);
+    //dataRow = tdNewDataRowFromSchema(pDestTagSchema);
+    dataRow = tdNewTagRowFromSchema(pDestTagSchema, numOfTags);
 
     for (int i = 0; i < numOfTags; i++) {
       STColumn *pTCol = schemaColAt(pDestTagSchema, i);
-      tdAppendColVal(dataRow, pTagData + accumBytes, pTCol->type, pTCol->bytes, pTCol->offset);
+//      tdAppendColVal(dataRow, pTagData + accumBytes, pTCol->type, pTCol->bytes, pTCol->offset);
+      tdAppendTagColVal(dataRow, pTagData + accumBytes, pTCol->type, pTCol->bytes, pTCol->colId);
       accumBytes += htons(pSchema[i + numOfColumns].bytes);
     }
     tsdbTableSetTagValue(&tCfg, dataRow, false);
   }
 
+  if (pTable->tableType == TSDB_STREAM_TABLE) {
+    // TODO: set sql value
+    tsdbTableSetStreamSql(&tCfg, sql, false);
+  }
+
   code = tsdbCreateTable(pVnode->tsdb, &tCfg);
   tdFreeDataRow(dataRow);
   tfree(pDestTagSchema);

tests/pytest/fulltest.sh

@@ -129,4 +129,6 @@ python3 ./test.py -f user/pass_len.py
 
 #query
 python3 ./test.py -f query/filter.py
-
+python3 ./test.py $1 -f query/filterCombo.py
+python3 ./test.py $1 -f query/queryNormal.py
+python3 ./test.py $1 -f query/queryError.py

tests/pytest/import_merge/importToCommit.py

@@ -46,7 +46,6 @@ class TDTestCase:
         tdLog.info('insert data until the first commit')
         dnodesDir = tdDnodes.getDnodesRootDir()
         dataDir = dnodesDir + '/dnode1/data/vnode'
-        tdLog.info('CBD: dataDir=%s' % dataDir)
         startTime = self.startTime
         rid0 = 1
         while (True):

tests/pytest/insert/randomNullCommit.py

@@ -29,7 +29,8 @@ class TDTestCase:
         tdSql.prepare()
 
         tdLog.info("=============== step1")
-        tdSql.execute('create table tb (ts timestamp, speed int, temp float, note binary(5), flag bool)')
+        tdSql.execute(
+            'create table tb (ts timestamp, speed int, temp float, note binary(5), flag bool)')
 
         numOfRecords = 0
         randomList = [10, 50, 100, 500, 1000, 5000]
@@ -38,23 +39,24 @@ class TDTestCase:
             tdLog.info("will insert %d records" % num)
             for x in range(0, num):
                 tdLog.info(
-                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' % x)
+                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' %
+                    x)
                 tdSql.execute(
-                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' % x)
+                    'insert into tb values (now + %da, NULL, NULL, NULL, TRUE)' %
+                    x)
 
             numOfRecords = numOfRecords + num
 
             tdSql.query("select * from tb")
             tdSql.checkRows(numOfRecords)
-            tdSql.checkData(numOfRecords-num, 1, None)
-            tdSql.checkData(numOfRecords-1, 2, None)
+            tdSql.checkData(numOfRecords - num, 1, None)
+            tdSql.checkData(numOfRecords - 1, 2, None)
 
             tdLog.info("stop dnode to commit data to disk")
             tdDnodes.stop(1)
             tdDnodes.start(1)
             tdLog.sleep(5)
 
-
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/pytest/insert/sparseData.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
+
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.prepare()
+
+        tdLog.info("=============== step1")
+        tdSql.execute(
+            'create table tb (ts timestamp, speed int, temp float, note binary(4000), flag bool)')
+
+        numOfRecords = 1000000
+        dividend = 1000
+        tdLog.info("will insert %d records" % numOfRecords)
+
+        ts = 1500000000000
+        for i in range(0, numOfRecords):
+
+            if (i % dividend):
+                print(".", end="")
+                tdSql.execute(
+                    'insert into tb values (%d + %da, NULL, NULL, NULL, TRUE)' %
+                    (ts, i))
+            else:
+                print("a", end="")
+                tdSql.execute(
+                    'insert into tb values (%d + %da, NULL, NULL, "a", FALSE)' %
+                    (ts, i))
+
+        tdSql.query("select * from tb")
+        tdSql.checkRows(numOfRecords)
+        tdSql.checkData(numOfRecords - dividend, 3, 'a')
+        tdSql.checkData(numOfRecords - dividend - 1, 3, None)
+
+        tdLog.info("stop dnode to commit data to disk")
+        tdDnodes.stop(1)
+        tdLog.info("dnodes:%d size is %d" % (1, tdDnodes.getDataSize(1)))
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/filterCombo.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 *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.prepare()
+
+        print("==============step1")
+        tdSql.execute(
+            "create table if not exists st (ts timestamp, tagtype int, name nchar(16)) tags(dev nchar(50))")
+        tdSql.execute(
+            'CREATE TABLE if not exists dev_001 using st tags("dev_01")')
+        tdSql.execute(
+            'CREATE TABLE if not exists dev_002 using st tags("dev_02")')
+
+        print("==============step2")
+
+        tdSql.execute(
+            """INSERT INTO dev_001(ts, tagtype, name) VALUES('2020-05-13 10:00:00.000', 1, 'first'),('2020-05-13 10:00:00.001', 2, 'second'),
+            ('2020-05-13 10:00:00.002', 3, 'third') dev_002 VALUES('2020-05-13 10:00:00.003', 1, 'first'), ('2020-05-13 10:00:00.004', 2, 'second'),
+            ('2020-05-13 10:00:00.005', 3, 'third')""")
+
+        # query with filter condition A OR condition B
+        tdSql.query("select * from db.st where ts > '2020-05-13 10:00:00.002' AND tagtype < 2")
+        tdSql.checkRows(1)
+
+        # query with filter condition A OR condition B, error expected
+        tdSql.error("select * from db.st where ts > '2020-05-13 10:00:00.002' OR tagtype < 2")
+
+        # illegal condition
+        tdSql.error("select * from db.st where ts != '2020-05-13 10:00:00.002' OR tagtype < 2")
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/queryError.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 *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.prepare()
+
+        print("==============step1")
+        tdSql.execute(
+            "create table if not exists st (ts timestamp, tagtype int, name nchar(16)) tags(dev nchar(50))")
+        tdSql.execute(
+            'CREATE TABLE if not exists dev_001 using st tags("dev_01")')
+        tdSql.execute(
+            'CREATE TABLE if not exists dev_002 using st tags("dev_02")')
+
+        print("==============step2")
+
+        tdSql.execute(
+            """INSERT INTO dev_001(ts, tagtype, name) VALUES('2020-05-13 10:00:00.000', 1, 'first'),('2020-05-13 10:00:00.001', 2, 'second'),
+            ('2020-05-13 10:00:00.002', 3, 'third') dev_002 VALUES('2020-05-13 10:00:00.003', 1, 'first'), ('2020-05-13 10:00:00.004', 2, 'second'),
+            ('2020-05-13 10:00:00.005', 3, 'third')""")
+
+        """Error expected here, but no errors
+        # query first .. as ..
+        tdSql.error("select first(*) as one from st")    
+
+        # query last .. as ..
+        tdSql.error("select last(*) as latest from st")
+        """ 
+
+        # query last row .. as ..
+        tdSql.error("select last_row as latest from st") 
+
+        # query distinct on normal colnum
+        tdSql.error("select distinct tagtype from st")     
+
+        # query .. order by non-time field
+        tdSql.error("select * from st order by name")
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/queryNormal.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 *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.prepare()
+
+        print("==============step1")
+
+        tdSql.execute("create table stb1 (ts timestamp, c1 int, c2 float) tags(t1 int, t2 binary(10), t3 nchar(10))")
+        tdSql.execute("insert into tb1 using stb1 tags(1,'tb1', '表1') values ('2020-04-18 15:00:00.000', 1, 0.1), ('2020-04-18 15:00:01.000', 2, 0.1)")
+        tdSql.execute("insert into tb2 using stb1 tags(2,'tb2', '表2') values ('2020-04-18 15:00:02.000', 3, 2.1), ('2020-04-18 15:00:03.000', 4, 2.2)")        
+
+        # join 2 tables -- bug exists
+        # tdSql.query("select * from tb1 a, tb2 b where a.ts = b.ts")
+        # tdSql.checkRows(1)
+
+        # join 3 tables -- bug exists
+        # tdSql.query("select stb_t.ts, stb_t.dscrption, stb_t.temperature, stb_p.id, stb_p.dscrption, stb_p.pressure,stb_v.velocity from stb_p, stb_t, stb_v where stb_p.ts=stb_t.ts and stb_p.ts=stb_v.ts and stb_p.id = stb_t.id")
+        
+        # query count
+        tdSql.query("select count(*) from stb1")
+        tdSql.checkData(0, 0, 4)
+
+        # query first 
+        tdSql.query("select first(*) from stb1")
+        tdSql.checkData(0, 1, 1)
+        
+        # query last 
+        tdSql.query("select last(*) from stb1")
+        tdSql.checkData(0, 1, 4)
+
+        # query as
+        tdSql.query("select t2 as number from stb1")
+        tdSql.checkRows(2)
+
+        # query first ... as
+        tdSql.query("select first(*) as begin from stb1")
+        tdSql.checkData(0, 1, 1)
+        
+        # query last ... as
+        tdSql.query("select last(*) as end from stb1")
+        tdSql.checkData(0, 1, 4)
+
+        # query group .. by
+        tdSql.query("select sum(c1), t2 from stb1 group by t2")
+        tdSql.checkRows(2)
+
+        # query ... limit
+        tdSql.query("select * from stb1 limit 2")
+        tdSql.checkRows(2)
+
+        # query ... limit offset
+        tdSql.query("select * from stb1 limit 2 offset 3")
+        tdSql.checkRows(1)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/random-test/random-test.py

@@ -121,6 +121,7 @@ class Test:
         tdDnodes.start(1)
         tdSql.prepare()
 
+
 class TDTestCase:
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)

tests/pytest/smoketest.sh

@@ -56,4 +56,10 @@ python3 ./test.py $1 -s && sleep 1
 #query
 python3 ./test.py $1 -f query/filter.py
 python3 ./test.py $1 -s && sleep 1
+python3 ./test.py $1 -f query/filterCombo.py
+python3 ./test.py $1 -s && sleep 1
+python3 ./test.py $1 -f query/queryNormal.py
+python3 ./test.py $1 -s && sleep 1
+python3 ./test.py $1 -f query/queryError.py
+python3 ./test.py $1 -s && sleep 1
 

tests/pytest/table/boundary.py

@@ -98,12 +98,16 @@ class TDTestCase:
         # create a super table with name exceed max length
         sname = self.generateString(maxTableNameLen + 1)
         tdLog.info("create a super table with length %d" % len(sname))
-        tdSql.error("create table %s (ts timestamp, value int) tags(id int)" % sname)
+        tdSql.error(
+            "create table %s (ts timestamp, value int) tags(id int)" %
+            sname)
 
         # create a super table with name of max length
         sname = self.generateString(maxTableNameLen)
         tdLog.info("create a super table with length %d" % len(sname))
-        tdSql.execute("create table %s (ts timestamp, value int) tags(id int)" % sname)
+        tdSql.execute(
+            "create table %s (ts timestamp, value int) tags(id int)" %
+            sname)
         tdLog.info("check table count, should be one")
         tdSql.query('show stables')
         tdSql.checkRows(1)

tests/pytest/tag_lite/column.py

@@ -103,7 +103,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(4)')
         tdSql.checkRows(4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step3
         tdLog.info('=============== step3')
@@ -149,7 +149,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -160,7 +160,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(4)')
         tdSql.checkRows(4)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select * from $mt where tgcol = 1
         tdLog.info('select * from %s where tgcol = 1' % (mt))
@@ -169,7 +169,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -183,7 +183,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end

tests/pytest/tag_lite/filter.py

@@ -120,7 +120,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: sql select count(tbcol), avg(tbcol), sum(tbcol), min(tbcol),
         # max(tbcol), first(tbcol), last(tbcol) from $mt where tg = '1' -x
@@ -162,12 +162,12 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(1)')
         tdSql.checkRows(1)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM: if $data00 != 10 then
         tdLog.info('tdSql.checkData(0, 0, 10)')
         tdSql.checkData(0, 0, 10)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step5
         tdLog.info('=============== step5')
@@ -194,7 +194,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 200)')
         tdSql.checkData(0, 0, 200)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step6
         tdLog.info('=============== step6')
@@ -263,7 +263,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step11
         tdLog.info('=============== step11')
@@ -293,7 +293,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step14
         tdLog.info('=============== step14')
@@ -313,7 +313,7 @@ class TDTestCase:
         # TSIM: print expect 100, actual $data00
         tdLog.info('expect 100, actual $data00')
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== step15
         tdLog.info('=============== step15')
@@ -344,7 +344,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkData(0, 0, 100)')
         tdSql.checkData(0, 0, 100)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: print =============== clear
         tdLog.info('=============== clear')
@@ -358,7 +358,7 @@ class TDTestCase:
         tdLog.info('tdSql.checkRow(0)')
         tdSql.checkRows(0)
         # TSIM: return -1
-        #TSIM: endi
+        # TSIM: endi
         # TSIM:
         # TSIM: system sh/exec.sh -n dnode1 -s stop -x SIGINT
 # convert end

tests/pytest/util/dnodes.py

@@ -99,6 +99,19 @@ class TDDnode:
     def setValgrind(self, value):
         self.valgrind = value
 
+    def getDataSize(self):
+        totalSize = 0
+
+        if (self.deployed == 1):
+            for dirpath, dirnames, filenames in os.walk(self.dataDir):
+                for f in filenames:
+                    fp = os.path.join(dirpath, f)
+
+                    if not os.path.islink(fp):
+                        totalSize = totalSize + os.path.getsize(fp)
+
+        return totalSize
+
     def deploy(self):
         self.logDir = "%s/pysim/dnode%d/log" % (self.path, self.index)
         self.dataDir = "%s/pysim/dnode%d/data" % (self.path, self.index)
@@ -384,6 +397,10 @@ class TDDnodes:
         self.check(index)
         self.dnodes[index - 1].stop()
 
+    def getDataSize(self, index):
+        self.check(index)
+        return self.dnodes[index - 1].getDataSize()
+
     def forcestop(self, index):
         self.check(index)
         self.dnodes[index - 1].forcestop()

tests/script/basicSuite.sim

 run general/cache/new_metrics.sim
+run general/column/commit.sim
 run general/compress/compress.sim
-run general/compute/avg.sim
-run general/compute/count.sim
-run general/db/len.sim
+run general/compute/interval.sim
 run general/db/basic4.sim
+run general/field/binary.sim
 run general/http/restful_insert.sim
-run general/import/basic.sim
 run general/import/commit.sim
-run general/insert/query_file_memory.sim
+run general/import/replica1.sim
+run general/parser/auto_create_tb_drop_tb.sim
 run general/parser/binary_escapeCharacter.sim
 run general/parser/select_from_cache_disk.sim
+run general/stable/vnode3.sim
 run general/table/autocreate.sim
-run general/table/column_name.sim
-run general/table/int.sim
+run general/table/fill.sim
 run general/table/vgroup.sim
-run general/user/basic1.sim
-run general/user/pass_alter.sim
-run general/vector/single.sim
-#run general/connection/connection.sim
+run general/tag/filter.sim
 run general/user/authority.sim
+run general/user/pass_alter.sim
+run general/vector/metrics_mix.sim
+run general/vector/table_field.sim