support json

2.0/src/query/inc/qExecutor.h

@@ -589,7 +589,7 @@ SOperatorInfo* createTableSeqScanOperatorInfo(void* pTsdbQueryHandle, SQueryRunt
 SOperatorInfo* createAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createProjectOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream);
-SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createAllTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, bool multigroupResult);

2.0/src/query/src/qExecutor.c

@@ -2166,7 +2166,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
       }
       case OP_TimeWindow: {
         pRuntimeEnv->proot =
-            createTimeIntervalOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
+            createIntervalOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
         int32_t opType = pRuntimeEnv->proot->upstream[0]->operatorType;
         if (opType != OP_DummyInput && opType != OP_Join) {
           setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
@@ -6756,7 +6756,7 @@ SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
   return pOperator;
 }
 
-SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
+SOperatorInfo* createIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
   STableIntervalOperatorInfo* pInfo = calloc(1, sizeof(STableIntervalOperatorInfo));
 
   pInfo->pCtx = createSQLFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->rowCellInfoOffset);

contrib/test/craft/CMakeLists.txt

 add_executable(simulate_vnode "simulate_vnode.c")
-target_link_libraries(simulate_vnode PUBLIC craft lz4 uv_a)
+target_link_libraries(simulate_vnode craft lz4 uv_a)
\ No newline at end of file

contrib/test/craft/raftMain.c

@@ -10,7 +10,7 @@
 #include <raft.h>
 #include <raft/uv.h>
 #include "raftServer.h"
-#include "common.h"
+#include "tcommon.h"
 
 const char *exe_name;
 

contrib/test/craft/raftServer.c

 #include <stdlib.h>
-#include "common.h"
+#include "tcommon.h"
 #include "raftServer.h"
 
 char *keys;

contrib/test/craft/raftServer.h

@@ -11,7 +11,7 @@ extern "C" {
 #include <string.h>
 #include "raft.h"
 #include "raft/uv.h"
-#include "common.h"
+#include "tcommon.h"
 
 
 // simulate a db store, just for test

contrib/test/traft/single_node/CMakeLists.txt

@@ -3,4 +3,4 @@ target_sources(singleNode
   PRIVATE
   "singleNode.c" 
 )
-target_link_libraries(singleNode PUBLIC traft lz4 uv_a)
+target_link_libraries(singleNode traft lz4 uv_a)

example/CMakeLists.txt

@@ -2,11 +2,7 @@ aux_source_directory(src TMQ_DEMO_SRC)
 
 add_executable(tmq ${TMQ_DEMO_SRC})
 target_link_libraries(
-    tmq
-    PUBLIC taos
-    #PUBLIC util
-    #PUBLIC common
-    #PUBLIC os
+    tmq taos
 )
 target_include_directories(
     tmq

example/src/tmq.c

@@ -160,7 +160,7 @@ void sync_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
   }
 
   while (running) {
-    tmq_message_t* tmqmessage = tmq_consumer_poll(tmq, 500);
+    tmq_message_t* tmqmessage = tmq_consumer_poll(tmq, 1000);
     if (tmqmessage) {
       msg_process(tmqmessage);
       tmq_message_destroy(tmqmessage);

include/client/taos.h

@@ -224,10 +224,8 @@ DLL_EXPORT const char *tmq_err2str(tmq_resp_err_t);
 
 /* ------------------------TMQ CONSUMER INTERFACE------------------------ */
 DLL_EXPORT tmq_resp_err_t tmq_subscribe(tmq_t *tmq, tmq_list_t *topic_list);
-#if 0
-DLL_EXPORT tmq_resp_err_t tmq_unsubscribe(tmq_t* tmq);
-DLL_EXPORT tmq_resp_err_t tmq_subscription(tmq_t* tmq, tmq_list_t** topics);
-#endif
+DLL_EXPORT tmq_resp_err_t tmq_unsubscribe(tmq_t *tmq);
+DLL_EXPORT tmq_resp_err_t tmq_subscription(tmq_t *tmq, tmq_list_t **topics);
 DLL_EXPORT tmq_message_t *tmq_consumer_poll(tmq_t *tmq, int64_t blocking_time);
 DLL_EXPORT tmq_resp_err_t tmq_consumer_close(tmq_t *tmq);
 #if 0

include/common/taosdef.h

@@ -16,27 +16,19 @@
 #ifndef _TD_COMMON_TAOS_DEF_H_
 #define _TD_COMMON_TAOS_DEF_H_
 
+#include "taos.h"
+#include "tdef.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "taos.h"
-#include "tdef.h"
-
 typedef int64_t tb_uid_t;
 
 #define TSWINDOW_INITIALIZER       ((STimeWindow){INT64_MIN, INT64_MAX})
 #define TSWINDOW_DESC_INITIALIZER  ((STimeWindow){INT64_MAX, INT64_MIN})
 #define IS_TSWINDOW_SPECIFIED(win) (((win).skey != INT64_MIN) || ((win).ekey != INT64_MAX))
 
-typedef enum {
-  TAOS_QTYPE_RPC = 1,
-  TAOS_QTYPE_FWD = 2,
-  TAOS_QTYPE_WAL = 3,
-  TAOS_QTYPE_CQ = 4,
-  TAOS_QTYPE_QUERY = 5
-} EQType;
-
 typedef enum {
   TSDB_SUPER_TABLE = 1,   // super table
   TSDB_CHILD_TABLE = 2,   // table created from super table
@@ -46,14 +38,6 @@ typedef enum {
   TSDB_TABLE_MAX = 6
 } ETableType;
 
-typedef enum {
-  TSDB_MOD_MNODE = 1,
-  TSDB_MOD_HTTP = 2,
-  TSDB_MOD_MONITOR = 3,
-  TSDB_MOD_MQTT = 4,
-  TSDB_MOD_MAX = 5
-} EModuleType;
-
 typedef enum {
   TSDB_CHECK_ITEM_NETWORK,
   TSDB_CHECK_ITEM_MEM,
@@ -67,6 +51,10 @@ typedef enum {
 } ECheckItemType;
 
 typedef enum { TD_ROW_DISCARD_UPDATE = 0, TD_ROW_OVERWRITE_UPDATE = 1, TD_ROW_PARTIAL_UPDATE = 2 } TDUpdateConfig;
+typedef enum {
+  TSDB_STATIS_OK = 0,    // statis part exist and load successfully
+  TSDB_STATIS_NONE = 1,  // statis part not exist
+} ETsdbStatisStatus;
 
 extern char *qtypeStr[];
 

include/common/common.h → include/common/tcommon.h

@@ -13,17 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_COMMON_H
-#define TDENGINE_COMMON_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef _TD_COMMON_DEF_H_
+#define _TD_COMMON_DEF_H_
 
 #include "taosdef.h"
 #include "tarray.h"
 #include "tmsg.h"
 #include "tvariant.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 // typedef struct STimeWindow {
 //   TSKEY skey;
 //   TSKEY ekey;
@@ -48,6 +49,11 @@ enum {
   TMQ_CONF__RESET_OFFSET__NONE = -3,
 };
 
+enum {
+  TMQ_MSG_TYPE__POLL_RSP = 0,
+  TMQ_MSG_TYPE__EP_RSP,
+};
+
 typedef struct {
   uint32_t  numOfTables;
   SArray*   pGroupList;
@@ -214,7 +220,7 @@ static FORCE_INLINE void tDeleteSMqConsumeRsp(SMqConsumeRsp* pRsp) {
   }
   taosArrayDestroyEx(pRsp->pBlockData, (void (*)(void*))tDeleteSSDataBlock);
   pRsp->pBlockData = NULL;
-  // for (int i = 0; i < taosArrayGetSize(pRsp->pBlockData); i++) {
+  // for (int32_t i = 0; i < taosArrayGetSize(pRsp->pBlockData); i++) {
   // SSDataBlock* pDataBlock = (SSDataBlock*)taosArrayGet(pRsp->pBlockData, i);
   // tDeleteSSDataBlock(pDataBlock);
   //}
@@ -279,4 +285,4 @@ typedef struct SSessionWindow {
 }
 #endif
 
-#endif  // TDENGINE_COMMON_H
+#endif  /*_TD_COMMON_DEF_H_*/

include/common/tdataformat.h

@@ -12,6 +12,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef _TD_COMMON_DATA_FORMAT_H_
 #define _TD_COMMON_DATA_FORMAT_H_
 
@@ -77,9 +78,9 @@ typedef struct {
 
 // ----------------- TSDB SCHEMA DEFINITION
 typedef struct {
-  int version;    // version
-  int numOfCols;  // Number of columns appended
-  int tlen;       // maximum length of a STpRow without the header part (sizeof(VarDataOffsetT) + sizeof(VarDataLenT) +
+  int32_t version;    // version
+  int32_t numOfCols;  // Number of columns appended
+  int32_t tlen;   // maximum length of a STpRow without the header part (sizeof(VarDataOffsetT) + sizeof(VarDataLenT) +
                   // (bytes))
   uint16_t flen;  // First part length in a STpRow after the header part
   uint16_t vlen;  // pure value part length, excluded the overhead (bytes only)
@@ -95,10 +96,10 @@ typedef struct {
 #define tdFreeSchema(s)   tfree((s))
 
 STSchema *tdDupSchema(const STSchema *pSchema);
-int       tdEncodeSchema(void **buf, STSchema *pSchema);
-void *    tdDecodeSchema(void *buf, STSchema **pRSchema);
+int32_t   tdEncodeSchema(void **buf, STSchema *pSchema);
+void     *tdDecodeSchema(void *buf, STSchema **pRSchema);
 
-static FORCE_INLINE int comparColId(const void *key1, const void *key2) {
+static FORCE_INLINE int32_t comparColId(const void *key1, const void *key2) {
   if (*(int16_t *)key1 > ((STColumn *)key2)->colId) {
     return 1;
   } else if (*(int16_t *)key1 < ((STColumn *)key2)->colId) {
@@ -116,12 +117,12 @@ static FORCE_INLINE STColumn *tdGetColOfID(STSchema *pSchema, int16_t colId) {
 
 // ----------------- SCHEMA BUILDER DEFINITION
 typedef struct {
-  int       tCols;
-  int       nCols;
-  int       tlen;
+  int32_t   tCols;
+  int32_t   nCols;
+  int32_t   tlen;
   uint16_t  flen;
   uint16_t  vlen;
-  int       version;
+  int32_t   version;
   STColumn *columns;
 } STSchemaBuilder;
 
@@ -132,10 +133,10 @@ typedef struct {
 #define TD_BITMAP_BYTES(cnt) (ceil((double)cnt / TD_VTYPE_PARTS))
 #define TD_BIT_TO_BYTES(cnt) (ceil((double)cnt / 8))
 
-int       tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version);
+int32_t   tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version);
 void      tdDestroyTSchemaBuilder(STSchemaBuilder *pBuilder);
 void      tdResetTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version);
-int       tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int16_t colId, int16_t bytes);
+int32_t   tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int16_t colId, int16_t bytes);
 STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder);
 
 // ----------------- Semantic timestamp key definition
@@ -194,7 +195,7 @@ static FORCE_INLINE TKEY keyToTkey(TSKEY key) {
   return tdGetTKEY(lkey);
 }
 
-static FORCE_INLINE int tkeyComparFn(const void *tkey1, const void *tkey2) {
+static FORCE_INLINE int32_t tkeyComparFn(const void *tkey1, const void *tkey2) {
   TSKEY key1 = tdGetKey(*(TKEY *)tkey1);
   TSKEY key2 = tdGetKey(*(TKEY *)tkey2);
 
@@ -243,7 +244,7 @@ void     tdInitDataRow(SDataRow row, STSchema *pSchema);
 SDataRow tdDataRowDup(SDataRow row);
 
 // offset here not include dataRow header length
-static FORCE_INLINE int tdAppendDataColVal(SDataRow row, const void *value, bool isCopyVarData, int8_t type,
+static FORCE_INLINE int32_t tdAppendDataColVal(SDataRow row, const void *value, bool isCopyVarData, int8_t type,
                                            int32_t offset) {
   assert(value != NULL);
   int32_t toffset = offset + TD_DATA_ROW_HEAD_SIZE;
@@ -268,7 +269,7 @@ static FORCE_INLINE int tdAppendDataColVal(SDataRow row, const void *value, bool
 }
 
 // offset here not include dataRow header length
-static FORCE_INLINE int tdAppendColVal(SDataRow row, const void *value, int8_t type, int32_t offset) {
+static FORCE_INLINE int32_t tdAppendColVal(SDataRow row, const void *value, int8_t type, int32_t offset) {
   return tdAppendDataColVal(row, value, true, type, offset);
 }
 
@@ -281,25 +282,25 @@ static FORCE_INLINE void *tdGetRowDataOfCol(SDataRow row, int8_t type, int32_t o
   }
 }
 
-static FORCE_INLINE void *tdGetPtrToCol(SDataRow row, STSchema *pSchema, int idx) {
+static FORCE_INLINE void *tdGetPtrToCol(SDataRow row, STSchema *pSchema, int32_t idx) {
   return POINTER_SHIFT(row, TD_DATA_ROW_HEAD_SIZE + pSchema->columns[idx].offset);
 }
 
-static FORCE_INLINE void *tdGetColOfRowBySchema(SDataRow row, STSchema *pSchema, int idx) {
+static FORCE_INLINE void *tdGetColOfRowBySchema(SDataRow row, STSchema *pSchema, int32_t idx) {
   int16_t offset = TD_DATA_ROW_HEAD_SIZE + pSchema->columns[idx].offset;
   int8_t  type = pSchema->columns[idx].type;
 
   return tdGetRowDataOfCol(row, type, offset);
 }
 
-static FORCE_INLINE bool tdIsColOfRowNullBySchema(SDataRow row, STSchema *pSchema, int idx) {
+static FORCE_INLINE bool tdIsColOfRowNullBySchema(SDataRow row, STSchema *pSchema, int32_t idx) {
   int16_t offset = TD_DATA_ROW_HEAD_SIZE + pSchema->columns[idx].offset;
   int8_t  type = pSchema->columns[idx].type;
 
   return isNull(tdGetRowDataOfCol(row, type, offset), type);
 }
 
-static FORCE_INLINE void tdSetColOfRowNullBySchema(SDataRow row, STSchema *pSchema, int idx) {
+static FORCE_INLINE void tdSetColOfRowNullBySchema(SDataRow row, STSchema *pSchema, int32_t idx) {
   int16_t offset = TD_DATA_ROW_HEAD_SIZE + pSchema->columns[idx].offset;
   int8_t  type = pSchema->columns[idx].type;
   int16_t bytes = pSchema->columns[idx].bytes;
@@ -307,8 +308,8 @@ static FORCE_INLINE void tdSetColOfRowNullBySchema(SDataRow row, STSchema *pSche
   setNull(tdGetRowDataOfCol(row, type, offset), type, bytes);
 }
 
-static FORCE_INLINE void tdCopyColOfRowBySchema(SDataRow dst, STSchema *pDstSchema, int dstIdx, SDataRow src,
-                                                STSchema *pSrcSchema, int srcIdx) {
+static FORCE_INLINE void tdCopyColOfRowBySchema(SDataRow dst, STSchema *pDstSchema, int32_t dstIdx, SDataRow src,
+                                                STSchema *pSrcSchema, int32_t srcIdx) {
   int8_t type = pDstSchema->columns[dstIdx].type;
   assert(type == pSrcSchema->columns[srcIdx].type);
   void *pData = tdGetPtrToCol(dst, pDstSchema, dstIdx);
@@ -364,13 +365,13 @@ typedef struct SDataCol {
   uint8_t         bitmap : 1;  // 0: has bitmap if has NULL/NORM rows, 1: no bitmap if all rows are NORM
   uint8_t         reserve : 7;
   int16_t         colId;      // column ID
-  int             bytes;      // column data bytes defined
-  int             offset;     // data offset in a SDataRow (including the header size)
-  int             spaceSize;  // Total space size for this column
-  int             len;        // column data length
+  int32_t         bytes;      // column data bytes defined
+  int32_t         offset;     // data offset in a SDataRow (including the header size)
+  int32_t         spaceSize;  // Total space size for this column
+  int32_t         len;        // column data length
   VarDataOffsetT *dataOff;    // For binary and nchar data, the offset in the data column
-  void *          pData;      // Actual data pointer
-  void *          pBitmap;    // Bitmap pointer
+  void           *pData;      // Actual data pointer
+  void           *pBitmap;    // Bitmap pointer
   TSKEY           ts;         // only used in last NULL column
 } SDataCol;
 
@@ -378,17 +379,17 @@ typedef struct SDataCol {
 #define isAllRowsNone(pCol) ((pCol)->len == 0)
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }
 
-int tdAllocMemForCol(SDataCol *pCol, int maxPoints);
+int32_t tdAllocMemForCol(SDataCol *pCol, int32_t maxPoints);
 
-void dataColInit(SDataCol *pDataCol, STColumn *pCol, int maxPoints);
-int  dataColAppendVal(SDataCol *pCol, const void *value, int numOfRows, int maxPoints);
-void *dataColSetOffset(SDataCol *pCol, int nEle);
+void    dataColInit(SDataCol *pDataCol, STColumn *pCol, int32_t maxPoints);
+int32_t dataColAppendVal(SDataCol *pCol, const void *value, int32_t numOfRows, int32_t maxPoints);
+void   *dataColSetOffset(SDataCol *pCol, int32_t nEle);
 
-bool isNEleNull(SDataCol *pCol, int nEle);
+bool isNEleNull(SDataCol *pCol, int32_t nEle);
 
 #if 0
 // Get the data pointer from a column-wised data
-static FORCE_INLINE const void *tdGetColDataOfRow(SDataCol *pCol, int row) {
+static FORCE_INLINE const void *tdGetColDataOfRow(SDataCol *pCol, int32_t row) {
   if (isAllRowsNull(pCol)) {
     return getNullValue(pCol->type);
   }
@@ -399,7 +400,7 @@ static FORCE_INLINE const void *tdGetColDataOfRow(SDataCol *pCol, int row) {
   }
 }
 
-static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int rows) {
+static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int32_t rows) {
   assert(rows > 0);
 
   if (IS_VAR_DATA_TYPE(pDataCol->type)) {
@@ -412,9 +413,9 @@ static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int rows) {
 typedef struct {
   col_id_t  maxCols;    // max number of columns
   col_id_t  numOfCols;  // Total number of cols
-  int       maxPoints;  // max number of points
-  int       numOfRows;
-  int       sversion;  // TODO: set sversion
+  int32_t   maxPoints;  // max number of points
+  int32_t   numOfRows;
+  int32_t   sversion;  // TODO: set sversion
   SDataCol *cols;
 } SDataCols;
 
@@ -429,7 +430,7 @@ static FORCE_INLINE TKEY dataColsTKeyFirst(SDataCols *pCols) {
   }
 }
 
-static FORCE_INLINE TSKEY dataColsKeyAtRow(SDataCols *pCols, int row) {
+static FORCE_INLINE TSKEY dataColsKeyAtRow(SDataCols *pCols, int32_t row) {
   assert(row < pCols->numOfRows);
   return dataColsKeyAt(pCols, row);
 }
@@ -458,12 +459,12 @@ static FORCE_INLINE TSKEY dataColsKeyLast(SDataCols *pCols) {
   }
 }
 
-SDataCols *tdNewDataCols(int maxCols, int maxRows);
+SDataCols *tdNewDataCols(int32_t maxCols, int32_t maxRows);
 void       tdResetDataCols(SDataCols *pCols);
-int        tdInitDataCols(SDataCols *pCols, STSchema *pSchema);
+int32_t    tdInitDataCols(SDataCols *pCols, STSchema *pSchema);
 SDataCols *tdDupDataCols(SDataCols *pCols, bool keepData);
 SDataCols *tdFreeDataCols(SDataCols *pCols);
-int        tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset, bool forceSetNull);
+int32_t tdMergeDataCols(SDataCols *target, SDataCols *source, int32_t rowsToMerge, int32_t *pOffset, bool forceSetNull);
 
 // ----------------- K-V data row structure
 /* |<-------------------------------------- len -------------------------------------------->|
@@ -501,12 +502,12 @@ typedef struct {
 #define kvRowDeleted(r)        TKEY_IS_DELETED(kvRowTKey(r))
 
 SKVRow  tdKVRowDup(SKVRow row);
-int    tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value);
-int    tdEncodeKVRow(void **buf, SKVRow row);
-void * tdDecodeKVRow(void *buf, SKVRow *row);
+int32_t tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value);
+int32_t tdEncodeKVRow(void **buf, SKVRow row);
+void   *tdDecodeKVRow(void *buf, SKVRow *row);
 void    tdSortKVRowByColIdx(SKVRow row);
 
-static FORCE_INLINE int comparTagId(const void *key1, const void *key2) {
+static FORCE_INLINE int32_t comparTagId(const void *key1, const void *key2) {
   if (*(int16_t *)key1 > ((SColIdx *)key2)->colId) {
     return 1;
   } else if (*(int16_t *)key1 < ((SColIdx *)key2)->colId) {
@@ -528,7 +529,7 @@ static FORCE_INLINE void *tdGetKVRowIdxOfCol(SKVRow row, int16_t colId) {
 
 #if 0
 // offset here not include kvRow header length
-static FORCE_INLINE int tdAppendKvColVal(SKVRow row, const void *value, bool isCopyValData, int16_t colId, int8_t type,
+static FORCE_INLINE int32_t tdAppendKvColVal(SKVRow row, const void *value, bool isCopyValData, int16_t colId, int8_t type,
                                          int32_t offset) {
   assert(value != NULL);
   int32_t  toffset = offset + TD_KV_ROW_HEAD_SIZE;
@@ -581,15 +582,15 @@ typedef struct {
   SColIdx *pColIdx;
   uint16_t alloc;
   uint16_t size;
-  void *   buf;
+  void    *buf;
 } SKVRowBuilder;
 
-int    tdInitKVRowBuilder(SKVRowBuilder *pBuilder);
+int32_t tdInitKVRowBuilder(SKVRowBuilder *pBuilder);
 void    tdDestroyKVRowBuilder(SKVRowBuilder *pBuilder);
 void    tdResetKVRowBuilder(SKVRowBuilder *pBuilder);
 SKVRow  tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder);
 
-static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, const void *value) {
+static FORCE_INLINE int32_t tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, const void *value) {
   if (pBuilder->nCols >= pBuilder->tCols) {
     pBuilder->tCols *= 2;
     SColIdx *pColIdx = (SColIdx *)realloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
@@ -602,7 +603,7 @@ static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId,
 
   pBuilder->nCols++;
 
-  int tlen = IS_VAR_DATA_TYPE(type) ? varDataTLen(value) : TYPE_BYTES[type];
+  int32_t tlen = IS_VAR_DATA_TYPE(type) ? varDataTLen(value) : TYPE_BYTES[type];
   if (tlen > pBuilder->alloc - pBuilder->size) {
     while (tlen > pBuilder->alloc - pBuilder->size) {
       pBuilder->alloc *= 2;
@@ -736,7 +737,7 @@ static FORCE_INLINE void *tdGetMemRowDataOfColEx(void *row, int16_t colId, int8_
   }
 }
 
-static FORCE_INLINE int tdAppendMemRowColVal(SMemRow row, const void *value, bool isCopyVarData, int16_t colId,
+static FORCE_INLINE int32_t tdAppendMemRowColVal(SMemRow row, const void *value, bool isCopyVarData, int16_t colId,
                                              int8_t type, int32_t offset) {
   if (isDataRow(row)) {
     tdAppendDataColVal(memRowDataBody(row), value, isCopyVarData, type, offset);

include/common/tep.h

-#ifndef TDENGINE_TEP_H
-#define TDENGINE_TEP_H
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_COMMON_EP_H_
+#define _TD_COMMON_EP_H_
+
+#include "tcommon.h"
+#include "tmsg.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-#include "tmsg.h"
-#include "common.h"
-
 typedef struct SCorEpSet {
   int32_t version;
   SEpSet  epSet;
@@ -17,19 +31,16 @@ typedef struct SCorEpSet {
 typedef struct SBlockOrderInfo {
   int32_t          order;
   int32_t          colIndex;
-  SColumnInfoData *pColData;
-//  int32_t          type;
-//  int32_t          bytes;
-//  bool             hasNull;
+  SColumnInfoData* pColData;
 } SBlockOrderInfo;
 
-int  taosGetFqdnPortFromEp(const char *ep, SEp *pEp);
-void addEpIntoEpSet(SEpSet *pEpSet, const char *fqdn, uint16_t port);
+int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp);
+void    addEpIntoEpSet(SEpSet* pEpSet, const char* fqdn, uint16_t port);
 
-bool isEpsetEqual(const SEpSet *s1, const SEpSet *s2);
+bool isEpsetEqual(const SEpSet* s1, const SEpSet* s2);
 
-void   updateEpSet_s(SCorEpSet *pEpSet, SEpSet *pNewEpSet);
-SEpSet getEpSet_s(SCorEpSet *pEpSet);
+void   updateEpSet_s(SCorEpSet* pEpSet, SEpSet* pNewEpSet);
+SEpSet getEpSet_s(SCorEpSet* pEpSet);
 
 #define NBIT                     (3u)
 #define BitPos(_n)               ((_n) & ((1 << NBIT) - 1))
@@ -41,7 +52,8 @@ SEpSet getEpSet_s(SCorEpSet *pEpSet);
     BMCharPos(bm_, r_) |= (1u << (7u - BitPos(r_))); \
   } while (0)
 
-static FORCE_INLINE bool colDataIsNull(const SColumnInfoData* pColumnInfoData, uint32_t totalRows, uint32_t row, SColumnDataAgg* pColAgg) {
+static FORCE_INLINE bool colDataIsNull(const SColumnInfoData* pColumnInfoData, uint32_t totalRows, uint32_t row,
+                                       SColumnDataAgg* pColAgg) {
   if (!pColumnInfoData->hasNull) {
     return false;
   }
@@ -67,22 +79,27 @@ static FORCE_INLINE bool colDataIsNull(const SColumnInfoData* pColumnInfoData, u
   }
 }
 
-#define colDataGet(p1_, r_)                                                          \
+#define BitmapLen(_n)     (((_n) + ((1<<NBIT)-1)) >> NBIT)
+
+
+#define colDataGetData(p1_, r_)                                                          \
   ((IS_VAR_DATA_TYPE((p1_)->info.type)) ? ((p1_)->pData + (p1_)->varmeta.offset[(r_)]) \
                                         : ((p1_)->pData + ((r_) * (p1_)->info.bytes)))
 
 int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, bool isNull);
-int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, const SColumnInfoData* pSource, uint32_t numOfRow2);
+int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, const SColumnInfoData* pSource,
+                        uint32_t numOfRow2);
 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock);
 
-int32_t colDataGetSize(const SColumnInfoData* pColumnInfoData, int32_t numOfRows);
+int32_t colDataGetLength(const SColumnInfoData* pColumnInfoData, int32_t numOfRows);
 void    colDataTrim(SColumnInfoData* pColumnInfoData);
 
 size_t colDataGetNumOfCols(const SSDataBlock* pBlock);
 size_t colDataGetNumOfRows(const SSDataBlock* pBlock);
 
 int32_t      blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
-int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex, int32_t pageSize);
+int32_t      blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex,
+                                int32_t pageSize);
 SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int32_t rowCount);
 
 int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock);
@@ -93,17 +110,20 @@ size_t blockDataGetRowSize(const SSDataBlock* pBlock);
 double blockDataGetSerialRowSize(const SSDataBlock* pBlock);
 size_t blockDataGetSerialMetaSize(const SSDataBlock* pBlock);
 
-size_t blockDataNumOfRowsForSerialize(const SSDataBlock* pBlock, int32_t blockSize);
+SSchema* blockDataExtractSchema(const SSDataBlock* pBlock, int32_t* numOfCols);
 
 int32_t blockDataSort(SSDataBlock* pDataBlock, SArray* pOrderInfo, bool nullFirst);
 int32_t blockDataSort_rv(SSDataBlock* pDataBlock, SArray* pOrderInfo, bool nullFirst);
 
+int32_t      blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRows);
 int32_t      blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
 void         blockDataClearup(SSDataBlock* pDataBlock, bool hasVarCol);
-void   *blockDataDestroy(SSDataBlock *pBlock);
+SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock);
+size_t       blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize);
+void*        blockDataDestroy(SSDataBlock* pBlock);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_TEP_H
+#endif  /*_TD_COMMON_EP_H_*/

include/common/tglobal.h

@@ -16,14 +16,13 @@
 #ifndef _TD_COMMON_GLOBAL_H_
 #define _TD_COMMON_GLOBAL_H_
 
+#include "tarray.h"
+#include "tdef.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tcfg.h"
-#include "tdef.h"
-#include "tarray.h"
-
 // cluster
 extern char     tsFirst[];
 extern char     tsSecond[];
@@ -53,6 +52,13 @@ extern bool    tsEnableSlaveQuery;
 extern bool    tsPrintAuth;
 extern int64_t tsTickPerDay[3];
 
+// monitor
+extern bool     tsEnableMonitor;
+extern int32_t  tsMonitorInterval;
+extern char     tsMonitorFqdn[];
+extern uint16_t tsMonitorPort;
+extern int32_t  tsMonitorMaxLogs;
+
 // query buffer management
 extern int32_t tsQueryBufferSize;  // maximum allowed usage buffer size in MB for each data node during query processing
 extern int64_t tsQueryBufferSizeBytes;   // maximum allowed usage buffer size in byte for each data node

include/common/tmsg.h

@@ -16,19 +16,19 @@
 #ifndef _TD_COMMON_TAOS_MSG_H_
 #define _TD_COMMON_TAOS_MSG_H_
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "encode.h"
 #include "taosdef.h"
 #include "taoserror.h"
 #include "tarray.h"
 #include "tcoding.h"
+#include "tencode.h"
 #include "thash.h"
 #include "tlist.h"
 #include "trow.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* ------------------------ MESSAGE DEFINITIONS ------------------------ */
 #define TD_MSG_NUMBER_
 #undef TD_MSG_DICT_
@@ -49,7 +49,7 @@ extern "C" {
 #include "tmsgdef.h"
 
 extern char*   tMsgInfo[];
-extern int   tMsgDict[];
+extern int32_t tMsgDict[];
 
 #define TMSG_SEG_CODE(TYPE) (((TYPE)&0xff00) >> 8)
 #define TMSG_SEG_SEQ(TYPE)  ((TYPE)&0xff)
@@ -167,6 +167,7 @@ typedef struct {
 
 typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
+  int64_t dbId;
   int32_t vgVersion;
 } SBuildUseDBInput;
 
@@ -563,6 +564,7 @@ int32_t tDeserializeSDropDbRsp(void* buf, int32_t bufLen, SDropDbRsp* pRsp);
 
 typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
+  int64_t dbId;
   int32_t vgVersion;
 } SUseDbReq;
 
@@ -737,6 +739,9 @@ typedef struct {
   int32_t  maxRows;
   int32_t  commitTime;
   int32_t  fsyncPeriod;
+  uint32_t hashBegin;
+  uint32_t hashEnd;
+  int8_t   hashMethod;  
   int8_t   walLevel;
   int8_t   precision;
   int8_t   compression;
@@ -747,6 +752,7 @@ typedef struct {
   int8_t   selfIndex;
   int8_t   streamMode;
   SReplica replicas[TSDB_MAX_REPLICA];
+  
 } SCreateVnodeReq, SAlterVnodeReq;
 
 int32_t tSerializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq);
@@ -1117,13 +1123,13 @@ typedef struct {
   SArray* topicNames;  // SArray<char*>
 } SCMSubscribeReq;
 
-static FORCE_INLINE int tSerializeSCMSubscribeReq(void** buf, const SCMSubscribeReq* pReq) {
-  int tlen = 0;
+static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubscribeReq* pReq) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pReq->topicNum);
   tlen += taosEncodeFixedI64(buf, pReq->consumerId);
   tlen += taosEncodeString(buf, pReq->consumerGroup);
 
-  for (int i = 0; i < pReq->topicNum; i++) {
+  for (int32_t i = 0; i < pReq->topicNum; i++) {
     tlen += taosEncodeString(buf, (char*)taosArrayGetP(pReq->topicNames, i));
   }
   return tlen;
@@ -1134,7 +1140,7 @@ static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq
   buf = taosDecodeFixedI64(buf, &pReq->consumerId);
   buf = taosDecodeString(buf, &pReq->consumerGroup);
   pReq->topicNames = taosArrayInit(pReq->topicNum, sizeof(void*));
-  for (int i = 0; i < pReq->topicNum; i++) {
+  for (int32_t i = 0; i < pReq->topicNum; i++) {
     char* name;
     buf = taosDecodeString(buf, &name);
     taosArrayPush(pReq->topicNames, &name);
@@ -1153,10 +1159,10 @@ typedef struct {
   SMqSubTopic topics[];
 } SCMSubscribeRsp;
 
-static FORCE_INLINE int tSerializeSCMSubscribeRsp(void** buf, const SCMSubscribeRsp* pRsp) {
-  int tlen = 0;
+static FORCE_INLINE int32_t tSerializeSCMSubscribeRsp(void** buf, const SCMSubscribeRsp* pRsp) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pRsp->topicNum);
-  for (int i = 0; i < pRsp->topicNum; i++) {
+  for (int32_t i = 0; i < pRsp->topicNum; i++) {
     tlen += taosEncodeFixedI32(buf, pRsp->topics[i].vgId);
     tlen += taosEncodeFixedI64(buf, pRsp->topics[i].topicId);
     tlen += taosEncodeSEpSet(buf, &pRsp->topics[i].epSet);
@@ -1166,7 +1172,7 @@ static FORCE_INLINE int tSerializeSCMSubscribeRsp(void** buf, const SCMSubscribe
 
 static FORCE_INLINE void* tDeserializeSCMSubscribeRsp(void* buf, SCMSubscribeRsp* pRsp) {
   buf = taosDecodeFixedI32(buf, &pRsp->topicNum);
-  for (int i = 0; i < pRsp->topicNum; i++) {
+  for (int32_t i = 0; i < pRsp->topicNum; i++) {
     buf = taosDecodeFixedI32(buf, &pRsp->topics[i].vgId);
     buf = taosDecodeFixedI64(buf, &pRsp->topics[i].topicId);
     buf = taosDecodeSEpSet(buf, &pRsp->topics[i].epSet);
@@ -1184,8 +1190,8 @@ typedef struct {
   char*   physicalPlan;
 } SMVSubscribeReq;
 
-static FORCE_INLINE int tSerializeSMVSubscribeReq(void** buf, SMVSubscribeReq* pReq) {
-  int tlen = 0;
+static FORCE_INLINE int32_t tSerializeSMVSubscribeReq(void** buf, SMVSubscribeReq* pReq) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI64(buf, pReq->topicId);
   tlen += taosEncodeFixedI64(buf, pReq->consumerId);
   tlen += taosEncodeFixedI64(buf, pReq->consumerGroupId);
@@ -1380,8 +1386,6 @@ typedef struct SMqCMGetSubEpReq {
   char    cgroup[TSDB_CONSUMER_GROUP_LEN];
 } SMqCMGetSubEpReq;
 
-#pragma pack(pop)
-
 static FORCE_INLINE int32_t tEncodeSMsgHead(void** buf, const SMsgHead* pMsg) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pMsg->contLen);
@@ -1397,8 +1401,8 @@ typedef struct SMqHbRsp {
   SEpSet epSet;
 } SMqHbRsp;
 
-static FORCE_INLINE int taosEncodeSMqHbRsp(void** buf, const SMqHbRsp* pRsp) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeSMqHbRsp(void** buf, const SMqHbRsp* pRsp) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pRsp->status);
   tlen += taosEncodeFixedI8(buf, pRsp->vnodeChanged);
   tlen += taosEncodeFixedI8(buf, pRsp->epChanged);
@@ -1419,8 +1423,8 @@ typedef struct SMqHbOneTopicBatchRsp {
   SArray* rsps;  // SArray<SMqHbRsp>
 } SMqHbOneTopicBatchRsp;
 
-static FORCE_INLINE int taosEncodeSMqHbOneTopicBatchRsp(void** buf, const SMqHbOneTopicBatchRsp* pBatchRsp) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeSMqHbOneTopicBatchRsp(void** buf, const SMqHbOneTopicBatchRsp* pBatchRsp) {
+  int32_t tlen = 0;
   tlen += taosEncodeString(buf, pBatchRsp->topicName);
   int32_t sz = taosArrayGetSize(pBatchRsp->rsps);
   tlen += taosEncodeFixedI32(buf, sz);
@@ -1449,8 +1453,8 @@ typedef struct SMqHbBatchRsp {
   SArray* batchRsps;  // SArray<SMqHbOneTopicBatchRsp>
 } SMqHbBatchRsp;
 
-static FORCE_INLINE int taosEncodeSMqHbBatchRsp(void** buf, const SMqHbBatchRsp* pBatchRsp) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeSMqHbBatchRsp(void** buf, const SMqHbBatchRsp* pBatchRsp) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI64(buf, pBatchRsp->consumerId);
   int32_t sz;
   tlen += taosEncodeFixedI32(buf, sz);
@@ -1591,8 +1595,8 @@ typedef struct SMqHbVgInfo {
   int32_t vgId;
 } SMqHbVgInfo;
 
-static FORCE_INLINE int taosEncodeSMqVgInfo(void** buf, const SMqHbVgInfo* pVgInfo) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeSMqVgInfo(void** buf, const SMqHbVgInfo* pVgInfo) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pVgInfo->vgId);
   return tlen;
 }
@@ -1609,8 +1613,8 @@ typedef struct SMqHbTopicInfo {
   SArray* pVgInfo;
 } SMqHbTopicInfo;
 
-static FORCE_INLINE int taosEncodeSMqHbTopicInfoMsg(void** buf, const SMqHbTopicInfo* pTopicInfo) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeSMqHbTopicInfoMsg(void** buf, const SMqHbTopicInfo* pTopicInfo) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pTopicInfo->epoch);
   tlen += taosEncodeFixedI64(buf, pTopicInfo->topicUid);
   tlen += taosEncodeString(buf, pTopicInfo->name);
@@ -1645,14 +1649,14 @@ typedef struct SMqHbMsg {
   SArray* pTopics;  // SArray<SMqHbTopicInfo>
 } SMqHbMsg;
 
-static FORCE_INLINE int taosEncodeSMqMsg(void** buf, const SMqHbMsg* pMsg) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeSMqMsg(void** buf, const SMqHbMsg* pMsg) {
+  int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pMsg->status);
   tlen += taosEncodeFixedI32(buf, pMsg->epoch);
   tlen += taosEncodeFixedI64(buf, pMsg->consumerId);
   int32_t sz = taosArrayGetSize(pMsg->pTopics);
   tlen += taosEncodeFixedI32(buf, sz);
-  for (int i = 0; i < sz; i++) {
+  for (int32_t i = 0; i < sz; i++) {
     SMqHbTopicInfo* topicInfo = (SMqHbTopicInfo*)taosArrayGet(pMsg->pTopics, i);
     tlen += taosEncodeSMqHbTopicInfoMsg(buf, topicInfo);
   }
@@ -1666,7 +1670,7 @@ static FORCE_INLINE void* taosDecodeSMqMsg(void* buf, SMqHbMsg* pMsg) {
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
   pMsg->pTopics = taosArrayInit(sz, sizeof(SMqHbTopicInfo));
-  for (int i = 0; i < sz; i++) {
+  for (int32_t i = 0; i < sz; i++) {
     SMqHbTopicInfo topicInfo;
     buf = taosDecodeSMqHbTopicInfoMsg(buf, &topicInfo);
     taosArrayPush(pMsg->pTopics, &topicInfo);
@@ -1851,6 +1855,12 @@ typedef struct {
   SMqTbData* tbData;
 } SMqTopicData;
 
+typedef struct {
+  int8_t  mqMsgType;
+  int32_t code;
+  int32_t epoch;
+} SMqRspHead;
+
 typedef struct {
   int64_t         consumerId;
   SSchemaWrapper* schemas;
@@ -1867,6 +1877,7 @@ typedef struct {
 
   int64_t consumerId;
   int64_t blockingTime;
+  int32_t epoch;
   char    cgroup[TSDB_CONSUMER_GROUP_LEN];
 
   int64_t currentOffset;
@@ -1886,11 +1897,19 @@ typedef struct {
 
 typedef struct {
   int64_t consumerId;
-  int32_t epoch;
   char    cgroup[TSDB_CONSUMER_GROUP_LEN];
   SArray* topics;  // SArray<SMqSubTopicEp>
 } SMqCMGetSubEpRsp;
 
+struct tmq_message_t {
+  SMqRspHead head;
+  union {
+    SMqConsumeRsp    consumeRsp;
+    SMqCMGetSubEpRsp getEpRsp;
+  };
+  void* extra;
+};
+
 static FORCE_INLINE void tDeleteSMqSubTopicEp(SMqSubTopicEp* pSubTopicEp) { taosArrayDestroy(pSubTopicEp->vgs); }
 
 static FORCE_INLINE int32_t tEncodeSMqSubVgEp(void** buf, const SMqSubVgEp* pVgEp) {
@@ -1943,7 +1962,6 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE
 static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSubEpRsp* pRsp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
-  tlen += taosEncodeFixedI32(buf, pRsp->epoch);
   tlen += taosEncodeString(buf, pRsp->cgroup);
   int32_t sz = taosArrayGetSize(pRsp->topics);
   tlen += taosEncodeFixedI32(buf, sz);
@@ -1956,7 +1974,6 @@ static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSu
 
 static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* pRsp) {
   buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
-  buf = taosDecodeFixedI32(buf, &pRsp->epoch);
   buf = taosDecodeStringTo(buf, pRsp->cgroup);
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
@@ -1972,6 +1989,8 @@ static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* p
   return buf;
 }
 
+#pragma pack(pop)
+
 #ifdef __cplusplus
 }
 #endif

include/common/tmsgdef.h

@@ -47,7 +47,7 @@ enum {
 #define TD_NEW_MSG_SEG(TYPE) TYPE##_NUM,
 #define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP)
 
-int tMsgDict[] = {
+int32_t tMsgDict[] = {
 
 #elif defined(TD_MSG_SEG_CODE_)
 
@@ -127,7 +127,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_STB, "mnode-create-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_STB, "mnode-alter-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_STB, "mnode-drop-stb", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_STB_META, "mnode-stb-meta", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TABLE_META, "mnode-table-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_VGROUP_LIST, "mnode-vgroup-list", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_QUERY, "mnode-kill-query", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_CONN, "mnode-kill-conn", NULL, NULL)

include/common/tname.h

@@ -13,17 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TNAME_H
-#define TDENGINE_TNAME_H
+#ifndef _TD_COMMON_NAME_H_
+#define _TD_COMMON_NAME_H_
+
+#include "tdef.h"
+#include "tmsg.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
-#include "tdef.h"
-#include "tmsg.h"
-
 #define TSDB_DB_NAME_T    1
 #define TSDB_TABLE_NAME_T 2
 
@@ -32,7 +31,7 @@ extern "C" {
 #define T_NAME_TABLE 0x4u
 
 typedef struct SName {
-  uint8_t type;  //db_name_t, table_name_t
+  uint8_t type;  // db_name_t, table_name_t
   int32_t acctId;
   char    dbname[TSDB_DB_NAME_LEN];
   char    tname[TSDB_TABLE_NAME_LEN];
@@ -68,5 +67,4 @@ SSchema createSchema(uint8_t type, int32_t bytes, int32_t colId, const char* nam
 }
 #endif
 
-
-#endif  // TDENGINE_TNAME_H
+#endif  /*_TD_COMMON_NAME_H_*/

include/common/trequest.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_TREQUEST_H_
-#define _TD_TREQUEST_H_
+#ifndef _TD_COMMON_REQUEST_H_
+#define _TD_COMMON_REQUEST_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -36,7 +36,7 @@ void            tdClearRBIter(SReqBatchIter *pIter);
 
 /* ------------------------ TYPES DEFINITION ------------------------ */
 struct SReqBatchIter {
-  int        iReq;
+  int32_t    iReq;
   SReqBatch *pReqBatch;
 };
 
@@ -44,4 +44,4 @@ struct SReqBatchIter {
 }
 #endif
 
-#endif /*_TD_TREQUEST_H_*/
+#endif /*_TD_COMMON_REQUEST_H_*/
\ No newline at end of file

include/common/trow.h

@@ -18,11 +18,11 @@
 
 #include "os.h"
 #include "talgo.h"
+#include "taosdef.h"
 #include "taoserror.h"
 #include "tbuffer.h"
-#include "tdef.h"
-#include "taosdef.h"
 #include "tdataformat.h"
+#include "tdef.h"
 #include "tschema.h"
 #include "ttypes.h"
 #include "tutil.h"
@@ -98,7 +98,7 @@ typedef void *SRow;
 
 typedef struct {
   TDRowValT valType;
-  void *    val;
+  void     *val;
 } SCellVal;
 
 typedef struct {
@@ -157,8 +157,8 @@ typedef struct {
   int16_t nBitmaps;
   int16_t nBoundBitmaps;
   int32_t offset;
-  void *  pBitmap;
-  void *  pOffset;
+  void   *pBitmap;
+  void   *pOffset;
   int32_t extendedRowSize;
 } SRowBuilder;
 
@@ -176,7 +176,7 @@ typedef struct {
 #define TD_ROW_KEY_ADDR(r) POINTER_SHIFT((r), 16)
 
 // N.B. If without STSchema, getExtendedRowSize() is used to get the rowMaxBytes and
-// (int)ceil((double)nCols/TD_VTYPE_PARTS) should be added if TD_SUPPORT_BITMAP defined.
+// (int32_t)ceil((double)nCols/TD_VTYPE_PARTS) should be added if TD_SUPPORT_BITMAP defined.
 #define TD_ROW_MAX_BYTES_FROM_SCHEMA(s) (schemaTLen(s) + TD_ROW_HEAD_LEN)
 
 #define TD_ROW_SET_TYPE(r, t)  (TD_ROW_TYPE(r) = (t))
@@ -217,7 +217,7 @@ static FORCE_INLINE void    tdRowCopy(void *dst, STSRow *row) { memcpy(dst, row,
 static FORCE_INLINE int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT valType);
 int32_t                     tdSetBitmapValTypeN(void *pBitmap, int16_t nEle, TDRowValT valType);
 static FORCE_INLINE int32_t tdGetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT *pValType);
-int tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int numOfRows, int maxPoints);
+int32_t tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int32_t numOfRows, int32_t maxPoints);
 static FORCE_INLINE int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val,
                                                   bool isCopyVarData, int8_t colType, int16_t colIdx, int32_t offset);
 static FORCE_INLINE int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val,
@@ -272,7 +272,7 @@ static FORCE_INLINE int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TD
   }
   int16_t nBytes = colIdx / TD_VTYPE_PARTS;
   int16_t nOffset = colIdx & TD_VTYPE_OPTR;
-  char *  pDestByte = (char *)POINTER_SHIFT(pBitmap, nBytes);
+  char   *pDestByte = (char *)POINTER_SHIFT(pBitmap, nBytes);
   switch (nOffset) {
     case 0:
       *pDestByte = ((*pDestByte) & 0x3F) | (valType << 6);
@@ -310,7 +310,7 @@ static FORCE_INLINE int32_t tdGetBitmapValType(void *pBitmap, int16_t colIdx, TD
   }
   int16_t nBytes = colIdx / TD_VTYPE_PARTS;
   int16_t nOffset = colIdx & TD_VTYPE_OPTR;
-  char *  pDestByte = (char *)POINTER_SHIFT(pBitmap, nBytes);
+  char   *pDestByte = (char *)POINTER_SHIFT(pBitmap, nBytes);
   switch (nOffset) {
     case 0:
       *pValType = (((*pDestByte) & 0xC0) >> 6);
@@ -355,7 +355,6 @@ static FORCE_INLINE int32_t tdGetBitmapValType(void *pBitmap, int16_t colIdx, TD
  *
  */
 
-
 /**
  * @brief
  *
@@ -432,7 +431,6 @@ static FORCE_INLINE int32_t tdSRowSetExtendedInfo(SRowBuilder *pBuilder, int32_t
       pBuilder->rowType = TD_ROW_TP;
     }
 
-
   } else {
     pBuilder->rowType = TD_ROW_TP;
   }
@@ -618,7 +616,7 @@ static FORCE_INLINE int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowVa
   if (tdValIsNorm(valType, val, colType)) {
     // ts key stored in STSRow.ts
     SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
-    char *     ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
+    char      *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
     pColIdx->colId = colId;
     pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
 
@@ -636,7 +634,7 @@ static FORCE_INLINE int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowVa
   // NULL/None value
   else {
     SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
-    char *     ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
+    char      *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
     pColIdx->colId = colId;
     pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
     const void *nullVal = getNullValue(colType);
@@ -731,7 +729,7 @@ static FORCE_INLINE int32_t tdGetTpRowValOfCol(SCellVal *output, STSRow *pRow, v
   return TSDB_CODE_SUCCESS;
 }
 
-static FORCE_INLINE int compareKvRowColId(const void *key1, const void *key2) {
+static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2) {
   if (*(int16_t *)key1 > ((SColIdx *)key2)->colId) {
     return 1;
   } else if (*(int16_t *)key1 < ((SColIdx *)key2)->colId) {
@@ -772,8 +770,8 @@ static FORCE_INLINE int32_t tdGetKvRowValOfCol(SCellVal *output, STSRow *pRow, v
 
 typedef struct {
   STSchema *pSchema;
-  STSRow *  pRow;
-  void *    pBitmap;
+  STSRow   *pRow;
+  void     *pBitmap;
   uint32_t  offset;
   col_id_t  maxColId;
   col_id_t  colIdx;  // [PRIMARYKEY_TIMESTAMP_COL_ID, nSchemaCols], PRIMARYKEY_TIMESTAMP_COL_ID equals 1
@@ -793,8 +791,8 @@ static FORCE_INLINE void tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema)
   pIter->maxColId = pSchema->columns[pSchema->numOfCols - 1].colId;
 }
 
-static int tdCompareColId(const void *arg1, const void *arg2) {
-  int       colId = *(int *)arg1;
+static int32_t tdCompareColId(const void *arg1, const void *arg2) {
+  int32_t   colId = *(int32_t *)arg1;
   STColumn *pCol = (STColumn *)arg2;
 
   if (colId < pCol->colId) {
@@ -878,7 +876,7 @@ static FORCE_INLINE bool tdGetTpRowDataOfCol(STSRowIter *pIter, col_type_t colTy
 // internal
 static FORCE_INLINE bool tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType, col_id_t *nIdx,
                                               SCellVal *pVal) {
-  STSRow *   pRow = pIter->pRow;
+  STSRow    *pRow = pIter->pRow;
   SKvRowIdx *pKvIdx = NULL;
   bool       colFound = false;
   col_id_t   kvNCols = tdRowGetNCols(pRow);
@@ -959,11 +957,11 @@ static FORCE_INLINE bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col
 STSRow *mergeTwoRows(void *buffer, STSRow *row1, STSRow *row2, STSchema *pSchema1, STSchema *pSchema2);
 
 // Get the data pointer from a column-wised data
-static FORCE_INLINE int32_t tdGetColDataOfRow(SCellVal *pVal, SDataCol *pCol, int row) {
+static FORCE_INLINE int32_t tdGetColDataOfRow(SCellVal *pVal, SDataCol *pCol, int32_t row) {
   if (isAllRowsNone(pCol)) {
     pVal->valType = TD_VTYPE_NULL;
 #ifdef TD_SUPPORT_READ2
-    pVal->val = (void*)getNullValue(pCol->type);
+    pVal->val = (void *)getNullValue(pCol->type);
 #else
     pVal->val = NULL;
 #endif
@@ -981,7 +979,7 @@ static FORCE_INLINE int32_t tdGetColDataOfRow(SCellVal *pVal, SDataCol *pCol, in
   } else {
     pVal->valType = TD_VTYPE_NULL;
 #ifdef TD_SUPPORT_READ2
-    pVal->val = (void*)getNullValue(pCol->type);
+    pVal->val = (void *)getNullValue(pCol->type);
 #else
     pVal->val = NULL;
 #endif
@@ -1000,7 +998,8 @@ static FORCE_INLINE bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t
   return true;
 }
 
-static FORCE_INLINE bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, uint32_t offset, col_id_t colIdx, SCellVal *pVal) {
+static FORCE_INLINE bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, uint32_t offset, col_id_t colIdx,
+                                        SCellVal *pVal) {
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     tdRowSetVal(pVal, TD_VTYPE_NORM, TD_ROW_KEY_ADDR(pRow));
     return true;
@@ -1010,7 +1009,7 @@ static FORCE_INLINE bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, uint32_t o
   return true;
 }
 
-static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int rows) {
+static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int32_t rows) {
   ASSERT(rows > 0);
   int32_t result = 0;
 
@@ -1068,7 +1067,7 @@ typedef struct {
 
 typedef struct {
   STSchema *pSchema;
-  STSRow *  pRow;
+  STSRow   *pRow;
 } STSRowReader;
 
 typedef struct {
@@ -1082,12 +1081,12 @@ typedef struct {
 void    trbSetRowInfo(STSRowBuilder *pRB, bool del, uint16_t sver);
 void    trbSetRowVersion(STSRowBuilder *pRB, uint64_t ver);
 void    trbSetRowTS(STSRowBuilder *pRB, TSKEY ts);
-int  trbWriteCol(STSRowBuilder *pRB, void *pData, col_id_t cid);
+int32_t trbWriteCol(STSRowBuilder *pRB, void *pData, col_id_t cid);
 
 // STSRowReader
 #define tRowReaderInit(schema, row) \
   { .schema = (schema), .row = (row) }
-int tRowReaderRead(STSRowReader *pRowReader, col_id_t cid, void *target, uint64_t size);
+int32_t tRowReaderRead(STSRowReader *pRowReader, col_id_t cid, void *target, uint64_t size);
 
 // STSRowBatchIter
 #define tRowBatchIterInit(pRB) \

include/common/tschema.h

@@ -70,7 +70,7 @@ typedef struct {
   { .size = (capacity), .pSchema = (target) }
 void tSchemaBuilderSetSver(STShemaBuilder *pSchemaBuilder, uint16_t sver);
 void tSchemaBuilderSetSMA(bool sma, SArray *smaArray);
-int  tSchemaBuilderPutColumn(char *cname, bool sma, uint8_t type, col_id_t cid, uint32_t bytes, char *comment);
+int32_t  tSchemaBuilderPutColumn(char *cname, bool sma, uint8_t type, col_id_t cid, uint32_t bytes, char *comment);
 
 #endif
 

include/common/ttime.h

@@ -16,13 +16,13 @@
 #ifndef _TD_COMMON_TIME_H_
 #define _TD_COMMON_TIME_H_
 
+#include "taosdef.h"
+#include "tmsg.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "taosdef.h"
-#include "tmsg.h"
-
 #define TIME_IS_VAR_DURATION(_t) ((_t) == 'n' || (_t) == 'y' || (_t) == 'N' || (_t) == 'Y')
 
 /*
@@ -35,7 +35,7 @@ static FORCE_INLINE int64_t taosGetTimestamp(int32_t precision) {
     return taosGetTimestampUs();
   } else if (precision == TSDB_TIME_PRECISION_NANO) {
     return taosGetTimestampNs();
-  }else {
+  } else {
     return taosGetTimestampMs();
   }
 }
@@ -52,6 +52,8 @@ void    deltaToUtcInitOnce();
 
 int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision);
 
+void taosFormatUtcTime(char *buf, int32_t bufLen, int64_t time, int32_t precision);
+
 #ifdef __cplusplus
 }
 #endif

include/common/ttokendef.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TTOKENDEF_H
-#define TDENGINE_TTOKENDEF_H
+#ifndef _TD_COMMON_TOKEN_H_
+#define _TD_COMMON_TOKEN_H_
 
 #define TK_ID           1
 #define TK_BOOL         2
@@ -291,6 +291,4 @@
 
 #define TK_NIL 65535
 
-#endif
-
-
+#endif /*_TD_COMMON_TOKEN_H_*/

include/common/ttszip.h

@@ -13,17 +13,17 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TTSZIP_H
-#define TDENGINE_TTSZIP_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef _TD_COMMON_TTSZIP_H_
+#define _TD_COMMON_TTSZIP_H_
 
 #include "os.h"
 #include "tdef.h"
 #include "tvariant.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define MEM_BUF_SIZE           (1 << 20)
 #define TS_COMP_FILE_MAGIC     0x87F5EC4C
 #define TS_COMP_FILE_GROUP_MAX 512
@@ -144,4 +144,4 @@ bool tsBufIsValidElem(STSElem* pElem);
 }
 #endif
 
-#endif  // TDENGINE_TTSZIP_H
+#endif  /*_TD_COMMON_TTSZIP_H_*/

include/common/ttypes.h

-#ifndef TDENGINE_TTYPE_H
-#define TDENGINE_TTYPE_H
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_COMMON_TTYPE_H_
+#define _TD_COMMON_TTYPE_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -15,11 +30,6 @@ typedef uint8_t  TDRowValT;
 typedef uint16_t col_id_t;
 typedef int8_t   col_type_t;
 
-typedef struct tstr {
-  VarDataLenT len;
-  char        data[];
-} tstr;
-
 #pragma pack(push, 1)
 typedef struct {
   VarDataLenT len;
@@ -33,15 +43,14 @@ typedef struct {
 #pragma pack(pop)
 
 #define varDataTLen(v)         (sizeof(VarDataLenT) + varDataLen(v))
-#define varDataCopy(dst, v) memcpy((dst), (void*) (v), varDataTLen(v))
-#define varDataLenByData(v) (*(VarDataLenT *)(((char*)(v)) - VARSTR_HEADER_SIZE))
-#define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT) (_len))
+#define varDataCopy(dst, v)    memcpy((dst), (void *)(v), varDataTLen(v))
+#define varDataLenByData(v)    (*(VarDataLenT *)(((char *)(v)) - VARSTR_HEADER_SIZE))
+#define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT)(_len))
 #define IS_VAR_DATA_TYPE(t)    (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
 #define varDataNetLen(v)  (htons(((VarDataLenT *)(v))[0]))
 #define varDataNetTLen(v) (sizeof(VarDataLenT) + varDataNetLen(v))
 
-
 // this data type is internally used only in 'in' query to hold the values
 #define TSDB_DATA_TYPE_POINTER_ARRAY (1000)
 #define TSDB_DATA_TYPE_VALUE_ARRAY   (1001)
@@ -62,7 +71,7 @@ typedef struct {
       case TSDB_DATA_TYPE_USMALLINT:                 \
         (_v) = (_finalType)GET_UINT16_VAL(_data);    \
         break;                                       \
-      case TSDB_DATA_TYPE_TIMESTAMP:\
+      case TSDB_DATA_TYPE_TIMESTAMP:                 \
       case TSDB_DATA_TYPE_BIGINT:                    \
         (_v) = (_finalType)(GET_INT64_VAL(_data));   \
         break;                                       \
@@ -146,7 +155,8 @@ typedef struct {
 #define IS_VALID_FLOAT(_t)     ((_t) >= -FLT_MAX && (_t) <= FLT_MAX)
 #define IS_VALID_DOUBLE(_t)    ((_t) >= -DBL_MAX && (_t) <= DBL_MAX)
 
-#define IS_CONVERT_AS_SIGNED(_t) (IS_SIGNED_NUMERIC_TYPE(_t) || (_t) == (TSDB_DATA_TYPE_BOOL) || (_t) == (TSDB_DATA_TYPE_TIMESTAMP))
+#define IS_CONVERT_AS_SIGNED(_t) \
+  (IS_SIGNED_NUMERIC_TYPE(_t) || (_t) == (TSDB_DATA_TYPE_BOOL) || (_t) == (TSDB_DATA_TYPE_TIMESTAMP))
 #define IS_CONVERT_AS_UNSIGNED(_t) (IS_UNSIGNED_NUMERIC_TYPE(_t) || (_t) == (TSDB_DATA_TYPE_BOOL))
 
 static FORCE_INLINE bool isNull(const void *val, int32_t type) {
@@ -167,17 +177,17 @@ static FORCE_INLINE bool isNull(const void *val, int32_t type) {
     case TSDB_DATA_TYPE_DOUBLE:
       return *(uint64_t *)val == TSDB_DATA_DOUBLE_NULL;
     case TSDB_DATA_TYPE_NCHAR:
-      return varDataLen(val) == sizeof(int32_t) && *(uint32_t*) varDataVal(val) == TSDB_DATA_NCHAR_NULL;
+      return varDataLen(val) == sizeof(int32_t) && *(uint32_t *)varDataVal(val) == TSDB_DATA_NCHAR_NULL;
     case TSDB_DATA_TYPE_BINARY:
-      return varDataLen(val) == sizeof(int8_t) && *(uint8_t *) varDataVal(val) == TSDB_DATA_BINARY_NULL;
+      return varDataLen(val) == sizeof(int8_t) && *(uint8_t *)varDataVal(val) == TSDB_DATA_BINARY_NULL;
     case TSDB_DATA_TYPE_UTINYINT:
-      return *(uint8_t*) val == TSDB_DATA_UTINYINT_NULL;
+      return *(uint8_t *)val == TSDB_DATA_UTINYINT_NULL;
     case TSDB_DATA_TYPE_USMALLINT:
-      return *(uint16_t*) val == TSDB_DATA_USMALLINT_NULL;
+      return *(uint16_t *)val == TSDB_DATA_USMALLINT_NULL;
     case TSDB_DATA_TYPE_UINT:
-      return *(uint32_t*) val == TSDB_DATA_UINT_NULL;
+      return *(uint32_t *)val == TSDB_DATA_UINT_NULL;
     case TSDB_DATA_TYPE_UBIGINT:
-      return *(uint64_t*) val == TSDB_DATA_UBIGINT_NULL;
+      return *(uint64_t *)val == TSDB_DATA_UBIGINT_NULL;
 
     default:
       return false;
@@ -188,32 +198,31 @@ typedef struct tDataTypeDescriptor {
   int16_t type;
   int16_t nameLen;
   int32_t bytes;
-  char *  name;
+  char   *name;
   int64_t minValue;
   int64_t maxValue;
-  int (*compFunc)(const char *const input, int inputSize, const int nelements, char *const output, int outputSize,
-                  char algorithm, char *const buffer, int bufferSize);
-  int (*decompFunc)(const char *const input, int compressedSize, const int nelements, char *const output,
-                    int outputSize, char algorithm, char *const buffer, int bufferSize);
-  void (*statisFunc)(const void *pData, int32_t numofrow, int64_t *min, int64_t *max, int64_t *sum,
-                        int16_t *minindex, int16_t *maxindex, int16_t *numofnull);
+  int32_t (*compFunc)(const char *const input, int32_t inputSize, const int32_t nelements, char *const output,
+                      int32_t outputSize, char algorithm, char *const buffer, int32_t bufferSize);
+  int32_t (*decompFunc)(const char *const input, int32_t compressedSize, const int32_t nelements, char *const output,
+                        int32_t outputSize, char algorithm, char *const buffer, int32_t bufferSize);
+  void (*statisFunc)(const void *pData, int32_t numofrow, int64_t *min, int64_t *max, int64_t *sum, int16_t *minindex,
+                     int16_t *maxindex, int16_t *numofnull);
 } tDataTypeDescriptor;
 
 extern tDataTypeDescriptor tDataTypes[15];
 
 bool isValidDataType(int32_t type);
 
-void  setVardataNull(void* val, int32_t type);
+void        setVardataNull(void *val, int32_t type);
 void        setNull(void *val, int32_t type, int32_t bytes);
 void        setNullN(void *val, int32_t type, int32_t bytes, int32_t numOfElems);
 const void *getNullValue(int32_t type);
 
 void  assignVal(char *val, const char *src, int32_t len, int32_t type);
-void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf);
+void  tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void *buf);
 void  operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type);
-void* getDataMin(int32_t type);
-void* getDataMax(int32_t type);
-
+void *getDataMin(int32_t type);
+void *getDataMax(int32_t type);
 
 #define SET_DOUBLE_NULL(v) (*(uint64_t *)(v) = TSDB_DATA_DOUBLE_NULL)
 #define SET_BIGINT_NULL(v) (*(uint64_t *)(v) = TSDB_DATA_BIGINT_NULL)
@@ -222,4 +231,4 @@ void* getDataMax(int32_t type);
 }
 #endif
 
-#endif  // TDENGINE_TTYPE_H
+#endif  /*_TD_COMMON_TTYPE_H_*/

include/common/tvariant.h

@@ -13,15 +13,15 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TVARIANT_H
-#define TDENGINE_TVARIANT_H
+#ifndef _TD_COMMON_VARIANT_H_
+#define _TD_COMMON_VARIANT_H_
+
+#include "tarray.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tarray.h"
-
 // variant, each number/string/field_id has a corresponding struct during parsing sql
 typedef struct SVariant {
   uint32_t nType;
@@ -36,11 +36,11 @@ typedef struct SVariant {
   };
 } SVariant;
 
-int32_t toInteger(const char* z, int32_t n, int32_t base, int64_t* value, bool* issigned);
+int32_t toInteger(const char *z, int32_t n, int32_t base, int64_t *value, bool *issigned);
 
 bool taosVariantIsValid(SVariant *pVar);
 
-void taosVariantCreate(SVariant *pVar, const char* z, int32_t n, int32_t type);
+void taosVariantCreate(SVariant *pVar, const char *z, int32_t n, int32_t type);
 
 void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uint32_t type);
 
@@ -48,7 +48,7 @@ void taosVariantDestroy(SVariant *pV);
 
 void taosVariantAssign(SVariant *pDst, const SVariant *pSrc);
 
-int32_t taosVariantCompare(const SVariant* p1, const SVariant* p2);
+int32_t taosVariantCompare(const SVariant *p1, const SVariant *p2);
 
 int32_t taosVariantToString(SVariant *pVar, char *dst);
 
@@ -64,4 +64,4 @@ int32_t taosVariantTypeSetType(SVariant *pVariant, char type);
 }
 #endif
 
-#endif  // TDENGINE_TVARIANT_H
+#endif  /*_TD_COMMON_VARIANT_H_*/

include/dnode/mgmt/dnode.h

@@ -17,7 +17,6 @@
 #define _TD_DNODE_H_
 
 #include "tdef.h"
-#include "tcfg.h"
 
 #ifdef __cplusplus
 extern "C" {

include/dnode/mnode/mnode.h

@@ -16,6 +16,8 @@
 #ifndef _TD_MND_H_
 #define _TD_MND_H_
 
+#include "monitor.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -30,20 +32,6 @@ typedef int32_t (*PutReqToMWriteQFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 typedef int32_t (*PutReqToMReadQFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 
-typedef struct SMnodeLoad {
-  int64_t numOfDnode;
-  int64_t numOfMnode;
-  int64_t numOfVgroup;
-  int64_t numOfDatabase;
-  int64_t numOfSuperTable;
-  int64_t numOfChildTable;
-  int64_t numOfNormalTable;
-  int64_t numOfColumn;
-  int64_t totalPoints;
-  int64_t totalStorage;
-  int64_t compStorage;
-} SMnodeLoad;
-
 typedef struct {
   int32_t           dnodeId;
   int64_t           clusterId;
@@ -92,13 +80,16 @@ int32_t mndAlter(SMnode *pMnode, const SMnodeOpt *pOption);
 void mndDestroy(const char *path);
 
 /**
- * @brief Get mnode statistics info.
+ * @brief Get mnode monitor info.
  *
  * @param pMnode The mnode object.
- * @param pLoad Statistics of the mnode.
+ * @param pClusterInfo
+ * @param pVgroupInfo
+ * @param pGrantInfo
  * @return int32_t 0 for success, -1 for failure.
  */
-int32_t mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad);
+int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
+                          SMonGrantInfo *pGrantInfo);
 
 /**
  * @brief Get user authentication info.

include/libs/catalog/catalog.h

@@ -24,7 +24,7 @@ extern "C" {
 #include "taosdef.h"
 #include "query.h"
 #include "tname.h"
-#include "common.h"
+#include "tcommon.h"
 #include "tarray.h"
 #include "thash.h"
 #include "tmsg.h"
@@ -95,7 +95,7 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle);
  */
 void catalogFreeHandle(SCatalog* pCatalog);
 
-int32_t catalogGetDBVgVersion(SCatalog* pCatalog, const char* dbName, int32_t* version);
+int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* version, int64_t* dbId);
 
 /**
  * Get a DB's all vgroup info.

include/libs/executor/executor.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#include "common.h"
+#include "tcommon.h"
 
 typedef void* qTaskInfo_t;
 typedef void* DataSinkHandle;
@@ -31,6 +31,7 @@ typedef struct SReadHandle {
   void* reader;
   void* meta;
 } SReadHandle;
+
  /**
   * Create the exec task for streaming mode
   * @param pMsg
@@ -40,13 +41,23 @@ typedef struct SReadHandle {
 qTaskInfo_t qCreateStreamExecTaskInfo(void *msg, void* streamReadHandle);
 
 /**
- *
+ * Set the input data block for the stream scan.
  * @param tinfo
  * @param input
  * @return
  */
 int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input);
 
+/**
+ * Update the table id list, add or remove.
+ *
+ * @param tinfo
+ * @param id
+ * @param isAdd
+ * @return
+ */
+int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, SArray* tableIdList, bool isAdd);
+
  /**
   * Create the exec task object according to task json
   * @param readHandle

include/libs/function/function.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#include "common.h"
+#include "tcommon.h"
 #include "tvariant.h"
 #include "tbuffer.h"
 
@@ -138,8 +138,10 @@ extern SFunctionFpSet fpSet[1];
 
 // sql function runtime context
 typedef struct SqlFunctionCtx {
+  int32_t      startRow;
   int32_t      size;      // number of rows
-  void *       pInput;    // input data buffer
+  SColumnInfoData* pInput;
+
   uint32_t     order;     // asc|desc
   int16_t      inputType;
   int16_t      inputBytes;
@@ -227,8 +229,13 @@ typedef struct SAggFunctionInfo {
 } SAggFunctionInfo;
 
 typedef struct SScalarParam {
-  void*   data;
-  bool    colData;
+  void            *data;
+  union {
+    SColumnInfoData *columnData;
+    void            *data;
+  } orig;  
+  char            *bitmap;
+  bool             dataInBlock;
   int32_t          num;
   int32_t          type;
   int32_t          bytes;

include/libs/monitor/monitor.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MONITOR_H_
+#define _TD_MONITOR_H_
+
+#include "tarray.h"
+#include "tdef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  int32_t dnode_id;
+  char    dnode_ep[TSDB_EP_LEN];
+} SMonBasicInfo;
+
+typedef struct {
+  int32_t dnode_id;
+  char    dnode_ep[TSDB_EP_LEN];
+  char    status[8];
+} SMonDnodeDesc;
+
+typedef struct {
+  int32_t mnode_id;
+  char    mnode_ep[TSDB_EP_LEN];
+  char    role[8];
+} SMonMnodeDesc;
+
+typedef struct {
+  char    first_ep[TSDB_EP_LEN];
+  int32_t first_ep_dnode_id;
+  char    version[12];
+  float   master_uptime;     // day
+  int32_t monitor_interval;  // sec
+  int32_t vgroups_total;
+  int32_t vgroups_alive;
+  int32_t vnodes_total;
+  int32_t vnodes_alive;
+  int32_t connections_total;
+  SArray *dnodes;  // array of SMonDnodeDesc
+  SArray *mnodes;  // array of SMonMnodeDesc
+} SMonClusterInfo;
+
+typedef struct {
+  int32_t dnode_id;
+  int8_t  vnode_online;
+  char    vnode_role[8];
+} SMonVnodeDesc;
+
+typedef struct {
+  int32_t       vgroup_id;
+  SMonVnodeDesc vnodes[TSDB_MAX_REPLICA];
+} SMonVgroupDesc;
+
+typedef struct {
+  char    database_name[TSDB_DB_NAME_LEN];
+  int32_t tables_num;
+  int8_t  status;
+  SArray *vgroups;  // array of SMonVgroupDesc
+} SMonVgroupInfo;
+
+typedef struct {
+  int32_t expire_time;
+  int32_t timeseries_used;
+  int32_t timeseries_total;
+} SMonGrantInfo;
+
+typedef struct {
+  float   uptime;  // day
+  float   cpu_engine;
+  float   cpu_system;
+  float   cpu_cores;
+  float   mem_engine;     // MB
+  float   mem_system;     // MB
+  float   mem_total;      // MB
+  float   disk_engine;    // GB
+  float   disk_used;      // GB
+  float   disk_total;     // GB
+  float   net_in;         // Kb/s
+  float   net_out;        // Kb/s
+  float   io_read;        // Mb/s
+  float   io_write;       // Mb/s
+  float   io_read_disk;   // Mb/s
+  float   io_write_disk;  // Mb/s
+  int32_t req_select;
+  float   req_select_rate;
+  int32_t req_insert;
+  int32_t req_insert_success;
+  float   req_insert_rate;
+  int32_t req_insert_batch;
+  int32_t req_insert_batch_success;
+  float   req_insert_batch_rate;
+  int32_t errors;
+  int32_t vnodes_num;
+  int32_t masters;
+  int32_t has_mnode;
+} SMonDnodeInfo;
+
+typedef struct {
+  char      name[TSDB_FILENAME_LEN];
+  int32_t   level;
+  SDiskSize size;
+} SMonDiskDesc;
+
+typedef struct {
+  SArray *disks;  // array of SMonDiskDesc
+} SMonDiskInfo;
+
+typedef struct {
+  int64_t ts;
+  int8_t  level;
+  char    content[1024];
+} SMonLogItem;
+
+typedef struct SMonInfo SMonInfo;
+
+typedef struct {
+  const char *server;
+  uint16_t    port;
+  int32_t     maxLogs;
+} SMonCfg;
+
+int32_t monInit(const SMonCfg *pCfg);
+void    monCleanup();
+void    monAddLogItem(SMonLogItem *pItem);
+
+SMonInfo *monCreateMonitorInfo();
+void      monSetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo);
+void      monSetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo);
+void      monSetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo);
+void      monSetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo);
+void      monSetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo);
+void      monSetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo);
+void      monSendReport(SMonInfo *pMonitor);
+void      monCleanupMonitorInfo(SMonInfo *pMonitor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MONITOR_H_*/

include/libs/parser/parsenodes.h

@@ -21,7 +21,7 @@ extern "C" {
 #endif
 
 #include "catalog.h"
-#include "common.h"
+#include "tcommon.h"
 #include "function.h"
 #include "tmsgtype.h"
 #include "tname.h"

include/libs/planner/plannerOp.h

@@ -47,5 +47,6 @@ OP_ENUM_MACRO(AllTimeWindow)
 OP_ENUM_MACRO(AllMultiTableTimeInterval)
 OP_ENUM_MACRO(Order)
 OP_ENUM_MACRO(Exchange)
+OP_ENUM_MACRO(SortedMerge)
 
 //OP_ENUM_MACRO(TableScan)

include/libs/qcom/query.h

@@ -156,6 +156,8 @@ int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code);
  */
 int32_t asyncSendMsgToServer(void *pTransporter, SEpSet* epSet, int64_t* pTransporterId, const SMsgSendInfo* pInfo);
 
+int32_t queryBuildUseDbOutput(SUseDbOutput *pOut, SUseDbRsp *usedbRsp);
+
 void initQueryModuleMsgHandle();
 
 const SSchema* tGetTbnameColumnSchema();

include/libs/scalar/scalar.h

@@ -25,9 +25,17 @@ extern "C" {
 
 typedef struct SFilterInfo SFilterInfo;
 
-
+/*
+pNode will be freed in API;
+*pRes need to freed in caller
+*/
 int32_t scalarCalculateConstants(SNode *pNode, SNode **pRes);
-int32_t scalarCalculate(SNode *pNode, SSDataBlock *pSrc, SScalarParam *pDst);
+
+/* 
+pDst need to freed in caller 
+*/
+int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst);
+
 int32_t scalarGetOperatorParamNum(EOperatorType type);
 int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type);
 

include/libs/sync/sync.h

@@ -21,7 +21,9 @@ extern "C" {
 #endif
 
 #include <stdint.h>
+#include <tep.h>
 #include "taosdef.h"
+#include "trpc.h"
 
 typedef uint64_t SyncNodeId;
 typedef int32_t  SyncGroupId;
@@ -32,25 +34,27 @@ typedef enum {
   TAOS_SYNC_STATE_FOLLOWER = 0,
   TAOS_SYNC_STATE_CANDIDATE = 1,
   TAOS_SYNC_STATE_LEADER = 2,
-} ESyncState;
+} ESyncRole;
 
-typedef struct {
+typedef ESyncRole ESyncState;
+
+typedef struct SSyncBuffer {
   void*  data;
   size_t len;
 } SSyncBuffer;
 
-typedef struct {
-  SyncNodeId nodeId;
+typedef struct SNodeInfo {
   uint16_t nodePort;                 // node sync Port
   char     nodeFqdn[TSDB_FQDN_LEN];  // node FQDN
 } SNodeInfo;
 
-typedef struct {
+typedef struct SSyncCfg {
   int32_t   replicaNum;
+  int32_t   myIndex;
   SNodeInfo nodeInfo[TSDB_MAX_REPLICA];
 } SSyncCfg;
 
-typedef struct {
+typedef struct SNodesRole {
   int32_t    replicaNum;
   SNodeInfo  nodeInfo[TSDB_MAX_REPLICA];
   ESyncState role[TSDB_MAX_REPLICA];
@@ -67,15 +71,15 @@ typedef struct SSyncFSM {
 
   // when value in pBuf finish a raft flow, FpCommitCb is called, code indicates the result
   // user can do something according to the code and isWeak. for example, write data into tsdb
-  void (*FpCommitCb)(struct SSyncFSM* pFsm, const SSyncBuffer* pBuf, SyncIndex index, bool isWeak, int32_t code);
+  void (*FpCommitCb)(struct SSyncFSM* pFsm, const SRpcMsg* pBuf, SyncIndex index, bool isWeak, int32_t code);
 
   // when value in pBuf has been written into local log store, FpPreCommitCb is called, code indicates the result
   // user can do something according to the code and isWeak. for example, write data into tsdb
-  void (*FpPreCommitCb)(struct SSyncFSM* pFsm, const SSyncBuffer* pBuf, SyncIndex index, bool isWeak, int32_t code);
+  void (*FpPreCommitCb)(struct SSyncFSM* pFsm, const SRpcMsg* pBuf, SyncIndex index, bool isWeak, int32_t code);
 
   // when log entry is updated by a new one, FpRollBackCb is called
   // user can do something to roll back. for example, delete data from tsdb, or just ignore it
-  void (*FpRollBackCb)(struct SSyncFSM* pFsm, const SSyncBuffer* pBuf, SyncIndex index, bool isWeak, int32_t code);
+  void (*FpRollBackCb)(struct SSyncFSM* pFsm, const SRpcMsg* pBuf, SyncIndex index, bool isWeak, int32_t code);
 
   // user should implement this function, use "data" to take snapshot into "snapshot"
   int32_t (*FpTakeSnapshot)(SSnapshot* snapshot);
@@ -91,10 +95,10 @@ typedef struct SSyncLogStore {
   void* data;
 
   // append one log entry
-  int32_t (*appendEntry)(struct SSyncLogStore* pLogStore, SSyncBuffer* pBuf);
+  int32_t (*appendEntry)(struct SSyncLogStore* pLogStore, SRpcMsg* pBuf);
 
   // get one log entry, user need to free pBuf->data
-  int32_t (*getEntry)(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncBuffer* pBuf);
+  int32_t (*getEntry)(struct SSyncLogStore* pLogStore, SyncIndex index, SRpcMsg* pBuf);
 
   // update log store commit index with "index"
   int32_t (*updateCommitIndex)(struct SSyncLogStore* pLogStore, SyncIndex index);
@@ -128,12 +132,14 @@ typedef struct SStateMgr {
 
 } SStateMgr;
 
-typedef struct {
+typedef struct SSyncInfo {
   SyncGroupId vgId;
   SSyncCfg    syncCfg;
-  SSyncLogStore logStore;
-  SStateMgr     stateManager;
-  SSyncFSM      syncFsm;
+  char        path[TSDB_FILENAME_LEN];
+  SSyncFSM*   pFsm;
+
+  void* rpcClient;
+  int32_t (*FpSendMsg)(void* rpcClient, const SEpSet* pEpSet, SRpcMsg* pMsg);
 
 } SSyncInfo;
 
@@ -147,8 +153,8 @@ int64_t syncStart(const SSyncInfo* pSyncInfo);
 void    syncStop(int64_t rid);
 int32_t syncReconfig(int64_t rid, const SSyncCfg* pSyncCfg);
 
-// int32_t syncForwardToPeer(int64_t rid, const SRpcMsg* pBuf, bool isWeak);
-int32_t syncForwardToPeer(int64_t rid, const SSyncBuffer* pBuf, bool isWeak);
+int32_t syncForwardToPeer(int64_t rid, const SRpcMsg* pBuf, bool isWeak);
+// int32_t syncForwardToPeer(int64_t rid, const SSyncBuffer* pBuf, bool isWeak);
 
 ESyncState syncGetMyRole(int64_t rid);
 void       syncGetNodesRole(int64_t rid, SNodesRole* pNodeRole);

include/libs/tfs/tfs.h

@@ -16,7 +16,7 @@
 #ifndef _TD_TFS_H_
 #define _TD_TFS_H_
 
-#include "tcfg.h"
+#include "tdef.h"
 
 #ifdef __cplusplus
 extern "C" {

include/os/os.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_OS_H
-#define TDENGINE_OS_H
+#ifndef _TD_OS_H_
+#define _TD_OS_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -82,4 +82,4 @@ void osInit();
 }
 #endif
 
-#endif
+#endif /*_TD_OS_H_*/

include/os/osDir.h

@@ -26,6 +26,7 @@ int32_t taosMkDir(const char *dirname);
 void    taosRemoveOldFiles(const char *dirname, int32_t keepDays);
 int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen);
 int32_t taosRealPath(char *dirname, int32_t maxlen);
+bool    taosIsDir(const char *dirname);
 
 #ifdef __cplusplus
 }

include/os/osFile.h

@@ -43,6 +43,7 @@ typedef struct TdFile *TdFilePtr;
 #define TD_FILE_TEXT      0x0020
 #define TD_FILE_AUTO_DEL  0x0040
 #define TD_FILE_EXCL      0x0080
+#define TD_FILE_STREAM    0x0100   // Only support taosFprintfFile, taosGetLineFile, taosGetLineFile, taosEOFFile
  
 int32_t taosLockFile(TdFilePtr pFile);
 int32_t taosUnLockFile(TdFilePtr pFile);

include/os/osSemaphore.h

@@ -16,12 +16,12 @@
 #ifndef _TD_OS_SEMPHONE_H_
 #define _TD_OS_SEMPHONE_H_
 
+#include <semaphore.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <semaphore.h>
-
 #if defined (_TD_DARWIN_64)
   typedef struct tsem_s *tsem_t;
   int tsem_init(tsem_t *sem, int pshared, unsigned int value);

include/os/osSocket.h

@@ -16,10 +16,6 @@
 #ifndef _TD_OS_SOCKET_H_
 #define _TD_OS_SOCKET_H_
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
   #include "winsock2.h"
   #include <WS2tcpip.h>
@@ -30,6 +26,10 @@ extern "C" {
   #include <sys/epoll.h>
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define TAOS_EPOLL_WAIT_TIME 500
 typedef int32_t SOCKET;
 typedef SOCKET  EpollFd;

include/os/osSysinfo.h

@@ -16,12 +16,12 @@
 #ifndef _TD_OS_SYSINFO_H_
 #define _TD_OS_SYSINFO_H_
 
+#include "os.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-
 typedef struct {
   int64_t total;
   int64_t used;
@@ -33,21 +33,25 @@ typedef struct {
   SDiskSize size;
 } SDiskSpace;
 
-int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize);
-int32_t taosGetCpuCores();
 void    taosGetSystemInfo();
+bool    taosGetEmail(char *email, int32_t maxLen);
+bool    taosGetOsReleaseName(char *releaseName, int32_t maxLen);
+bool    taosGetCpuInfo(char *cpuModel, int32_t maxLen, int32_t *numOfCores);
+int32_t taosGetCpuCores();
+bool    taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage);
+bool    taosGetTotalSysMemoryKB(uint64_t *kb);
+bool    taosGetProcMemory(float *memoryUsedMB);  //
+bool    taosGetSysMemory(float *memoryUsedMB);   //
+int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize);
 bool    taosReadProcIO(int64_t *rchars, int64_t *wchars);
 bool    taosGetProcIO(float *readKB, float *writeKB);
 bool    taosGetCardInfo(int64_t *bytes, int64_t *rbytes, int64_t *tbytes);
 bool    taosGetBandSpeed(float *bandSpeedKb);
-void    taosGetDisk();
-bool    taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage);
-bool    taosGetProcMemory(float *memoryUsedMB);
-bool    taosGetSysMemory(float *memoryUsedMB);
-int     taosSystem(const char *cmd);
+
+int32_t taosSystem(const char *cmd);
 void    taosKillSystem();
 int32_t taosGetSystemUUID(char *uid, int32_t uidlen);
-char *  taosGetCmdlineByPID(int pid);
+char   *taosGetCmdlineByPID(int32_t pid);
 void    taosSetCoreDump(bool enable);
 
 typedef struct {

include/os/osThread.h

@@ -16,12 +16,12 @@
 #ifndef _TD_OS_THREAD_H_
 #define _TD_OS_THREAD_H_
 
+#include <pthread.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <pthread.h>
-
 #ifdef __cplusplus
 }
 #endif

include/util/exception.h

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

include/util/talgo.h

@@ -13,16 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_TALGO_H
-#define _TD_UTIL_TALGO_H
+#ifndef _TD_UTIL_TALGO_H_
+#define _TD_UTIL_TALGO_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifndef __COMPAR_FN_T
-# define __COMPAR_FN_T
-typedef int (*__compar_fn_t) (const void *, const void *);
+#define __COMPAR_FN_T
+typedef int32_t (*__compar_fn_t)(const void *, const void *);
 #endif
 
 #define TD_EQ 0x1
@@ -45,7 +47,7 @@ typedef void (*__ext_swap_fn_t)(void *p1, void *p2, const void *param);
  * @param param
  * @param comparFn
  */
-void taosqsort(void *src, size_t numOfElem, size_t size, const void* param, __ext_compar_fn_t comparFn);
+void taosqsort(void *src, int64_t numOfElem, int64_t size, const void *param, __ext_compar_fn_t comparFn);
 
 /**
  * binary search, with range support
@@ -58,7 +60,7 @@ void taosqsort(void *src, size_t numOfElem, size_t size, const void* param, __ex
  * @param flags
  * @return
  */
-void *taosbsearch(const void *key, const void *base, size_t nmemb, size_t size, __compar_fn_t fn, int flags);
+void *taosbsearch(const void *key, const void *base, int64_t nmemb, int64_t size, __compar_fn_t fn, int32_t flags);
 
 /**
  * adjust heap
@@ -74,7 +76,8 @@ void *taosbsearch(const void *key, const void *base, size_t nmemb, size_t size,
  * @param maxroot: if heap is max root heap
  * @return
  */
-void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const void *parcompar, __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot);
+void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const void *parcompar,
+                    __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot);
 
 /**
  * sort heap to make sure it is a max/min root heap
@@ -89,10 +92,11 @@ void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const
  * @param maxroot: if heap is max root heap
  * @return
  */
-void taosheapsort(void *base, int32_t size, int32_t len, const void *parcompar, __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot);
-
+void taosheapsort(void *base, int32_t size, int32_t len, const void *parcompar, __ext_compar_fn_t compar,
+                  const void *parswap, __ext_swap_fn_t swap, bool maxroot);
 
 #ifdef __cplusplus
 }
 #endif
-#endif  /*_TD_UTIL_TALGO_H*/
+
+#endif /*_TD_UTIL_TALGO_H_*/

include/util/tarray.h

@@ -13,16 +13,15 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_ARRAY_H
-#define _TD_UTIL_ARRAY_H
+#ifndef _TD_UTIL_ARRAY_H_
+#define _TD_UTIL_ARRAY_H_
+
+#include "talgo.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-#include "talgo.h"
-
 #if 0
 #define TARRAY(TYPE)             \
   struct {                       \
@@ -43,8 +42,8 @@ extern "C" {
 
 typedef struct SArray {
   size_t size;
-  size_t capacity;
-  size_t elemSize;
+  uint32_t capacity;
+  uint32_t elemSize;
   void*  pData;
 } SArray;
 
@@ -70,7 +69,7 @@ int32_t taosArrayEnsureCap(SArray* pArray, size_t tsize);
  * @param nEles
  * @return
  */
-void* taosArrayAddBatch(SArray* pArray, const void* pData, int nEles);
+void* taosArrayAddBatch(SArray* pArray, const void* pData, int32_t nEles);
 
 /**
  *
@@ -238,7 +237,7 @@ void taosArraySortString(SArray* pArray, __compar_fn_t comparFn);
  * @param compar
  * @param key
  */
-void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn, int flags);
+void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags);
 
 /**
  * search the array, return index of the element
@@ -246,14 +245,14 @@ void* taosArraySearch(const SArray* pArray, const void* key, __compar_fn_t compa
  * @param compar
  * @param key
  */
-int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t comparFn, int flags);
+int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t comparFn, int32_t flags);
 
 /**
  * search the array
  * @param pArray
  * @param key
  */
-char* taosArraySearchString(const SArray* pArray, const char* key, __compar_fn_t comparFn, int flags);
+char* taosArraySearchString(const SArray* pArray, const char* key, __compar_fn_t comparFn, int32_t flags);
 
 /**
  * sort the pointer data in the array
@@ -269,4 +268,4 @@ void taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void* par
 }
 #endif
 
-#endif /*_TD_UTIL_ARRAY_H*/
+#endif /*_TD_UTIL_ARRAY_H_*/

include/util/tkey.h → include/util/tbase64.h

@@ -12,20 +12,21 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_UTIL_KEY_H
-#define _TD_UTIL_KEY_H
+
+#ifndef _TD_UTIL_BASE64_H_
+#define _TD_UTIL_BASE64_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned char *base64_decode(const char *value, int inlen, int *outlen);
-char *         base64_encode(const unsigned char *value, int vlen);
-char *         taosDesEncode(int64_t key, char *src, int len);
-char *         taosDesDecode(int64_t key, char *src, int len);
+uint8_t *base64_decode(const char *value, int32_t inlen, int32_t *outlen);
+char    *base64_encode(const uint8_t *value, int32_t vlen);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_UTIL_KEY_H*/
+#endif /*_TD_UTIL_BASE64_H_*/
\ No newline at end of file

include/util/tbuffer.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_BUFFER_H
-#define _TD_UTIL_BUFFER_H
+#ifndef _TD_UTIL_BUFFER_H_
+#define _TD_UTIL_BUFFER_H_
 
 #include "os.h"
 
@@ -26,9 +26,9 @@ extern "C" {
 // usage example
 /*
 #include <stdio.h>
-#include "exception.h"
+#include "texception.h"
 
-int main( int argc, char** argv ) {
+int32_t main( int32_t argc, char** argv ) {
   SBufferWriter bw = tbufInitWriter( NULL, false );
 
   TRY( 1 ) {
@@ -39,7 +39,7 @@ int main( int argc, char** argv ) {
     // reserve space for the interger count
     size_t pos = tbufReserve( &bw, sizeof(int32_t) );
     // write 5 integers to the buffer
-    for( int i = 0; i < 5; i++) {
+    for( int32_t i = 0; i < 5; i++) {
       tbufWriteInt32( &bw, i );
     }
     // write the integer count to buffer at reserved position
@@ -55,7 +55,7 @@ int main( int argc, char** argv ) {
     SBufferReader br = tbufInitReader( data, size, false );
     // read & print out all integers
     int32_t count = tbufReadInt32( &br );
-    for( int i = 0; i < count; i++ ) {
+    for( int32_t i = 0; i < count; i++ ) {
       printf( "%d\n", tbufReadInt32(&br) );
     }
     // read & print out a string
@@ -87,12 +87,10 @@ typedef struct SBufferWriter {
   void* (*allocator)(void*, size_t);
 } SBufferWriter;
 
-////////////////////////////////////////////////////////////////////////////////
 // common functions & macros for both reader & writer
 
 #define tbufTell(buf) ((buf)->pos)
 
-////////////////////////////////////////////////////////////////////////////////
 /* ------------------------ BUFFER WRITER FUNCTIONS AND MACROS ------------------------ */
 // *Allocator*, function to allocate memory, will use 'realloc' if NULL
 // *Endian*, if true, writer functions of primitive types will do 'hton' automatically
@@ -167,4 +165,4 @@ double      tbufReadDouble(SBufferReader* buf);
 }
 #endif
 
-#endif /*_TD_UTIL_BUFFER_H*/
+#endif /*_TD_UTIL_BUFFER_H_*/

include/util/tcache.h

@@ -13,27 +13,25 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_CACHE_H
-#define _TD_UTIL_CACHE_H
+#ifndef _TD_UTIL_CACHE_H_
+#define _TD_UTIL_CACHE_H_
+
+#include "thash.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-#include "tlockfree.h"
-#include "thash.h"
-
 #if defined(_TD_ARM_32)
-  #define TSDB_CACHE_PTR_KEY  TSDB_DATA_TYPE_INT
-  #define TSDB_CACHE_PTR_TYPE int32_t
+#define TSDB_CACHE_PTR_KEY  TSDB_DATA_TYPE_INT
+#define TSDB_CACHE_PTR_TYPE int32_t
 #else
-  #define TSDB_CACHE_PTR_KEY  TSDB_DATA_TYPE_BIGINT  
-  #define TSDB_CACHE_PTR_TYPE int64_t
+#define TSDB_CACHE_PTR_KEY  TSDB_DATA_TYPE_BIGINT
+#define TSDB_CACHE_PTR_TYPE int64_t
 #endif
 
-typedef void (*__cache_free_fn_t)(void*);
-typedef void (*__cache_trav_fn_t)(void*, void*);
+typedef void (*__cache_free_fn_t)(void *);
+typedef void (*__cache_trav_fn_t)(void *, void *);
 
 typedef struct SCacheStatis {
   int64_t missCount;
@@ -50,8 +48,8 @@ typedef struct SCacheDataNode {
   uint64_t           expireTime;  // expire time
   uint64_t           signature;
   struct STrashElem *pTNodeHeader;    // point to trash node head
-  uint16_t           keySize: 15;  // max key size: 32kb
-  bool               inTrashcan: 1;// denote if it is in trash or not
+  uint16_t           keySize : 15;    // max key size: 32kb
+  bool               inTrashcan : 1;  // denote if it is in trash or not
   uint32_t           size;            // allocated size for current SCacheDataNode
   T_REF_DECLARE()
   char *key;
@@ -75,10 +73,10 @@ typedef struct STrashElem {
 typedef struct {
   int64_t           totalSize;  // total allocated buffer in this hash table, SCacheObj is not included.
   int64_t           refreshTime;
-  STrashElem *    pTrash;
-  char*           name;
+  STrashElem       *pTrash;
+  char             *name;
   SCacheStatis      statistics;
-  SHashObj *      pHashTable;
+  SHashObj         *pHashTable;
   __cache_free_fn_t freeFp;
   uint32_t          numOfElemsInTrash;  // number of element in trash
   uint8_t           deleting;           // set the deleting flag to stop refreshing ASAP.
@@ -101,7 +99,8 @@ typedef struct {
  * @param fn                   free resource callback function
  * @return
  */
-SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInSeconds, bool extendLifespan, __cache_free_fn_t fn, const char *cacheName);
+SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInSeconds, bool extendLifespan, __cache_free_fn_t fn,
+                         const char *cacheName);
 
 /**
  * add data into cache
@@ -113,7 +112,8 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInSeconds, bool ext
  * @param keepTime      survival time in second
  * @return              cached element
  */
-void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const void *pData, size_t dataSize, int durationMS);
+void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const void *pData, size_t dataSize,
+                   int32_t durationMS);
 
 /**
  * get data from cache
@@ -177,7 +177,7 @@ void taosCacheCleanup(SCacheObj *pCacheObj);
  * @param fp
  * @return
  */
-void taosCacheRefresh(SCacheObj *pCacheObj, __cache_trav_fn_t fp, void* param1);
+void taosCacheRefresh(SCacheObj *pCacheObj, __cache_trav_fn_t fp, void *param1);
 
 /**
  * stop background refresh worker thread
@@ -188,4 +188,4 @@ void taosStopCacheRefreshWorker();
 }
 #endif
 
-#endif  /*_TD_UTIL_CACHE_H*/
+#endif /*_TD_UTIL_CACHE_H_*/

include/util/tchecksum.h

@@ -13,24 +13,22 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_CHECKSUM_H
-#define _TD_UTIL_CHECKSUM_H
+#ifndef _TD_UTIL_CHECKSUM_H_
+#define _TD_UTIL_CHECKSUM_H_
+
+#include "tcrc32c.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-#include "tcrc32c.h"
-#include "tutil.h"
-
 typedef uint32_t TSCKSUM;
 
 static FORCE_INLINE TSCKSUM taosCalcChecksum(TSCKSUM csi, const uint8_t *stream, uint32_t ssize) {
   return (*crc32c)(csi, stream, (size_t)ssize);
 }
 
-static FORCE_INLINE int taosCalcChecksumAppend(TSCKSUM csi, uint8_t *stream, uint32_t ssize) {
+static FORCE_INLINE int32_t taosCalcChecksumAppend(TSCKSUM csi, uint8_t *stream, uint32_t ssize) {
   if (ssize < sizeof(TSCKSUM)) return -1;
 
   *((TSCKSUM *)(stream + ssize - sizeof(TSCKSUM))) = (*crc32c)(csi, stream, (size_t)(ssize - sizeof(TSCKSUM)));
@@ -38,11 +36,11 @@ static FORCE_INLINE int taosCalcChecksumAppend(TSCKSUM csi, uint8_t *stream, uin
   return 0;
 }
 
-static FORCE_INLINE int taosCheckChecksum(const uint8_t *stream, uint32_t ssize, TSCKSUM checksum) {
+static FORCE_INLINE int32_t taosCheckChecksum(const uint8_t *stream, uint32_t ssize, TSCKSUM checksum) {
   return (checksum != (*crc32c)(0, stream, (size_t)ssize));
 }
 
-static FORCE_INLINE int taosCheckChecksumWhole(const uint8_t *stream, uint32_t ssize) {
+static FORCE_INLINE int32_t taosCheckChecksumWhole(const uint8_t *stream, uint32_t ssize) {
   if (ssize < sizeof(TSCKSUM)) return 0;
 
 #if (_WIN64)
@@ -56,4 +54,4 @@ static FORCE_INLINE int taosCheckChecksumWhole(const uint8_t *stream, uint32_t s
 }
 #endif
 
-#endif  /*_TD_UTIL_CHECKSUM_H*/
+#endif /*_TD_UTIL_CHECKSUM_H_*/

include/util/tcoding.h

@@ -12,15 +12,16 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_UTIL_CODING_H
-#define _TD_UTIL_CODING_H
+
+#ifndef _TD_UTIL_CODING_H_
+#define _TD_UTIL_CODING_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-
 #define ENCODE_LIMIT  (((uint8_t)1) << 7)
 #define ZIGZAGE(T, v) ((u##T)((v) >> (sizeof(T) * 8 - 1))) ^ (((u##T)(v)) << 1)  // zigzag encode
 #define ZIGZAGD(T, v) ((v) >> 1) ^ -((T)((v)&1))                                 // zigzag decode
@@ -28,13 +29,13 @@ extern "C" {
 /* ------------------------ LEGACY CODES ------------------------ */
 #if 1
 // ---- Fixed U8
-static FORCE_INLINE int taosEncodeFixedU8(void **buf, uint8_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedU8(void **buf, uint8_t value) {
   if (buf != NULL) {
     ((uint8_t *)(*buf))[0] = value;
     *buf = POINTER_SHIFT(*buf, sizeof(value));
   }
 
-  return (int)sizeof(value);
+  return (int32_t)sizeof(value);
 }
 
 static FORCE_INLINE void *taosDecodeFixedU8(const void *buf, uint8_t *value) {
@@ -43,12 +44,12 @@ static FORCE_INLINE void *taosDecodeFixedU8(const void *buf, uint8_t *value) {
 }
 
 // ---- Fixed I8
-static FORCE_INLINE int taosEncodeFixedI8(void **buf, int8_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedI8(void **buf, int8_t value) {
   if (buf != NULL) {
     ((int8_t *)(*buf))[0] = value;
     *buf = POINTER_SHIFT(*buf, sizeof(value));
   }
-  return (int)sizeof(value);
+  return (int32_t)sizeof(value);
 }
 
 static FORCE_INLINE void *taosDecodeFixedI8(const void *buf, int8_t *value) {
@@ -57,7 +58,7 @@ static FORCE_INLINE void *taosDecodeFixedI8(const void *buf, int8_t *value) {
 }
 
 // ---- Fixed U16
-static FORCE_INLINE int taosEncodeFixedU16(void **buf, uint16_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedU16(void **buf, uint16_t value) {
   if (buf != NULL) {
     if (IS_LITTLE_ENDIAN()) {
       memcpy(*buf, &value, sizeof(value));
@@ -68,7 +69,7 @@ static FORCE_INLINE int taosEncodeFixedU16(void **buf, uint16_t value) {
     *buf = POINTER_SHIFT(*buf, sizeof(value));
   }
 
-  return (int)sizeof(value);
+  return (int32_t)sizeof(value);
 }
 
 static FORCE_INLINE void *taosDecodeFixedU16(const void *buf, uint16_t *value) {
@@ -83,7 +84,7 @@ static FORCE_INLINE void *taosDecodeFixedU16(const void *buf, uint16_t *value) {
 }
 
 // ---- Fixed I16
-static FORCE_INLINE int taosEncodeFixedI16(void **buf, int16_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedI16(void **buf, int16_t value) {
   return taosEncodeFixedU16(buf, ZIGZAGE(int16_t, value));
 }
 
@@ -95,7 +96,7 @@ static FORCE_INLINE void *taosDecodeFixedI16(const void *buf, int16_t *value) {
 }
 
 // ---- Fixed U32
-static FORCE_INLINE int taosEncodeFixedU32(void **buf, uint32_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedU32(void **buf, uint32_t value) {
   if (buf != NULL) {
     if (IS_LITTLE_ENDIAN()) {
       memcpy(*buf, &value, sizeof(value));
@@ -108,7 +109,7 @@ static FORCE_INLINE int taosEncodeFixedU32(void **buf, uint32_t value) {
     *buf = POINTER_SHIFT(*buf, sizeof(value));
   }
 
-  return (int)sizeof(value);
+  return (int32_t)sizeof(value);
 }
 
 static FORCE_INLINE void *taosDecodeFixedU32(const void *buf, uint32_t *value) {
@@ -125,7 +126,7 @@ static FORCE_INLINE void *taosDecodeFixedU32(const void *buf, uint32_t *value) {
 }
 
 // ---- Fixed I32
-static FORCE_INLINE int taosEncodeFixedI32(void **buf, int32_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedI32(void **buf, int32_t value) {
   return taosEncodeFixedU32(buf, ZIGZAGE(int32_t, value));
 }
 
@@ -137,7 +138,7 @@ static FORCE_INLINE void *taosDecodeFixedI32(const void *buf, int32_t *value) {
 }
 
 // ---- Fixed U64
-static FORCE_INLINE int taosEncodeFixedU64(void **buf, uint64_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedU64(void **buf, uint64_t value) {
   if (buf != NULL) {
     if (IS_LITTLE_ENDIAN()) {
       memcpy(*buf, &value, sizeof(value));
@@ -155,7 +156,7 @@ static FORCE_INLINE int taosEncodeFixedU64(void **buf, uint64_t value) {
     *buf = POINTER_SHIFT(*buf, sizeof(value));
   }
 
-  return (int)sizeof(value);
+  return (int32_t)sizeof(value);
 }
 
 static FORCE_INLINE void *taosDecodeFixedU64(const void *buf, uint64_t *value) {
@@ -176,7 +177,7 @@ static FORCE_INLINE void *taosDecodeFixedU64(const void *buf, uint64_t *value) {
 }
 
 // ---- Fixed I64
-static FORCE_INLINE int taosEncodeFixedI64(void **buf, int64_t value) {
+static FORCE_INLINE int32_t taosEncodeFixedI64(void **buf, int64_t value) {
   return taosEncodeFixedU64(buf, ZIGZAGE(int64_t, value));
 }
 
@@ -188,8 +189,8 @@ static FORCE_INLINE void *taosDecodeFixedI64(const void *buf, int64_t *value) {
 }
 
 // ---- Variant U16
-static FORCE_INLINE int taosEncodeVariantU16(void **buf, uint16_t value) {
-  int i = 0;
+static FORCE_INLINE int32_t taosEncodeVariantU16(void **buf, uint16_t value) {
+  int32_t i = 0;
   while (value >= ENCODE_LIMIT) {
     if (buf != NULL) ((uint8_t *)(*buf))[i] = (uint8_t)(value | ENCODE_LIMIT);
     value >>= 7;
@@ -206,7 +207,7 @@ static FORCE_INLINE int taosEncodeVariantU16(void **buf, uint16_t value) {
 }
 
 static FORCE_INLINE void *taosDecodeVariantU16(const void *buf, uint16_t *value) {
-  int      i = 0;
+  int32_t  i = 0;
   uint16_t tval = 0;
   *value = 0;
   while (i < 3) {
@@ -224,7 +225,7 @@ static FORCE_INLINE void *taosDecodeVariantU16(const void *buf, uint16_t *value)
 }
 
 // ---- Variant I16
-static FORCE_INLINE int taosEncodeVariantI16(void **buf, int16_t value) {
+static FORCE_INLINE int32_t taosEncodeVariantI16(void **buf, int16_t value) {
   return taosEncodeVariantU16(buf, ZIGZAGE(int16_t, value));
 }
 
@@ -236,8 +237,8 @@ static FORCE_INLINE void *taosDecodeVariantI16(const void *buf, int16_t *value)
 }
 
 // ---- Variant U32
-static FORCE_INLINE int taosEncodeVariantU32(void **buf, uint32_t value) {
-  int i = 0;
+static FORCE_INLINE int32_t taosEncodeVariantU32(void **buf, uint32_t value) {
+  int32_t i = 0;
   while (value >= ENCODE_LIMIT) {
     if (buf != NULL) ((uint8_t *)(*buf))[i] = (value | ENCODE_LIMIT);
     value >>= 7;
@@ -254,7 +255,7 @@ static FORCE_INLINE int taosEncodeVariantU32(void **buf, uint32_t value) {
 }
 
 static FORCE_INLINE void *taosDecodeVariantU32(const void *buf, uint32_t *value) {
-  int      i = 0;
+  int32_t  i = 0;
   uint32_t tval = 0;
   *value = 0;
   while (i < 5) {
@@ -272,7 +273,7 @@ static FORCE_INLINE void *taosDecodeVariantU32(const void *buf, uint32_t *value)
 }
 
 // ---- Variant I32
-static FORCE_INLINE int taosEncodeVariantI32(void **buf, int32_t value) {
+static FORCE_INLINE int32_t taosEncodeVariantI32(void **buf, int32_t value) {
   return taosEncodeVariantU32(buf, ZIGZAGE(int32_t, value));
 }
 
@@ -284,8 +285,8 @@ static FORCE_INLINE void *taosDecodeVariantI32(const void *buf, int32_t *value)
 }
 
 // ---- Variant U64
-static FORCE_INLINE int taosEncodeVariantU64(void **buf, uint64_t value) {
-  int i = 0;
+static FORCE_INLINE int32_t taosEncodeVariantU64(void **buf, uint64_t value) {
+  int32_t i = 0;
   while (value >= ENCODE_LIMIT) {
     if (buf != NULL) ((uint8_t *)(*buf))[i] = (uint8_t)(value | ENCODE_LIMIT);
     value >>= 7;
@@ -302,7 +303,7 @@ static FORCE_INLINE int taosEncodeVariantU64(void **buf, uint64_t value) {
 }
 
 static FORCE_INLINE void *taosDecodeVariantU64(const void *buf, uint64_t *value) {
-  int      i = 0;
+  int32_t  i = 0;
   uint64_t tval = 0;
   *value = 0;
   while (i < 10) {
@@ -320,7 +321,7 @@ static FORCE_INLINE void *taosDecodeVariantU64(const void *buf, uint64_t *value)
 }
 
 // ---- Variant I64
-static FORCE_INLINE int taosEncodeVariantI64(void **buf, int64_t value) {
+static FORCE_INLINE int32_t taosEncodeVariantI64(void **buf, int64_t value) {
   return taosEncodeVariantU64(buf, ZIGZAGE(int64_t, value));
 }
 
@@ -332,8 +333,8 @@ static FORCE_INLINE void *taosDecodeVariantI64(const void *buf, int64_t *value)
 }
 
 // ---- string
-static FORCE_INLINE int taosEncodeString(void **buf, const char *value) {
-  int    tlen = 0;
+static FORCE_INLINE int32_t taosEncodeString(void **buf, const char *value) {
+  int32_t tlen = 0;
   size_t  size = strlen(value);
 
   tlen += taosEncodeVariantU64(buf, size);
@@ -341,7 +342,7 @@ static FORCE_INLINE int taosEncodeString(void **buf, const char *value) {
     memcpy(*buf, value, size);
     *buf = POINTER_SHIFT(*buf, size);
   }
-  tlen += (int)size;
+  tlen += (int32_t)size;
 
   return tlen;
 }
@@ -372,14 +373,14 @@ static FORCE_INLINE void *taosDecodeStringTo(const void *buf, char *value) {
 }
 
 // ---- binary
-static FORCE_INLINE int taosEncodeBinary(void **buf, const void *value, int32_t valueLen) {
-  int tlen = 0;
+static FORCE_INLINE int32_t taosEncodeBinary(void **buf, const void *value, int32_t valueLen) {
+  int32_t tlen = 0;
 
   if (buf != NULL) {
     memcpy(*buf, value, valueLen);
     *buf = POINTER_SHIFT(*buf, valueLen);
   }
-  tlen += (int)valueLen;
+  tlen += (int32_t)valueLen;
 
   return tlen;
 }
@@ -403,4 +404,4 @@ static FORCE_INLINE void *taosDecodeBinaryTo(const void *buf, void *value, int32
 }
 #endif
 
-#endif /*_TD_UTIL_CODING_H*/
+#endif /*_TD_UTIL_CODING_H_*/

include/util/compare.h → include/util/tcompare.h

@@ -16,12 +16,13 @@
 #ifndef _TD_UTIL_COMPARE_H_
 #define _TD_UTIL_COMPARE_H_
 
+#include "os.h"
+#include "taos.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-
 #define TSDB_PATTERN_MATCH              0
 #define TSDB_PATTERN_NOMATCH            1
 #define TSDB_PATTERN_NOWILDCARDMATCH    2
@@ -62,7 +63,6 @@ int32_t setChkNotInBytes8(const void *pLeft, const void *pRight);
 int32_t compareChkInString(const void *pLeft, const void *pRight);
 int32_t compareChkNotInString(const void *pLeft, const void *pRight);
 
-
 int32_t compareInt8Val(const void *pLeft, const void *pRight);
 int32_t compareInt16Val(const void *pLeft, const void *pRight);
 int32_t compareInt32Val(const void *pLeft, const void *pRight);
@@ -83,7 +83,6 @@ int32_t compareStrRegexComp(const void *pLeft, const void *pRight);
 int32_t compareStrRegexCompMatch(const void *pLeft, const void *pRight);
 int32_t compareStrRegexCompNMatch(const void *pLeft, const void *pRight);
 
-
 int32_t compareInt8ValDesc(const void *pLeft, const void *pRight);
 int32_t compareInt16ValDesc(const void *pLeft, const void *pRight);
 int32_t compareInt32ValDesc(const void *pLeft, const void *pRight);
@@ -100,8 +99,15 @@ int32_t compareUint64ValDesc(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedStrDesc(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedWStrDesc(const void *pLeft, const void *pRight);
 
-__compar_fn_t getComparFunc(int32_t type, int32_t optr);
+int32_t compareStrPatternMatch(const void *pLeft, const void *pRight);
+int32_t compareStrPatternNotMatch(const void *pLeft, const void *pRight);
 
+int32_t compareWStrPatternMatch(const void *pLeft, const void *pRight);
+int32_t compareWStrPatternNotMatch(const void *pLeft, const void *pRight);
+
+__compar_fn_t getComparFunc(int32_t type, int32_t optr);
+__compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order);
+int32_t       doCompare(const char *a, const char *b, int32_t type, size_t size);
 
 #ifdef __cplusplus
 }

include/util/tconfig.h

@@ -17,7 +17,6 @@
 #ifndef _TD_CONFIG_H_
 #define _TD_CONFIG_H_
 
-#include "os.h"
 #include "tarray.h"
 
 #ifdef __cplusplus
@@ -76,16 +75,17 @@ typedef struct {
   const char *value;
 } SConfigPair;
 
-typedef struct SConfig SConfig;
+typedef struct SConfig {
+  ECfgSrcType stype;
+  SArray     *array;
+} SConfig;
 
 SConfig *cfgInit();
 int32_t  cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const char *sourceStr);
-int32_t  cfgLoadArray(SConfig *pCfg, SArray *pArgs); // SConfigPair
+int32_t  cfgLoadFromArray(SConfig *pCfg, SArray *pArgs);  // SConfigPair
 void     cfgCleanup(SConfig *pCfg);
 
 int32_t      cfgGetSize(SConfig *pCfg);
-SConfigItem *cfgIterate(SConfig *pCfg, SConfigItem *pIter);
-void         cfgCancelIterate(SConfig *pCfg, SConfigItem *pIter);
 SConfigItem *cfgGetItem(SConfig *pCfg, const char *name);
 int32_t      cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype);
 

include/util/tcrc32c.h

@@ -18,8 +18,10 @@
 	  3. This notice may not be removed or altered from any source distribution.
 	*/
 
-#ifndef _TD_UTIL_CRC32_H
-#define _TD_UTIL_CRC32_H
+#ifndef _TD_UTIL_CRC32_H_
+#define _TD_UTIL_CRC32_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -39,4 +41,4 @@ void taosResolveCRC();
 }
 #endif
 
-#endif  /*_TD_UTIL_CRC32_H*/
+#endif  /*_TD_UTIL_CRC32_H_*/

include/util/tdef.h

@@ -13,10 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-// clang-format off
-
-#ifndef _TD_UTIL_DEF_H
-#define _TD_UTIL_DEF_H
+#ifndef _TD_UTIL_DEF_H_
+#define _TD_UTIL_DEF_H_
 
 #include "os.h"
 
@@ -96,19 +94,36 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_TIME_PRECISION_MICRO_STR "us"
 #define TSDB_TIME_PRECISION_NANO_STR  "ns"
 
-#define TSDB_TICK_PER_SECOND(precision) ((int64_t)((precision)==TSDB_TIME_PRECISION_MILLI ? 1e3L : ((precision)==TSDB_TIME_PRECISION_MICRO ? 1e6L : 1e9L)))
+#define TSDB_INFORMATION_SCHEMA_DB            "information_schema"
+#define TSDB_INS_TABLE_DNODES                 "dnodes"
+#define TSDB_INS_TABLE_MNODES                 "mnodes"
+#define TSDB_INS_TABLE_MODULES                "modules"
+#define TSDB_INS_TABLE_QNODES                 "qnodes"
+#define TSDB_INS_TABLE_USER_DATABASE          "user_database"
+#define TSDB_INS_TABLE_USER_FUNCTIONS         "user_functions"
+#define TSDB_INS_TABLE_USER_INDEXES           "user_indexes"
+#define TSDB_INS_TABLE_USER_STABLES           "user_stables"
+#define TSDB_INS_TABLE_USER_STREAMS           "user_streams"
+#define TSDB_INS_TABLE_USER_TABLES            "user_tables"
+#define TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED "user_table_distributed"
+#define TSDB_INS_TABLE_USER_USERS             "user_users"
+#define TSDB_INS_TABLE_VGROUPS                "vgroups"
+
+#define TSDB_TICK_PER_SECOND(precision)                      \
+  ((int64_t)((precision) == TSDB_TIME_PRECISION_MILLI ? 1e3L \
+                                                      : ((precision) == TSDB_TIME_PRECISION_MICRO ? 1e6L : 1e9L)))
 
 #define T_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #define T_APPEND_MEMBER(dst, ptr, type, member)                                     \
-do {\
-  memcpy((void *)(dst), (void *)(&((ptr)->member)), T_MEMBER_SIZE(type, member));\
-  dst = (void *)((char *)(dst) + T_MEMBER_SIZE(type, member));\
-} while(0)
+  do {                                                                              \
+    memcpy((void *)(dst), (void *)(&((ptr)->member)), T_MEMBER_SIZE(type, member)); \
+    dst = (void *)((char *)(dst) + T_MEMBER_SIZE(type, member));                    \
+  } while (0)
 #define T_READ_MEMBER(src, type, target)          \
-do { \
+  do {                                            \
     (target) = *(type *)(src);                    \
-  (src) = (void *)((char *)src + sizeof(type));\
-} while(0)
+    (src) = (void *)((char *)src + sizeof(type)); \
+  } while (0)
 
 typedef enum EOperatorType {
   // arithmetic operator
@@ -149,14 +164,12 @@ typedef enum EOperatorType {
   OP_TYPE_JSON_CONTAINS
 } EOperatorType;
 
-
 typedef enum ELogicConditionType {
   LOGIC_COND_TYPE_AND,
   LOGIC_COND_TYPE_OR,
   LOGIC_COND_TYPE_NOT,
 } ELogicConditionType;
 
-
 #define FUNCTION_CEIL  4500
 #define FUNCTION_FLOOR 4501
 #define FUNCTION_ABS   4502
@@ -177,7 +190,7 @@ typedef enum ELogicConditionType {
 #define TSDB_ACCT_ID_LEN 11
 
 #define TSDB_MAX_COLUMNS 4096
-#define TSDB_MIN_COLUMNS          2       //PRIMARY COLUMN(timestamp) + other columns
+#define TSDB_MIN_COLUMNS 2  // PRIMARY COLUMN(timestamp) + other columns
 
 #define TSDB_NODE_NAME_LEN  64
 #define TSDB_TABLE_NAME_LEN 193  // it is a null-terminated string
@@ -203,11 +216,11 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_SAVED_SQL_LEN   TSDB_MAX_COLUMNS * 64
 #define TSDB_MAX_SQL_LEN         TSDB_PAYLOAD_SIZE
 #define TSDB_MAX_SQL_SHOW_LEN    1024
-#define TSDB_MAX_ALLOWED_SQL_LEN  (1*1024*1024u)          // sql length should be less than 1mb
+#define TSDB_MAX_ALLOWED_SQL_LEN (1 * 1024 * 1024u)  // sql length should be less than 1mb
 
 #define TSDB_APP_NAME_LEN    TSDB_UNI_LEN
 #define TSDB_STB_COMMENT_LEN 1024
-  /**
+/**
  *  In some scenarios uint16_t (0~65535) is used to store the row len.
  *  - Firstly, we use 65531(65535 - 4), as the SDataRow/SKVRow contains 4 bits header.
  *  - Secondly, if all cols are VarDataT type except primary key, we need 4 bits to store the offset, thus
@@ -254,7 +267,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_TYPE_DEFAULT 0
 #define TSDB_DB_TYPE_TOPIC   1
 
-#define TSDB_DEFAULT_PKT_SIZE     65480  //same as RPC_MAX_UDP_SIZE
+#define TSDB_DEFAULT_PKT_SIZE 65480  // same as RPC_MAX_UDP_SIZE
 
 #define TSDB_PAYLOAD_SIZE         TSDB_DEFAULT_PKT_SIZE
 #define TSDB_DEFAULT_PAYLOAD_SIZE 5120  // default payload size, greater than PATH_MAX value
@@ -342,8 +355,8 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_UNION_CLAUSE   5
 
 #define TSDB_MAX_FIELD_LEN             16384
-#define TSDB_MAX_BINARY_LEN            (TSDB_MAX_FIELD_LEN-TSDB_KEYSIZE) // keep 16384
-#define TSDB_MAX_NCHAR_LEN             (TSDB_MAX_FIELD_LEN-TSDB_KEYSIZE) // keep 16384
+#define TSDB_MAX_BINARY_LEN            (TSDB_MAX_FIELD_LEN - TSDB_KEYSIZE)  // keep 16384
+#define TSDB_MAX_NCHAR_LEN             (TSDB_MAX_FIELD_LEN - TSDB_KEYSIZE)  // keep 16384
 #define PRIMARYKEY_TIMESTAMP_COL_ID    1
 #define COL_REACH_END(colId, maxColId) ((colId) > (maxColId))
 
@@ -354,8 +367,6 @@ typedef enum ELogicConditionType {
 
 #define TSDB_META_COMPACT_RATIO 0  // disable tsdb meta compact by default
 
-
-
 /*
  * 1. ordinary sub query for select * from super_table
  * 2. all sqlobj generated by createSubqueryObj with this flag
@@ -394,7 +405,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DEFAULT_STABLES_HASH_SIZE  100
 #define TSDB_DEFAULT_CTABLES_HASH_SIZE  20000
 
-#define TSDB_MAX_WAL_SIZE    (1024*1024*3)
+#define TSDB_MAX_WAL_SIZE (1024 * 1024 * 3)
 
 #define TSDB_ARB_DUMMY_TIME 4765104000000  // 2121-01-01 00:00:00.000, :P
 
@@ -410,6 +421,12 @@ typedef enum ELogicConditionType {
 enum { TRANS_STAT_INIT = 0, TRANS_STAT_EXECUTING, TRANS_STAT_EXECUTED, TRANS_STAT_ROLLBACKING, TRANS_STAT_ROLLBACKED };
 enum { TRANS_OPER_INIT = 0, TRANS_OPER_EXECUTE, TRANS_OPER_ROLLBACK };
 
+typedef struct {
+  char    dir[TSDB_FILENAME_LEN];
+  int32_t level;
+  int32_t primary;
+} SDiskCfg;
+
 #ifdef __cplusplus
 }
 #endif

include/util/tdes.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_UTIL_DES_H
+#define _TD_UTIL_DES_H
+
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char *taosDesEncode(int64_t key, char *src, int32_t len);
+char *taosDesDecode(int64_t key, char *src, int32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_UTIL_DES_H*/
\ No newline at end of file

include/util/encode.h → include/util/tencode.h

@@ -16,8 +16,8 @@
 #ifndef _TD_UTIL_ENCODE_H_
 #define _TD_UTIL_ENCODE_H_
 
-#include "freelist.h"
 #include "tcoding.h"
+#include "tfreelist.h"
 #include "tmacro.h"
 
 #ifdef __cplusplus
@@ -81,52 +81,52 @@ void tCoderInit(SCoder* pCoder, td_endian_t endian, uint8_t* data, int32_t size,
 void tCoderClear(SCoder* pCoder);
 
 /* ------------------------ ENCODE ------------------------ */
-int        tStartEncode(SCoder* pEncoder);
+int32_t        tStartEncode(SCoder* pEncoder);
 void           tEndEncode(SCoder* pEncoder);
-static int tEncodeU8(SCoder* pEncoder, uint8_t val);
-static int tEncodeI8(SCoder* pEncoder, int8_t val);
-static int tEncodeU16(SCoder* pEncoder, uint16_t val);
-static int tEncodeI16(SCoder* pEncoder, int16_t val);
-static int tEncodeU32(SCoder* pEncoder, uint32_t val);
-static int tEncodeI32(SCoder* pEncoder, int32_t val);
-static int tEncodeU64(SCoder* pEncoder, uint64_t val);
-static int tEncodeI64(SCoder* pEncoder, int64_t val);
-static int tEncodeU16v(SCoder* pEncoder, uint16_t val);
-static int tEncodeI16v(SCoder* pEncoder, int16_t val);
-static int tEncodeU32v(SCoder* pEncoder, uint32_t val);
-static int tEncodeI32v(SCoder* pEncoder, int32_t val);
-static int tEncodeU64v(SCoder* pEncoder, uint64_t val);
-static int tEncodeI64v(SCoder* pEncoder, int64_t val);
-static int tEncodeFloat(SCoder* pEncoder, float val);
-static int tEncodeDouble(SCoder* pEncoder, double val);
-static int tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len);
-static int tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len);
-static int tEncodeCStr(SCoder* pEncoder, const char* val);
+static int32_t tEncodeU8(SCoder* pEncoder, uint8_t val);
+static int32_t tEncodeI8(SCoder* pEncoder, int8_t val);
+static int32_t tEncodeU16(SCoder* pEncoder, uint16_t val);
+static int32_t tEncodeI16(SCoder* pEncoder, int16_t val);
+static int32_t tEncodeU32(SCoder* pEncoder, uint32_t val);
+static int32_t tEncodeI32(SCoder* pEncoder, int32_t val);
+static int32_t tEncodeU64(SCoder* pEncoder, uint64_t val);
+static int32_t tEncodeI64(SCoder* pEncoder, int64_t val);
+static int32_t tEncodeU16v(SCoder* pEncoder, uint16_t val);
+static int32_t tEncodeI16v(SCoder* pEncoder, int16_t val);
+static int32_t tEncodeU32v(SCoder* pEncoder, uint32_t val);
+static int32_t tEncodeI32v(SCoder* pEncoder, int32_t val);
+static int32_t tEncodeU64v(SCoder* pEncoder, uint64_t val);
+static int32_t tEncodeI64v(SCoder* pEncoder, int64_t val);
+static int32_t tEncodeFloat(SCoder* pEncoder, float val);
+static int32_t tEncodeDouble(SCoder* pEncoder, double val);
+static int32_t tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len);
+static int32_t tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len);
+static int32_t tEncodeCStr(SCoder* pEncoder, const char* val);
 
 /* ------------------------ DECODE ------------------------ */
-int         tStartDecode(SCoder* pDecoder);
+int32_t        tStartDecode(SCoder* pDecoder);
 void           tEndDecode(SCoder* pDecoder);
 static bool    tDecodeIsEnd(SCoder* pCoder);
-static int  tDecodeU8(SCoder* pDecoder, uint8_t* val);
-static int  tDecodeI8(SCoder* pDecoder, int8_t* val);
-static int  tDecodeU16(SCoder* pDecoder, uint16_t* val);
-static int  tDecodeI16(SCoder* pDecoder, int16_t* val);
-static int  tDecodeU32(SCoder* pDecoder, uint32_t* val);
-static int  tDecodeI32(SCoder* pDecoder, int32_t* val);
-static int  tDecodeU64(SCoder* pDecoder, uint64_t* val);
-static int  tDecodeI64(SCoder* pDecoder, int64_t* val);
-static int  tDecodeU16v(SCoder* pDecoder, uint16_t* val);
-static int  tDecodeI16v(SCoder* pDecoder, int16_t* val);
-static int  tDecodeU32v(SCoder* pDecoder, uint32_t* val);
-static int  tDecodeI32v(SCoder* pDecoder, int32_t* val);
-static int  tDecodeU64v(SCoder* pDecoder, uint64_t* val);
-static int  tDecodeI64v(SCoder* pDecoder, int64_t* val);
-static int  tDecodeFloat(SCoder* pDecoder, float* val);
-static int  tDecodeDouble(SCoder* pDecoder, double* val);
-static int  tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len);
-static int  tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len);
-static int  tDecodeCStr(SCoder* pDecoder, const char** val);
-static int  tDecodeCStrTo(SCoder* pDecoder, char* val);
+static int32_t tDecodeU8(SCoder* pDecoder, uint8_t* val);
+static int32_t tDecodeI8(SCoder* pDecoder, int8_t* val);
+static int32_t tDecodeU16(SCoder* pDecoder, uint16_t* val);
+static int32_t tDecodeI16(SCoder* pDecoder, int16_t* val);
+static int32_t tDecodeU32(SCoder* pDecoder, uint32_t* val);
+static int32_t tDecodeI32(SCoder* pDecoder, int32_t* val);
+static int32_t tDecodeU64(SCoder* pDecoder, uint64_t* val);
+static int32_t tDecodeI64(SCoder* pDecoder, int64_t* val);
+static int32_t tDecodeU16v(SCoder* pDecoder, uint16_t* val);
+static int32_t tDecodeI16v(SCoder* pDecoder, int16_t* val);
+static int32_t tDecodeU32v(SCoder* pDecoder, uint32_t* val);
+static int32_t tDecodeI32v(SCoder* pDecoder, int32_t* val);
+static int32_t tDecodeU64v(SCoder* pDecoder, uint64_t* val);
+static int32_t tDecodeI64v(SCoder* pDecoder, int64_t* val);
+static int32_t tDecodeFloat(SCoder* pDecoder, float* val);
+static int32_t tDecodeDouble(SCoder* pDecoder, double* val);
+static int32_t tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len);
+static int32_t tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len);
+static int32_t tDecodeCStr(SCoder* pDecoder, const char** val);
+static int32_t tDecodeCStrTo(SCoder* pDecoder, char* val);
 
 /* ------------------------ IMPL ------------------------ */
 #define TD_ENCODE_MACRO(CODER, VAL, TYPE, BITS)                        \
@@ -190,7 +190,7 @@ static int  tDecodeCStrTo(SCoder* pDecoder, char* val);
   return 0;
 
 // 8
-static FORCE_INLINE int tEncodeU8(SCoder* pEncoder, uint8_t val) {
+static FORCE_INLINE int32_t tEncodeU8(SCoder* pEncoder, uint8_t val) {
   if (pEncoder->data) {
     if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
     tPut(uint8_t, TD_CODER_CURRENT(pEncoder), val);
@@ -199,7 +199,7 @@ static FORCE_INLINE int tEncodeU8(SCoder* pEncoder, uint8_t val) {
   return 0;
 }
 
-static FORCE_INLINE int tEncodeI8(SCoder* pEncoder, int8_t val) {
+static FORCE_INLINE int32_t tEncodeI8(SCoder* pEncoder, int8_t val) {
   if (pEncoder->data) {
     if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
     tPut(int8_t, TD_CODER_CURRENT(pEncoder), val);
@@ -209,31 +209,31 @@ static FORCE_INLINE int tEncodeI8(SCoder* pEncoder, int8_t val) {
 }
 
 // 16
-static FORCE_INLINE int tEncodeU16(SCoder* pEncoder, uint16_t val) { TD_ENCODE_MACRO(pEncoder, val, uint16_t, 16); }
-static FORCE_INLINE int tEncodeI16(SCoder* pEncoder, int16_t val) { TD_ENCODE_MACRO(pEncoder, val, int16_t, 16); }
+static FORCE_INLINE int32_t tEncodeU16(SCoder* pEncoder, uint16_t val) { TD_ENCODE_MACRO(pEncoder, val, uint16_t, 16); }
+static FORCE_INLINE int32_t tEncodeI16(SCoder* pEncoder, int16_t val) { TD_ENCODE_MACRO(pEncoder, val, int16_t, 16); }
 // 32
-static FORCE_INLINE int tEncodeU32(SCoder* pEncoder, uint32_t val) { TD_ENCODE_MACRO(pEncoder, val, uint32_t, 32); }
-static FORCE_INLINE int tEncodeI32(SCoder* pEncoder, int32_t val) { TD_ENCODE_MACRO(pEncoder, val, int32_t, 32); }
+static FORCE_INLINE int32_t tEncodeU32(SCoder* pEncoder, uint32_t val) { TD_ENCODE_MACRO(pEncoder, val, uint32_t, 32); }
+static FORCE_INLINE int32_t tEncodeI32(SCoder* pEncoder, int32_t val) { TD_ENCODE_MACRO(pEncoder, val, int32_t, 32); }
 // 64
-static FORCE_INLINE int tEncodeU64(SCoder* pEncoder, uint64_t val) { TD_ENCODE_MACRO(pEncoder, val, uint64_t, 64); }
-static FORCE_INLINE int tEncodeI64(SCoder* pEncoder, int64_t val) { TD_ENCODE_MACRO(pEncoder, val, int64_t, 64); }
+static FORCE_INLINE int32_t tEncodeU64(SCoder* pEncoder, uint64_t val) { TD_ENCODE_MACRO(pEncoder, val, uint64_t, 64); }
+static FORCE_INLINE int32_t tEncodeI64(SCoder* pEncoder, int64_t val) { TD_ENCODE_MACRO(pEncoder, val, int64_t, 64); }
 // 16v
-static FORCE_INLINE int tEncodeU16v(SCoder* pEncoder, uint16_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
-static FORCE_INLINE int tEncodeI16v(SCoder* pEncoder, int16_t val) {
+static FORCE_INLINE int32_t tEncodeU16v(SCoder* pEncoder, uint16_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
+static FORCE_INLINE int32_t tEncodeI16v(SCoder* pEncoder, int16_t val) {
   return tEncodeU16v(pEncoder, ZIGZAGE(int16_t, val));
 }
 // 32v
-static FORCE_INLINE int tEncodeU32v(SCoder* pEncoder, uint32_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
-static FORCE_INLINE int tEncodeI32v(SCoder* pEncoder, int32_t val) {
+static FORCE_INLINE int32_t tEncodeU32v(SCoder* pEncoder, uint32_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
+static FORCE_INLINE int32_t tEncodeI32v(SCoder* pEncoder, int32_t val) {
   return tEncodeU32v(pEncoder, ZIGZAGE(int32_t, val));
 }
 // 64v
-static FORCE_INLINE int tEncodeU64v(SCoder* pEncoder, uint64_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
-static FORCE_INLINE int tEncodeI64v(SCoder* pEncoder, int64_t val) {
+static FORCE_INLINE int32_t tEncodeU64v(SCoder* pEncoder, uint64_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
+static FORCE_INLINE int32_t tEncodeI64v(SCoder* pEncoder, int64_t val) {
   return tEncodeU64v(pEncoder, ZIGZAGE(int64_t, val));
 }
 
-static FORCE_INLINE int tEncodeFloat(SCoder* pEncoder, float val) {
+static FORCE_INLINE int32_t tEncodeFloat(SCoder* pEncoder, float val) {
   union {
     uint32_t ui;
     float    f;
@@ -242,7 +242,7 @@ static FORCE_INLINE int tEncodeFloat(SCoder* pEncoder, float val) {
   return tEncodeU32(pEncoder, v.ui);
 }
 
-static FORCE_INLINE int tEncodeDouble(SCoder* pEncoder, double val) {
+static FORCE_INLINE int32_t tEncodeDouble(SCoder* pEncoder, double val) {
   union {
     uint64_t ui;
     double   d;
@@ -251,7 +251,7 @@ static FORCE_INLINE int tEncodeDouble(SCoder* pEncoder, double val) {
   return tEncodeU64(pEncoder, v.ui);
 }
 
-static FORCE_INLINE int tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len) {
+static FORCE_INLINE int32_t tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len) {
   if (tEncodeU64v(pEncoder, len) < 0) return -1;
   if (pEncoder->data) {
     if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, len)) return -1;
@@ -262,24 +262,24 @@ static FORCE_INLINE int tEncodeBinary(SCoder* pEncoder, const void* val, uint64_
   return 0;
 }
 
-static FORCE_INLINE int tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len) {
+static FORCE_INLINE int32_t tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len) {
   return tEncodeBinary(pEncoder, (void*)val, len + 1);
 }
 
-static FORCE_INLINE int tEncodeCStr(SCoder* pEncoder, const char* val) {
+static FORCE_INLINE int32_t tEncodeCStr(SCoder* pEncoder, const char* val) {
   return tEncodeCStrWithLen(pEncoder, val, (uint64_t)strlen(val));
 }
 
 /* ------------------------ FOR DECODER ------------------------ */
 // 8
-static FORCE_INLINE int tDecodeU8(SCoder* pDecoder, uint8_t* val) {
+static FORCE_INLINE int32_t tDecodeU8(SCoder* pDecoder, uint8_t* val) {
   if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
   tGet(uint8_t, TD_CODER_CURRENT(pDecoder), *val);
   TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
   return 0;
 }
 
-static FORCE_INLINE int tDecodeI8(SCoder* pDecoder, int8_t* val) {
+static FORCE_INLINE int32_t tDecodeI8(SCoder* pDecoder, int8_t* val) {
   if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
   tGet(int8_t, TD_CODER_CURRENT(pDecoder), *val);
   TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
@@ -287,21 +287,27 @@ static FORCE_INLINE int tDecodeI8(SCoder* pDecoder, int8_t* val) {
 }
 
 // 16
-static FORCE_INLINE int tDecodeU16(SCoder* pDecoder, uint16_t* val) { TD_DECODE_MACRO(pDecoder, val, uint16_t, 16); }
-static FORCE_INLINE int tDecodeI16(SCoder* pDecoder, int16_t* val) { TD_DECODE_MACRO(pDecoder, val, int16_t, 16); }
+static FORCE_INLINE int32_t tDecodeU16(SCoder* pDecoder, uint16_t* val) {
+  TD_DECODE_MACRO(pDecoder, val, uint16_t, 16);
+}
+static FORCE_INLINE int32_t tDecodeI16(SCoder* pDecoder, int16_t* val) { TD_DECODE_MACRO(pDecoder, val, int16_t, 16); }
 // 32
-static FORCE_INLINE int tDecodeU32(SCoder* pDecoder, uint32_t* val) { TD_DECODE_MACRO(pDecoder, val, uint32_t, 32); }
-static FORCE_INLINE int tDecodeI32(SCoder* pDecoder, int32_t* val) { TD_DECODE_MACRO(pDecoder, val, int32_t, 32); }
+static FORCE_INLINE int32_t tDecodeU32(SCoder* pDecoder, uint32_t* val) {
+  TD_DECODE_MACRO(pDecoder, val, uint32_t, 32);
+}
+static FORCE_INLINE int32_t tDecodeI32(SCoder* pDecoder, int32_t* val) { TD_DECODE_MACRO(pDecoder, val, int32_t, 32); }
 // 64
-static FORCE_INLINE int tDecodeU64(SCoder* pDecoder, uint64_t* val) { TD_DECODE_MACRO(pDecoder, val, uint64_t, 64); }
-static FORCE_INLINE int tDecodeI64(SCoder* pDecoder, int64_t* val) { TD_DECODE_MACRO(pDecoder, val, int64_t, 64); }
+static FORCE_INLINE int32_t tDecodeU64(SCoder* pDecoder, uint64_t* val) {
+  TD_DECODE_MACRO(pDecoder, val, uint64_t, 64);
+}
+static FORCE_INLINE int32_t tDecodeI64(SCoder* pDecoder, int64_t* val) { TD_DECODE_MACRO(pDecoder, val, int64_t, 64); }
 
 // 16v
-static FORCE_INLINE int tDecodeU16v(SCoder* pDecoder, uint16_t* val) {
+static FORCE_INLINE int32_t tDecodeU16v(SCoder* pDecoder, uint16_t* val) {
   TD_DECODE_VARIANT_MACRO(pDecoder, val, uint16_t);
 }
 
-static FORCE_INLINE int tDecodeI16v(SCoder* pDecoder, int16_t* val) {
+static FORCE_INLINE int32_t tDecodeI16v(SCoder* pDecoder, int16_t* val) {
   uint16_t tval;
   if (tDecodeU16v(pDecoder, &tval) < 0) {
     return -1;
@@ -311,11 +317,11 @@ static FORCE_INLINE int tDecodeI16v(SCoder* pDecoder, int16_t* val) {
 }
 
 // 32v
-static FORCE_INLINE int tDecodeU32v(SCoder* pDecoder, uint32_t* val) {
+static FORCE_INLINE int32_t tDecodeU32v(SCoder* pDecoder, uint32_t* val) {
   TD_DECODE_VARIANT_MACRO(pDecoder, val, uint32_t);
 }
 
-static FORCE_INLINE int tDecodeI32v(SCoder* pDecoder, int32_t* val) {
+static FORCE_INLINE int32_t tDecodeI32v(SCoder* pDecoder, int32_t* val) {
   uint32_t tval;
   if (tDecodeU32v(pDecoder, &tval) < 0) {
     return -1;
@@ -325,11 +331,11 @@ static FORCE_INLINE int tDecodeI32v(SCoder* pDecoder, int32_t* val) {
 }
 
 // 64v
-static FORCE_INLINE int tDecodeU64v(SCoder* pDecoder, uint64_t* val) {
+static FORCE_INLINE int32_t tDecodeU64v(SCoder* pDecoder, uint64_t* val) {
   TD_DECODE_VARIANT_MACRO(pDecoder, val, uint64_t);
 }
 
-static FORCE_INLINE int tDecodeI64v(SCoder* pDecoder, int64_t* val) {
+static FORCE_INLINE int32_t tDecodeI64v(SCoder* pDecoder, int64_t* val) {
   uint64_t tval;
   if (tDecodeU64v(pDecoder, &tval) < 0) {
     return -1;
@@ -338,7 +344,7 @@ static FORCE_INLINE int tDecodeI64v(SCoder* pDecoder, int64_t* val) {
   return 0;
 }
 
-static FORCE_INLINE int tDecodeFloat(SCoder* pDecoder, float* val) {
+static FORCE_INLINE int32_t tDecodeFloat(SCoder* pDecoder, float* val) {
   union {
     uint32_t ui;
     float    f;
@@ -352,7 +358,7 @@ static FORCE_INLINE int tDecodeFloat(SCoder* pDecoder, float* val) {
   return 0;
 }
 
-static FORCE_INLINE int tDecodeDouble(SCoder* pDecoder, double* val) {
+static FORCE_INLINE int32_t tDecodeDouble(SCoder* pDecoder, double* val) {
   union {
     uint64_t ui;
     double   d;
@@ -366,7 +372,7 @@ static FORCE_INLINE int tDecodeDouble(SCoder* pDecoder, double* val) {
   return 0;
 }
 
-static FORCE_INLINE int tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len) {
+static FORCE_INLINE int32_t tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len) {
   if (tDecodeU64v(pDecoder, len) < 0) return -1;
 
   if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, *len)) return -1;
@@ -376,18 +382,18 @@ static FORCE_INLINE int tDecodeBinary(SCoder* pDecoder, const void** val, uint64
   return 0;
 }
 
-static FORCE_INLINE int tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len) {
+static FORCE_INLINE int32_t tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len) {
   if (tDecodeBinary(pDecoder, (const void**)val, len) < 0) return -1;
   (*len) -= 1;
   return 0;
 }
 
-static FORCE_INLINE int tDecodeCStr(SCoder* pDecoder, const char** val) {
+static FORCE_INLINE int32_t tDecodeCStr(SCoder* pDecoder, const char** val) {
   uint64_t len;
   return tDecodeCStrAndLen(pDecoder, val, &len);
 }
 
-static int tDecodeCStrTo(SCoder* pDecoder, char* val) {
+static int32_t tDecodeCStrTo(SCoder* pDecoder, char* val) {
   const char* pStr;
   uint64_t    len;
   if (tDecodeCStrAndLen(pDecoder, &pStr, &len) < 0) return -1;

include/util/texception.h

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

include/util/freelist.h → include/util/tfreelist.h

@@ -16,7 +16,6 @@
 #ifndef _TD_UTIL_FREELIST_H_
 #define _TD_UTIL_FREELIST_H_
 
-#include "os.h"
 #include "tlist.h"
 
 #ifdef __cplusplus

include/util/tfunctional.h

@@ -12,39 +12,39 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_UTIL_FUNCTIONAL_H
-#define _TD_UTIL_FUNCTIONAL_H
+#ifndef _TD_UTIL_FUNCTIONAL_H_
+#define _TD_UTIL_FUNCTIONAL_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-
-//TODO: hard to use, trying to rewrite it using va_list
+// TODO: hard to use, trying to rewrite it using va_list
 
 typedef void* (*GenericVaFunc)(void* args[]);
-typedef int32_t (*I32VaFunc) (void* args[]);
-typedef void (*VoidVaFunc) (void* args[]);
+typedef int32_t (*I32VaFunc)(void* args[]);
+typedef void (*VoidVaFunc)(void* args[]);
 
 typedef struct GenericSavedFunc {
   GenericVaFunc func;
-  void * args[];
+  void*         args[];
 } tGenericSavedFunc;
 
 typedef struct I32SavedFunc {
   I32VaFunc func;
-  void * args[];
+  void*     args[];
 } tI32SavedFunc;
 
 typedef struct VoidSavedFunc {
   VoidVaFunc func;
-  void * args[];
+  void*      args[];
 } tVoidSavedFunc;
 
-tGenericSavedFunc* genericSavedFuncInit(GenericVaFunc func, int numOfArgs);
-tI32SavedFunc* i32SavedFuncInit(I32VaFunc func, int numOfArgs);
-tVoidSavedFunc* voidSavedFuncInit(VoidVaFunc func, int numOfArgs);
+tGenericSavedFunc* genericSavedFuncInit(GenericVaFunc func, int32_t numOfArgs);
+tI32SavedFunc*     i32SavedFuncInit(I32VaFunc func, int32_t numOfArgs);
+tVoidSavedFunc*    voidSavedFuncInit(VoidVaFunc func, int32_t numOfArgs);
 void*              genericInvoke(tGenericSavedFunc* const pSavedFunc);
 int32_t            i32Invoke(tI32SavedFunc* const pSavedFunc);
 void               voidInvoke(tVoidSavedFunc* const pSavedFunc);
@@ -53,4 +53,4 @@ void voidInvoke(tVoidSavedFunc* const pSavedFunc);
 }
 #endif
 
-#endif /*_TD_UTIL_FUNCTIONAL_H*/
+#endif /*_TD_UTIL_FUNCTIONAL_H_*/

include/util/thash.h

@@ -13,18 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_HASH_H
-#define TDENGINE_HASH_H
+#ifndef _TD_UTIL_HASH_H_
+#define _TD_UTIL_HASH_H_
+
+#include "tarray.h"
+#include "tlockfree.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tarray.h"
-#include "tlockfree.h"
-
 typedef uint32_t (*_hash_fn_t)(const char *, uint32_t);
-typedef int32_t  (*_equal_fn_t)(const void*, const void*, size_t len);
+typedef int32_t (*_equal_fn_t)(const void *, const void *, size_t len);
 typedef void (*_hash_before_fn_t)(void *);
 typedef void (*_hash_free_fn_t)(void *);
 
@@ -67,9 +67,9 @@ typedef struct SHashNode {
   char              data[];
 } SHashNode;
 
-#define GET_HASH_NODE_KEY(_n)  ((char*)(_n) + sizeof(SHashNode) + (_n)->dataLen)
-#define GET_HASH_NODE_DATA(_n) ((char*)(_n) + sizeof(SHashNode))
-#define GET_HASH_PNODE(_n) ((SHashNode *)((char*)(_n) - sizeof(SHashNode)))
+#define GET_HASH_NODE_KEY(_n)  ((char *)(_n) + sizeof(SHashNode) + (_n)->dataLen)
+#define GET_HASH_NODE_DATA(_n) ((char *)(_n) + sizeof(SHashNode))
+#define GET_HASH_PNODE(_n)     ((SHashNode *)((char *)(_n) - sizeof(SHashNode)))
 
 typedef enum SHashLockTypeE {
   HASH_NO_LOCK = 0,
@@ -128,7 +128,6 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da
 
 int32_t taosHashPutExt(SHashObj *pHashObj, const void *key, size_t keyLen, void *data, size_t size, bool *newAdded);
 
-
 /**
  * return the payload data with the specified key
  *
@@ -147,7 +146,7 @@ void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen);
  * @param destBuf
  * @return
  */
-void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void* destBuf);
+void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void *destBuf);
 
 /**
  * Clone the result to interval allocated buffer
@@ -157,7 +156,7 @@ void *taosHashGetClone(SHashObj *pHashObj, const void *key, size_t keyLen, void*
  * @param destBuf
  * @return
  */
-void* taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void** d, size_t *sz);
+void *taosHashGetCloneExt(SHashObj *pHashObj, const void *key, size_t keyLen, void (*fp)(void *), void **d, size_t *sz);
 
 /**
  * remove item with the specified key
@@ -213,8 +212,7 @@ void  taosHashCancelIterate(SHashObj *pHashObj, void *p);
  * @param data
  * @return
  */
-int32_t taosHashGetKey(void *data, void** key, size_t* keyLen);
-
+int32_t taosHashGetKey(void *data, void **key, size_t *keyLen);
 
 /**
  * Get the corresponding key information for a given data in hash table, using memcpy
@@ -222,13 +220,13 @@ int32_t taosHashGetKey(void *data, void** key, size_t* keyLen);
  * @param dst
  * @return
  */
-static FORCE_INLINE int32_t taosHashCopyKey(void *data, void* dst) {
+static FORCE_INLINE int32_t taosHashCopyKey(void *data, void *dst) {
   if (NULL == data || NULL == dst) {
     return -1;
   }
 
-  SHashNode * node = GET_HASH_PNODE(data);
-  void* key = GET_HASH_NODE_KEY(node);
+  SHashNode *node = GET_HASH_PNODE(data);
+  void      *key = GET_HASH_NODE_KEY(node);
   memcpy(dst, key, node->keyLen);
 
   return 0;
@@ -249,7 +247,7 @@ int32_t taosHashGetDataLen(void *data);
  * @param keyLen
  * @return
  */
-void* taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen);
+void *taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen);
 
 /**
  * release the prevous acquired obj
@@ -262,9 +260,8 @@ void taosHashRelease(SHashObj *pHashObj, void *p);
 
 void taosHashSetEqualFp(SHashObj *pHashObj, _equal_fn_t fp);
 
-
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_HASH_H
+#endif  // _TD_UTIL_HASH_H_

include/util/theap.h

@@ -12,19 +12,20 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef TDENGINE_HEAP_H
-#define TDENGINE_HEAP_H
+
+#ifndef _TD_UTIL_HEAP_H_
+#define _TD_UTIL_HEAP_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-
 struct HeapNode;
 
 /* Return non-zero if a < b. */
-typedef int (*HeapCompareFn)(const struct HeapNode* a, const struct HeapNode* b);
+typedef int32_t (*HeapCompareFn)(const struct HeapNode* a, const struct HeapNode* b);
 
 typedef struct HeapNode {
   struct HeapNode* left;
@@ -43,10 +44,9 @@ typedef struct {
   HeapCompareFn compFn;
 } Heap;
 
-
 Heap* heapCreate(HeapCompareFn fn);
 
-void heapDestroy(Heap *heap);
+void heapDestroy(Heap* heap);
 
 HeapNode* heapMin(const Heap* heap);
 
@@ -56,10 +56,10 @@ void heapRemove(Heap* heap, struct HeapNode* node);
 
 void heapDequeue(Heap* heap);
 
-size_t heapSize(Heap *heap);
+size_t heapSize(Heap* heap);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_HASH_H
+#endif /*_TD_UTIL_HEAP_H_*/

include/util/tcfg.h → include/util/thttp.h

@@ -13,23 +13,19 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_COMMON_CFG_H_
-#define _TD_COMMON_CFG_H_
+#ifndef _TD_UTIL_HTTP_H_
+#define _TD_UTIL_HTTP_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tdef.h"
-
-typedef struct {
-  char dir[TSDB_FILENAME_LEN];
-  int  level;
-  int  primary;
-} SDiskCfg;
+int32_t taosSendHttpReport(const char* server, uint16_t port, const char* pCont, int32_t contLen);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_COMMON_CFG_H_*/
+#endif /*_TD_UTIL_UTIL_H_*/

include/util/tidpool.h

@@ -13,31 +13,34 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_IDPOOL_H
-#define _TD_UTIL_IDPOOL_H
+#ifndef _TD_UTIL_IDPOOL_H_
+#define _TD_UTIL_IDPOOL_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void *taosInitIdPool(int maxId);
-
-int taosUpdateIdPool(void *handle, int maxId);
-
-int taosIdPoolMaxSize(void *handle);
-
-int taosAllocateId(void *handle);
-
-void taosFreeId(void *handle, int id);
-
-void taosIdPoolCleanUp(void *handle);
-
-int taosIdPoolNumOfUsed(void *handle);
-
-bool taosIdPoolMarkStatus(void *handle, int id);
+typedef struct {
+  int32_t         maxId;
+  int32_t         numOfFree;
+  int32_t         freeSlot;
+  bool           *freeList;
+  pthread_mutex_t mutex;
+} id_pool_t;
+
+void   *taosInitIdPool(int32_t maxId);
+int32_t taosUpdateIdPool(id_pool_t *handle, int32_t maxId);
+int32_t taosIdPoolMaxSize(id_pool_t *handle);
+int32_t taosAllocateId(id_pool_t *handle);
+void    taosFreeId(id_pool_t *handle, int32_t id);
+void    taosIdPoolCleanUp(id_pool_t *handle);
+int32_t taosIdPoolNumOfUsed(id_pool_t *handle);
+bool    taosIdPoolMarkStatus(id_pool_t *handle, int32_t id);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_UTIL_IDPOOL_H*/
+#endif /*_TD_UTIL_IDPOOL_H_*/

include/util/tjson.h

@@ -16,12 +16,12 @@
 #ifndef _TD_UTIL_JSON_H_
 #define _TD_UTIL_JSON_H_
 
+#include "os.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-
 typedef void SJson;
 
 SJson* tjsonCreateObject();

include/util/tlist.h

@@ -12,8 +12,11 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_UTIL_LIST_H
-#define _TD_UTIL_LIST_H
+
+#ifndef _TD_UTIL_LIST_H_
+#define _TD_UTIL_LIST_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -28,7 +31,7 @@ extern "C" {
 #define TD_SLIST(TYPE)      \
   struct {                  \
     struct TYPE *sl_head_;  \
-    int          sl_neles_; \
+    int32_t      sl_neles_; \
   }
 
 #define TD_SLIST_HEAD(sl)                         ((sl)->sl_head_)
@@ -79,7 +82,7 @@ extern "C" {
   struct {                  \
     struct TYPE *dl_head_;  \
     struct TYPE *dl_tail_;  \
-    int          dl_neles_; \
+    int32_t      dl_neles_; \
   }
 
 #define TD_DLIST_NODE_PREV(dln)                   ((dln)->dl_prev_)
@@ -200,11 +203,11 @@ typedef struct SListNode {
 
 typedef struct {
   TD_DLIST(SListNode);
-  int eleSize;
+  int32_t eleSize;
 } SList;
 
 typedef struct {
-  SListNode *         next;
+  SListNode          *next;
   TD_LIST_DIRECTION_T direction;
 } SListIter;
 
@@ -215,14 +218,14 @@ typedef struct {
 #define isListEmpty(l)  (TD_DLIST_NELES(l) == 0)
 #define listNodeFree(n) free(n)
 
-void       tdListInit(SList *list, int eleSize);
+void       tdListInit(SList *list, int32_t eleSize);
 void       tdListEmpty(SList *list);
-SList *    tdListNew(int eleSize);
-void *     tdListFree(SList *list);
+SList     *tdListNew(int32_t eleSize);
+void      *tdListFree(SList *list);
 void       tdListPrependNode(SList *list, SListNode *node);
 void       tdListAppendNode(SList *list, SListNode *node);
-int        tdListPrepend(SList *list, void *data);
-int        tdListAppend(SList *list, void *data);
+int32_t    tdListPrepend(SList *list, void *data);
+int32_t    tdListAppend(SList *list, void *data);
 SListNode *tdListPopHead(SList *list);
 SListNode *tdListPopTail(SList *list);
 SListNode *tdListGetHead(SList *list);
@@ -239,4 +242,4 @@ SListNode *tdListNext(SListIter *pIter);
 }
 #endif
 
-#endif /*_TD_UTIL_LIST_H*/
+#endif /*_TD_UTIL_LIST_H_*/
\ No newline at end of file

include/util/tlockfree.h

@@ -12,8 +12,9 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_UTIL_LOCK_FREE_H
-#define _TD_UTIL_LOCK_FREE_H
+
+#ifndef _TD_UTIL_LOCK_FREE_H_
+#define _TD_UTIL_LOCK_FREE_H_
 
 #include "os.h"
 
@@ -22,7 +23,7 @@ extern "C" {
 #endif
 
 // reference counting
-typedef void (*_ref_fn_t)(const void* pObj);
+typedef void (*_ref_fn_t)(const void *pObj);
 
 #define T_REF_DECLARE() \
   struct {              \
@@ -67,8 +68,6 @@ typedef void (*_ref_fn_t)(const void* pObj);
 
 #define T_REF_VAL_GET(x) (x)->_ref.val
 
-
-
 // single writer multiple reader lock
 typedef volatile int32_t SRWLatch;
 
@@ -78,10 +77,9 @@ void taosWUnLockLatch(SRWLatch *pLatch);
 void taosRLockLatch(SRWLatch *pLatch);
 void taosRUnLockLatch(SRWLatch *pLatch);
 
-
-
 // copy on read
-#define taosCorBeginRead(x) for (uint32_t i_ = 1; 1; ++i_) { \
+#define taosCorBeginRead(x)                     \
+  for (uint32_t i_ = 1; 1; ++i_) {              \
     int32_t old_ = atomic_add_fetch_32((x), 0); \
     if (old_ & 0x00000001) {                    \
       if (i_ % 1000 == 0) {                     \
@@ -96,12 +94,11 @@ void taosRUnLockLatch(SRWLatch *pLatch);
   }                                          \
   }
 
-#define taosCorBeginWrite(x) taosCorBeginRead(x) \
-    if (atomic_val_compare_exchange_32((x), old_, old_ + 1) != old_) { \
-        continue; \
-    }
+#define taosCorBeginWrite(x) \
+  taosCorBeginRead(x) if (atomic_val_compare_exchange_32((x), old_, old_ + 1) != old_) { continue; }
 
-#define taosCorEndWrite(x) atomic_add_fetch_32((x), 1); \
+#define taosCorEndWrite(x)     \
+  atomic_add_fetch_32((x), 1); \
   break;                       \
   }
 
@@ -109,4 +106,4 @@ void taosRUnLockLatch(SRWLatch *pLatch);
 }
 #endif
 
-#endif /*_TD_UTIL_LOCK_FREE_H*/
+#endif /*_TD_UTIL_LOCK_FREE_H_*/

include/util/tlog.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_LOG_H
-#define _TD_UTIL_LOG_H
+#ifndef _TD_UTIL_LOG_H_
+#define _TD_UTIL_LOG_H_
 
 #include "os.h"
 
@@ -22,7 +22,6 @@
 extern "C" {
 #endif
 
-extern bool    tsLogInited;
 extern bool    tsAsyncLog;
 extern int32_t tsNumOfLogLines;
 extern int32_t tsLogKeepDays;
@@ -55,7 +54,7 @@ int32_t taosInitLog(const char *logName, int32_t maxFiles);
 void    taosCloseLog();
 void    taosResetLog();
 void    taosSetAllDebugFlag(int32_t flag);
-void    taosDumpData(unsigned char *msg, int32_t len);
+void    taosDumpData(uint8_t *msg, int32_t len);
 
 void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...)
 #ifdef __GNUC__
@@ -69,8 +68,20 @@ void taosPrintLongString(const char *flags, int32_t dflag, const char *format, .
 #endif
     ;
 
+extern int8_t tscEmbeddedInUtil;
+
+#define uFatal(...) { if (uDebugFlag & DEBUG_FATAL) { taosPrintLog("UTL FATAL", tscEmbeddedInUtil ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uError(...) { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("UTL ERROR ", tscEmbeddedInUtil ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uWarn(...)  { if (uDebugFlag & DEBUG_WARN)  { taosPrintLog("UTL WARN ", tscEmbeddedInUtil ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uInfo(...)  { if (uDebugFlag & DEBUG_INFO)  { taosPrintLog("UTL ", tscEmbeddedInUtil ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uDebug(...) { if (uDebugFlag & DEBUG_DEBUG) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }}
+#define uTrace(...) { if (uDebugFlag & DEBUG_TRACE) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }}
+
+#define pError(...) { taosPrintLog("APP ERROR ", 255, __VA_ARGS__); }
+#define pPrint(...) { taosPrintLog("APP ", 255, __VA_ARGS__); }
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_UTIL_LOG_H*/
+#endif /*_TD_UTIL_LOG_H_*/

include/util/tlosertree.h

@@ -13,14 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_UTIL_LOSERTREE_H
-#define _TD_UTIL_LOSERTREE_H
+#ifndef _TD_UTIL_LOSERTREE_H_
+#define _TD_UTIL_LOSERTREE_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef int (*__merge_compare_fn_t)(const void *, const void *, void *param);
+typedef int32_t (*__merge_compare_fn_t)(const void *, const void *, void *param);
 
 typedef struct STreeNode {
   int32_t index;
@@ -31,16 +33,17 @@ typedef struct SMultiwayMergeTreeInfo {
   int32_t              numOfSources;
   int32_t              totalSources;
   __merge_compare_fn_t comparFn;
-  void *               param;
+  void                *param;
   struct STreeNode    *pNode;
 } SMultiwayMergeTreeInfo;
 
 #define tMergeTreeGetChosenIndex(t_) ((t_)->pNode[0].index)
 #define tMergeTreeGetAdjustIndex(t_) (tMergeTreeGetChosenIndex(t_) + (t_)->numOfSources)
 
-int32_t tMergeTreeCreate(SMultiwayMergeTreeInfo **pTree, uint32_t numOfEntries, void *param, __merge_compare_fn_t compareFn);
+int32_t tMergeTreeCreate(SMultiwayMergeTreeInfo **pTree, uint32_t numOfEntries, void *param,
+                         __merge_compare_fn_t compareFn);
 
-void tMergeTreeDestroy(SMultiwayMergeTreeInfo* pTree);
+void tMergeTreeDestroy(SMultiwayMergeTreeInfo *pTree);
 
 void tMergeTreeAdjust(SMultiwayMergeTreeInfo *pTree, int32_t idx);
 
@@ -52,4 +55,4 @@ void tMergeTreePrint(const SMultiwayMergeTreeInfo *pTree);
 }
 #endif
 
-#endif  /*_TD_UTIL_LOSERTREE_H*/
+#endif /*_TD_UTIL_LOSERTREE_H_*/

include/util/mallocator.h → include/util/tmallocator.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_MALLOCATOR_H_
-#define _TD_MALLOCATOR_H_
+#ifndef _TD_UTIL_MALLOCATOR_H_
+#define _TD_UTIL_MALLOCATOR_H_
 
 #include "os.h"
 
@@ -52,4 +52,4 @@ typedef struct SMemAllocatorFactory {
 }
 #endif
 
-#endif /*_TD_MALLOCATOR_H_*/
+#endif /*_TD_UTIL_MALLOCATOR_H_*/
\ No newline at end of file

include/util/tmd5.h

@@ -25,6 +25,12 @@
 #ifndef _TD_UTIL_MD5_H
 #define _TD_UTIL_MD5_H
 
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
   uint32_t i[2];       /* number of _bits_ handled mod 2^64 */
   uint32_t buf[4];     /* scratch buffer */
@@ -33,7 +39,11 @@ typedef struct {
 } T_MD5_CTX;
 
 void tMD5Init(T_MD5_CTX *mdContext);
-void tMD5Update(T_MD5_CTX *mdContext, uint8_t *inBuf, unsigned int inLen);
+void tMD5Update(T_MD5_CTX *mdContext, uint8_t *inBuf, uint32_t inLen);
 void tMD5Final(T_MD5_CTX *mdContext);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /*_TD_UTIL_MD5_H*/

include/util/tmempool.h

@@ -12,25 +12,24 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef _TD_UTIL_MEMPOOL_H
-#define _TD_UTIL_MEMPOOL_H
+#ifndef _TD_UTIL_MEMPOOL_H_
+#define _TD_UTIL_MEMPOOL_H_
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define mpool_h void *
-
-mpool_h taosMemPoolInit(int maxNum, int blockSize);
+typedef void *mpool_h;
 
+mpool_h taosMemPoolInit(int32_t maxNum, int32_t blockSize);
 char   *taosMemPoolMalloc(mpool_h handle);
-
 void    taosMemPoolFree(mpool_h handle, char *p);
-
 void    taosMemPoolCleanUp(mpool_h handle);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_UTIL_MEMPOOL_H*/
+#endif /*_TD_UTIL_MEMPOOL_H_*/

include/util/tpagedbuf.h

@@ -13,27 +13,25 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TPAGEDBUF_H
-#define TDENGINE_TPAGEDBUF_H
+#ifndef _TD_UTIL_PAGEDBUF_H_
+#define _TD_UTIL_PAGEDBUF_H_
+
+#include "thash.h"
+#include "tlist.h"
+#include "tlockfree.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tlist.h"
-#include "thash.h"
-#include "os.h"
-#include "tlockfree.h"
-
 typedef struct SArray*       SIDList;
 typedef struct SPageInfo     SPageInfo;
 typedef struct SDiskbasedBuf SDiskbasedBuf;
 
 #define DEFAULT_INTERN_BUF_PAGE_SIZE (1024L)  // in bytes
-#define DEFAULT_PAGE_SIZE             (16384L)
 
 typedef struct SFilePage {
-  int64_t num;
+  int32_t num;
   char    data[];
 } SFilePage;
 
@@ -55,7 +53,7 @@ typedef struct SDiskbasedBufStatis {
  * @param handle
  * @return
  */
-int32_t createDiskbasedBuffer(SDiskbasedBuf** pBuf, int32_t pagesize, int32_t inMemBufSize, uint64_t qId, const char* dir);
+int32_t createDiskbasedBuf(SDiskbasedBuf** pBuf, int32_t pagesize, int32_t inMemBufSize, uint64_t qId, const char* dir);
 
 /**
  *
@@ -64,7 +62,7 @@ int32_t createDiskbasedBuffer(SDiskbasedBuf** pBuf, int32_t pagesize, int32_t in
  * @param pageId
  * @return
  */
-SFilePage* getNewDataBuf(SDiskbasedBuf* pBuf, int32_t groupId, int32_t* pageId);
+void* getNewBufPage(SDiskbasedBuf* pBuf, int32_t groupId, int32_t* pageId);
 
 /**
  *
@@ -80,7 +78,7 @@ SIDList getDataBufPagesIdList(SDiskbasedBuf* pBuf, int32_t groupId);
  * @param id
  * @return
  */
-SFilePage* getBufPage(SDiskbasedBuf* pBuf, int32_t id);
+void* getBufPage(SDiskbasedBuf* pBuf, int32_t id);
 
 /**
  * release the referenced buf pages
@@ -108,13 +106,13 @@ size_t getTotalBufSize(const SDiskbasedBuf* pBuf);
  * @param pBuf
  * @return
  */
-size_t getNumOfResultBufGroupId(const SDiskbasedBuf* pBuf);
+size_t getNumOfBufGroupId(const SDiskbasedBuf* pBuf);
 
 /**
  * destroy result buffer
  * @param pBuf
  */
-void destroyResultBuf(SDiskbasedBuf* pBuf);
+void destroyDiskbasedBuf(SDiskbasedBuf* pBuf);
 
 /**
  *
@@ -137,6 +135,11 @@ int32_t getPageId(const SPageInfo* pPgInfo);
  */
 int32_t getBufPageSize(const SDiskbasedBuf* pBuf);
 
+/**
+ *
+ * @param pBuf
+ * @return
+ */
 int32_t getNumOfInMemBufPages(const SDiskbasedBuf* pBuf);
 
 /**
@@ -148,24 +151,45 @@ bool isAllDataInMemBuf(const SDiskbasedBuf* pBuf);
 
 /**
  * Set the buffer page is dirty, and needs to be flushed to disk when swap out.
- * @param pPageInfo
+ * @param pPage
  * @param dirty
  */
-void setBufPageDirty(SFilePage* pPageInfo, bool dirty);
+void setBufPageDirty(void* pPage, bool dirty);
+
+/**
+ * Set the compress/ no-compress flag for paged buffer, when flushing data in disk.
+ * @param pBuf
+ */
+void setBufPageCompressOnDisk(SDiskbasedBuf* pBuf, bool comp);
+
+/**
+ * Set the pageId page buffer is not need
+ * @param pBuf
+ * @param pageId
+ */
+void dBufSetBufPageRecycled(SDiskbasedBuf *pBuf, void* pPage);
 
 /**
  * Print the statistics when closing this buffer
  * @param pBuf
  */
-void printStatisBeforeClose(SDiskbasedBuf* pBuf);
+void dBufSetPrintInfo(SDiskbasedBuf* pBuf);
 
 /**
- * return buf statistics.
+ * Return buf statistics.
+ * @param pBuf
+ * @return
  */
 SDiskbasedBufStatis getDBufStatis(const SDiskbasedBuf* pBuf);
 
+/**
+ * Print the buffer statistics information
+ * @param pBuf
+ */
+void dBufPrintStatis(const SDiskbasedBuf* pBuf);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_TPAGEDBUF_H
+#endif  // _TD_UTIL_PAGEDBUF_H_

source/client/inc/clientInt.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#include "common.h"
+#include "tcommon.h"
 #include "parser.h"
 #include "query.h"
 #include "taos.h"