Merge branch '3.0' into feature/tq

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/CMakeLists.txt

@@ -193,6 +193,7 @@ endif(${BUILD_WITH_TRAFT})
 
 # LIBUV
 if(${BUILD_WITH_UV})
+    add_compile_options(-Wno-sign-compare)
     add_subdirectory(libuv)
 endif(${BUILD_WITH_UV})
 

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

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 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,

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;
@@ -214,7 +215,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 +280,4 @@ typedef struct SSessionWindow {
 }
 #endif
 
-#endif  // TDENGINE_COMMON_H
+#endif  /*_TD_COMMON_DEF_H_*/

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_)                                                          \
-  ((IS_VAR_DATA_TYPE((p1_)->info.type)) ? (p1_)->pData + (p1_)->varmeta.offset[(r_)] \
-                                        : (p1_)->pData + ((r_) * (p1_)->info.bytes));
+#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);
-void colDataTrim(SColumnInfoData* pColumnInfoData);
+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      blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
+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 blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
-void    blockDataClearup(SSDataBlock* pDataBlock, bool hasVarCol);
-void   *blockDataDestroy(SSDataBlock *pBlock);
+int32_t      blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRows);
+int32_t      blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
+void         blockDataClearup(SSDataBlock* pDataBlock, bool hasVarCol);
+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,57 +16,52 @@
 #ifndef _TD_COMMON_GLOBAL_H_
 #define _TD_COMMON_GLOBAL_H_
 
+#include "tarray.h"
+#include "tdef.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tdef.h"
-#include "tcfg.h"
-
 // cluster
 extern char     tsFirst[];
 extern char     tsSecond[];
 extern char     tsLocalFqdn[];
 extern char     tsLocalEp[];
 extern uint16_t tsServerPort;
+extern int32_t  tsVersion;
 extern int32_t  tsStatusInterval;
-extern int8_t   tsEnableTelemetryReporting;
-extern int32_t  tsNumOfSupportVnodes;
+extern bool     tsEnableTelemetryReporting;
 
 // common
-extern int      tsRpcTimer;
-extern int      tsRpcMaxTime;
-extern int      tsRpcForceTcp;  // all commands go to tcp protocol if this is enabled
-extern int32_t  tsMaxConnections;
-extern int32_t  tsMaxShellConns;
-extern int32_t  tsShellActivityTimer;
-extern uint32_t tsMaxTmrCtrl;
-extern float    tsNumOfThreadsPerCore;
-extern int32_t  tsNumOfCommitThreads;
-extern float    tsRatioOfQueryCores;
-extern int8_t   tsDaylight;
-extern int8_t   tsEnableCoreFile;
-extern int32_t  tsCompressMsgSize;
-extern int32_t  tsCompressColData;
-extern int32_t  tsMaxNumOfDistinctResults;
-extern char     tsTempDir[];
-extern int      tsCompatibleModel;  // 2.0 compatible model
-extern int8_t   tsEnableSlaveQuery;
-extern int8_t   tsEnableAdjustMaster;
-extern int8_t   tsPrintAuth;
-extern int64_t  tsTickPerDay[3];
+extern int32_t tsRpcTimer;
+extern int32_t tsRpcMaxTime;
+extern bool    tsRpcForceTcp;  // all commands go to tcp protocol if this is enabled
+extern int32_t tsMaxConnections;
+extern int32_t tsMaxShellConns;
+extern int32_t tsShellActivityTimer;
+extern int32_t tsMaxTmrCtrl;
+extern float   tsNumOfThreadsPerCore;
+extern int32_t tsNumOfCommitThreads;
+extern float   tsRatioOfQueryCores;
+extern int32_t tsCompressMsgSize;
+extern int32_t tsCompressColData;
+extern int32_t tsMaxNumOfDistinctResults;
+extern int32_t tsCompatibleModel;
+extern bool    tsEnableSlaveQuery;
+extern bool    tsPrintAuth;
+extern int64_t tsTickPerDay[3];
 
 // 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
-extern int32_t tsRetrieveBlockingModel;  // retrieve threads will be blocked
-extern int8_t  tsKeepOriginalColumnName;
-extern int8_t  tsDeadLockKillQuery;
+extern bool    tsRetrieveBlockingModel;  // retrieve threads will be blocked
+extern bool    tsKeepOriginalColumnName;
+extern bool    tsDeadLockKillQuery;
 
 // client
 extern int32_t tsMaxWildCardsLen;
 extern int32_t tsMaxRegexStringLen;
-extern int8_t  tsTscEnableRecordSql;
 extern int32_t tsMaxNumOfOrderedResults;
 extern int32_t tsMinSlidingTime;
 extern int32_t tsMinIntervalTime;
@@ -77,19 +72,6 @@ extern float   tsStreamComputDelayRatio;  // the delayed computing ration of the
 extern int32_t tsProjectExecInterval;
 extern int64_t tsMaxRetentWindow;
 
-// system info
-extern float    tsTotalLogDirGB;
-extern float    tsTotalTmpDirGB;
-extern float    tsTotalDataDirGB;
-extern float    tsAvailLogDirGB;
-extern float    tsAvailTmpDirectorySpace;
-extern float    tsAvailDataDirGB;
-extern float    tsUsedDataDirGB;
-extern float    tsMinimalLogDirGB;
-extern float    tsReservedTmpDirectorySpace;
-extern float    tsMinimalDataDirGB;
-extern uint32_t tsVersion;
-
 // build info
 extern char version[];
 extern char compatible_version[];
@@ -105,18 +87,19 @@ extern uint32_t tsMaxRange;
 extern uint32_t tsCurRange;
 extern char     tsCompressor[];
 
+// tfs
 extern int32_t  tsDiskCfgNum;
 extern SDiskCfg tsDiskCfg[];
 
 #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
-void    taosInitGlobalCfg();
-int32_t taosCheckAndPrintCfg();
-int32_t taosCfgDynamicOptions(char *msg);
-bool    taosCheckBalanceCfgOptions(const char *option, int32_t *vnodeId, int32_t *dnodeId);
-void    taosAddDataDir(int index, char *v1, int level, int primary);
-void    taosReadDataDirCfg(char *v1, char *v2, char *v3);
-void    taosPrintDataDirCfg();
+int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char *envFile,
+                      const char *apolloUrl, SArray *pArgs, bool tsc);
+int32_t taosInitCfg(const char *cfgDir, const char *envFile, const char *apolloUrl, SArray *pArgs, bool tsc);
+void    taosCleanupCfg();
+void    taosCfgDynamicOptions(const char *option, const char *value);
+
+struct SConfig *taosGetCfg();
 
 #ifdef __cplusplus
 }

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_
@@ -48,8 +48,8 @@ extern "C" {
 #undef TD_MSG_SEG_CODE_
 #include "tmsgdef.h"
 
-extern char* tMsgInfo[];
-extern int   tMsgDict[];
+extern char*   tMsgInfo[];
+extern int32_t tMsgDict[];
 
 #define TMSG_SEG_CODE(TYPE) (((TYPE)&0xff00) >> 8)
 #define TMSG_SEG_SEQ(TYPE)  ((TYPE)&0xff)
@@ -655,10 +655,10 @@ int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp
 
 typedef struct {
   int32_t statusInterval;
-  int64_t checkTime;                    // 1970-01-01 00:00:00.000
-  char    timezone[TSDB_TIMEZONE_LEN];  // tsTimezone
-  char    locale[TSDB_LOCALE_LEN];      // tsLocale
-  char    charset[TSDB_LOCALE_LEN];     // tsCharset
+  int64_t checkTime;                  // 1970-01-01 00:00:00.000
+  char    timezone[TD_TIMEZONE_LEN];  // tsTimezone
+  char    locale[TD_LOCALE_LEN];      // tsLocale
+  char    charset[TD_LOCALE_LEN];     // tsCharset
 } SClusterCfg;
 
 typedef struct {
@@ -1117,13 +1117,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 +1134,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 +1153,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 +1166,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 +1184,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);
@@ -1395,8 +1395,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);
@@ -1417,8 +1417,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);
@@ -1447,8 +1447,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);
@@ -1589,8 +1589,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;
 }
@@ -1607,8 +1607,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);
@@ -1643,14 +1643,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);
   }
@@ -1664,7 +1664,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);

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)
@@ -135,8 +135,9 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_SHOW, "mnode-show", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SHOW_RETRIEVE, "mnode-retrieve", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_STATUS, "mnode-status", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_TRANS, "mnode-trans", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TRANS_TIMER, "mnode-trans-tmr", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_TRANS, "mnode-kill-trans", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TELEM_TIMER, "mnode-telem-tmr", SMTimerReq, SMTimerReq)
   TD_DEF_MSG_TYPE(TDMT_MND_GRANT, "mnode-grant", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_AUTH, "mnode-auth", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TOPIC, "mnode-create-topic", SMCreateTopicReq, SMCreateTopicRsp)
@@ -144,7 +145,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_TOPIC, "mnode-drop-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SUBSCRIBE, "mnode-subscribe", SCMSubscribeReq, SCMSubscribeRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_SUB_EP, "mnode-get-sub-ep", SMqCMGetSubEpReq, SMqCMGetSubEpRsp)
-  TD_DEF_MSG_TYPE(TDMT_MND_MQ_TIMER, "mnode-mq-timer", SMTimerReq, SMTimerReq)
+  TD_DEF_MSG_TYPE(TDMT_MND_MQ_TIMER, "mnode-mq-tmr", SMTimerReq, SMTimerReq)
   TD_DEF_MSG_TYPE(TDMT_MND_MQ_DO_REBALANCE, "mnode-mq-do-rebalance", SMqDoRebalanceMsg, SMqDoRebalanceMsg)
   TD_DEF_MSG_TYPE(TDMT_MND_MQ_COMMIT_OFFSET, "mnode-mq-commit-offset", SMqCMCommitOffsetReq, SMqCMCommitOffsetRsp)
 

include/common/tname.h

@@ -13,26 +13,25 @@
  * 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
 
+#define TSDB_DB_NAME_T    1
+#define TSDB_TABLE_NAME_T 2
 
-#include "tdef.h"
-#include "tmsg.h"
-
-#define TSDB_DB_NAME_T     1
-#define TSDB_TABLE_NAME_T  2
-
-#define T_NAME_ACCT        0x1u
-#define T_NAME_DB          0x2u
-#define T_NAME_TABLE       0x4u
+#define T_NAME_ACCT  0x1u
+#define T_NAME_DB    0x2u
+#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"
@@ -47,21 +47,21 @@ extern "C" {
 #define TD_VTYPE_NONE 0x0U   // none or unknown/undefined
 #define TD_VTYPE_NULL 0x01U  // null val
 #define TD_VTYPE_NORM 0x02U  // normal val: not none, not null
-#define TD_VTYPE_MAX 0x03U   //
+#define TD_VTYPE_MAX  0x03U  //
 
 #define TD_VTYPE_NONE_BYTE 0x0U
 #define TD_VTYPE_NULL_BYTE 0x55U
 #define TD_VTYPE_NORM_BYTE 0xAAU
 
-#define TD_ROWS_ALL_NORM 0x01U
+#define TD_ROWS_ALL_NORM  0x01U
 #define TD_ROWS_NULL_NORM 0x0U
 
-#define TD_COL_ROWS_NORM(c) ((c)->bitmap == TD_ROWS_ALL_NORM)  // all rows of SDataCol/SBlockCol is NORM
+#define TD_COL_ROWS_NORM(c)          ((c)->bitmap == TD_ROWS_ALL_NORM)  // all rows of SDataCol/SBlockCol is NORM
 #define TD_SET_COL_ROWS_BTIMAP(c, v) ((c)->bitmap = (v))
-#define TD_SET_COL_ROWS_NORM(c) TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_ALL_NORM)
-#define TD_SET_COL_ROWS_MISC(c) TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_NULL_NORM)
+#define TD_SET_COL_ROWS_NORM(c)      TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_ALL_NORM)
+#define TD_SET_COL_ROWS_MISC(c)      TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_NULL_NORM)
 
-#define KvConvertRatio (0.9f)
+#define KvConvertRatio            (0.9f)
 #define isSelectKVRow(klen, tlen) ((klen) < ((tlen)*KvConvertRatio))
 
 #ifdef TD_SUPPORT_BITMAP
@@ -98,7 +98,7 @@ typedef void *SRow;
 
 typedef struct {
   TDRowValT valType;
-  void *    val;
+  void     *val;
 } SCellVal;
 
 typedef struct {
@@ -157,41 +157,41 @@ typedef struct {
   int16_t nBitmaps;
   int16_t nBoundBitmaps;
   int32_t offset;
-  void *  pBitmap;
-  void *  pOffset;
+  void   *pBitmap;
+  void   *pOffset;
   int32_t extendedRowSize;
 } SRowBuilder;
 
-#define TD_ROW_HEAD_LEN (sizeof(STSRow))
+#define TD_ROW_HEAD_LEN  (sizeof(STSRow))
 #define TD_ROW_NCOLS_LEN (sizeof(col_id_t))
 
-#define TD_ROW_TYPE(r) ((r)->type)
-#define TD_ROW_DELETE(r) ((r)->del)
-#define TD_ROW_ENDIAN(r) ((r)->endian)
-#define TD_ROW_SVER(r) ((r)->sver)
-#define TD_ROW_NCOLS(r) ((r)->data)  // only valid for SKvRow
-#define TD_ROW_DATA(r) ((r)->data)
-#define TD_ROW_LEN(r) ((r)->len)
-#define TD_ROW_KEY(r) ((r)->ts)
+#define TD_ROW_TYPE(r)     ((r)->type)
+#define TD_ROW_DELETE(r)   ((r)->del)
+#define TD_ROW_ENDIAN(r)   ((r)->endian)
+#define TD_ROW_SVER(r)     ((r)->sver)
+#define TD_ROW_NCOLS(r)    ((r)->data)  // only valid for SKvRow
+#define TD_ROW_DATA(r)     ((r)->data)
+#define TD_ROW_LEN(r)      ((r)->len)
+#define TD_ROW_KEY(r)      ((r)->ts)
 #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))
-#define TD_ROW_SET_DELETE(r) (TD_ROW_DELETE(r) = 1)
-#define TD_ROW_SET_SVER(r, v) (TD_ROW_SVER(r) = (v))
-#define TD_ROW_SET_LEN(r, l) (TD_ROW_LEN(r) = (l))
+#define TD_ROW_SET_TYPE(r, t)  (TD_ROW_TYPE(r) = (t))
+#define TD_ROW_SET_DELETE(r)   (TD_ROW_DELETE(r) = 1)
+#define TD_ROW_SET_SVER(r, v)  (TD_ROW_SVER(r) = (v))
+#define TD_ROW_SET_LEN(r, l)   (TD_ROW_LEN(r) = (l))
 #define TD_ROW_SET_NCOLS(r, n) (*(col_id_t *)TD_ROW_NCOLS(r) = (n))
 
 #define TD_ROW_IS_DELETED(r) (TD_ROW_DELETE(r) == 1)
-#define TD_IS_TP_ROW(r) (TD_ROW_TYPE(r) == TD_ROW_TP)
-#define TD_IS_KV_ROW(r) (TD_ROW_TYPE(r) == TD_ROW_KV)
-#define TD_IS_TP_ROW_T(t) ((t) == TD_ROW_TP)
-#define TD_IS_KV_ROW_T(t) ((t) == TD_ROW_KV)
+#define TD_IS_TP_ROW(r)      (TD_ROW_TYPE(r) == TD_ROW_TP)
+#define TD_IS_KV_ROW(r)      (TD_ROW_TYPE(r) == TD_ROW_KV)
+#define TD_IS_TP_ROW_T(t)    ((t) == TD_ROW_TP)
+#define TD_IS_KV_ROW_T(t)    ((t) == TD_ROW_KV)
 
-#define TD_BOOL_STR(b) ((b) ? "true" : "false")
+#define TD_BOOL_STR(b)       ((b) ? "true" : "false")
 #define isUtilizeKVRow(k, d) ((k) < ((d)*KVRatioConvert))
 
 #define TD_ROW_COL_IDX(r) POINTER_SHIFT(TD_ROW_DATA(r), sizeof(col_id_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 {
@@ -1079,15 +1078,15 @@ typedef struct {
 // STSRowBuilder
 #define trbInit(rt, allocator, endian, target, size) \
   { .type = (rt), .bw = tbufInitWriter(allocator, endian), .pRow = (target) }
-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);
+void    trbSetRowInfo(STSRowBuilder *pRB, bool del, uint16_t sver);
+void    trbSetRowVersion(STSRowBuilder *pRB, uint64_t ver);
+void    trbSetRowTS(STSRowBuilder *pRB, TSKEY ts);
+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();
   }
 }
@@ -56,4 +56,4 @@ int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrec
 }
 #endif
 
-#endif  /*_TD_COMMON_TIME_H_*/
+#endif /*_TD_COMMON_TIME_H_*/

include/common/ttszip.h

@@ -13,19 +13,19 @@
  * 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"
 
-#define MEM_BUF_SIZE (1 << 20)
-#define TS_COMP_FILE_MAGIC 0x87F5EC4C
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MEM_BUF_SIZE           (1 << 20)
+#define TS_COMP_FILE_MAGIC     0x87F5EC4C
 #define TS_COMP_FILE_GROUP_MAX 512
 
 typedef struct STSList {
@@ -61,10 +61,10 @@ typedef struct STSBlock {
  * and the offset of int32_t type is enough
  */
 typedef struct STSGroupBlockInfo {
-  int32_t id;          // group id
-  int32_t offset;      // offset set value in file
-  int32_t numOfBlocks; // number of total blocks
-  int32_t compLen;     // compressed size
+  int32_t id;           // group id
+  int32_t offset;       // offset set value in file
+  int32_t numOfBlocks;  // number of total blocks
+  int32_t compLen;      // compressed size
 } STSGroupBlockInfo;
 
 typedef struct STSGroupBlockInfoEx {
@@ -73,9 +73,9 @@ typedef struct STSGroupBlockInfoEx {
 } STSGroupBlockInfoEx;
 
 typedef struct STSBuf {
-  FILE*    f;
-  char     path[PATH_MAX];
-  uint32_t fileSize;
+  TdFilePtr pFile;
+  char      path[PATH_MAX];
+  uint32_t  fileSize;
 
   // todo use array
   STSGroupBlockInfoEx* pData;
@@ -112,9 +112,9 @@ STSBuf* tsBufClone(STSBuf* pTSBuf);
 
 STSGroupBlockInfo* tsBufGetGroupBlockInfo(STSBuf* pTSBuf, int32_t id);
 
-void    tsBufFlush(STSBuf* pTSBuf);
-void    tsBufResetPos(STSBuf* pTSBuf);
-bool    tsBufNextPos(STSBuf* pTSBuf);
+void tsBufFlush(STSBuf* pTSBuf);
+void tsBufResetPos(STSBuf* pTSBuf);
+bool tsBufNextPos(STSBuf* pTSBuf);
 
 STSElem tsBufGetElem(STSBuf* pTSBuf);
 STSElem tsBufGetElemStartPos(STSBuf* pTSBuf, int32_t id, SVariant* tag);
@@ -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;
@@ -32,19 +42,18 @@ typedef struct {
 } SNCharNullT;
 #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 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))
+#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 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)
+#define TSDB_DATA_TYPE_POINTER_ARRAY (1000)
+#define TSDB_DATA_TYPE_VALUE_ARRAY   (1001)
 
 #define GET_TYPED_DATA(_v, _finalType, _type, _data) \
   do {                                               \
@@ -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;                                       \
@@ -91,7 +100,7 @@ typedef struct {
   do {                                         \
     switch (_type) {                           \
       case TSDB_DATA_TYPE_BOOL:                \
-        *(bool *)(_v) = (bool)(_data);     \
+        *(bool *)(_v) = (bool)(_data);         \
         break;                                 \
       case TSDB_DATA_TYPE_TINYINT:             \
         *(int8_t *)(_v) = (int8_t)(_data);     \
@@ -135,18 +144,19 @@ typedef struct {
 
 #define IS_NUMERIC_TYPE(_t) ((IS_SIGNED_NUMERIC_TYPE(_t)) || (IS_UNSIGNED_NUMERIC_TYPE(_t)) || (IS_FLOAT_TYPE(_t)))
 
-#define IS_VALID_TINYINT(_t)    ((_t) > INT8_MIN  && (_t) <= INT8_MAX)
-#define IS_VALID_SMALLINT(_t)   ((_t) > INT16_MIN && (_t) <= INT16_MAX)
-#define IS_VALID_INT(_t)        ((_t) > INT32_MIN && (_t) <= INT32_MAX)
-#define IS_VALID_BIGINT(_t)     ((_t) > INT64_MIN && (_t) <= INT64_MAX)
-#define IS_VALID_UTINYINT(_t)   ((_t) >= 0 && (_t) < UINT8_MAX)
-#define IS_VALID_USMALLINT(_t)  ((_t) >= 0 && (_t) < UINT16_MAX)
-#define IS_VALID_UINT(_t)       ((_t) >= 0 && (_t) < UINT32_MAX)
-#define IS_VALID_UBIGINT(_t)    ((_t) >= 0 && (_t) < UINT64_MAX)
-#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_VALID_TINYINT(_t)   ((_t) > INT8_MIN && (_t) <= INT8_MAX)
+#define IS_VALID_SMALLINT(_t)  ((_t) > INT16_MIN && (_t) <= INT16_MAX)
+#define IS_VALID_INT(_t)       ((_t) > INT32_MIN && (_t) <= INT32_MAX)
+#define IS_VALID_BIGINT(_t)    ((_t) > INT64_MIN && (_t) <= INT64_MAX)
+#define IS_VALID_UTINYINT(_t)  ((_t) >= 0 && (_t) < UINT8_MAX)
+#define IS_VALID_USMALLINT(_t) ((_t) >= 0 && (_t) < UINT16_MAX)
+#define IS_VALID_UINT(_t)      ((_t) >= 0 && (_t) < UINT32_MAX)
+#define IS_VALID_UBIGINT(_t)   ((_t) >= 0 && (_t) < UINT64_MAX)
+#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_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  setNull(void *val, int32_t type, int32_t bytes);
-void  setNullN(void *val, int32_t type, int32_t bytes, int32_t numOfElems);
+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 operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type);
-void* getDataMin(int32_t type);
-void* getDataMax(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  operateVal(void *dst, void *s1, void *s2, int32_t optr, 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,34 +13,34 @@
  * 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;
-  int32_t    nLen;  // only used for string, for number, it is useless
+  uint32_t nType;
+  int32_t  nLen;  // only used for string, for number, it is useless
   union {
     int64_t  i;
     uint64_t u;
     double   d;
     char    *pz;
     wchar_t *wpz;
-    SArray  *arr; // only for 'in' query to hold value list, not value for a field
+    SArray  *arr;  // only for 'in' query to hold value list, not value for a field
   };
 } 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

@@ -25,26 +25,12 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ---------------- */
 typedef struct SDnode SDnode;
 
-/* ------------------------ Environment ------------------ */
-typedef struct {
-  int32_t sver;
-  int32_t numOfCores;
-  int16_t numOfCommitThreads;
-  int8_t  enableTelem;
-  char    timezone[TSDB_TIMEZONE_LEN];
-  char    locale[TSDB_LOCALE_LEN];
-  char    charset[TSDB_LOCALE_LEN];
-  char    buildinfo[64];
-  char    gitinfo[48];
-} SDnodeEnvCfg;
-
 /**
  * @brief Initialize the environment
  *
- * @param pOption Option of the environment
  * @return int32_t 0 for success and -1 for failure
  */
-int32_t dndInit(const SDnodeEnvCfg *pCfg);
+int32_t dndInit();
 
 /**
  * @brief clear the environment
@@ -54,17 +40,15 @@ void dndCleanup();
 
 /* ------------------------ SDnode ----------------------- */
 typedef struct {
-  int32_t  numOfSupportVnodes;
-  int32_t  statusInterval;
-  float    numOfThreadsPerCore;
-  float    ratioOfQueryCores;
-  int32_t  maxShellConns;
-  int32_t  shellActivityTimer;
-  uint16_t serverPort;
-  char     dataDir[TSDB_FILENAME_LEN];
-  char     localEp[TSDB_EP_LEN];
-  char     localFqdn[TSDB_FQDN_LEN];
-  char     firstEp[TSDB_EP_LEN];
+  int32_t   numOfSupportVnodes;
+  uint16_t  serverPort;
+  char      dataDir[TSDB_FILENAME_LEN];
+  char      localEp[TSDB_EP_LEN];
+  char      localFqdn[TSDB_FQDN_LEN];
+  char      firstEp[TSDB_EP_LEN];
+  char      secondEp[TSDB_EP_LEN];
+  SDiskCfg *pDisks;
+  int32_t   numOfDisks;
 } SDnodeObjCfg;
 
 /**

include/dnode/mnode/mnode.h

@@ -44,25 +44,12 @@ typedef struct SMnodeLoad {
   int64_t compStorage;
 } SMnodeLoad;
 
-typedef struct SMnodeCfg {
-  int32_t sver;
-  int8_t  enableTelem;
-  int32_t statusInterval;
-  int32_t shellActivityTimer;
-  char   *timezone;
-  char   *locale;
-  char   *charset;
-  char   *buildinfo;
-  char   *gitinfo;
-} SMnodeCfg;
-
 typedef struct {
   int32_t           dnodeId;
   int64_t           clusterId;
   int8_t            replica;
   int8_t            selfIndex;
   SReplica          replicas[TSDB_MAX_REPLICA];
-  SMnodeCfg         cfg;
   SDnode           *pDnode;
   PutReqToMWriteQFp putReqToMWriteQFp;
   PutReqToMReadQFp  putReqToMReadQFp;

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"

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,12 +41,22 @@ 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);
+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

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,11 +229,16 @@ typedef struct SAggFunctionInfo {
 } SAggFunctionInfo;
 
 typedef struct SScalarParam {
-  void*   data;
-  bool    colData;
-  int32_t num;
-  int32_t type;
-  int32_t bytes;
+  void            *data;
+  union {
+    SColumnInfoData *columnData;
+    void            *data;
+  } orig;  
+  char            *bitmap;
+  bool             dataInBlock;
+  int32_t          num;
+  int32_t          type;
+  int32_t          bytes;
 } SScalarParam;
 
 typedef struct SScalarFunctionInfo {

include/libs/nodes/nodes.h

@@ -62,9 +62,8 @@ typedef enum ENodeType {
   QUERY_NODE_NODE_LIST,
   QUERY_NODE_FILL,
   QUERY_NODE_RAW_EXPR, // Only be used in parser module.
-  QUERY_NODE_COLUMN_REF,
   QUERY_NODE_TARGET,
-  QUERY_NODE_TUPLE_DESC,
+  QUERY_NODE_DATABLOCK_DESC,
   QUERY_NODE_SLOT_DESC,
 
   // Statement nodes are used in parser and planner module.
@@ -81,7 +80,9 @@ typedef enum ENodeType {
   // physical plan node
   QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN,
   QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_PROJECT
+  QUERY_NODE_PHYSICAL_PLAN_PROJECT,
+  QUERY_NODE_PHYSICAL_PLAN_JOIN,
+  QUERY_NODE_PHYSICAL_PLAN_AGG
 } ENodeType;
 
 /**

include/libs/nodes/plannodes.h

@@ -69,21 +69,20 @@ typedef struct SSlotDescNode {
   ENodeType type;
   int16_t slotId;
   SDataType dataType;
-  int16_t srcTupleId;
-  int16_t srcSlotId;
   bool reserve;
   bool output;
+  bool tag;
 } SSlotDescNode;
 
-typedef struct STupleDescNode {
+typedef struct SDataBlockDescNode {
   ENodeType type;
-  int16_t tupleId;
+  int16_t dataBlockId;
   SNodeList* pSlots;
-} STupleDescNode;
+} SDataBlockDescNode;
 
 typedef struct SPhysiNode {
   ENodeType type;
-  STupleDescNode outputTuple;
+  SDataBlockDescNode outputDataBlockDesc;
   SNode* pConditions;
   SNodeList* pChildren;
   struct SPhysiNode* pParent;
@@ -106,6 +105,7 @@ typedef struct STableScanPhysiNode {
   SScanPhysiNode scan;
   uint8_t scanFlag;         // denotes reversed scan of data or not
   STimeWindow scanRange;
+  SNode* pScanConditions;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;
@@ -115,6 +115,20 @@ typedef struct SProjectPhysiNode {
   SNodeList* pProjections;
 } SProjectPhysiNode;
 
+typedef struct SJoinPhysiNode {
+  SPhysiNode node;
+  EJoinType joinType;
+  SNode* pOnConditions; // in or out tuple ?
+  SNodeList* pTargets;
+} SJoinPhysiNode;
+
+typedef struct SAggPhysiNode {
+  SPhysiNode node;
+  SNodeList* pExprs;   // these are expression list of group_by_clause and parameter expression of aggregate function
+  SNodeList* pGroupKeys; // SColumnRefNode list
+  SNodeList* pAggFuncs;
+} SAggPhysiNode;
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/querynodes.h

@@ -58,19 +58,13 @@ typedef struct SColumnNode {
   char tableAlias[TSDB_TABLE_NAME_LEN];
   char colName[TSDB_COL_NAME_LEN];
   SNode* pProjectRef;
-} SColumnNode;
-
-typedef struct SColumnRefNode {
-  ENodeType type;
-  SDataType dataType;
-  int16_t tupleId;
+  int16_t dataBlockId;
   int16_t slotId;
-  int16_t columnId;
-} SColumnRefNode;
+} SColumnNode;
 
 typedef struct STargetNode {
   ENodeType type;
-  int16_t tupleId;
+  int16_t dataBlockId;
   int16_t slotId;
   SNode* pExpr;
 } STargetNode;

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/scalar/filter.h

@@ -37,8 +37,8 @@ typedef struct SFilterColumnParam{
 
 extern int32_t filterInitFromNode(SNode *pNode, SFilterInfo **pinfo, uint32_t options);
 extern bool filterExecute(SFilterInfo *info, SSDataBlock *pSrc, int8_t** p, SColumnDataAgg *statis, int16_t numOfCols);
-extern int32_t filterSetDataFromSlotId(SFilterInfo *info, void *param, filer_get_col_from_id fp);
-extern int32_t filterSetDataFromColId(SFilterInfo *info, void *param, filer_get_col_from_id fp);
+extern int32_t filterSetDataFromSlotId(SFilterInfo *info, void *param);
+extern int32_t filterSetDataFromColId(SFilterInfo *info, void *param);
 extern int32_t filterGetTimeRange(SFilterInfo *info, STimeWindow *win);
 extern int32_t filterConverNcharColumns(SFilterInfo* pFilterInfo, int32_t rows, bool *gotNchar);
 extern int32_t filterFreeNcharColumns(SFilterInfo* pFilterInfo);

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;
@@ -34,23 +36,23 @@ typedef enum {
   TAOS_SYNC_STATE_LEADER = 2,
 } ESyncState;
 
-typedef struct {
+typedef struct SSyncBuffer {
   void*  data;
   size_t len;
 } SSyncBuffer;
 
-typedef struct {
-  SyncNodeId nodeId;
-  uint16_t   nodePort;                 // node sync Port
-  char       nodeFqdn[TSDB_FQDN_LEN];  // node FQDN
+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];
@@ -128,12 +130,12 @@ typedef struct SStateMgr {
 
 } SStateMgr;
 
-typedef struct {
-  SyncGroupId   vgId;
-  SSyncCfg      syncCfg;
-  SSyncLogStore logStore;
-  SStateMgr     stateManager;
-  SSyncFSM      syncFsm;
+typedef struct SSyncInfo {
+  SyncGroupId vgId;
+  SSyncCfg    syncCfg;
+  char        path[TSDB_FILENAME_LEN];
+  SSyncFSM*   pFsm;
+  int32_t (*FpSendMsg)(void* handle, const SEpSet* pEpSet, SRpcMsg* pMsg);
 
 } SSyncInfo;
 

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/libs/transport/trpc.h

@@ -78,12 +78,15 @@ typedef struct SRpcInit {
   // call back to retrieve the client auth info, for server app only
   int (*afp)(void *parent, char *tableId, char *spi, char *encrypt, char *secret, char *ckey);
 
+  // call back to keep conn or not
+  bool (*pfp)(void *parent, tmsg_t msgType);
+
   void *parent;
 } SRpcInit;
 
 int32_t rpcInit();
 void    rpcCleanup();
-void *  rpcOpen(const SRpcInit *pRpc);
+void   *rpcOpen(const SRpcInit *pRpc);
 void    rpcClose(void *);
 void *  rpcMallocCont(int contLen);
 void    rpcFreeCont(void *pCont);

include/libs/wal/wal.h

@@ -120,8 +120,8 @@ typedef struct SWal {
   int32_t fsyncSeq;
   // meta
   SWalVer vers;
-  int64_t writeLogTfd;
-  int64_t writeIdxTfd;
+  TdFilePtr pWriteLogTFile;
+  TdFilePtr pWriteIdxTFile;
   int32_t writeCur;
   SArray *fileInfoSet;
   // status
@@ -138,8 +138,8 @@ typedef struct SWal {
 
 typedef struct SWalReadHandle {
   SWal     *pWal;
-  int64_t   readLogTfd;
-  int64_t   readIdxTfd;
+  TdFilePtr pReadLogTFile;
+  TdFilePtr pReadIdxTFile;
   int64_t   curFileFirstVer;
   int64_t   curVersion;
   int64_t   capacity;

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" {
@@ -59,6 +59,7 @@ extern "C" {
 #include "osEndian.h"
 #include "osEnv.h"
 #include "osFile.h"
+#include "osLocale.h"
 #include "osLz4.h"
 #include "osMath.h"
 #include "osMemory.h"
@@ -73,6 +74,7 @@ extern "C" {
 #include "osThread.h"
 #include "osTime.h"
 #include "osTimer.h"
+#include "osTimezone.h"
 
 void osInit();
 
@@ -80,4 +82,4 @@ void osInit();
 }
 #endif
 
-#endif
+#endif /*_TD_OS_H_*/

include/os/osDef.h

@@ -191,6 +191,10 @@ extern "C" {
 #define TD_DIRSEP	"/"
 #endif
 
+#define TD_LOCALE_LEN   64
+#define TD_CHARSET_LEN  64
+#define TD_TIMEZONE_LEN 96
+
 #ifdef __cplusplus
 }
 #endif

include/os/osDir.h

@@ -23,8 +23,8 @@ extern "C" {
 void    taosRemoveDir(const char *dirname);
 int32_t taosDirExist(char *dirname);
 int32_t taosMkDir(const char *dirname);
-void    taosRemoveOldFiles(char *dirname, int32_t keepDays);
-int32_t taosExpandDir(char *dirname, char *outname, int32_t maxlen);
+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);
 
 #ifdef __cplusplus

include/os/osEnv.h

@@ -16,15 +16,37 @@
 #ifndef _TD_OS_ENV_H_
 #define _TD_OS_ENV_H_
 
+#include "osSysinfo.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-extern char tsOsName[];
+extern char    tsOsName[];
+extern char    tsTimezone[];
+extern char    tsCharset[];
+extern char    tsLocale[];
+extern int8_t  tsDaylight;
+extern bool    tsEnableCoreFile;
+extern int64_t tsPageSize;
+extern int64_t tsOpenMax;
+extern int64_t tsStreamMax;
+extern int32_t tsNumOfCores;
+extern int32_t tsTotalMemoryMB;
+
+extern char configDir[];
 extern char tsDataDir[];
 extern char tsLogDir[];
-extern char tsScriptDir[];
-extern char configDir[];
+extern char tsTempDir[];
+
+extern SDiskSpace tsDataSpace;
+extern SDiskSpace tsLogSpace;
+extern SDiskSpace tsTempSpace;
+
+void osInit();
+void osUpdate();
+bool osLogSpaceAvailable();
+void osSetTimezone(const char *timezone);
 
 #ifdef __cplusplus
 }

include/os/osFile.h

@@ -22,49 +22,64 @@ extern "C" {
 
 #include "osSocket.h"
 
-#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-typedef int32_t FileFd;
-#else
-typedef int32_t FileFd;
+#ifndef ALLOW_FORBID_FUNC
+    #define open OPEN_FUNC_TAOS_FORBID
+    #define fopen FOPEN_FUNC_TAOS_FORBID
+    // #define close CLOSE_FUNC_TAOS_FORBID
+    // #define fclose FCLOSE_FUNC_TAOS_FORBID
 #endif
 
-#define FD_INITIALIZER ((int32_t)-1)
-
 #ifndef PATH_MAX
 #define PATH_MAX 256
 #endif
 
-int32_t taosLockFile(FileFd fd);
-int32_t taosUnLockFile(FileFd fd);
-
-int32_t taosUmaskFile(FileFd fd);
-
+typedef struct TdFile *TdFilePtr;
+ 
+#define TD_FILE_CTEATE    0x0001
+#define TD_FILE_WRITE     0x0002
+#define TD_FILE_READ      0x0004
+#define TD_FILE_TRUNC     0x0008
+#define TD_FILE_APPEND    0x0010
+#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);
+ 
+int32_t taosUmaskFile(int32_t maskVal);
+ 
 int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime);
-int32_t taosFStatFile(FileFd fd, int64_t *size, int32_t *mtime);
-
-FileFd taosOpenFileWrite(const char *path);
-FileFd taosOpenFileCreateWrite(const char *path);
-FileFd taosOpenFileCreateWriteTrunc(const char *path);
-FileFd taosOpenFileCreateWriteAppend(const char *path);
-FileFd taosOpenFileRead(const char *path);
-FileFd taosOpenFileReadWrite(const char *path);
-
-int64_t taosLSeekFile(FileFd fd, int64_t offset, int32_t whence);
-int32_t taosFtruncateFile(FileFd fd, int64_t length);
-int32_t taosFsyncFile(FileFd fd);
-
-int64_t taosReadFile(FileFd fd, void *buf, int64_t count);
-int64_t taosWriteFile(FileFd fd, const void *buf, int64_t count);
-
-void taosCloseFile(FileFd fd);
-
+int32_t taosFStatFile(TdFilePtr pFile, int64_t *size, int32_t *mtime);
+ 
+TdFilePtr taosOpenFile(const char *path,int32_t tdFileOptions);
+ 
+int64_t taosLSeekFile(TdFilePtr pFile, int64_t offset, int32_t whence);
+int32_t taosFtruncateFile(TdFilePtr pFile, int64_t length);
+int32_t taosFsyncFile(TdFilePtr pFile);
+ 
+int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count);
+int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset);
+int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count);
+void taosFprintfFile(TdFilePtr pFile, const char *format, ...);
+int64_t taosGetLineFile(TdFilePtr pFile, char ** __restrict__ ptrBuf);
+int32_t taosEOFFile(TdFilePtr pFile);
+ 
+int64_t taosCloseFile(TdFilePtr *ppFile);
+ 
 int32_t taosRenameFile(const char *oldName, const char *newName);
 int64_t taosCopyFile(const char *from, const char *to);
-
+ 
 void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, char *dstPath);
+ 
+int64_t taosSendFile(SocketFd fdDst, TdFilePtr pFileSrc, int64_t *offset, int64_t size);
+int64_t taosFSendFile(TdFilePtr pFileOut, TdFilePtr pFileIn, int64_t *offset, int64_t size);
+
+void *taosMmapReadOnlyFile(TdFilePtr pFile, int64_t length);
+bool taosValidFile(TdFilePtr pFile);
 
-int64_t taosSendFile(SocketFd dfd, FileFd sfd, int64_t *offset, int64_t size);
-int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size);
+int taosGetErrorFile(TdFilePtr pFile);
 
 #ifdef __cplusplus
 }

include/os/osLocale.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_OS_LOCALE_H_
+#define _TD_OS_LOCALE_H_
+
+#include "os.h"
+#include "osString.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char *taosCharsetReplace(char *charsetstr);
+void  taosGetSystemLocale(char *outLocale, char *outCharset);
+void  taosSetSystemLocale(const char *inLocale, const char *inCharSet);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_OS_LOCALE_H_*/

include/os/osMemory.h

@@ -20,12 +20,12 @@
 extern "C" {
 #endif
 
-#define tfree(x)       \
-  do {                 \
-    if (x) {           \
+#define tfree(x)         \
+  do {                   \
+    if (x) {             \
       free((void *)(x)); \
       (x) = 0;           \
-    }                  \
+    }                    \
   } while (0)
 
 #ifdef __cplusplus

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;
@@ -55,7 +55,7 @@ void    taosSetMaskSIGPIPE();
 int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t optlen);
 int32_t taosGetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t *optlen);
 
-uint32_t    taosInetAddr(char *ipAddr);
+uint32_t    taosInetAddr(const char *ipAddr);
 const char *taosInetNtoa(struct in_addr ipInt);
 
 #if (defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)) 

include/os/osString.h

@@ -45,7 +45,6 @@ int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs);
 bool    taosMbsToUcs4(const char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, int32_t *len);
 int32_t tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int32_t bytes, int8_t ncharSize);
 bool    taosValidateEncodec(const char *encodec);
-char *  taosCharsetReplace(char *charsetstr);
 
 #ifdef __cplusplus
 }

include/os/osSysinfo.h

@@ -16,30 +16,23 @@
 #ifndef _TD_OS_SYSINFO_H_
 #define _TD_OS_SYSINFO_H_
 
+#include "os.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-  
-#define TSDB_LOCALE_LEN   64
-#define TSDB_TIMEZONE_LEN 96
-
-extern int64_t tsPageSize;
-extern int64_t tsOpenMax;
-extern int64_t tsStreamMax;
-extern int32_t tsNumOfCores;
-extern int32_t tsTotalMemoryMB;
-extern char     tsTimezone[];
-extern char     tsLocale[];
-extern char     tsCharset[];            // default encode string
-
 typedef struct {
   int64_t total;
   int64_t used;
   int64_t avail;
 } SDiskSize;
 
+typedef struct {
+  int64_t   reserved;
+  SDiskSize size;
+} SDiskSpace;
+
 int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize);
 int32_t taosGetCpuCores();
 void    taosGetSystemInfo();
@@ -51,7 +44,6 @@ void    taosGetDisk();
 bool    taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage);
 bool    taosGetProcMemory(float *memoryUsedMB);
 bool    taosGetSysMemory(float *memoryUsedMB);
-void    taosPrintOsInfo();
 int     taosSystem(const char *cmd);
 void    taosKillSystem();
 int32_t taosGetSystemUUID(char *uid, int32_t uidlen);

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/common/tlocale.h → include/os/osTimezone.h

@@ -13,17 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_COMMON_LOCALE_H_
-#define _TD_COMMON_LOCALE_H_
+#ifndef _TD_OS_TIMEZONE_H_
+#define _TD_OS_TIMEZONE_H_
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void tsSetLocale();
+void taosGetSystemTimezone(char *outTimezone);
+void taosSetSystemTimezone(const char *inTimezone, char *outTimezone, int8_t *outDaylight);
 
 #ifdef __cplusplus
 }
-#endif /*_TD_COMMON_LOCALE_H_*/
-
 #endif
+
+#endif /*_TD_OS_TIMEZONE_H_*/

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 {                       \
@@ -31,20 +30,20 @@ extern "C" {
     struct TYPE* td_array_data_; \
   }
 
-#define TARRAY_SIZE(ARRAY) (ARRAY)->tarray_size_
-#define TARRAY_NELES(ARRAY) (ARRAY)->tarray_neles_
+#define TARRAY_SIZE(ARRAY)        (ARRAY)->tarray_size_
+#define TARRAY_NELES(ARRAY)       (ARRAY)->tarray_neles_
 #define TARRAY_ELE_AT(ARRAY, IDX) ((ARRAY)->td_array_data_ + idx)
 #endif
 
-#define TARRAY_MIN_SIZE 8
+#define TARRAY_MIN_SIZE               8
 #define TARRAY_GET_ELEM(array, index) ((void*)((char*)((array)->pData) + (index) * (array)->elemSize))
-#define TARRAY_ELEM_IDX(array, ele) (POINTER_DISTANCE(ele, (array)->pData) / (array)->elemSize)
-#define TARRAY_GET_START(array) ((array)->pData)
+#define TARRAY_ELEM_IDX(array, ele)   (POINTER_DISTANCE(ele, (array)->pData) / (array)->elemSize)
+#define TARRAY_GET_START(array)       ((array)->pData)
 
 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/tbase64.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_BASE64_H_
+#define _TD_UTIL_BASE64_H_
+
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+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_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
+#if defined(_TD_ARM_32)
+#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;
@@ -45,17 +43,17 @@ typedef struct SCacheStatis {
 struct STrashElem;
 
 typedef struct SCacheDataNode {
-  uint64_t           addedTime;    // the added time when this element is added or updated into cache
-  uint64_t           lifespan;     // life duration when this element should be remove from cache
-  uint64_t           expireTime;   // expire time
+  uint64_t           addedTime;   // the added time when this element is added or updated into cache
+  uint64_t           lifespan;    // life duration when this element should be remove from cache
+  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
-  uint32_t           size;         // allocated size for current SCacheDataNode
+  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
+  uint32_t           size;            // allocated size for current SCacheDataNode
   T_REF_DECLARE()
-  char              *key;
-  char               data[];
+  char *key;
+  char  data[];
 } SCacheDataNode;
 
 typedef struct STrashElem {
@@ -73,22 +71,22 @@ typedef struct STrashElem {
  * when the node in pTrash does not be referenced, it will be release at the expired expiredTime
  */
 typedef struct {
-  int64_t         totalSize;          // total allocated buffer in this hash table, SCacheObj is not included.
-  int64_t         refreshTime;
-  STrashElem *    pTrash;
-  char*           name;
-  SCacheStatis    statistics;
-  SHashObj *      pHashTable;
+  int64_t           totalSize;  // total allocated buffer in this hash table, SCacheObj is not included.
+  int64_t           refreshTime;
+  STrashElem       *pTrash;
+  char             *name;
+  SCacheStatis      statistics;
+  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.
-  pthread_t       refreshWorker;
-  bool            extendLifespan;     // auto extend life span when one item is accessed.
-  int64_t         checkTick;          // tick used to record the check times of the refresh threads
+  uint32_t          numOfElemsInTrash;  // number of element in trash
+  uint8_t           deleting;           // set the deleting flag to stop refreshing ASAP.
+  pthread_t         refreshWorker;
+  bool              extendLifespan;  // auto extend life span when one item is accessed.
+  int64_t           checkTick;       // tick used to record the check times of the refresh threads
 #if defined(LINUX)
   pthread_rwlock_t lock;
 #else
-  pthread_mutex_t  lock;
+  pthread_mutex_t lock;
 #endif
 } SCacheObj;
 
@@ -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,29 +12,30 @@
  * 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 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
 
 /* ------------------------ 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,16 +333,16 @@ 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;
-  size_t size = strlen(value);
+static FORCE_INLINE int32_t taosEncodeString(void **buf, const char *value) {
+  int32_t tlen = 0;
+  size_t  size = strlen(value);
 
   tlen += taosEncodeVariantU64(buf, size);
   if (buf != NULL) {
     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,17 +16,18 @@
 #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
+#define TSDB_PATTERN_MATCH              0
+#define TSDB_PATTERN_NOMATCH            1
+#define TSDB_PATTERN_NOWILDCARDMATCH    2
 #define TSDB_PATTERN_STRING_DEFAULT_LEN 100
-#define TSDB_REGEX_STRING_DEFAULT_LEN 128
+#define TSDB_REGEX_STRING_DEFAULT_LEN   128
 
 #define FLT_COMPAR_TOL_FACTOR    4
 #define FLT_EQUAL(_x, _y)        (fabs((_x) - (_y)) <= (FLT_COMPAR_TOL_FACTOR * FLT_EPSILON))
@@ -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/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/common/tcfg.h → include/util/tdes.h

@@ -13,23 +13,20 @@
  * 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_DES_H
+#define _TD_UTIL_DES_H
+
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tdef.h"
-
-typedef struct {
-  char dir[TSDB_FILENAME_LEN];
-  int  level;
-  int  primary;
-} SDiskCfg;
+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_COMMON_CFG_H_*/
+#endif /*_TD_UTIL_DES_H*/
\ No newline at end of file

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,45 +12,45 @@
  * 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);
-void* genericInvoke(tGenericSavedFunc* const pSavedFunc);
-int32_t i32Invoke(tI32SavedFunc* const pSavedFunc);
-void voidInvoke(tVoidSavedFunc* const pSavedFunc);
+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);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_UTIL_FUNCTIONAL_H*/
+#endif /*_TD_UTIL_FUNCTIONAL_H_*/

include/util/tmacro.h

@@ -24,7 +24,7 @@ extern "C" {
 
 // Module init/clear MACRO definitions
 #define TD_MOD_UNINITIALIZED 0
-#define TD_MOD_INITIALIZED 1
+#define TD_MOD_INITIALIZED   1
 
 typedef int8_t td_mode_flag_t;