Merge branch '3.0' into feature/3.0_liaohj

.gitignore

@@ -5,6 +5,7 @@ compile_commands.json
 .tasks
 .vimspector.json
 .vscode/
+.vscode
 .idea/
 cmake-build-debug/
 cmake-build-release/

include/common/tmsg.h

@@ -70,11 +70,7 @@ typedef uint16_t tmsg_t;
 #define TSDB_IE_TYPE_DNODE_EXT   6
 #define TSDB_IE_TYPE_DNODE_STATE 7
 
-enum {
+enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__MAX };
-  CONN_TYPE__QUERY = 1,
-  CONN_TYPE__TMQ,
-  CONN_TYPE__MAX
-};
 
 enum {
   HEARTBEAT_KEY_DBINFO = 1,
@@ -257,22 +253,16 @@ typedef struct {
   SSubmitRspBlock failedBlocks[];
 } SSubmitRsp;
 
+#define SCHEMA_SMA_ON 0x1
+#define SCHEMA_IDX_ON 0x2
 typedef struct SSchema {
   int8_t   type;
-  int8_t   index;  // default is 0, not index created
+  int8_t   flags;
   col_id_t colId;
   int32_t  bytes;
   char     name[TSDB_COL_NAME_LEN];
 } SSchema;
 
-typedef struct {
-  int8_t   type;
-  int8_t   sma;  // ETsdbBSmaType and default is TSDB_BSMA_TYPE_I
-  col_id_t colId;
-  int32_t  bytes;
-  char     name[TSDB_COL_NAME_LEN];
-} SSchemaEx;
-
 #define SSCHMEA_TYPE(s)  ((s)->type)
 #define SSCHMEA_SMA(s)   ((s)->sma)
 #define SSCHMEA_COLID(s) ((s)->colId)
@@ -663,14 +653,13 @@ typedef struct {
   int32_t outputLen;
   int32_t bufSize;
   int64_t signature;
-  int32_t commentSize;
+  char*   pComment;
-  int32_t codeSize;
+  char*   pCode;
-  char    pComment[TSDB_FUNC_COMMENT_LEN];
-  char    pCode[TSDB_FUNC_CODE_LEN];
 } SCreateFuncReq;
 
 int32_t tSerializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq);
 int32_t tDeserializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq);
+void    tFreeSCreateFuncReq(SCreateFuncReq* pReq);
 
 typedef struct {
   char   name[TSDB_FUNC_NAME_LEN];
@@ -687,6 +676,7 @@ typedef struct {
 
 int32_t tSerializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq);
 int32_t tDeserializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq);
+void    tFreeSRetrieveFuncReq(SRetrieveFuncReq* pReq);
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -698,8 +688,8 @@ typedef struct {
   int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
-  char    pComment[TSDB_FUNC_COMMENT_LEN];
+  char*   pComment;
-  char    pCode[TSDB_FUNC_CODE_LEN];
+  char*   pCode;
 } SFuncInfo;
 
 typedef struct {
@@ -709,6 +699,7 @@ typedef struct {
 
 int32_t tSerializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp);
 int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp);
+void    tFreeSRetrieveFuncRsp(SRetrieveFuncRsp* pRsp);
 
 typedef struct {
   int32_t statusInterval;
@@ -1457,7 +1448,7 @@ typedef struct SVCreateTbReq {
       tb_uid_t    suid;
       col_id_t    nCols;
       col_id_t    nBSmaCols;
-      SSchemaEx*  pSchema;
+      SSchema*    pSchema;
       col_id_t    nTagCols;
       SSchema*    pTagSchema;
       SRSmaParam* pRSmaParam;
@@ -1469,7 +1460,7 @@ typedef struct SVCreateTbReq {
     struct {
       col_id_t    nCols;
       col_id_t    nBSmaCols;
-      SSchemaEx*  pSchema;
+      SSchema*    pSchema;
       SRSmaParam* pRSmaParam;
     } ntbCfg;
   };
@@ -2034,16 +2025,13 @@ int32_t tDecodeSMqCMCommitOffsetReq(SCoder* decoder, SMqCMCommitOffsetReq* pReq)
 
 typedef struct {
   uint32_t nCols;
-  union {
   SSchema* pSchema;
-    SSchemaEx* pSchemaEx;
-  };
 } SSchemaWrapper;
 
 static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pSchema->type);
-  tlen += taosEncodeFixedI8(buf, pSchema->index);
+  tlen += taosEncodeFixedI8(buf, pSchema->flags);
   tlen += taosEncodeFixedI32(buf, pSchema->bytes);
   tlen += taosEncodeFixedI16(buf, pSchema->colId);
   tlen += taosEncodeString(buf, pSchema->name);
@@ -2052,7 +2040,7 @@ static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema
 
 static FORCE_INLINE void* taosDecodeSSchema(void* buf, SSchema* pSchema) {
   buf = taosDecodeFixedI8(buf, &pSchema->type);
-  buf = taosDecodeFixedI8(buf, &pSchema->index);
+  buf = taosDecodeFixedI8(buf, &pSchema->flags);
   buf = taosDecodeFixedI32(buf, &pSchema->bytes);
   buf = taosDecodeFixedI16(buf, &pSchema->colId);
   buf = taosDecodeStringTo(buf, pSchema->name);
@@ -2061,7 +2049,7 @@ static FORCE_INLINE void* taosDecodeSSchema(void* buf, SSchema* pSchema) {
 
 static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSchema) {
   if (tEncodeI8(pEncoder, pSchema->type) < 0) return -1;
-  if (tEncodeI8(pEncoder, pSchema->index) < 0) return -1;
+  if (tEncodeI8(pEncoder, pSchema->flags) < 0) return -1;
   if (tEncodeI32(pEncoder, pSchema->bytes) < 0) return -1;
   if (tEncodeI16(pEncoder, pSchema->colId) < 0) return -1;
   if (tEncodeCStr(pEncoder, pSchema->name) < 0) return -1;
@@ -2070,7 +2058,7 @@ static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSch
 
 static FORCE_INLINE int32_t tDecodeSSchema(SCoder* pDecoder, SSchema* pSchema) {
   if (tDecodeI8(pDecoder, &pSchema->type) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pSchema->index) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pSchema->flags) < 0) return -1;
   if (tDecodeI32(pDecoder, &pSchema->bytes) < 0) return -1;
   if (tDecodeI16(pDecoder, &pSchema->colId) < 0) return -1;
   if (tDecodeCStrTo(pDecoder, pSchema->name) < 0) return -1;

include/common/trow.h

@@ -48,9 +48,12 @@ extern "C" {
 #define TD_VTYPE_NONE 0x02U  // none or unknown/undefined
 #define TD_VTYPE_MAX  0x03U  //
 
-#define TD_VTYPE_NORM_BYTE 0x0U
+#define TD_VTYPE_NORM_BYTE_I 0x0U
-#define TD_VTYPE_NULL_BYTE 0x55U
+#define TD_VTYPE_NULL_BYTE_I 0xFFU
-#define TD_VTYPE_NONE_BYTE 0xAAU
+
+#define TD_VTYPE_NORM_BYTE_II 0x0U
+#define TD_VTYPE_NULL_BYTE_II 0x55U
+#define TD_VTYPE_NONE_BYTE_II 0xAAU
 
 #define TD_ROWS_ALL_NORM  0x00U
 #define TD_ROWS_NULL_NORM 0x01U
@@ -224,8 +227,10 @@ static FORCE_INLINE int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TD
 int32_t                     tdSetBitmapValTypeN(void *pBitmap, int16_t nEle, TDRowValT valType, int8_t bitmapMode);
 static FORCE_INLINE int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pValType);
 static FORCE_INLINE int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType);
-static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType, int8_t bitmapMode);
+static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType,
-static FORCE_INLINE bool    tdIsBitmapValTypeNormII(const void *pBitmap, int16_t idx);
+                                               int8_t bitmapMode);
+static FORCE_INLINE bool    tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx, int8_t bitmapMode);
+bool                        tdIsBitmapBlkNorm(const void *pBitmap, int32_t numOfBits, int8_t bitmapMode);
 int32_t tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int32_t numOfRows, int32_t maxPoints,
                              int8_t bitmapMode);
 static FORCE_INLINE int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val,
@@ -327,9 +332,9 @@ static FORCE_INLINE int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx,
   return TSDB_CODE_SUCCESS;
 }
 
-static FORCE_INLINE bool tdIsBitmapValTypeNormII(const void *pBitmap, int16_t idx) {
+static FORCE_INLINE bool tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx, int8_t bitmapMode) {
   TDRowValT valType = 0;
-  tdGetBitmapValTypeII(pBitmap, idx, &valType);
+  tdGetBitmapValType(pBitmap, idx, &valType, bitmapMode);
   if (tdValTypeIsNorm(valType)) {
     return true;
   }

include/common/ttypes.h

@@ -248,8 +248,8 @@ typedef struct tDataTypeDescriptor {
                       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* pBitmap, const void *pData, int32_t numofrow, int64_t *min, int64_t *max, int64_t *sum, int16_t *minindex,
+  void (*statisFunc)(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numofrow, int64_t *min,
-                     int16_t *maxindex, int16_t *numofnull);
+                     int64_t *max, int64_t *sum, int16_t *minindex, int16_t *maxindex, int16_t *numofnull);
 } tDataTypeDescriptor;
 
 extern tDataTypeDescriptor tDataTypes[15];

include/libs/nodes/plannodes.h

@@ -355,8 +355,11 @@ typedef struct SQueryPlan {
   int32_t numOfSubplans;
   SNodeList* pSubplans; // Element is SNodeListNode. The execution level of subplan, starting from 0.
   SExplainInfo explainInfo;
+  SNodeList* pPlaceholderValues;
 } SQueryPlan;
 
+void nodesWalkPhysiPlan(SNode* pNode, FNodeWalker walker, void* pContext);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/querynodes.h

@@ -82,6 +82,7 @@ typedef struct SValueNode {
   bool isDuration;
   bool translate;
   bool genByCalc;
+  int16_t placeholderNo;
   union {
     bool b;
     int64_t i;

include/libs/planner/planner.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "plannodes.h"
+#include "taos.h"
 
 typedef struct SPlanContext {
   uint64_t queryId;
@@ -32,6 +33,7 @@ typedef struct SPlanContext {
   bool showRewrite;
   int8_t triggerType;
   int64_t watermark;
+  bool isStmtQuery;
 } SPlanContext;
 
 // Create the physical plan for the query, according to the AST.
@@ -43,6 +45,9 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
 // @pSource one execution location of this group of datasource subplans 
 int32_t qSetSubplanExecutionNode(SSubplan* pSubplan, int32_t groupId, SDownstreamSourceNode* pSource);
 
+typedef TAOS_MULTI_BIND TAOS_BIND_v2; // todo remove
+int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_BIND_v2* pParams);
+
 // Convert to subplan to string for the scheduler to send to the executor
 int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen);
 int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan);

include/os/osThread.h

@@ -22,6 +22,10 @@
 extern "C" {
 #endif
 
+#ifndef __USE_XOPEN2K
+typedef pthread_mutex_t pthread_spinlock_t;
+#endif
+
 typedef pthread_t TdThread;
 typedef pthread_spinlock_t TdThreadSpinlock;
 typedef pthread_mutex_t TdThreadMutex;
@@ -33,8 +37,6 @@ typedef pthread_rwlockattr_t TdThreadRwlockAttr;
 typedef pthread_cond_t TdThreadCond;
 typedef pthread_condattr_t TdThreadCondAttr;
 typedef pthread_key_t TdThreadKey;
-typedef pthread_barrier_t TdThreadBarrier;
-typedef pthread_barrierattr_t TdThreadBarrierAttr;
 
 #define taosThreadCleanupPush pthread_cleanup_push
 #define taosThreadCleanupPop pthread_cleanup_pop
@@ -156,13 +158,6 @@ int32_t taosThreadAttrSetSchedParam(TdThreadAttr * attr, const struct sched_para
 int32_t taosThreadAttrSetSchedPolicy(TdThreadAttr * attr, int32_t policy);
 int32_t taosThreadAttrSetScope(TdThreadAttr * attr, int32_t contentionscope);
 int32_t taosThreadAttrSetStackSize(TdThreadAttr * attr, size_t stacksize);
-int32_t taosThreadBarrierDestroy(TdThreadBarrier * barrier);
-int32_t taosThreadBarrierInit(TdThreadBarrier * barrier, const TdThreadBarrierAttr * attr, uint32_t count);
-int32_t taosThreadBarrierWait(TdThreadBarrier * barrier);
-int32_t taosThreadBarrierAttrDestroy(TdThreadBarrierAttr * attr);
-int32_t taosThreadBarrierAttrGetPshared(const TdThreadBarrierAttr * attr, int32_t *pshared);
-int32_t taosThreadBarrierAttrInit(TdThreadBarrierAttr * attr);
-int32_t taosThreadBarrierAttrSetPshared(TdThreadBarrierAttr * attr, int32_t pshared);
 int32_t taosThreadCancel(TdThread thread);
 int32_t taosThreadCondDestroy(TdThreadCond * cond);
 int32_t taosThreadCondInit(TdThreadCond * cond, const TdThreadCondAttr * attr);

include/util/tdef.h

@@ -234,8 +234,8 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_FNAME_LEN   (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
 
 #define TSDB_FUNC_NAME_LEN       65
-#define TSDB_FUNC_COMMENT_LEN    4096
+#define TSDB_FUNC_COMMENT_LEN    1024 * 1024
-#define TSDB_FUNC_CODE_LEN       (65535 - 512)
+#define TSDB_FUNC_CODE_LEN       10 * 1024 * 1024
 #define TSDB_FUNC_BUF_SIZE       512
 #define TSDB_FUNC_TYPE_SCALAR    1
 #define TSDB_FUNC_TYPE_AGGREGATE 2
@@ -524,7 +524,6 @@ enum {
 
 #define MAX_NUM_STR_SIZE 40
 
-
 #ifdef __cplusplus
 }
 #endif

source/client/src/clientMain.c

@@ -71,6 +71,7 @@ void taos_cleanup(void) {
   schedulerDestroy();
 
   tscInfo("all local resources released");
+  taosCleanupCfg();
   taosCloseLog();
 }
 

source/common/src/tdatablock.c

@@ -1101,6 +1101,11 @@ int32_t colInfoDataEnsureCapacity(SColumnInfoData* pColumn, uint32_t numOfRows)
 
     pColumn->nullbitmap = tmp;
     memset(pColumn->nullbitmap, 0, BitmapLen(numOfRows));
+
+    if (pColumn->info.type == TSDB_DATA_TYPE_NULL) {
+      return TSDB_CODE_SUCCESS;
+    }
+
     assert(pColumn->info.bytes);
     tmp = taosMemoryRealloc(pColumn->pData, numOfRows * pColumn->info.bytes);
     if (tmp == NULL) {

source/common/src/tmsg.c

@@ -411,7 +411,7 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
       tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nBSmaCols);
       for (col_id_t i = 0; i < pReq->stbCfg.nCols; ++i) {
         tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pSchema[i].type);
-        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pSchema[i].sma);
+        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pSchema[i].flags);
         tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pSchema[i].colId);
         tlen += taosEncodeFixedI32(buf, pReq->stbCfg.pSchema[i].bytes);
         tlen += taosEncodeString(buf, pReq->stbCfg.pSchema[i].name);
@@ -419,7 +419,7 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
       tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nTagCols);
       for (col_id_t i = 0; i < pReq->stbCfg.nTagCols; ++i) {
         tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].type);
-        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].index);
+        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].flags);
         tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pTagSchema[i].colId);
         tlen += taosEncodeFixedI32(buf, pReq->stbCfg.pTagSchema[i].bytes);
         tlen += taosEncodeString(buf, pReq->stbCfg.pTagSchema[i].name);
@@ -443,7 +443,7 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
       tlen += taosEncodeFixedI16(buf, pReq->ntbCfg.nBSmaCols);
       for (col_id_t i = 0; i < pReq->ntbCfg.nCols; ++i) {
         tlen += taosEncodeFixedI8(buf, pReq->ntbCfg.pSchema[i].type);
-        tlen += taosEncodeFixedI8(buf, pReq->ntbCfg.pSchema[i].sma);
+        tlen += taosEncodeFixedI8(buf, pReq->ntbCfg.pSchema[i].flags);
         tlen += taosEncodeFixedI16(buf, pReq->ntbCfg.pSchema[i].colId);
         tlen += taosEncodeFixedI32(buf, pReq->ntbCfg.pSchema[i].bytes);
         tlen += taosEncodeString(buf, pReq->ntbCfg.pSchema[i].name);
@@ -478,10 +478,10 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
       buf = taosDecodeFixedI64(buf, &(pReq->stbCfg.suid));
       buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.nCols));
       buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.nBSmaCols));
-      pReq->stbCfg.pSchema = (SSchemaEx *)taosMemoryMalloc(pReq->stbCfg.nCols * sizeof(SSchemaEx));
+      pReq->stbCfg.pSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nCols * sizeof(SSchema));
       for (col_id_t i = 0; i < pReq->stbCfg.nCols; ++i) {
         buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pSchema[i].type));
-        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pSchema[i].sma));
+        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pSchema[i].flags));
         buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.pSchema[i].colId));
         buf = taosDecodeFixedI32(buf, &(pReq->stbCfg.pSchema[i].bytes));
         buf = taosDecodeStringTo(buf, pReq->stbCfg.pSchema[i].name);
@@ -490,7 +490,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
       pReq->stbCfg.pTagSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nTagCols * sizeof(SSchema));
       for (col_id_t i = 0; i < pReq->stbCfg.nTagCols; ++i) {
         buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].type));
-        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].index));
+        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].flags));
         buf = taosDecodeFixedI16(buf, &pReq->stbCfg.pTagSchema[i].colId);
         buf = taosDecodeFixedI32(buf, &pReq->stbCfg.pTagSchema[i].bytes);
         buf = taosDecodeStringTo(buf, pReq->stbCfg.pTagSchema[i].name);
@@ -520,10 +520,10 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
     case TD_NORMAL_TABLE:
       buf = taosDecodeFixedI16(buf, &pReq->ntbCfg.nCols);
       buf = taosDecodeFixedI16(buf, &(pReq->ntbCfg.nBSmaCols));
-      pReq->ntbCfg.pSchema = (SSchemaEx *)taosMemoryMalloc(pReq->ntbCfg.nCols * sizeof(SSchemaEx));
+      pReq->ntbCfg.pSchema = (SSchema *)taosMemoryMalloc(pReq->ntbCfg.nCols * sizeof(SSchema));
       for (col_id_t i = 0; i < pReq->ntbCfg.nCols; ++i) {
         buf = taosDecodeFixedI8(buf, &pReq->ntbCfg.pSchema[i].type);
-        buf = taosDecodeFixedI8(buf, &pReq->ntbCfg.pSchema[i].sma);
+        buf = taosDecodeFixedI8(buf, &pReq->ntbCfg.pSchema[i].flags);
         buf = taosDecodeFixedI16(buf, &pReq->ntbCfg.pSchema[i].colId);
         buf = taosDecodeFixedI32(buf, &pReq->ntbCfg.pSchema[i].bytes);
         buf = taosDecodeStringTo(buf, pReq->ntbCfg.pSchema[i].name);
@@ -1492,10 +1492,25 @@ int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq
   if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->signature) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->commentSize) < 0) return -1;
+
-  if (tEncodeI32(&encoder, pReq->codeSize) < 0) return -1;
+  int32_t codeSize = 0;
-  if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
+  if (pReq->pCode != NULL) {
+    codeSize = strlen(pReq->pCode) + 1;
+  }
+  if (tEncodeI32(&encoder, codeSize) < 0) return -1;
+  if (pReq->pCode != NULL) {
     if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1;
+  }
+
+  int32_t commentSize = 0;
+  if (pReq->pComment != NULL) {
+    commentSize = strlen(pReq->pComment) + 1;
+  }
+  if (tEncodeI32(&encoder, commentSize) < 0) return -1;
+  if (pReq->pComment != NULL) {
+    if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
+  }
+
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1516,16 +1531,40 @@ int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pR
   if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->commentSize) < 0) return -1;
+
-  if (tDecodeI32(&decoder, &pReq->codeSize) < 0) return -1;
+  int32_t codeSize = 0;
-  if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
+  if (tDecodeI32(&decoder, &codeSize) < 0) return -1;
+  if (codeSize > 0) {
+    pReq->pCode = taosMemoryCalloc(1, codeSize);
+    if (pReq->pCode == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
     if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1;
+  }
+
+  int32_t commentSize = 0;
+  if (tDecodeI32(&decoder, &commentSize) < 0) return -1;
+  if (commentSize > 0) {
+    pReq->pComment = taosMemoryCalloc(1, commentSize);
+    if (pReq->pComment == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
 
   tCoderClear(&decoder);
   return 0;
 }
 
+void tFreeSCreateFuncReq(SCreateFuncReq *pReq) {
+  taosMemoryFree(pReq->pCode);
+  taosMemoryFree(pReq->pComment);
+}
+
 int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -1594,6 +1633,8 @@ int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq
   return 0;
 }
 
+void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); }
+
 int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -1612,10 +1653,10 @@ int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *
     if (tEncodeI32(&encoder, pInfo->outputLen) < 0) return -1;
     if (tEncodeI32(&encoder, pInfo->bufSize) < 0) return -1;
     if (tEncodeI64(&encoder, pInfo->signature) < 0) return -1;
-    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
     if (tEncodeI32(&encoder, pInfo->codeSize) < 0) return -1;
-    if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
+    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
     if (tEncodeCStr(&encoder, pInfo->pCode) < 0) return -1;
+    if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
   }
 
   tEndEncode(&encoder);
@@ -1644,10 +1685,17 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp
     if (tDecodeI32(&decoder, &fInfo.outputLen) < 0) return -1;
     if (tDecodeI32(&decoder, &fInfo.bufSize) < 0) return -1;
     if (tDecodeI64(&decoder, &fInfo.signature) < 0) return -1;
-    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
     if (tDecodeI32(&decoder, &fInfo.codeSize) < 0) return -1;
-    if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1;
+    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
+    fInfo.pCode = taosMemoryCalloc(1, fInfo.codeSize);
+    fInfo.pComment = taosMemoryCalloc(1, fInfo.commentSize);
+    if (fInfo.pCode == NULL || fInfo.pComment == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+
     if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1;
     taosArrayPush(pRsp->pFuncInfos, &fInfo);
   }
   tEndDecode(&decoder);
@@ -1656,6 +1704,16 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp
   return 0;
 }
 
+void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp *pRsp) {
+  int32_t size = taosArrayGetSize(pRsp->pFuncInfos);
+  for (int32_t i = 0; i < size; ++i) {
+    SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i);
+    taosMemoryFree(pInfo->pCode);
+    taosMemoryFree(pInfo->pComment);
+  }
+  taosArrayDestroy(pRsp->pFuncInfos);
+}
+
 int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);

source/common/src/trow.c

@@ -16,10 +16,19 @@
 #define _DEFAULT_SOURCE
 #include "trow.h"
 
-const uint8_t tdVTypeByte[3] = {
+const uint8_t tdVTypeByte[2][3] = {{
-    TD_VTYPE_NORM_BYTE,  // TD_VTYPE_NORM
+                                       // 2 bits
-    TD_VTYPE_NONE_BYTE,  // TD_VTYPE_NONE
+                                       TD_VTYPE_NORM_BYTE_II,
-    TD_VTYPE_NULL_BYTE,  // TD_VTYPE_NULL
+                                       TD_VTYPE_NONE_BYTE_II,
+                                       TD_VTYPE_NULL_BYTE_II,
+                                   },
+                                   {
+                                       // 1 bit
+                                       TD_VTYPE_NORM_BYTE_I,
+                                       TD_VTYPE_NULL_BYTE_I,
+                                       TD_VTYPE_NULL_BYTE_I, // padding
+                                   }
+
 };
 
 // declaration
@@ -266,21 +275,53 @@ static FORCE_INLINE void dataColSetNullAt(SDataCol *pCol, int index, bool setBit
 //   }
 // }
 
+/**
+ * @brief Set bitmap area by byte preferentially and then by bit.
+ *
+ * @param pBitmap
+ * @param nEle
+ * @param valType
+ * @param bitmapMode 0 for 2 bits, 1 for 1 bit
+ * @return int32_t
+ */
 int32_t tdSetBitmapValTypeN(void *pBitmap, int16_t nEle, TDRowValT valType, int8_t bitmapMode) {
   TASSERT(valType < TD_VTYPE_MAX);
-  int16_t nBytes = nEle / TD_VTYPE_PARTS;
+  int32_t nBytes = (bitmapMode == 0 ? nEle / TD_VTYPE_PARTS : nEle / TD_VTYPE_PARTS_I);
+  uint8_t vTypeByte = tdVTypeByte[bitmapMode][valType];
   for (int i = 0; i < nBytes; ++i) {
-    *(uint8_t *)pBitmap = tdVTypeByte[valType];
+    *(uint8_t *)pBitmap = vTypeByte;
     pBitmap = POINTER_SHIFT(pBitmap, 1);
   }
-  int16_t nLeft = nEle - nBytes * TD_VTYPE_BITS;
 
+  int32_t nLeft = nEle - nBytes * (bitmapMode == 0 ? TD_VTYPE_BITS : TD_VTYPE_BITS_I);
   for (int j = 0; j < nLeft; ++j) {
     tdSetBitmapValType(pBitmap, j, valType, bitmapMode);
   }
   return TSDB_CODE_SUCCESS;
 }
 
+bool tdIsBitmapBlkNorm(const void *pBitmap, int32_t numOfBits, int8_t bitmapMode) {
+  int32_t nBytes = (bitmapMode == 0 ? numOfBits / TD_VTYPE_PARTS : numOfBits / TD_VTYPE_PARTS_I);
+  uint8_t vTypeByte = tdVTypeByte[bitmapMode][TD_VTYPE_NORM];
+  for (int i = 0; i < nBytes; ++i) {
+    if (*((uint8_t *)pBitmap) != vTypeByte) {
+      return false;
+    }
+    pBitmap = POINTER_SHIFT(pBitmap, 1);
+  }
+
+  int32_t nLeft = numOfBits - nBytes * (bitmapMode == 0 ? TD_VTYPE_BITS : TD_VTYPE_BITS_I);
+
+  for (int j = 0; j < nLeft; ++j) {
+    uint8_t vType;
+    tdGetBitmapValType(pBitmap, j, &vType, bitmapMode);
+    if (vType != TD_VTYPE_NORM) {
+      return false;
+    }
+  }
+  return true;
+}
+
 static FORCE_INLINE void dataColSetNoneAt(SDataCol *pCol, int index, bool setBitmap, int8_t bitmapMode) {
   if (IS_VAR_DATA_TYPE(pCol->type)) {
     pCol->dataOff[index] = pCol->len;

source/common/src/ttime.c

@@ -415,7 +415,11 @@ int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec
   if (type == TSDB_DATA_TYPE_BINARY) {
     newColData = taosMemoryCalloc(1,  charLen + 1);
     memcpy(newColData, varDataVal(inputData), charLen);
-    taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, 0);
+    bool ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, 0);
+    if (ret != TSDB_CODE_SUCCESS) {
+      taosMemoryFree(newColData);
+      return ret;
+    }
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
     newColData = taosMemoryCalloc(1,  charLen / TSDB_NCHAR_SIZE + 1);
@@ -425,7 +429,11 @@ int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec
       return TSDB_CODE_FAILED;
     }
     newColData[len] = 0;
-    taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, 0);
+    bool ret = taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, 0);
+    if (ret != TSDB_CODE_SUCCESS) {
+      taosMemoryFree(newColData);
+      return ret;
+    }
     taosMemoryFree(newColData);
   } else {
     return TSDB_CODE_FAILED;

source/common/src/ttypes.c

@@ -50,8 +50,8 @@ const int32_t TYPE_BYTES[15] = {
     }                                                                          \
   } while (0)
 
-static void getStatics_bool(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_bool(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                            int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                            int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int8_t *data = (int8_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -62,7 +62,7 @@ static void getStatics_bool(const void *pBitmap, const void *pData, int32_t numO
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (data[i] == TSDB_DATA_BOOL_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -71,8 +71,8 @@ static void getStatics_bool(const void *pBitmap, const void *pData, int32_t numO
   }
 }
 
-static void getStatics_i8(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_i8(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                          int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                          int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int8_t *data = (int8_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -83,7 +83,7 @@ static void getStatics_i8(const void *pBitmap, const void *pData, int32_t numOfR
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint8_t)data[i]) == TSDB_DATA_TINYINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -92,8 +92,8 @@ static void getStatics_i8(const void *pBitmap, const void *pData, int32_t numOfR
   }
 }
 
-static void getStatics_u8(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_u8(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                          int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                          int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint8_t *data = (uint8_t *)pData;
   uint64_t _min = UINT64_MAX;
   uint64_t _max = 0;
@@ -106,7 +106,7 @@ static void getStatics_u8(const void *pBitmap, const void *pData, int32_t numOfR
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint8_t)data[i]) == TSDB_DATA_UTINYINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -119,8 +119,8 @@ static void getStatics_u8(const void *pBitmap, const void *pData, int32_t numOfR
   *sum = _sum;
 }
 
-static void getStatics_i16(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_i16(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int16_t *data = (int16_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -131,7 +131,7 @@ static void getStatics_i16(const void *pBitmap, const void *pData, int32_t numOf
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint16_t)data[i]) == TSDB_DATA_SMALLINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -140,8 +140,8 @@ static void getStatics_i16(const void *pBitmap, const void *pData, int32_t numOf
   }
 }
 
-static void getStatics_u16(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_u16(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint16_t *data = (uint16_t *)pData;
   uint64_t  _min = UINT64_MAX;
   uint64_t  _max = 0;
@@ -154,7 +154,7 @@ static void getStatics_u16(const void *pBitmap, const void *pData, int32_t numOf
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint16_t)data[i]) == TSDB_DATA_USMALLINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -167,8 +167,8 @@ static void getStatics_u16(const void *pBitmap, const void *pData, int32_t numOf
   *sum = _sum;
 }
 
-static void getStatics_i32(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_i32(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int32_t *data = (int32_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -179,7 +179,7 @@ static void getStatics_i32(const void *pBitmap, const void *pData, int32_t numOf
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint32_t)data[i]) == TSDB_DATA_INT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -188,8 +188,8 @@ static void getStatics_i32(const void *pBitmap, const void *pData, int32_t numOf
   }
 }
 
-static void getStatics_u32(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_u32(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint32_t *data = (uint32_t *)pData;
   uint64_t  _min = UINT64_MAX;
   uint64_t  _max = 0;
@@ -202,7 +202,7 @@ static void getStatics_u32(const void *pBitmap, const void *pData, int32_t numOf
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint32_t)data[i]) == TSDB_DATA_UINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -215,8 +215,8 @@ static void getStatics_u32(const void *pBitmap, const void *pData, int32_t numOf
   *sum = _sum;
 }
 
-static void getStatics_i64(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_i64(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int64_t *data = (int64_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -227,7 +227,7 @@ static void getStatics_i64(const void *pBitmap, const void *pData, int32_t numOf
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint64_t)data[i]) == TSDB_DATA_BIGINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -236,8 +236,8 @@ static void getStatics_i64(const void *pBitmap, const void *pData, int32_t numOf
   }
 }
 
-static void getStatics_u64(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_u64(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint64_t *data = (uint64_t *)pData;
   uint64_t  _min = UINT64_MAX;
   uint64_t  _max = 0;
@@ -250,7 +250,7 @@ static void getStatics_u64(const void *pBitmap, const void *pData, int32_t numOf
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (((uint64_t)data[i]) == TSDB_DATA_UBIGINT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -263,8 +263,8 @@ static void getStatics_u64(const void *pBitmap, const void *pData, int32_t numOf
   *sum = _sum;
 }
 
-static void getStatics_f(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_f(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                         int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                         int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   float *data = (float *)pData;
   float  fmin = FLT_MAX;
   float  fmax = -FLT_MAX;
@@ -276,7 +276,7 @@ static void getStatics_f(const void *pBitmap, const void *pData, int32_t numOfRo
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if ((*(uint32_t *)&(data[i])) == TSDB_DATA_FLOAT_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -300,8 +300,8 @@ static void getStatics_f(const void *pBitmap, const void *pData, int32_t numOfRo
   SET_DOUBLE_VAL(min, fmin);
 }
 
-static void getStatics_d(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_d(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                         int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                         int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   double *data = (double *)pData;
   double  dmin = DBL_MAX;
   double  dmax = -DBL_MAX;
@@ -313,7 +313,7 @@ static void getStatics_d(const void *pBitmap, const void *pData, int32_t numOfRo
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if ((*(uint64_t *)&(data[i])) == TSDB_DATA_DOUBLE_NULL) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -337,14 +337,14 @@ static void getStatics_d(const void *pBitmap, const void *pData, int32_t numOfRo
   SET_DOUBLE_PTR(min, &dmin);
 }
 
-static void getStatics_bin(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_bin(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   const char *data = pData;
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (isNull(data, TSDB_DATA_TYPE_BINARY)) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
     }
 
@@ -358,14 +358,14 @@ static void getStatics_bin(const void *pBitmap, const void *pData, int32_t numOf
   *maxIndex = 0;
 }
 
-static void getStatics_nchr(const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
+static void getStatics_nchr(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
-                            int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+                            int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   const char *data = pData;
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
     // if (isNull(data, TSDB_DATA_TYPE_NCHAR)) {
-    if (!tdIsBitmapValTypeNormII(pBitmap, i)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
     }
 

source/dnode/mgmt/test/vnode/CMakeLists.txt

@@ -1,11 +1,11 @@
-aux_source_directory(. DND_VNODE_TEST_SRC)
+# aux_source_directory(. DND_VNODE_TEST_SRC)
-add_executable(dvnodeTest ${DND_VNODE_TEST_SRC})
+# add_executable(dvnodeTest ${DND_VNODE_TEST_SRC})
-target_link_libraries(
+# target_link_libraries(
-    dvnodeTest
+#     dvnodeTest
-    PUBLIC sut
+#     PUBLIC sut
-)
+# )
 
-add_test(
+# add_test(
-    NAME dvnodeTest
+#     NAME dvnodeTest
-    COMMAND dvnodeTest
+#     COMMAND dvnodeTest
-)
+# )

source/dnode/mnode/impl/inc/mndDef.h

@@ -285,6 +285,7 @@ typedef struct {
   int32_t  vgVersion;
   int8_t   hashMethod;  // default is 1
   SDbCfg   cfg;
+  SRWLatch lock;
 } SDbObj;
 
 typedef struct {

source/dnode/mnode/impl/src/mndDb.c

@@ -219,10 +219,14 @@ static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {
 
 static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
   mTrace("db:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);
+  taosWLockLatch(&pOld->lock);
+  SArray *pOldRetensions = pOld->cfg.pRetensions;
   pOld->updateTime = pNew->updateTime;
   pOld->cfgVersion = pNew->cfgVersion;
   pOld->vgVersion = pNew->vgVersion;
   memcpy(&pOld->cfg, &pNew->cfg, sizeof(SDbCfg));
+  pNew->cfg.pRetensions = pOldRetensions;
+  taosWUnLockLatch(&pOld->lock);
   return 0;
 }
 

source/dnode/mnode/impl/src/mndFunc.c

@@ -63,28 +63,28 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
 
   int32_t  size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj) + SDB_FUNC_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_FUNC, SDB_FUNC_VER, size);
-  if (pRaw == NULL) goto FUNC_ENCODE_OVER;
+  if (pRaw == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, FUNC_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, FUNC_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, FUNC_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->align, FUNC_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->align, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, FUNC_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, FUNC_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, FUNC_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pFunc->signature, FUNC_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pFunc->signature, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, FUNC_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, FUNC_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER)
-  SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_ENCODE_OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER)
-  SDB_SET_DATALEN(pRaw, dataPos, FUNC_ENCODE_OVER);
+  SDB_SET_DATALEN(pRaw, dataPos, _OVER);
 
   terrno = 0;
 
-FUNC_ENCODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("func:%s, failed to encode to raw:%p since %s", pFunc->name, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -99,45 +99,45 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto FUNC_DECODE_OVER;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
 
   if (sver != SDB_FUNC_VER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto FUNC_DECODE_OVER;
+    goto _OVER;
   }
 
   SSdbRow *pRow = sdbAllocRow(sizeof(SFuncObj));
-  if (pRow == NULL) goto FUNC_DECODE_OVER;
+  if (pRow == NULL) goto _OVER;
 
   SFuncObj *pFunc = sdbGetRowObj(pRow);
-  if (pFunc == NULL) goto FUNC_DECODE_OVER;
+  if (pFunc == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, FUNC_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, FUNC_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, FUNC_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->align, FUNC_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->align, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, FUNC_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, FUNC_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, FUNC_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, FUNC_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, FUNC_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, FUNC_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, _OVER)
 
   pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize);
   pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize);
   if (pFunc->pComment == NULL || pFunc->pCode == NULL) {
-    goto FUNC_DECODE_OVER;
+    goto _OVER;
   }
 
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER)
-  SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_DECODE_OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER)
 
   terrno = 0;
 
-FUNC_DECODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("func:%s, failed to decode from raw:%p since %s", pFunc->name, pRaw, terrstr());
     taosMemoryFreeClear(pRow);
@@ -192,40 +192,40 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr
   func.outputLen = pCreate->outputLen;
   func.bufSize = pCreate->bufSize;
   func.signature = pCreate->signature;
-  func.commentSize = pCreate->commentSize;
+  func.commentSize = strlen(pCreate->pComment) + 1;
-  func.codeSize = pCreate->codeSize;
+  func.codeSize = strlen(pCreate->pCode) + 1;
   func.pComment = taosMemoryMalloc(func.commentSize);
   func.pCode = taosMemoryMalloc(func.codeSize);
   if (func.pCode == NULL || func.pCode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
-  memcpy(func.pComment, pCreate->pComment, pCreate->commentSize);
+  memcpy(func.pComment, pCreate->pComment, func.commentSize);
   memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, &pReq->rpcMsg);
-  if (pTrans == NULL) goto CREATE_FUNC_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create func:%s", pTrans->id, pCreate->name);
 
   SSdbRaw *pRedoRaw = mndFuncActionEncode(&func);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto CREATE_FUNC_OVER;
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto CREATE_FUNC_OVER;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto _OVER;
 
   SSdbRaw *pUndoRaw = mndFuncActionEncode(&func);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto CREATE_FUNC_OVER;
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
-  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto CREATE_FUNC_OVER;
+  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto _OVER;
 
   SSdbRaw *pCommitRaw = mndFuncActionEncode(&func);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto CREATE_FUNC_OVER;
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto CREATE_FUNC_OVER;
+  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER;
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_FUNC_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-CREATE_FUNC_OVER:
+_OVER:
   taosMemoryFree(func.pCode);
   taosMemoryFree(func.pComment);
   mndTransDrop(pTrans);
@@ -235,27 +235,27 @@ CREATE_FUNC_OVER:
 static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_FUNC, &pReq->rpcMsg);
-  if (pTrans == NULL) goto DROP_FUNC_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop user:%s", pTrans->id, pFunc->name);
 
   SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto DROP_FUNC_OVER;
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
   sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
 
   SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto DROP_FUNC_OVER;
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
   sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
 
   SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto DROP_FUNC_OVER;
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_FUNC_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-DROP_FUNC_OVER:
+_OVER:
   mndTransDrop(pTrans);
   return code;
 }
@@ -269,7 +269,7 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
 
   if (tDeserializeSCreateFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   mDebug("func:%s, start to create", createReq.name);
@@ -279,60 +279,66 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
     if (createReq.igExists) {
       mDebug("func:%s, already exist, ignore exist is set", createReq.name);
       code = 0;
-      goto CREATE_FUNC_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
-      goto CREATE_FUNC_OVER;
+      goto _OVER;
     }
   } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (createReq.name[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
-  if (createReq.commentSize <= 0 || createReq.commentSize > TSDB_FUNC_COMMENT_LEN) {
+  if (createReq.pComment == NULL) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
-  if (createReq.codeSize <= 0 || createReq.codeSize > TSDB_FUNC_CODE_LEN) {
+  if (createReq.pComment[0] == 0) {
+    terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
+    goto _OVER;
+  }
+
+  if (createReq.pCode == NULL) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (createReq.pCode[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (createReq.bufSize <= 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (mndCheckFuncAuth(pUser)) {
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   code = mndCreateFunc(pMnode, pReq, &createReq);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-CREATE_FUNC_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("func:%s, failed to create since %s", createReq.name, terrstr());
   }
 
   mndReleaseFunc(pMnode, pFunc);
   mndReleaseUser(pMnode, pUser);
+  tFreeSCreateFuncReq(&createReq);
 
   return code;
 }
@@ -346,14 +352,14 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) {
 
   if (tDeserializeSDropFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   mDebug("func:%s, start to drop", dropReq.name);
 
   if (dropReq.name[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   pFunc = mndAcquireFunc(pMnode, dropReq.name);
@@ -361,27 +367,27 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) {
     if (dropReq.igNotExists) {
       mDebug("func:%s, not exist, ignore not exist is set", dropReq.name);
       code = 0;
-      goto DROP_FUNC_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
-      goto DROP_FUNC_OVER;
+      goto _OVER;
     }
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   if (mndCheckFuncAuth(pUser)) {
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   code = mndDropFunc(pMnode, pReq, pFunc);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-DROP_FUNC_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("func:%s, failed to drop since %s", dropReq.name, terrstr());
   }
@@ -434,6 +440,12 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
     funcInfo.signature = pFunc->signature;
     funcInfo.commentSize = pFunc->commentSize;
     funcInfo.codeSize = pFunc->codeSize;
+    funcInfo.pCode = taosMemoryCalloc(1, sizeof(funcInfo.codeSize));
+    funcInfo.pComment = taosMemoryCalloc(1, sizeof(funcInfo.commentSize));
+    if (funcInfo.pCode == NULL || funcInfo.pComment == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto RETRIEVE_FUNC_OVER;
+    }
     memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
     memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
     taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo);
@@ -455,8 +467,8 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
   code = 0;
 
 RETRIEVE_FUNC_OVER:
-  taosArrayDestroy(retrieveReq.pFuncNames);
+  tFreeSRetrieveFuncReq(&retrieveReq);
-  taosArrayDestroy(retrieveRsp.pFuncInfos);
+  tFreeSRetrieveFuncRsp(&retrieveRsp);
 
   return code;
 }
@@ -511,7 +523,8 @@ static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pB
     colDataAppend(pColInfo, numOfRows, (const char *)&isAgg, false);
 
     char b3[TSDB_TYPE_STR_MAX_LEN] = {0};
-    STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen), pShow->bytes[cols]);
+    STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen),
+                               pShow->bytes[cols]);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, (const char *)b3, false);

source/dnode/mnode/impl/src/mndMnode.c

@@ -78,13 +78,13 @@ void mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj) {
 const char *mndGetRoleStr(int32_t showType) {
   switch (showType) {
     case TAOS_SYNC_STATE_FOLLOWER:
-      return "unsynced";
+      return "FOLLOWER";
     case TAOS_SYNC_STATE_CANDIDATE:
-      return "slave";
+      return "CANDIDATE";
     case TAOS_SYNC_STATE_LEADER:
-      return "master";
+      return "LEADER";
     default:
-      return "undefined";
+      return "ERROR";
   }
 }
 

source/dnode/mnode/impl/src/mndStb.c

@@ -18,8 +18,8 @@
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndInfoSchema.h"
-#include "mndPerfSchema.h"
 #include "mndMnode.h"
+#include "mndPerfSchema.h"
 #include "mndShow.h"
 #include "mndTrans.h"
 #include "mndUser.h"
@@ -74,59 +74,59 @@ SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
   int32_t size = sizeof(SStbObj) + (pStb->numOfColumns + pStb->numOfTags + pStb->numOfSmas) * sizeof(SSchema) +
                  TSDB_STB_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_STB, TSDB_STB_VER_NUMBER, size);
-  if (pRaw == NULL) goto STB_ENCODE_OVER;
+  if (pRaw == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, STB_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, STB_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pStb->createdTime, STB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pStb->createdTime, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pStb->updateTime, STB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pStb->updateTime, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pStb->uid, STB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pStb->uid, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pStb->dbUid, STB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pStb->dbUid, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->version, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->version, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->nextColId, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->nextColId, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, (int32_t)(pStb->xFilesFactor * 10000), STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, (int32_t)(pStb->xFilesFactor * 10000), _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->aggregationMethod, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->aggregationMethod, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->delay, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->delay, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->ttl, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->ttl, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->numOfSmas, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->numOfSmas, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->commentLen, STB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->commentLen, _OVER)
 
   for (int32_t i = 0; i < pStb->numOfColumns; ++i) {
     SSchema *pSchema = &pStb->pColumns[i];
-    SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER)
+    SDB_SET_INT8(pRaw, dataPos, pSchema->type, _OVER)
-    SDB_SET_INT16(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER)
+    SDB_SET_INT16(pRaw, dataPos, pSchema->colId, _OVER)
-    SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER)
+    SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, _OVER)
-    SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER)
+    SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER)
   }
 
   for (int32_t i = 0; i < pStb->numOfTags; ++i) {
     SSchema *pSchema = &pStb->pTags[i];
-    SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER)
+    SDB_SET_INT8(pRaw, dataPos, pSchema->type, _OVER)
-    SDB_SET_INT16(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER)
+    SDB_SET_INT16(pRaw, dataPos, pSchema->colId, _OVER)
-    SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER)
+    SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, _OVER)
-    SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER)
+    SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER)
   }
 
   for (int32_t i = 0; i < pStb->numOfSmas; ++i) {
     SSchema *pSchema = &pStb->pSmas[i];
-    SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER)
+    SDB_SET_INT8(pRaw, dataPos, pSchema->type, _OVER)
-    SDB_SET_INT16(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER)
+    SDB_SET_INT16(pRaw, dataPos, pSchema->colId, _OVER)
-    SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER)
+    SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, _OVER)
-    SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER)
+    SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER)
   }
 
   if (pStb->commentLen > 0) {
-    SDB_SET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, STB_ENCODE_OVER)
+    SDB_SET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, _OVER)
   }
-  SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, STB_ENCODE_OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, _OVER)
-  SDB_SET_DATALEN(pRaw, dataPos, STB_ENCODE_OVER)
+  SDB_SET_DATALEN(pRaw, dataPos, _OVER)
 
   terrno = 0;
 
-STB_ENCODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("stb:%s, failed to encode to raw:%p since %s", pStb->name, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -141,80 +141,80 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto STB_DECODE_OVER;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
 
   if (sver != TSDB_STB_VER_NUMBER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto STB_DECODE_OVER;
+    goto _OVER;
   }
 
   SSdbRow *pRow = sdbAllocRow(sizeof(SStbObj));
-  if (pRow == NULL) goto STB_DECODE_OVER;
+  if (pRow == NULL) goto _OVER;
 
   SStbObj *pStb = sdbGetRowObj(pRow);
-  if (pStb == NULL) goto STB_DECODE_OVER;
+  if (pStb == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_GET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, STB_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, _OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, STB_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pStb->createdTime, STB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pStb->createdTime, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pStb->updateTime, STB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pStb->updateTime, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pStb->uid, STB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pStb->uid, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pStb->dbUid, STB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pStb->dbUid, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->version, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->version, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->nextColId, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->nextColId, _OVER)
   int32_t xFilesFactor = 0;
-  SDB_GET_INT32(pRaw, dataPos, &xFilesFactor, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &xFilesFactor, _OVER)
   pStb->xFilesFactor = xFilesFactor / 10000.0f;
-  SDB_GET_INT32(pRaw, dataPos, &pStb->aggregationMethod, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->aggregationMethod, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->delay, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->delay, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->ttl, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->ttl, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfColumns, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfColumns, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfTags, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfTags, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfSmas, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfSmas, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pStb->commentLen, STB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->commentLen, _OVER)
 
   pStb->pColumns = taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchema));
   pStb->pTags = taosMemoryCalloc(pStb->numOfTags, sizeof(SSchema));
   pStb->pSmas = taosMemoryCalloc(pStb->numOfSmas, sizeof(SSchema));
   if (pStb->pColumns == NULL || pStb->pTags == NULL || pStb->pSmas == NULL) {
-    goto STB_DECODE_OVER;
+    goto _OVER;
   }
 
   for (int32_t i = 0; i < pStb->numOfColumns; ++i) {
     SSchema *pSchema = &pStb->pColumns[i];
-    SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER)
+    SDB_GET_INT8(pRaw, dataPos, &pSchema->type, _OVER)
-    SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER)
+    SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, _OVER)
-    SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER)
+    SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, _OVER)
-    SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER)
+    SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER)
   }
 
   for (int32_t i = 0; i < pStb->numOfTags; ++i) {
     SSchema *pSchema = &pStb->pTags[i];
-    SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER)
+    SDB_GET_INT8(pRaw, dataPos, &pSchema->type, _OVER)
-    SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER)
+    SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, _OVER)
-    SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER)
+    SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, _OVER)
-    SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER)
+    SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER)
   }
 
   for (int32_t i = 0; i < pStb->numOfSmas; ++i) {
     SSchema *pSchema = &pStb->pSmas[i];
-    SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER)
+    SDB_GET_INT8(pRaw, dataPos, &pSchema->type, _OVER)
-    SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER)
+    SDB_GET_INT16(pRaw, dataPos, &pSchema->colId, _OVER)
-    SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER)
+    SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, _OVER)
-    SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER)
+    SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, _OVER)
   }
 
   if (pStb->commentLen > 0) {
     pStb->comment = taosMemoryCalloc(pStb->commentLen, 1);
-    if (pStb->comment == NULL) goto STB_DECODE_OVER;
+    if (pStb->comment == NULL) goto _OVER;
-    SDB_GET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, STB_DECODE_OVER)
+    SDB_GET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, _OVER)
   }
-  SDB_GET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, STB_DECODE_OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, _OVER)
 
   terrno = 0;
 
-STB_DECODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("stb:%s, failed to decode from raw:%p since %s", pStb->name, pRaw, terrstr());
     taosMemoryFreeClear(pStb->pColumns);
@@ -333,9 +333,9 @@ static SDbObj *mndAcquireDbByStb(SMnode *pMnode, const char *stbName) {
 }
 
 static FORCE_INLINE int schemaExColIdCompare(const void *colId, const void *pSchema) {
-  if (*(col_id_t *)colId < ((SSchemaEx *)pSchema)->colId) {
+  if (*(col_id_t *)colId < ((SSchema *)pSchema)->colId) {
     return -1;
-  } else if (*(col_id_t *)colId > ((SSchemaEx *)pSchema)->colId) {
+  } else if (*(col_id_t *)colId > ((SSchema *)pSchema)->colId) {
     return 1;
   }
   return 0;
@@ -360,49 +360,15 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
   req.stbCfg.nTagCols = pStb->numOfTags;
   req.stbCfg.pTagSchema = pStb->pTags;
   req.stbCfg.nBSmaCols = pStb->numOfSmas;
-  req.stbCfg.pSchema = (SSchemaEx *)taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchemaEx));
+  req.stbCfg.pSchema = (SSchema *)taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchema));
   if (req.stbCfg.pSchema == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
-  int bSmaStat = 0;                             // no column has bsma
+  memcpy(req.stbCfg.pSchema, pStb->pColumns, sizeof(SSchema) * pStb->numOfColumns);
-  if (pStb->numOfSmas == pStb->numOfColumns) {  // assume pColumns > 0
+  for (int i = 0; i < pStb->numOfColumns; i++) {
-    bSmaStat = 1;                               // all columns have bsma
+    req.stbCfg.pSchema[i].flags = SCHEMA_SMA_ON;
-  } else if (pStb->numOfSmas != 0) {
-    bSmaStat = 2;                  // partial columns have bsma
-    TASSERT(pStb->pSmas != NULL);  // TODO: remove the assert
-  }
-
-  for (int32_t i = 0; i < req.stbCfg.nCols; ++i) {
-    SSchemaEx *pSchemaEx = req.stbCfg.pSchema + i;
-    SSchema   *pSchema = pStb->pColumns + i;
-    pSchemaEx->type = pSchema->type;
-    pSchemaEx->sma = (bSmaStat == 1) ? TSDB_BSMA_TYPE_LATEST : TSDB_BSMA_TYPE_NONE;
-    pSchemaEx->colId = pSchema->colId;
-    pSchemaEx->bytes = pSchema->bytes;
-    memcpy(pSchemaEx->name, pSchema->name, TSDB_COL_NAME_LEN);
-  }
-
-  if (bSmaStat == 2) {
-    if (pStb->pSmas == NULL) {
-      mError("stb:%s, sma options is empty", pStb->name);
-      taosMemoryFreeClear(req.stbCfg.pSchema);
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return NULL;
-    }
-    for (int32_t i = 0; i < pStb->numOfSmas; ++i) {
-      SSchema   *pSmaSchema = pStb->pSmas + i;
-      SSchemaEx *pColSchema = taosbsearch(&pSmaSchema->colId, req.stbCfg.pSchema, req.stbCfg.nCols, sizeof(SSchemaEx),
-                                          schemaExColIdCompare, TD_EQ);
-      if (pColSchema == NULL) {
-        terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-        taosMemoryFreeClear(req.stbCfg.pSchema);
-        mError("stb:%s, sma col:%s not found in columns", pStb->name, pSmaSchema->name);
-        return NULL;
-      }
-      pColSchema->sma = TSDB_BSMA_TYPE_LATEST;
-    }
   }
 
   SRSmaParam *pRSmaParam = NULL;
@@ -724,21 +690,21 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre
 
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_STB, &pReq->rpcMsg);
-  if (pTrans == NULL) goto CREATE_STB_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create stb:%s", pTrans->id, pCreate->name);
   mndTransSetDbInfo(pTrans, pDb);
 
-  if (mndSetCreateStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER;
+  if (mndSetCreateStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndSetCreateStbUndoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER;
+  if (mndSetCreateStbUndoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndSetCreateStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER;
+  if (mndSetCreateStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndSetCreateStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER;
+  if (mndSetCreateStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndSetCreateStbUndoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto CREATE_STB_OVER;
+  if (mndSetCreateStbUndoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_STB_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-CREATE_STB_OVER:
+_OVER:
   mndTransDrop(pTrans);
   return code;
 }
@@ -754,13 +720,13 @@ static int32_t mndProcessMCreateStbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSMCreateStbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   mDebug("stb:%s, start to create", createReq.name);
   if (mndCheckCreateStbReq(&createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   pStb = mndAcquireStb(pMnode, createReq.name);
@@ -768,40 +734,40 @@ static int32_t mndProcessMCreateStbReq(SNodeMsg *pReq) {
     if (createReq.igExists) {
       mDebug("stb:%s, already exist, ignore exist is set", createReq.name);
       code = 0;
-      goto CREATE_STB_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_STB_ALREADY_EXIST;
-      goto CREATE_STB_OVER;
+      goto _OVER;
     }
   } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) {
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   pTopicStb = mndAcquireStb(pMnode, createReq.name);
   if (pTopicStb != NULL) {
     terrno = TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC;
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   pDb = mndAcquireDbByStb(pMnode, createReq.name);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   if (mndCheckWriteAuth(pUser, pDb) != 0) {
-    goto CREATE_STB_OVER;
+    goto _OVER;
   }
 
   code = mndCreateStb(pMnode, pReq, &createReq, pDb);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-CREATE_STB_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("stb:%s, failed to create since %s", createReq.name, terrstr());
   }
@@ -1211,23 +1177,23 @@ static int32_t mndAlterStb(SMnode *pMnode, SNodeMsg *pReq, const SMAltertbReq *p
       break;
   }
 
-  if (code != 0) goto ALTER_STB_OVER;
+  if (code != 0) goto _OVER;
 
   code = -1;
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_ALTER_STB, &pReq->rpcMsg);
-  if (pTrans == NULL) goto ALTER_STB_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to alter stb:%s", pTrans->id, pAlter->name);
   mndTransSetDbInfo(pTrans, pDb);
 
-  if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto ALTER_STB_OVER;
+  if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto ALTER_STB_OVER;
+  if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto ALTER_STB_OVER;
+  if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto ALTER_STB_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-ALTER_STB_OVER:
+_OVER:
   mndTransDrop(pTrans);
   taosMemoryFreeClear(stbObj.pTags);
   taosMemoryFreeClear(stbObj.pColumns);
@@ -1244,37 +1210,37 @@ static int32_t mndProcessMAlterStbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSMAlterStbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &alterReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto ALTER_STB_OVER;
+    goto _OVER;
   }
 
   mDebug("stb:%s, start to alter", alterReq.name);
-  if (mndCheckAlterStbReq(&alterReq) != 0) goto ALTER_STB_OVER;
+  if (mndCheckAlterStbReq(&alterReq) != 0) goto _OVER;
 
   pDb = mndAcquireDbByStb(pMnode, alterReq.name);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_INVALID_DB;
-    goto ALTER_STB_OVER;
+    goto _OVER;
   }
 
   pStb = mndAcquireStb(pMnode, alterReq.name);
   if (pStb == NULL) {
     terrno = TSDB_CODE_MND_STB_NOT_EXIST;
-    goto ALTER_STB_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto ALTER_STB_OVER;
+    goto _OVER;
   }
 
   if (mndCheckWriteAuth(pUser, pDb) != 0) {
-    goto ALTER_STB_OVER;
+    goto _OVER;
   }
 
   code = mndAlterStb(pMnode, pReq, &alterReq, pDb, pStb);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-ALTER_STB_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("stb:%s, failed to alter since %s", alterReq.name, terrstr());
   }
@@ -1353,19 +1319,19 @@ static int32_t mndSetDropStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
 static int32_t mndDropStb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pDb, SStbObj *pStb) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_STB, &pReq->rpcMsg);
-  if (pTrans == NULL) goto DROP_STB_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop stb:%s", pTrans->id, pStb->name);
   mndTransSetDbInfo(pTrans, pDb);
 
-  if (mndSetDropStbRedoLogs(pMnode, pTrans, pStb) != 0) goto DROP_STB_OVER;
+  if (mndSetDropStbRedoLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
-  if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto DROP_STB_OVER;
+  if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
-  if (mndSetDropStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto DROP_STB_OVER;
+  if (mndSetDropStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_STB_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-DROP_STB_OVER:
+_OVER:
   mndTransDrop(pTrans);
   return code;
 }
@@ -1380,7 +1346,7 @@ static int32_t mndProcessMDropStbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSMDropStbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto DROP_STB_OVER;
+    goto _OVER;
   }
 
   mDebug("stb:%s, start to drop", dropReq.name);
@@ -1390,32 +1356,32 @@ static int32_t mndProcessMDropStbReq(SNodeMsg *pReq) {
     if (dropReq.igNotExists) {
       mDebug("stb:%s, not exist, ignore not exist is set", dropReq.name);
       code = 0;
-      goto DROP_STB_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_STB_NOT_EXIST;
-      goto DROP_STB_OVER;
+      goto _OVER;
     }
   }
 
   pDb = mndAcquireDbByStb(pMnode, dropReq.name);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    goto DROP_STB_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto DROP_STB_OVER;
+    goto _OVER;
   }
 
   if (mndCheckWriteAuth(pUser, pDb) != 0) {
-    goto DROP_STB_OVER;
+    goto _OVER;
   }
 
   code = mndDropStb(pMnode, pReq, pDb, pStb);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-DROP_STB_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("stb:%s, failed to drop since %s", dropReq.name, terrstr());
   }
@@ -1509,36 +1475,36 @@ static int32_t mndProcessTableMetaReq(SNodeMsg *pReq) {
 
   if (tDeserializeSTableInfoReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &infoReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto RETRIEVE_META_OVER;
+    goto _OVER;
   }
 
   if (0 == strcmp(infoReq.dbFName, TSDB_INFORMATION_SCHEMA_DB)) {
     mDebug("information_schema table:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName);
     if (mndBuildInsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) {
-      goto RETRIEVE_META_OVER;
+      goto _OVER;
     }
   } else if (0 == strcmp(infoReq.dbFName, TSDB_PERFORMANCE_SCHEMA_DB)) {
     mDebug("performance_schema table:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName);
     if (mndBuildPerfsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) {
-      goto RETRIEVE_META_OVER;
+      goto _OVER;
     }
   } else {
     mDebug("stb:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName);
     if (mndBuildStbSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) {
-      goto RETRIEVE_META_OVER;
+      goto _OVER;
     }
   }
 
   int32_t rspLen = tSerializeSTableMetaRsp(NULL, 0, &metaRsp);
   if (rspLen < 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto RETRIEVE_META_OVER;
+    goto _OVER;
   }
 
   void *pRsp = rpcMallocCont(rspLen);
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto RETRIEVE_META_OVER;
+    goto _OVER;
   }
 
   tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp);
@@ -1548,7 +1514,7 @@ static int32_t mndProcessTableMetaReq(SNodeMsg *pReq) {
 
   mDebug("stb:%s.%s, meta is retrieved", infoReq.dbFName, infoReq.tbName);
 
-RETRIEVE_META_OVER:
+_OVER:
   if (code != 0) {
     mError("stb:%s.%s, failed to retrieve meta since %s", infoReq.dbFName, infoReq.tbName, terrstr());
   }

source/dnode/mnode/impl/test/func/func.cpp

@@ -21,10 +21,25 @@ class MndTestFunc : public ::testing::Test {
  public:
   void SetUp() override {}
   void TearDown() override {}
+
+  void SetCode(SCreateFuncReq* pReq, const char* pCode);
+  void SetComment(SCreateFuncReq* pReq, const char* pComment);
 };
 
 Testbase MndTestFunc::test;
 
+void MndTestFunc::SetCode(SCreateFuncReq* pReq, const char* pCode) {
+  int32_t len = strlen(pCode);
+  pReq->pCode = (char*)taosMemoryCalloc(1, len + 1);
+  strcpy(pReq->pCode, pCode);
+}
+
+void MndTestFunc::SetComment(SCreateFuncReq* pReq, const char* pComment) {
+  int32_t len = strlen(pComment);
+  pReq->pComment = (char*)taosMemoryCalloc(1, len + 1);
+  strcpy(pReq->pComment, pComment);
+}
+
 TEST_F(MndTestFunc, 01_Show_Func) {
   test.SendShowReq(TSDB_MGMT_TABLE_FUNC, "user_functions", "");
   EXPECT_EQ(test.GetShowRows(), 0);
@@ -38,6 +53,7 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -47,10 +63,12 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
+    SetCode(&createReq, "code1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -60,11 +78,28 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN + 1;
+    SetComment(&createReq, "comment1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
+  }
+
+  {
+    SCreateFuncReq createReq = {0};
+    strcpy(createReq.name, "f1");
+    SetCode(&createReq, "code1");
+    SetComment(&createReq, "");
+
+    int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
+    void*   pReq = rpcMallocCont(contLen);
+    tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -74,11 +109,13 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
+    SetCode(&createReq, "");
+    SetComment(&createReq, "comment1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -88,43 +125,13 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
+    SetCode(&createReq, "code1");
-    createReq.codeSize = TSDB_FUNC_CODE_LEN + 1;
+    SetComment(&createReq, "comment1");
-
-    int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
-    void*   pReq = rpcMallocCont(contLen);
-    tSerializeSCreateFuncReq(pReq, contLen, &createReq);
-
-    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
-    ASSERT_NE(pRsp, nullptr);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
-  }
-
-  {
-    SCreateFuncReq createReq = {0};
-    strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
-
-    int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
-    void*   pReq = rpcMallocCont(contLen);
-    tSerializeSCreateFuncReq(pReq, contLen, &createReq);
-
-    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
-    ASSERT_NE(pRsp, nullptr);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
-  }
-
-  {
-    SCreateFuncReq createReq = {0};
-    strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
-    createReq.pCode[0] = 'a';
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -134,14 +141,14 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
+    SetCode(&createReq, "code1");
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
+    SetComment(&createReq, "comment1");
-    createReq.pCode[0] = 'a';
     createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1;
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -151,9 +158,8 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   for (int32_t i = 0; i < 3; ++i) {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
+    SetCode(&createReq, "code1");
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
+    SetComment(&createReq, "comment1");
-    createReq.pCode[0] = 'a';
     createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1;
     createReq.igExists = 0;
     if (i == 2) createReq.igExists = 1;
@@ -163,16 +169,11 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     createReq.outputLen = 12;
     createReq.bufSize = 4;
     createReq.signature = 5;
-    for (int32_t i = 0; i < createReq.commentSize - 1; ++i) {
-      createReq.pComment[i] = 'm';
-    }
-    for (int32_t i = 0; i < createReq.codeSize - 1; ++i) {
-      createReq.pCode[i] = 'd';
-    }
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -197,7 +198,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -217,20 +218,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     EXPECT_EQ(pFuncInfo->outputLen, 12);
     EXPECT_EQ(pFuncInfo->bufSize, 4);
     EXPECT_EQ(pFuncInfo->signature, 5);
-    EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN);
+    EXPECT_STREQ("comment1", pFuncInfo->pComment);
-    EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN);
+    EXPECT_STREQ("code1", pFuncInfo->pCode);
 
-    char comments[TSDB_FUNC_COMMENT_LEN] = {0};
+    tFreeSRetrieveFuncRsp(&retrieveRsp);
-    for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) {
-      comments[i] = 'm';
-    }
-    char codes[TSDB_FUNC_CODE_LEN] = {0};
-    for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) {
-      codes[i] = 'd';
-    }
-    EXPECT_STREQ(comments, pFuncInfo->pComment);
-    EXPECT_STREQ(codes, pFuncInfo->pCode);
-    taosArrayDestroy(retrieveRsp.pFuncInfos);
   }
 
   {
@@ -241,7 +232,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -259,7 +250,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -275,7 +266,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -285,8 +276,6 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f2");
-    createReq.commentSize = 1024;
-    createReq.codeSize = 9527;
     createReq.igExists = 1;
     createReq.funcType = 2;
     createReq.scriptType = 3;
@@ -294,16 +283,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     createReq.outputLen = 24;
     createReq.bufSize = 6;
     createReq.signature = 18;
-    for (int32_t i = 0; i < createReq.commentSize - 1; ++i) {
+    SetCode(&createReq, "code2");
-      createReq.pComment[i] = 'p';
+    SetComment(&createReq, "comment2");
-    }
-    for (int32_t i = 0; i < createReq.codeSize - 1; ++i) {
-      createReq.pCode[i] = 'q';
-    }
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -322,7 +308,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -342,21 +328,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     EXPECT_EQ(pFuncInfo->outputLen, 24);
     EXPECT_EQ(pFuncInfo->bufSize, 6);
     EXPECT_EQ(pFuncInfo->signature, 18);
-    EXPECT_EQ(pFuncInfo->commentSize, 1024);
+    EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1);
-    EXPECT_EQ(pFuncInfo->codeSize, 9527);
+    EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1);
 
-    char comments[TSDB_FUNC_COMMENT_LEN] = {0};
+    EXPECT_STREQ("comment2", pFuncInfo->pComment);
-    for (int32_t i = 0; i < 1024 - 1; ++i) {
+    EXPECT_STREQ("code2", pFuncInfo->pCode);
-      comments[i] = 'p';
-    }
-    char codes[TSDB_FUNC_CODE_LEN] = {0};
-    for (int32_t i = 0; i < 9527 - 1; ++i) {
-      codes[i] = 'q';
-    }
 
-    EXPECT_STREQ(comments, pFuncInfo->pComment);
+    tFreeSRetrieveFuncRsp(&retrieveRsp);
-    EXPECT_STREQ(codes, pFuncInfo->pCode);
-    taosArrayDestroy(retrieveRsp.pFuncInfos);
   }
 
   {
@@ -369,7 +347,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -389,20 +367,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
       EXPECT_EQ(pFuncInfo->outputLen, 24);
       EXPECT_EQ(pFuncInfo->bufSize, 6);
       EXPECT_EQ(pFuncInfo->signature, 18);
-      EXPECT_EQ(pFuncInfo->commentSize, 1024);
+      EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1);
-      EXPECT_EQ(pFuncInfo->codeSize, 9527);
+      EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1);
-
+      EXPECT_STREQ("comment2", pFuncInfo->pComment);
-      char comments[TSDB_FUNC_COMMENT_LEN] = {0};
+      EXPECT_STREQ("code2", pFuncInfo->pCode);
-      for (int32_t i = 0; i < 1024 - 1; ++i) {
-        comments[i] = 'p';
-      }
-      char codes[TSDB_FUNC_CODE_LEN] = {0};
-      for (int32_t i = 0; i < 9527 - 1; ++i) {
-        codes[i] = 'q';
-      }
-
-      EXPECT_STREQ(comments, pFuncInfo->pComment);
-      EXPECT_STREQ(codes, pFuncInfo->pCode);
     }
 
     {
@@ -414,21 +382,11 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
       EXPECT_EQ(pFuncInfo->outputLen, 12);
       EXPECT_EQ(pFuncInfo->bufSize, 4);
       EXPECT_EQ(pFuncInfo->signature, 5);
-      EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN);
+      EXPECT_STREQ("comment1", pFuncInfo->pComment);
-      EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN);
+      EXPECT_STREQ("code1", pFuncInfo->pCode);
+    }
 
-      char comments[TSDB_FUNC_COMMENT_LEN] = {0};
+    tFreeSRetrieveFuncRsp(&retrieveRsp);
-      for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) {
-        comments[i] = 'm';
-      }
-      char codes[TSDB_FUNC_CODE_LEN] = {0};
-      for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) {
-        codes[i] = 'd';
-      }
-      EXPECT_STREQ(comments, pFuncInfo->pComment);
-      EXPECT_STREQ(codes, pFuncInfo->pCode);
-    }
-    taosArrayDestroy(retrieveRsp.pFuncInfos);
   }
 
   {
@@ -441,7 +399,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);

source/dnode/vnode/src/inc/tsdb.h

@@ -43,10 +43,8 @@ typedef struct STable {
 #define TABLE_TID(t) (t)->tid
 #define TABLE_UID(t) (t)->uid
 
-STsdb  *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
+STsdb  *tsdbOpen(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
-                 STfs *pTfs);
 void    tsdbClose(STsdb *);
-void    tsdbRemove(const char *path);
 int     tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp);
 int     tsdbPrepareCommit(STsdb *pTsdb);
 int     tsdbCommit(STsdb *pTsdb);
@@ -167,16 +165,14 @@ struct STsdb {
   SRtn                  rtn;
   SMemAllocatorFactory *pmaf;
   STsdbFS              *fs;
-  SMeta                *pMeta;
-  STfs                 *pTfs;
   SSmaEnvs              smaEnvs;
 };
 
 #define REPO_ID(r)        ((r)->vgId)
 #define REPO_CFG(r)       (&(r)->config)
 #define REPO_FS(r)        ((r)->fs)
-#define REPO_META(r)      ((r)->pMeta)
+#define REPO_META(r)      ((r)->pVnode->pMeta)
-#define REPO_TFS(r)       ((r)->pTfs)
+#define REPO_TFS(r)       ((r)->pVnode->pTfs)
 #define IS_REPO_LOCKED(r) ((r)->repoLocked)
 #define REPO_TSMA_NUM(r)  ((r)->smaEnvs.nTSma)
 #define REPO_RSMA_NUM(r)  ((r)->smaEnvs.nRSma)

source/dnode/vnode/src/meta/metaTDBImpl.c

@@ -299,10 +299,10 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
 
     if (pTbCfg->type == META_SUPER_TABLE) {
       schemaWrapper.nCols = pTbCfg->stbCfg.nCols;
-      schemaWrapper.pSchemaEx = pTbCfg->stbCfg.pSchema;
+      schemaWrapper.pSchema = pTbCfg->stbCfg.pSchema;
     } else {
       schemaWrapper.nCols = pTbCfg->ntbCfg.nCols;
-      schemaWrapper.pSchemaEx = pTbCfg->ntbCfg.pSchema;
+      schemaWrapper.pSchema = pTbCfg->ntbCfg.pSchema;
     }
     pVal = pBuf = buf;
     metaEncodeSchemaEx(&pBuf, &schemaWrapper);
@@ -464,7 +464,7 @@ STSchema *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver) {
   tb_uid_t        quid;
   SSchemaWrapper *pSW;
   STSchemaBuilder sb;
-  SSchemaEx      *pSchema;
+  SSchema        *pSchema;
   STSchema       *pTSchema;
   STbCfg         *pTbCfg;
 
@@ -482,8 +482,8 @@ STSchema *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver) {
 
   tdInitTSchemaBuilder(&sb, 0);
   for (int i = 0; i < pSW->nCols; i++) {
-    pSchema = pSW->pSchemaEx + i;
+    pSchema = pSW->pSchema + i;
-    tdAddColToSchema(&sb, pSchema->type, pSchema->sma, pSchema->colId, pSchema->bytes);
+    tdAddColToSchema(&sb, pSchema->type, pSchema->flags, pSchema->colId, pSchema->bytes);
   }
   pTSchema = tdGetSchemaFromBuilder(&sb);
   tdDestroyTSchemaBuilder(&sb);
@@ -939,7 +939,7 @@ static int metaEncodeSchema(void **buf, SSchemaWrapper *pSW) {
   for (int i = 0; i < pSW->nCols; i++) {
     pSchema = pSW->pSchema + i;
     tlen += taosEncodeFixedI8(buf, pSchema->type);
-    tlen += taosEncodeFixedI8(buf, pSchema->index);
+    tlen += taosEncodeFixedI8(buf, pSchema->flags);
     tlen += taosEncodeFixedI16(buf, pSchema->colId);
     tlen += taosEncodeFixedI32(buf, pSchema->bytes);
     tlen += taosEncodeString(buf, pSchema->name);
@@ -967,13 +967,13 @@ static void *metaDecodeSchema(void *buf, SSchemaWrapper *pSW) {
 
 static int metaEncodeSchemaEx(void **buf, SSchemaWrapper *pSW) {
   int      tlen = 0;
-  SSchemaEx *pSchema;
+  SSchema *pSchema;
 
   tlen += taosEncodeFixedU32(buf, pSW->nCols);
   for (int i = 0; i < pSW->nCols; ++i) {
-    pSchema = pSW->pSchemaEx + i;
+    pSchema = pSW->pSchema + i;
     tlen += taosEncodeFixedI8(buf, pSchema->type);
-    tlen += taosEncodeFixedI8(buf, pSchema->sma);
+    tlen += taosEncodeFixedI8(buf, pSchema->flags);
     tlen += taosEncodeFixedI16(buf, pSchema->colId);
     tlen += taosEncodeFixedI32(buf, pSchema->bytes);
     tlen += taosEncodeString(buf, pSchema->name);
@@ -985,11 +985,11 @@ static int metaEncodeSchemaEx(void **buf, SSchemaWrapper *pSW) {
 static void *metaDecodeSchemaEx(void *buf, SSchemaWrapper *pSW, bool isGetEx) {
   buf = taosDecodeFixedU32(buf, &pSW->nCols);
   if (isGetEx) {
-    pSW->pSchemaEx = (SSchemaEx *)taosMemoryMalloc(sizeof(SSchemaEx) * pSW->nCols);
+    pSW->pSchema = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * pSW->nCols);
     for (int i = 0; i < pSW->nCols; i++) {
-      SSchemaEx *pSchema = pSW->pSchemaEx + i;
+      SSchema *pSchema = pSW->pSchema + i;
       buf = taosDecodeFixedI8(buf, &pSchema->type);
-      buf = taosDecodeFixedI8(buf, &pSchema->sma);
+      buf = taosDecodeFixedI8(buf, &pSchema->flags);
       buf = taosDecodeFixedI16(buf, &pSchema->colId);
       buf = taosDecodeFixedI32(buf, &pSchema->bytes);
       buf = taosDecodeStringTo(buf, pSchema->name);

source/dnode/vnode/src/tsdb/tsdbCommit.c

@@ -100,7 +100,7 @@ int tsdbApplyRtnOnFSet(STsdb *pRepo, SDFileSet *pSet, SRtn *pRtn) {
 
   level = tsdbGetFidLevel(pSet->fid, pRtn);
 
-  if (tfsAllocDisk(pRepo->pTfs, level, &did) < 0) {
+  if (tfsAllocDisk(pRepo->pVnode->pTfs, level, &did) < 0) {
     terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
     return -1;
   }
@@ -427,7 +427,7 @@ static int tsdbCreateCommitIters(SCommitH *pCommith) {
     pCommitIter->pTable = (STable *)taosMemoryMalloc(sizeof(STable));
     pCommitIter->pTable->uid = pTbData->uid;
     pCommitIter->pTable->tid = pTbData->uid;
-    pCommitIter->pTable->pSchema = metaGetTbTSchema(pRepo->pMeta, pTbData->uid, 0);
+    pCommitIter->pTable->pSchema = metaGetTbTSchema(REPO_META(pRepo), pTbData->uid, 0);
   }
 
   return 0;
@@ -459,7 +459,7 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
   STsdb     *pRepo = TSDB_COMMIT_REPO(pCommith);
   SDFileSet *pWSet = TSDB_COMMIT_WRITE_FSET(pCommith);
 
-  if (tfsAllocDisk(pRepo->pTfs, tsdbGetFidLevel(fid, &(pCommith->rtn)), &did) < 0) {
+  if (tfsAllocDisk(REPO_TFS(pRepo), tsdbGetFidLevel(fid, &(pCommith->rtn)), &did) < 0) {
     terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
     return -1;
   }
@@ -1201,6 +1201,23 @@ static int tsdbComparKeyBlock(const void *arg1, const void *arg2) {
   }
 }
 
+/**
+ * @brief Write SDataCols to data file.
+ *
+ * @param pRepo
+ * @param pTable
+ * @param pDFile
+ * @param pDFileAggr
+ * @param pDataCols The pDataCols would be generated from mem/imem directly with 2 bits bitmap or from tsdbRead
+ * interface with 1 bit bitmap.
+ * @param pBlock
+ * @param isLast
+ * @param isSuper
+ * @param ppBuf
+ * @param ppCBuf
+ * @param ppExBuf
+ * @return int
+ */
 int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDFileAggr, SDataCols *pDataCols,
                        SBlock *pBlock, bool isLast, bool isSuper, void **ppBuf, void **ppCBuf, void **ppExBuf) {
   STsdbCfg     *pCfg = REPO_CFG(pRepo);
@@ -1244,14 +1261,15 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
     pBlockCol->type = pDataCol->type;
     pAggrBlkCol->colId = pDataCol->colId;
 
-    if (tDataTypes[pDataCol->type].statisFunc) {
+    if (isSuper && pColumn->sma && tDataTypes[pDataCol->type].statisFunc) {
 #if 0
       (*tDataTypes[pDataCol->type].statisFunc)(pDataCol->pData, rowsToWrite, &(pBlockCol->min), &(pBlockCol->max),
                                                &(pBlockCol->sum), &(pBlockCol->minIndex), &(pBlockCol->maxIndex),
                                                &(pBlockCol->numOfNull));
 #endif
-      (*tDataTypes[pDataCol->type].statisFunc)(pDataCol->pBitmap, pDataCol->pData, rowsToWrite, &(pAggrBlkCol->min), &(pAggrBlkCol->max),
+      (*tDataTypes[pDataCol->type].statisFunc)(pDataCols->bitmapMode, pDataCol->pBitmap, pDataCol->pData, rowsToWrite,
-                                               &(pAggrBlkCol->sum), &(pAggrBlkCol->minIndex), &(pAggrBlkCol->maxIndex),
+                                               &(pAggrBlkCol->min), &(pAggrBlkCol->max), &(pAggrBlkCol->sum),
+                                               &(pAggrBlkCol->minIndex), &(pAggrBlkCol->maxIndex),
                                                &(pAggrBlkCol->numOfNull));
 
       if (pAggrBlkCol->numOfNull == 0) {
@@ -1259,13 +1277,16 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
       } else {
         TD_SET_COL_ROWS_MISC(pBlockCol);
       }
+    } else if (tdIsBitmapBlkNorm(pDataCol->pBitmap, rowsToWrite, pDataCols->bitmapMode)) {
+      // check if all rows normal
+      TD_SET_COL_ROWS_NORM(pBlockCol);
     } else {
       TD_SET_COL_ROWS_MISC(pBlockCol);
     }
 
     ++nColsNotAllNull;
 
-    if (pColumn->sma) {
+    if (isSuper && pColumn->sma) {
       ++nColsOfBlockSma;
     }
   }
@@ -1277,7 +1298,7 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
   uint32_t toffset = 0;
   int32_t  tsize = (int32_t)tsdbBlockStatisSize(nColsNotAllNull, SBlockVerLatest);
   int32_t  lsize = tsize;
-  uint32_t tsizeAggr = (uint32_t)tsdbBlockAggrSize(nColsNotAllNull, SBlockVerLatest);
+  uint32_t tsizeAggr = (uint32_t)tsdbBlockAggrSize(nColsOfBlockSma, SBlockVerLatest);
   int32_t  keyLen = 0;
   int32_t  nBitmaps = (int32_t)TD_BITMAP_BYTES(rowsToWrite);
   int32_t  sBitmaps = isSuper ? (int32_t)TD_BITMAP_BYTES_I(rowsToWrite) : nBitmaps;

source/dnode/vnode/src/tsdb/tsdbFS.c

@@ -644,7 +644,7 @@ static int tsdbComparFidFSet(const void *arg1, const void *arg2) {
 }
 
 static void tsdbGetTxnFname(STsdb *pRepo, TSDB_TXN_FILE_T ftype, char fname[]) {
-  snprintf(fname, TSDB_FILENAME_LEN, "%s/vnode/vnode%d/tsdb/%s", tfsGetPrimaryPath(pRepo->pTfs), pRepo->vgId,
+  snprintf(fname, TSDB_FILENAME_LEN, "%s/vnode/vnode%d/tsdb/%s", tfsGetPrimaryPath(REPO_TFS(pRepo)), pRepo->vgId,
            tsdbTxnFname[ftype]);
 }
 
@@ -912,7 +912,7 @@ static int tsdbScanRootDir(STsdb *pRepo) {
   const STfsFile *pf;
 
   tsdbGetRootDir(REPO_ID(pRepo), rootDir);
-  STfsDir *tdir = tfsOpendir(pRepo->pTfs, rootDir);
+  STfsDir *tdir = tfsOpendir(REPO_TFS(pRepo), rootDir);
   if (tdir == NULL) {
     tsdbError("vgId:%d failed to open directory %s since %s", REPO_ID(pRepo), rootDir, tstrerror(terrno));
     return -1;
@@ -946,7 +946,7 @@ static int tsdbScanDataDir(STsdb *pRepo) {
   const STfsFile *pf;
 
   tsdbGetDataDir(REPO_ID(pRepo), dataDir);
-  STfsDir *tdir = tfsOpendir(pRepo->pTfs, dataDir);
+  STfsDir *tdir = tfsOpendir(REPO_TFS(pRepo), dataDir);
   if (tdir == NULL) {
     tsdbError("vgId:%d failed to open directory %s since %s", REPO_ID(pRepo), dataDir, tstrerror(terrno));
     return -1;
@@ -1128,7 +1128,7 @@ static int tsdbRestoreDFileSet(STsdb *pRepo) {
     return -1;
   }
 
-  tdir = tfsOpendir(pRepo->pTfs, dataDir);
+  tdir = tfsOpendir(REPO_TFS(pRepo), dataDir);
   if (tdir == NULL) {
     tsdbError("vgId:%d failed to restore DFileSet while open directory %s since %s", REPO_ID(pRepo), dataDir,
               tstrerror(terrno));

source/dnode/vnode/src/tsdb/tsdbFile.c

@@ -311,7 +311,7 @@ void tsdbInitDFile(STsdb *pRepo, SDFile *pDFile, SDiskID did, int fid, uint32_t
   pDFile->info.fver = tsdbGetDFSVersion(ftype);
 
   tsdbGetFilename(pRepo->vgId, fid, ver, ftype, fname);
-  tfsInitFile(pRepo->pTfs, &(pDFile->f), did, fname);
+  tfsInitFile(REPO_TFS(pRepo), &(pDFile->f), did, fname);
 }
 
 void tsdbInitDFileEx(SDFile *pDFile, SDFile *pODFile) {
@@ -330,7 +330,7 @@ int tsdbEncodeSDFile(void **buf, SDFile *pDFile) {
 
 void *tsdbDecodeSDFile(STsdb *pRepo, void *buf, SDFile *pDFile) {
   buf = tsdbDecodeDFInfo(buf, &(pDFile->info));
-  buf = tfsDecodeFile(pRepo->pTfs, buf, &(pDFile->f));
+  buf = tfsDecodeFile(REPO_TFS(pRepo), buf, &(pDFile->f));
   TSDB_FILE_SET_CLOSED(pDFile);
 
   return buf;
@@ -365,7 +365,7 @@ int tsdbCreateDFile(STsdb *pRepo, SDFile *pDFile, bool updateHeader, TSDB_FILE_T
     if (errno == ENOENT) {
       // Try to create directory recursively
       char *s = strdup(TSDB_FILE_REL_NAME(pDFile));
-      if (tfsMkdirRecurAt(pRepo->pTfs, taosDirName(s), TSDB_FILE_DID(pDFile)) < 0) {
+      if (tfsMkdirRecurAt(REPO_TFS(pRepo), taosDirName(s), TSDB_FILE_DID(pDFile)) < 0) {
         taosMemoryFreeClear(s);
         return -1;
       }

source/dnode/vnode/src/tsdb/tsdbMain.c

@@ -15,14 +15,12 @@
 
 #include "vnodeInt.h"
 
-static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF,
+static STsdb *tsdbNew(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
-                      SMeta *pMeta, STfs *pTfs);
 static void   tsdbFree(STsdb *pTsdb);
 static int    tsdbOpenImpl(STsdb *pTsdb);
 static void   tsdbCloseImpl(STsdb *pTsdb);
 
-STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
+STsdb *tsdbOpen(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF) {
-                STfs *pTfs) {
   STsdb *pTsdb = NULL;
 
   // Set default TSDB Options
@@ -37,7 +35,7 @@ STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAl
   }
 
   // Create the handle
-  pTsdb = tsdbNew(path, vgId, pTsdbCfg, pMAF, pMeta, pTfs);
+  pTsdb = tsdbNew(path, pVnode, pTsdbCfg, pMAF);
   if (pTsdb == NULL) {
     // TODO: handle error
     return NULL;
@@ -61,11 +59,8 @@ void tsdbClose(STsdb *pTsdb) {
   }
 }
 
-void tsdbRemove(const char *path) { taosRemoveDir(path); }
-
 /* ------------------------ STATIC METHODS ------------------------ */
-static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF,
+static STsdb *tsdbNew(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF) {
-                      SMeta *pMeta, STfs *pTfs) {
   STsdb *pTsdb = NULL;
 
   pTsdb = (STsdb *)taosMemoryCalloc(1, sizeof(STsdb));
@@ -75,11 +70,10 @@ static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg,
   }
 
   pTsdb->path = strdup(path);
-  pTsdb->vgId = vgId;
+  pTsdb->vgId = TD_VID(pVnode);
+  pTsdb->pVnode = pVnode;
   tsdbOptionsCopy(&(pTsdb->config), pTsdbCfg);
   pTsdb->pmaf = pMAF;
-  pTsdb->pMeta = pMeta;
-  pTsdb->pTfs = pTfs;
   pTsdb->fs = tsdbNewFS(pTsdbCfg);
 
   return pTsdb;

source/dnode/vnode/src/tsdb/tsdbRead.c

@@ -986,7 +986,7 @@ static int32_t loadBlockInfo(STsdbReadHandle* pTsdbReadHandle, int32_t index, in
   pCheckInfo->numOfBlocks = 0;
 
   STable table = {.uid = pCheckInfo->tableId, .tid = pCheckInfo->tableId};
-  table.pSchema = metaGetTbTSchema(pTsdbReadHandle->pTsdb->pMeta, pCheckInfo->tableId, 0);
+  table.pSchema = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), pCheckInfo->tableId, 0);
 
   if (tsdbSetReadTable(&pTsdbReadHandle->rhelper, &table) != TSDB_CODE_SUCCESS) {
     code = terrno;
@@ -1091,7 +1091,7 @@ static int32_t doLoadFileDataBlock(STsdbReadHandle* pTsdbReadHandle, SBlock* pBl
                                    int32_t slotIndex) {
   int64_t st = taosGetTimestampUs();
 
-  STSchema* pSchema = metaGetTbTSchema(pTsdbReadHandle->pTsdb->pMeta, pCheckInfo->tableId, 0);
+  STSchema* pSchema = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), pCheckInfo->tableId, 0);
   int32_t   code = tdInitDataCols(pTsdbReadHandle->pDataCols, pSchema);
   if (code != TSDB_CODE_SUCCESS) {
     tsdbError("%p failed to malloc buf for pDataCols, %s", pTsdbReadHandle, pTsdbReadHandle->idStr);
@@ -1483,7 +1483,7 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
   int32_t numOfColsOfRow1 = 0;
 
   if (pSchema1 == NULL) {
-    pSchema1 = metaGetTbTSchema(pTsdbReadHandle->pTsdb->pMeta, uid, TD_ROW_SVER(row1));
+    pSchema1 = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), uid, TD_ROW_SVER(row1));
   }
 
   if (isRow1DataRow) {
@@ -1496,7 +1496,7 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
   if (row2) {
     isRow2DataRow = TD_IS_TP_ROW(row2);
     if (pSchema2 == NULL) {
-      pSchema2 = metaGetTbTSchema(pTsdbReadHandle->pTsdb->pMeta, uid, TD_ROW_SVER(row2));
+      pSchema2 = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), uid, TD_ROW_SVER(row2));
     }
     if (isRow2DataRow) {
       numOfColsOfRow2 = schemaNCols(pSchema2);
@@ -2514,7 +2514,7 @@ static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int
 
     win->ekey = key;
     if (rv != TD_ROW_SVER(row)) {
-      pSchema = metaGetTbTSchema(pTsdbReadHandle->pTsdb->pMeta, pCheckInfo->tableId, 0);
+      pSchema = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), pCheckInfo->tableId, 0);
       rv = TD_ROW_SVER(row);
     }
     mergeTwoRowFromMem(pTsdbReadHandle, maxRowsToRead, numOfRows, row, NULL, numOfCols, pCheckInfo->tableId, pSchema,

source/dnode/vnode/src/tsdb/tsdbSma.c

@@ -260,7 +260,7 @@ static void poolFree(void *arg, void *ptr) {
 
 int32_t tsdbInitSma(STsdb *pTsdb) {
   // tSma
-  int32_t numOfTSma = taosArrayGetSize(metaGetSmaTbUids(pTsdb->pMeta, false));
+  int32_t numOfTSma = taosArrayGetSize(metaGetSmaTbUids(REPO_META(pTsdb), false));
   if (numOfTSma > 0) {
     atomic_store_16(&REPO_TSMA_NUM(pTsdb), (int16_t)numOfTSma);
   }
@@ -348,7 +348,7 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path, SDiskID did)
   }
 
   char aname[TSDB_FILENAME_LEN] = {0};
-  tfsAbsoluteName(pTsdb->pTfs, did, path, aname);
+  tfsAbsoluteName(REPO_TFS(pTsdb), did, path, aname);
   if (tsdbOpenDBEnv(&pEnv->dbEnv, aname) != TSDB_CODE_SUCCESS) {
     tsdbFreeSmaEnv(pEnv);
     return NULL;
@@ -519,14 +519,14 @@ static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
     char rname[TSDB_FILENAME_LEN] = {0};
 
     SDiskID did = {0};
-    tfsAllocDisk(pTsdb->pTfs, TFS_PRIMARY_LEVEL, &did);
+    tfsAllocDisk(REPO_TFS(pTsdb), TFS_PRIMARY_LEVEL, &did);
     if (did.level < 0 || did.id < 0) {
       tsdbUnlockRepo(pTsdb);
       return TSDB_CODE_FAILED;
     }
     tsdbGetSmaDir(REPO_ID(pTsdb), smaType, rname);
 
-    if (tfsMkdirRecurAt(pTsdb->pTfs, rname, did) != TSDB_CODE_SUCCESS) {
+    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rname, did) != TSDB_CODE_SUCCESS) {
       tsdbUnlockRepo(pTsdb);
       return TSDB_CODE_FAILED;
     }
@@ -557,7 +557,7 @@ static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t
     }
 
     // cache smaMeta
-    STSma *pSma = metaGetSmaInfoByIndex(pTsdb->pMeta, indexUid, true);
+    STSma *pSma = metaGetSmaInfoByIndex(REPO_META(pTsdb), indexUid, true);
     if (pSma == NULL) {
       terrno = TSDB_CODE_TDB_NO_SMA_INDEX_IN_META;
       taosHashCleanup(pItem->expiredWindows);
@@ -613,7 +613,7 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
     return TSDB_CODE_SUCCESS;
   }
 
-  if (!pTsdb->pMeta) {
+  if (!REPO_META(pTsdb)) {
     terrno = TSDB_CODE_INVALID_PTR;
     return TSDB_CODE_FAILED;
   }
@@ -1583,7 +1583,7 @@ int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg) {
   // record current timezone of server side
   vCreateSmaReq.tSma.timezoneInt = tsTimezone;
 
-  if (metaCreateTSma(pTsdb->pMeta, &vCreateSmaReq) < 0) {
+  if (metaCreateTSma(REPO_META(pTsdb), &vCreateSmaReq) < 0) {
     // TODO: handle error
     tdDestroyTSma(&vCreateSmaReq.tSma);
     return -1;
@@ -1610,7 +1610,7 @@ int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
   // }
   //
 
-  if (metaDropTSma(pTsdb->pMeta, vDropSmaReq.indexUid) < 0) {
+  if (metaDropTSma(REPO_META(pTsdb), vDropSmaReq.indexUid) < 0) {
     // TODO: handle error
     return -1;
   }

source/dnode/vnode/src/vnd/vnodeOpen.c

@@ -96,8 +96,7 @@ SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb) {
 
   // open tsdb
   sprintf(tdir, "%s%s%s", dir, TD_DIRSEP, VNODE_TSDB_DIR);
-  pVnode->pTsdb =
+  pVnode->pTsdb = tsdbOpen(tdir, pVnode, &(pVnode->config.tsdbCfg), vBufPoolGetMAF(pVnode));
-      tsdbOpen(tdir, TD_VID(pVnode), &(pVnode->config.tsdbCfg), vBufPoolGetMAF(pVnode), pVnode->pMeta, pVnode->pTfs);
   if (pVnode->pTsdb == NULL) {
     vError("vgId: %d failed to open vnode tsdb since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;

source/libs/function/src/builtins.c

@@ -237,33 +237,45 @@ static int32_t translateLength(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t translateConcatImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t len, int32_t minParaNum, int32_t maxParaNum, int32_t primaryParaNo) {
+static int32_t translateConcatImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t len, int32_t minParaNum, int32_t maxParaNum, bool hasSep) {
   int32_t paraNum = LIST_LENGTH(pFunc->pParameterList);
   if (paraNum < minParaNum || paraNum > maxParaNum) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t resultType = TSDB_DATA_TYPE_NCHAR;
+  uint8_t resultType = TSDB_DATA_TYPE_BINARY;
   int32_t resultBytes = 0;
   int32_t sepBytes = 0;
-  for (int32_t i = 0; i < LIST_LENGTH(pFunc->pParameterList); ++i) {
+
+  /* For concat/concat_ws function, if params have NCHAR type, promote the final result to NCHAR */
+  for (int32_t i = 0; i < paraNum; ++i) {
     SNode* pPara = nodesListGetNode(pFunc->pParameterList, i);
     uint8_t paraType = ((SExprNode*)pPara)->resType.type;
-    int32_t paraBytes = ((SExprNode*)pPara)->resType.bytes;
     if (!IS_VAR_DATA_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
-    if (i < primaryParaNo) {
+    if (TSDB_DATA_TYPE_NCHAR == paraType) {
-      sepBytes = paraBytes;
+      resultType = paraType;
-      continue;
     }
-    if (TSDB_DATA_TYPE_BINARY == paraType) {
-      resultType = TSDB_DATA_TYPE_BINARY;
   }
-    resultBytes += paraBytes;
+
+  for (int32_t i = 0; i < paraNum; ++i) {
+    SNode* pPara = nodesListGetNode(pFunc->pParameterList, i);
+    uint8_t paraType = ((SExprNode*)pPara)->resType.type;
+    int32_t paraBytes = ((SExprNode*)pPara)->resType.bytes;
+    int32_t factor = 1;
+    if (TSDB_DATA_TYPE_NCHAR == resultType && TSDB_DATA_TYPE_VARCHAR == paraType) {
+      factor *= TSDB_NCHAR_SIZE;
     }
-  if (sepBytes > 0) {
+    resultBytes += paraBytes * factor;
-    resultBytes += sepBytes * (paraNum - 2);
+
+    if (i == 0) {
+      sepBytes = paraBytes * factor;
+    }
+  }
+
+  if (hasSep) {
+    resultBytes += sepBytes * (paraNum - 3);
   }
 
   pFunc->node.resType = (SDataType) { .bytes = resultBytes, .type = resultType };
@@ -271,11 +283,11 @@ static int32_t translateConcatImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
 }
 
 static int32_t translateConcat(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
-  return translateConcatImpl(pFunc, pErrBuf, len, 2, 8, 0);
+  return translateConcatImpl(pFunc, pErrBuf, len, 2, 8, false);
 }
 
 static int32_t translateConcatWs(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
-  return translateConcatImpl(pFunc, pErrBuf, len, 3, 9, 1);
+  return translateConcatImpl(pFunc, pErrBuf, len, 3, 9, true);
 }
 
 static int32_t translateSubstr(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
@@ -318,7 +330,7 @@ static int32_t translateToIso8601(SFunctionNode* pFunc, char* pErrBuf, int32_t l
   }
 
   uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  if (!IS_VAR_DATA_TYPE(paraType) && TSDB_DATA_TYPE_TIMESTAMP != paraType) {
+  if (!IS_INTEGER_TYPE(paraType) && TSDB_DATA_TYPE_TIMESTAMP != paraType) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -346,7 +358,7 @@ static int32_t translateTimeTruncate(SFunctionNode* pFunc, char* pErrBuf, int32_
 
   uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
   uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
-  if ((!IS_VAR_DATA_TYPE(para1Type) && TSDB_DATA_TYPE_TIMESTAMP != para1Type) || !IS_INTEGER_TYPE(para2Type)) {
+  if ((!IS_VAR_DATA_TYPE(para1Type) && !IS_INTEGER_TYPE(para1Type) && TSDB_DATA_TYPE_TIMESTAMP != para1Type) || !IS_INTEGER_TYPE(para2Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -360,12 +372,13 @@ static int32_t translateTimeDiff(SFunctionNode* pFunc, char* pErrBuf, int32_t le
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  for (int32_t i = 0; i < 2; ++i) {
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
-  if ((!IS_VAR_DATA_TYPE(para1Type) && TSDB_DATA_TYPE_TIMESTAMP != para1Type) || 
+    if (!IS_VAR_DATA_TYPE(paraType) && !IS_INTEGER_TYPE(paraType) && TSDB_DATA_TYPE_TIMESTAMP != paraType) {
-      (!IS_VAR_DATA_TYPE(para2Type) && TSDB_DATA_TYPE_TIMESTAMP != para2Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
+  }
+
   if (3 == paraNum) {
     if (!IS_INTEGER_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);

source/libs/nodes/src/nodesTraverseFuncs.c

@@ -14,6 +14,7 @@
  */
 
 #include "querynodes.h"
+#include "plannodes.h"
 
 typedef enum ETraversalOrder {
   TRAVERSAL_PREORDER = 1,
@@ -21,9 +22,14 @@ typedef enum ETraversalOrder {
   TRAVERSAL_POSTORDER,
 } ETraversalOrder;
 
-static EDealRes walkList(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
+typedef EDealRes (*FNodeDispatcher)(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
 
-static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
+static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
+static EDealRes walkPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
+static EDealRes walkPhysiPlans(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
+
+static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext, FNodeDispatcher dispatcher) {
   if (NULL == pNode) {
     return DEAL_RES_CONTINUE;
   }
@@ -37,94 +43,7 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
     }
   }
 
-  switch (nodeType(pNode)) {
+  res = dispatcher(pNode, order, walker, pContext);
-    case QUERY_NODE_COLUMN:
-    case QUERY_NODE_VALUE:
-    case QUERY_NODE_LIMIT:
-      // these node types with no subnodes
-      break;
-    case QUERY_NODE_OPERATOR: {
-      SOperatorNode* pOpNode = (SOperatorNode*)pNode;
-      res = walkNode(pOpNode->pLeft, order, walker, pContext);
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pOpNode->pRight, order, walker, pContext);
-      }
-      break;
-    }
-    case QUERY_NODE_LOGIC_CONDITION:
-      res = walkList(((SLogicConditionNode*)pNode)->pParameterList, order, walker, pContext);
-      break;
-    case QUERY_NODE_FUNCTION:
-      res = walkList(((SFunctionNode*)pNode)->pParameterList, order, walker, pContext);
-      break;
-    case QUERY_NODE_REAL_TABLE:
-    case QUERY_NODE_TEMP_TABLE:
-      break; // todo
-    case QUERY_NODE_JOIN_TABLE: {
-      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
-      res = walkNode(pJoinTableNode->pLeft, order, walker, pContext);
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pJoinTableNode->pRight, order, walker, pContext);
-      }
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pJoinTableNode->pOnCond, order, walker, pContext);
-      }
-      break;
-    }
-    case QUERY_NODE_GROUPING_SET:
-      res = walkList(((SGroupingSetNode*)pNode)->pParameterList, order, walker, pContext);
-      break;
-    case QUERY_NODE_ORDER_BY_EXPR:
-      res = walkNode(((SOrderByExprNode*)pNode)->pExpr, order, walker, pContext);
-      break;
-    case QUERY_NODE_STATE_WINDOW: {
-      SStateWindowNode* pState = (SStateWindowNode*)pNode;
-      res = walkNode(pState->pExpr, order, walker, pContext);
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pState->pCol, order, walker, pContext);
-      }
-      break;
-    }
-    case QUERY_NODE_SESSION_WINDOW: {
-      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
-      res = walkNode((SNode*)pSession->pCol, order, walker, pContext);
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode((SNode*)pSession->pGap, order, walker, pContext);
-      }
-      break;
-    }
-    case QUERY_NODE_INTERVAL_WINDOW: {
-      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
-      res = walkNode(pInterval->pInterval, order, walker, pContext);
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pInterval->pOffset, order, walker, pContext);
-      }
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pInterval->pSliding, order, walker, pContext);
-      }
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pInterval->pFill, order, walker, pContext);
-      }
-      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = walkNode(pInterval->pCol, order, walker, pContext);
-      }
-      break;
-    }
-    case QUERY_NODE_NODE_LIST:
-      res = walkList(((SNodeListNode*)pNode)->pNodeList, order, walker, pContext);
-      break;
-    case QUERY_NODE_FILL:
-      res = walkNode(((SFillNode*)pNode)->pValues, order, walker, pContext);
-      break;
-    case QUERY_NODE_RAW_EXPR:
-      res = walkNode(((SRawExprNode*)pNode)->pNode, order, walker, pContext);
-      break;
-    case QUERY_NODE_TARGET:
-      res = walkNode(((STargetNode*)pNode)->pExpr, order, walker, pContext);
-      break;
-    default:
-      break;
-  }
 
   if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {
     res = walker(pNode, pContext);
@@ -133,10 +52,109 @@ static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker
   return res;
 }
 
-static EDealRes walkList(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+static EDealRes dispatchExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  EDealRes res = DEAL_RES_CONTINUE;
+
+  switch (nodeType(pNode)) {
+    case QUERY_NODE_COLUMN:
+    case QUERY_NODE_VALUE:
+    case QUERY_NODE_LIMIT:
+      // these node types with no subnodes
+      break;
+    case QUERY_NODE_OPERATOR: {
+      SOperatorNode* pOpNode = (SOperatorNode*)pNode;
+      res = walkExpr(pOpNode->pLeft, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pOpNode->pRight, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_LOGIC_CONDITION:
+      res = walkExprs(((SLogicConditionNode*)pNode)->pParameterList, order, walker, pContext);
+      break;
+    case QUERY_NODE_FUNCTION:
+      res = walkExprs(((SFunctionNode*)pNode)->pParameterList, order, walker, pContext);
+      break;
+    case QUERY_NODE_REAL_TABLE:
+    case QUERY_NODE_TEMP_TABLE:
+      break; // todo
+    case QUERY_NODE_JOIN_TABLE: {
+      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
+      res = walkExpr(pJoinTableNode->pLeft, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pJoinTableNode->pRight, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pJoinTableNode->pOnCond, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_GROUPING_SET:
+      res = walkExprs(((SGroupingSetNode*)pNode)->pParameterList, order, walker, pContext);
+      break;
+    case QUERY_NODE_ORDER_BY_EXPR:
+      res = walkExpr(((SOrderByExprNode*)pNode)->pExpr, order, walker, pContext);
+      break;
+    case QUERY_NODE_STATE_WINDOW: {
+      SStateWindowNode* pState = (SStateWindowNode*)pNode;
+      res = walkExpr(pState->pExpr, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pState->pCol, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_SESSION_WINDOW: {
+      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
+      res = walkExpr((SNode*)pSession->pCol, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr((SNode*)pSession->pGap, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_INTERVAL_WINDOW: {
+      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
+      res = walkExpr(pInterval->pInterval, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pInterval->pOffset, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pInterval->pSliding, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pInterval->pFill, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkExpr(pInterval->pCol, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_NODE_LIST:
+      res = walkExprs(((SNodeListNode*)pNode)->pNodeList, order, walker, pContext);
+      break;
+    case QUERY_NODE_FILL:
+      res = walkExpr(((SFillNode*)pNode)->pValues, order, walker, pContext);
+      break;
+    case QUERY_NODE_RAW_EXPR:
+      res = walkExpr(((SRawExprNode*)pNode)->pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_TARGET:
+      res = walkExpr(((STargetNode*)pNode)->pExpr, order, walker, pContext);
+      break;
+    default:
+      break;
+  }
+
+  return res;
+}
+
+static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  return walkNode(pNode, order, walker, pContext, dispatchExpr);
+}
+
+static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {
   SNode* node;
   FOREACH(node, pNodeList) {
-    EDealRes res = walkNode(node, order, walker, pContext);
+    EDealRes res = walkExpr(node, order, walker, pContext);
     if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
       return res;
     }
@@ -145,24 +163,24 @@ static EDealRes walkList(SNodeList* pNodeList, ETraversalOrder order, FNodeWalke
 }
 
 void nodesWalkExpr(SNodeptr pNode, FNodeWalker walker, void* pContext) {
-  (void)walkNode(pNode, TRAVERSAL_PREORDER, walker, pContext);
+  (void)walkExpr(pNode, TRAVERSAL_PREORDER, walker, pContext);
 }
 
 void nodesWalkExprs(SNodeList* pNodeList, FNodeWalker walker, void* pContext) {
-  (void)walkList(pNodeList, TRAVERSAL_PREORDER, walker, pContext);
+  (void)walkExprs(pNodeList, TRAVERSAL_PREORDER, walker, pContext);
 }
 
 void nodesWalkExprPostOrder(SNodeptr pNode, FNodeWalker walker, void* pContext) {
-  (void)walkNode(pNode, TRAVERSAL_POSTORDER, walker, pContext);
+  (void)walkExpr(pNode, TRAVERSAL_POSTORDER, walker, pContext);
 }
 
 void nodesWalkExprsPostOrder(SNodeList* pList, FNodeWalker walker, void* pContext) {
-  (void)walkList(pList, TRAVERSAL_POSTORDER, walker, pContext);
+  (void)walkExprs(pList, TRAVERSAL_POSTORDER, walker, pContext);
 }
 
-static EDealRes rewriteList(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext);
+static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext);
 
-static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
+static EDealRes rewriteExpr(SNode** pRawNode, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
   if (NULL == pRawNode || NULL == *pRawNode) {
     return DEAL_RES_CONTINUE;
   }
@@ -185,82 +203,82 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
       break;
     case QUERY_NODE_OPERATOR: {
       SOperatorNode* pOpNode = (SOperatorNode*)pNode;
-      res = rewriteNode(&(pOpNode->pLeft), order, rewriter, pContext);
+      res = rewriteExpr(&(pOpNode->pLeft), order, rewriter, pContext);
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pOpNode->pRight), order, rewriter, pContext);
+        res = rewriteExpr(&(pOpNode->pRight), order, rewriter, pContext);
       }
       break;
     }
     case QUERY_NODE_LOGIC_CONDITION:
-      res = rewriteList(((SLogicConditionNode*)pNode)->pParameterList, order, rewriter, pContext);
+      res = rewriteExprs(((SLogicConditionNode*)pNode)->pParameterList, order, rewriter, pContext);
       break;
     case QUERY_NODE_FUNCTION:
-      res = rewriteList(((SFunctionNode*)pNode)->pParameterList, order, rewriter, pContext);
+      res = rewriteExprs(((SFunctionNode*)pNode)->pParameterList, order, rewriter, pContext);
       break;
     case QUERY_NODE_REAL_TABLE:
     case QUERY_NODE_TEMP_TABLE:
       break; // todo
     case QUERY_NODE_JOIN_TABLE: {
       SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
-      res = rewriteNode(&(pJoinTableNode->pLeft), order, rewriter, pContext);
+      res = rewriteExpr(&(pJoinTableNode->pLeft), order, rewriter, pContext);
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pJoinTableNode->pRight), order, rewriter, pContext);
+        res = rewriteExpr(&(pJoinTableNode->pRight), order, rewriter, pContext);
       }
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pJoinTableNode->pOnCond), order, rewriter, pContext);
+        res = rewriteExpr(&(pJoinTableNode->pOnCond), order, rewriter, pContext);
       }
       break;
     }
     case QUERY_NODE_GROUPING_SET:
-      res = rewriteList(((SGroupingSetNode*)pNode)->pParameterList, order, rewriter, pContext);
+      res = rewriteExprs(((SGroupingSetNode*)pNode)->pParameterList, order, rewriter, pContext);
       break;
     case QUERY_NODE_ORDER_BY_EXPR:
-      res = rewriteNode(&(((SOrderByExprNode*)pNode)->pExpr), order, rewriter, pContext);
+      res = rewriteExpr(&(((SOrderByExprNode*)pNode)->pExpr), order, rewriter, pContext);
       break;
     case QUERY_NODE_STATE_WINDOW: {
       SStateWindowNode* pState = (SStateWindowNode*)pNode;
-      res = rewriteNode(&pState->pExpr, order, rewriter, pContext);
+      res = rewriteExpr(&pState->pExpr, order, rewriter, pContext);
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&pState->pCol, order, rewriter, pContext);
+        res = rewriteExpr(&pState->pCol, order, rewriter, pContext);
       }
       break;
     }
     case QUERY_NODE_SESSION_WINDOW: {
       SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
-      res = rewriteNode((SNode**)&pSession->pCol, order, rewriter, pContext);
+      res = rewriteExpr((SNode**)&pSession->pCol, order, rewriter, pContext);
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode((SNode**)&pSession->pGap, order, rewriter, pContext);
+        res = rewriteExpr((SNode**)&pSession->pGap, order, rewriter, pContext);
       }
       break;
     }
     case QUERY_NODE_INTERVAL_WINDOW: {
       SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
-      res = rewriteNode(&(pInterval->pInterval), order, rewriter, pContext);
+      res = rewriteExpr(&(pInterval->pInterval), order, rewriter, pContext);
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pInterval->pOffset), order, rewriter, pContext);
+        res = rewriteExpr(&(pInterval->pOffset), order, rewriter, pContext);
       }
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pInterval->pSliding), order, rewriter, pContext);
+        res = rewriteExpr(&(pInterval->pSliding), order, rewriter, pContext);
       }
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pInterval->pFill), order, rewriter, pContext);
+        res = rewriteExpr(&(pInterval->pFill), order, rewriter, pContext);
       }
       if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
-        res = rewriteNode(&(pInterval->pCol), order, rewriter, pContext);
+        res = rewriteExpr(&(pInterval->pCol), order, rewriter, pContext);
       }
       break;
     }
     case QUERY_NODE_NODE_LIST:
-      res = rewriteList(((SNodeListNode*)pNode)->pNodeList, order, rewriter, pContext);
+      res = rewriteExprs(((SNodeListNode*)pNode)->pNodeList, order, rewriter, pContext);
       break;
     case QUERY_NODE_FILL:
-      res = rewriteNode(&(((SFillNode*)pNode)->pValues), order, rewriter, pContext);
+      res = rewriteExpr(&(((SFillNode*)pNode)->pValues), order, rewriter, pContext);
       break;
     case QUERY_NODE_RAW_EXPR:
-      res = rewriteNode(&(((SRawExprNode*)pNode)->pNode), order, rewriter, pContext);
+      res = rewriteExpr(&(((SRawExprNode*)pNode)->pNode), order, rewriter, pContext);
       break;
     case QUERY_NODE_TARGET:
-      res = rewriteNode(&(((STargetNode*)pNode)->pExpr), order, rewriter, pContext);
+      res = rewriteExpr(&(((STargetNode*)pNode)->pExpr), order, rewriter, pContext);
       break;
     default:
       break;
@@ -273,10 +291,10 @@ static EDealRes rewriteNode(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
   return res;
 }
 
-static EDealRes rewriteList(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
+static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
   SNode** pNode;
   FOREACH_FOR_REWRITE(pNode, pNodeList) {
-    EDealRes res = rewriteNode(pNode, order, rewriter, pContext);
+    EDealRes res = rewriteExpr(pNode, order, rewriter, pContext);
     if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
       return res;
     }
@@ -285,19 +303,19 @@ static EDealRes rewriteList(SNodeList* pNodeList, ETraversalOrder order, FNodeRe
 }
 
 void nodesRewriteExpr(SNode** pNode, FNodeRewriter rewriter, void* pContext) {
-  (void)rewriteNode(pNode, TRAVERSAL_PREORDER, rewriter, pContext);
+  (void)rewriteExpr(pNode, TRAVERSAL_PREORDER, rewriter, pContext);
 }
 
 void nodesRewriteExprs(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {
-  (void)rewriteList(pList, TRAVERSAL_PREORDER, rewriter, pContext);
+  (void)rewriteExprs(pList, TRAVERSAL_PREORDER, rewriter, pContext);
 }
 
 void nodesRewriteExprPostOrder(SNode** pNode, FNodeRewriter rewriter, void* pContext) {
-  (void)rewriteNode(pNode, TRAVERSAL_POSTORDER, rewriter, pContext);
+  (void)rewriteExpr(pNode, TRAVERSAL_POSTORDER, rewriter, pContext);
 }
 
 void nodesRewriteExprsPostOrder(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {
-  (void)rewriteList(pList, TRAVERSAL_POSTORDER, rewriter, pContext);
+  (void)rewriteExprs(pList, TRAVERSAL_POSTORDER, rewriter, pContext);
 }
 
 void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext) {
@@ -357,3 +375,206 @@ void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewrit
 
   return;
 }
+
+static EDealRes walkPhysiNode(SPhysiNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  EDealRes res = walkPhysiPlan((SNode*)pNode->pOutputDataBlockDesc, order, walker, pContext);
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlan(pNode->pConditions, order, walker, pContext);
+  }
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlans(pNode->pChildren, order, walker, pContext);
+  }
+  return res;
+}
+
+static EDealRes walkScanPhysi(SScanPhysiNode* pScan, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  EDealRes res = walkPhysiNode((SPhysiNode*)pScan, order, walker, pContext);
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlans(pScan->pScanCols, order, walker, pContext);
+  }
+  return res;
+}
+
+static EDealRes walkTableScanPhysi(STableScanPhysiNode* pScan, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  EDealRes res = walkScanPhysi((SScanPhysiNode*)pScan, order, walker, pContext);
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlans(pScan->pDynamicScanFuncs, order, walker, pContext);
+  }
+  return res;
+}
+
+static EDealRes walkWindowPhysi(SWinodwPhysiNode* pWindow, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  EDealRes res = walkPhysiNode((SPhysiNode*)pWindow, order, walker, pContext);
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlans(pWindow->pExprs, order, walker, pContext);
+  }
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlans(pWindow->pFuncs, order, walker, pContext);
+  }
+  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+    res = walkPhysiPlan(pWindow->pTspk, order, walker, pContext);
+  }
+  return res;
+}
+
+static EDealRes dispatchPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  EDealRes res = DEAL_RES_CONTINUE;
+
+  switch (nodeType(pNode)) {
+    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
+      res = walkScanPhysi((SScanPhysiNode*)pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
+      res = walkTableScanPhysi((STableScanPhysiNode*)pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:
+      res = walkTableScanPhysi((STableScanPhysiNode*)pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
+      res = walkScanPhysi((SScanPhysiNode*)pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
+      res = walkScanPhysi((SScanPhysiNode*)pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_PROJECT: {
+      SProjectPhysiNode* pProject = (SProjectPhysiNode*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pProject->pProjections, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_JOIN: {
+      SJoinPhysiNode* pJoin = (SJoinPhysiNode*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlan(pJoin->pOnConditions, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pJoin->pTargets, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_AGG: {
+      SAggPhysiNode* pAgg = (SAggPhysiNode*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pAgg->pExprs, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pAgg->pGroupKeys, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pAgg->pAggFuncs, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: {
+      SExchangePhysiNode* pExchange = (SExchangePhysiNode*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pExchange->pSrcEndPoints, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_SORT: {
+      SSortPhysiNode* pSort = (SSortPhysiNode*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pSort->pExprs, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pSort->pSortKeys, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pSort->pTargets, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_INTERVAL: {
+      SIntervalPhysiNode* pInterval = (SIntervalPhysiNode*)pNode;
+      res = walkWindowPhysi((SWinodwPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlan((SNode*)pInterval->pFill, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_SESSION_WINDOW:
+      res = walkWindowPhysi((SWinodwPhysiNode*)pNode, order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_STATE_WINDOW: {
+      SStateWinodwPhysiNode* pState = (SStateWinodwPhysiNode*)pNode;
+      res = walkWindowPhysi((SWinodwPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlan(pState->pStateKey, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_PARTITION: {
+      SPartitionPhysiNode* pPart = (SPartitionPhysiNode*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pPart->pExprs, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pPart->pPartitionKeys, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pPart->pTargets, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
+      res = walkPhysiPlan((SNode*)(((SDataSinkNode*)pNode)->pInputDataBlockDesc), order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_INSERT:
+      res = walkPhysiPlan((SNode*)(((SDataSinkNode*)pNode)->pInputDataBlockDesc), order, walker, pContext);
+      break;
+    case QUERY_NODE_PHYSICAL_SUBPLAN: {
+      SSubplan* pSubplan = (SSubplan*)pNode;
+      res = walkPhysiNode((SPhysiNode*)pNode, order, walker, pContext);
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlans(pSubplan->pChildren, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlan((SNode*)pSubplan->pNode, order, walker, pContext);
+      }
+      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
+        res = walkPhysiPlan((SNode*)pSubplan->pDataSink, order, walker, pContext);
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN: {
+      SQueryPlan* pPlan = (SQueryPlan*)pNode;
+      if (NULL != pPlan->pSubplans) {
+        // only need to walk the top-level subplans, because they will recurse to all the subplans below
+        walkPhysiPlan(nodesListGetNode(pPlan->pSubplans, 0), order, walker, pContext);
+      }
+      break;
+    }
+    default:
+      res = dispatchExpr(pNode, order, walker, pContext);
+      break;
+  }
+
+  return res;
+}
+
+static EDealRes walkPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  return walkNode(pNode, order, walker, pContext, dispatchPhysiPlan);
+}
+
+static EDealRes walkPhysiPlans(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+  SNode* node;
+  FOREACH(node, pNodeList) {
+    EDealRes res = walkPhysiPlan(node, order, walker, pContext);
+    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
+      return res;
+    }
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+void nodesWalkPhysiPlan(SNode* pNode, FNodeWalker walker, void* pContext) {
+  (void)walkPhysiPlan(pNode, TRAVERSAL_PREORDER, walker, pContext);
+}

source/libs/nodes/src/nodesUtilFuncs.c

@@ -1226,7 +1226,7 @@ void valueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
-      pVal->pz = pNode->datum.p + VARSTR_HEADER_SIZE;
+      pVal->pz = pNode->datum.p;
       break;
     case TSDB_DATA_TYPE_JSON:
     case TSDB_DATA_TYPE_DECIMAL:

source/libs/parser/inc/parAst.h

@@ -32,6 +32,7 @@ typedef struct SAstCreateContext {
   bool notSupport;
   bool valid;
   SNode* pRootNode;
+  int16_t placeholderNo;
 } SAstCreateContext;
 
 typedef enum EDatabaseOptionType {
@@ -86,7 +87,7 @@ SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pC
 SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral);
 SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral);
 SNode* createDefaultDatabaseCondValue(SAstCreateContext* pCxt);
-SNode* createPlaceholderValueNode(SAstCreateContext* pCxt);
+SNode* createPlaceholderValueNode(SAstCreateContext* pCxt, const SToken* pLiteral);
 SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias);
 SNode* createLogicConditionNode(SAstCreateContext* pCxt, ELogicConditionType type, SNode* pParam1, SNode* pParam2);
 SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pLeft, SNode* pRight);

source/libs/parser/inc/sql.y

@@ -465,8 +465,8 @@ literal(A) ::= NK_STRING(B).
 literal(A) ::= NK_BOOL(B).                                                        { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B)); }
 literal(A) ::= TIMESTAMP(B) NK_STRING(C).                                         { A = createRawExprNodeExt(pCxt, &B, &C, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &C)); }
 literal(A) ::= duration_literal(B).                                               { A = B; }
-literal(A) ::= NULL(B).                                                           { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL)); }
+literal(A) ::= NULL(B).                                                           { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &B)); }
-literal(A) ::= NK_QUESTION(B).                                                    { A = createRawExprNode(pCxt, &B, createPlaceholderValueNode(pCxt)); }
+literal(A) ::= NK_QUESTION(B).                                                    { A = createRawExprNode(pCxt, &B, createPlaceholderValueNode(pCxt, &B)); }
 
 duration_literal(A) ::= NK_VARIABLE(B).                                           { A = createRawExprNode(pCxt, &B, createDurationValueNode(pCxt, &B)); }
 

source/libs/parser/src/parAstCreater.c

@@ -44,6 +44,7 @@ void initAstCreateContext(SParseContext* pParseCxt, SAstCreateContext* pCxt) {
   pCxt->notSupport = false;
   pCxt->valid = true;
   pCxt->pRootNode = NULL;
+  pCxt->placeholderNo = 1;
 }
 
 static void trimEscape(SToken* pName) {
@@ -258,14 +259,12 @@ SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pC
 SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral) {
   SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
   CHECK_OUT_OF_MEM(val);
-  if (NULL != pLiteral) {
   val->literal = strndup(pLiteral->z, pLiteral->n);
   if (TK_NK_ID != pLiteral->type && TK_TIMEZONE != pLiteral->type &&
       (IS_VAR_DATA_TYPE(dataType) || TSDB_DATA_TYPE_TIMESTAMP == dataType)) {
     trimString(pLiteral->z, pLiteral->n, val->literal, pLiteral->n);
   }
   CHECK_OUT_OF_MEM(val->literal);
-  }
   val->node.resType.type = dataType;
   val->node.resType.bytes = IS_VAR_DATA_TYPE(dataType) ? strlen(val->literal) : tDataTypes[dataType].bytes;
   if (TSDB_DATA_TYPE_TIMESTAMP == dataType) {
@@ -306,10 +305,12 @@ SNode* createDefaultDatabaseCondValue(SAstCreateContext* pCxt) {
   return (SNode*)val;
 }
 
-SNode* createPlaceholderValueNode(SAstCreateContext* pCxt) {
+SNode* createPlaceholderValueNode(SAstCreateContext* pCxt, const SToken* pLiteral) {
   SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
   CHECK_OUT_OF_MEM(val);
-  // todo
+  val->literal = strndup(pLiteral->z, pLiteral->n);
+  CHECK_OUT_OF_MEM(val->literal);
+  val->placeholderNo = pCxt->placeholderNo++;
   return (SNode*)val;
 }
 

source/libs/parser/src/parAstParser.c

@@ -50,7 +50,6 @@ int32_t parse(SParseContext* pParseCxt, SQuery** pQuery) {
         Parse(pParser, 0, t0, &cxt);
         goto abort_parse;
       }
-      case TK_NK_QUESTION:
       case TK_NK_ILLEGAL: {
         snprintf(cxt.pQueryCxt->pMsg, cxt.pQueryCxt->msgLen, "unrecognized token: \"%s\"", t0.z);
         cxt.valid = false;

source/libs/parser/src/parTranslater.c

@@ -403,6 +403,9 @@ static EDealRes translateColumn(STranslateContext* pCxt, SColumnNode* pCol) {
 static EDealRes translateValue(STranslateContext* pCxt, SValueNode* pVal) {
   uint8_t precision = (NULL != pCxt->pCurrStmt ? pCxt->pCurrStmt->precision : pVal->node.resType.precision);
   pVal->node.resType.precision = precision;
+  if (pVal->placeholderNo > 0) {
+    return DEAL_RES_CONTINUE;
+  }
   if (pVal->isDuration) {
     if (parseNatualDuration(pVal->literal, strlen(pVal->literal), &pVal->datum.i, &pVal->unit, precision) !=
         TSDB_CODE_SUCCESS) {
@@ -492,8 +495,10 @@ static EDealRes translateOperator(STranslateContext* pCxt, SOperatorNode* pOp) {
       return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_WRONG_VALUE_TYPE, ((SExprNode*)(pOp->pRight))->aliasName);
     }
 
-    if ((TSDB_DATA_TYPE_TIMESTAMP == ldt.type && TSDB_DATA_TYPE_BIGINT == rdt.type) ||
+    if ((TSDB_DATA_TYPE_TIMESTAMP == ldt.type && IS_INTEGER_TYPE(rdt.type)) ||
-        (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && TSDB_DATA_TYPE_BIGINT == ldt.type)) {
+        (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && IS_INTEGER_TYPE(ldt.type)) ||
+        (TSDB_DATA_TYPE_TIMESTAMP == ldt.type && TSDB_DATA_TYPE_BOOL == rdt.type) ||
+        (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && TSDB_DATA_TYPE_BOOL == ldt.type)) {
       pOp->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;
       pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
     } else {
@@ -833,7 +838,8 @@ static SNode* createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr) {
     return NULL;
   }
   pFunc->pParameterList = nodesMakeList();
-  if (NULL == pFunc->pParameterList || TSDB_CODE_SUCCESS != nodesListStrictAppend(pFunc->pParameterList, nodesCloneNode(pExpr))) {
+  if (NULL == pFunc->pParameterList ||
+      TSDB_CODE_SUCCESS != nodesListStrictAppend(pFunc->pParameterList, nodesCloneNode(pExpr))) {
     nodesDestroyNode(pFunc);
     return NULL;
   }
@@ -884,11 +890,13 @@ static int32_t createTableAllCols(STranslateContext* pCxt, SColumnNode* pCol, SN
 }
 
 static bool isStar(SNode* pNode) {
-  return (QUERY_NODE_COLUMN == nodeType(pNode)) && ('\0' == ((SColumnNode*)pNode)->tableAlias[0]) && (0 == strcmp(((SColumnNode*)pNode)->colName, "*"));
+  return (QUERY_NODE_COLUMN == nodeType(pNode)) && ('\0' == ((SColumnNode*)pNode)->tableAlias[0]) &&
+         (0 == strcmp(((SColumnNode*)pNode)->colName, "*"));
 }
 
 static bool isTableStar(SNode* pNode) {
-  return (QUERY_NODE_COLUMN == nodeType(pNode)) && ('\0' != ((SColumnNode*)pNode)->tableAlias[0]) && (0 == strcmp(((SColumnNode*)pNode)->colName, "*"));
+  return (QUERY_NODE_COLUMN == nodeType(pNode)) && ('\0' != ((SColumnNode*)pNode)->tableAlias[0]) &&
+         (0 == strcmp(((SColumnNode*)pNode)->colName, "*"));
 }
 
 static int32_t createMultiResFuncsParas(STranslateContext* pCxt, SNodeList* pSrcParas, SNodeList** pOutput) {
@@ -1123,9 +1131,7 @@ static int32_t translateGroupBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
   return translateExprList(pCxt, pSelect->pGroupByList);
 }
 
-static bool isValTimeUnit(char unit) {
+static bool isValTimeUnit(char unit) { return ('n' == unit || 'y' == unit); }
-  return ('n' == unit || 'y' == unit);
-}
 
 static int64_t getMonthsFromTimeVal(int64_t val, int32_t fromPrecision, char unit) {
   int64_t days = convertTimeFromPrecisionToUnit(val, fromPrecision, 'd');
@@ -1169,7 +1175,8 @@ static int32_t checkIntervalWindow(STranslateContext* pCxt, SIntervalWindowNode*
     }
     bool fixed = !isValTimeUnit(pOffset->unit) && !valInter;
     if ((fixed && pOffset->datum.i >= pInter->datum.i) ||
-        (!fixed && getMonthsFromTimeVal(pOffset->datum.i, precision, pOffset->unit) >= getMonthsFromTimeVal(pInter->datum.i, precision, pInter->unit))) {
+        (!fixed && getMonthsFromTimeVal(pOffset->datum.i, precision, pOffset->unit) >=
+                       getMonthsFromTimeVal(pInter->datum.i, precision, pInter->unit))) {
       return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTER_OFFSET_TOO_BIG);
     }
   }
@@ -1362,7 +1369,8 @@ static int32_t checkRangeOption(STranslateContext* pCxt, const char* pName, SVal
     if (DEAL_RES_ERROR == translateValue(pCxt, pVal)) {
       return pCxt->errCode;
     }
-    if (pVal->isDuration && (TIME_UNIT_MINUTE != pVal->unit && TIME_UNIT_HOUR != pVal->unit && TIME_UNIT_DAY != pVal->unit)) {
+    if (pVal->isDuration &&
+        (TIME_UNIT_MINUTE != pVal->unit && TIME_UNIT_HOUR != pVal->unit && TIME_UNIT_DAY != pVal->unit)) {
       return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_OPTION_UNIT, pName, pVal->unit);
     }
     int64_t val = getBigintFromValueNode(pVal);
@@ -1457,9 +1465,12 @@ static int32_t checkKeepOption(STranslateContext* pCxt, SNodeList* pKeep) {
   SValueNode* pKeep0 = (SValueNode*)nodesListGetNode(pKeep, 0);
   SValueNode* pKeep1 = (SValueNode*)nodesListGetNode(pKeep, 1);
   SValueNode* pKeep2 = (SValueNode*)nodesListGetNode(pKeep, 2);
-  if ((pKeep0->isDuration && (TIME_UNIT_MINUTE != pKeep0->unit && TIME_UNIT_HOUR != pKeep0->unit && TIME_UNIT_DAY != pKeep0->unit)) ||
+  if ((pKeep0->isDuration &&
-      (pKeep1->isDuration && (TIME_UNIT_MINUTE != pKeep1->unit && TIME_UNIT_HOUR != pKeep1->unit && TIME_UNIT_DAY != pKeep1->unit)) ||
+       (TIME_UNIT_MINUTE != pKeep0->unit && TIME_UNIT_HOUR != pKeep0->unit && TIME_UNIT_DAY != pKeep0->unit)) ||
-      (pKeep2->isDuration && (TIME_UNIT_MINUTE != pKeep2->unit && TIME_UNIT_HOUR != pKeep2->unit && TIME_UNIT_DAY != pKeep2->unit))) {
+      (pKeep1->isDuration &&
+       (TIME_UNIT_MINUTE != pKeep1->unit && TIME_UNIT_HOUR != pKeep1->unit && TIME_UNIT_DAY != pKeep1->unit)) ||
+      (pKeep2->isDuration &&
+       (TIME_UNIT_MINUTE != pKeep2->unit && TIME_UNIT_HOUR != pKeep2->unit && TIME_UNIT_DAY != pKeep2->unit))) {
     return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_KEEP_UNIT, pKeep0->unit, pKeep1->unit, pKeep2->unit);
   }
 
@@ -1516,7 +1527,8 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, SDatabaseOptions* p
     code = checkRangeOption(pCxt, "compression", pOptions->pCompressionLevel, TSDB_MIN_COMP_LEVEL, TSDB_MAX_COMP_LEVEL);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkRangeOption(pCxt, "daysPerFile", pOptions->pDaysPerFile, TSDB_MIN_DAYS_PER_FILE, TSDB_MAX_DAYS_PER_FILE);
+    code =
+        checkRangeOption(pCxt, "daysPerFile", pOptions->pDaysPerFile, TSDB_MIN_DAYS_PER_FILE, TSDB_MAX_DAYS_PER_FILE);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkRangeOption(pCxt, "fsyncPeriod", pOptions->pFsyncPeriod, TSDB_MIN_FSYNC_PERIOD, TSDB_MAX_FSYNC_PERIOD);
@@ -2174,7 +2186,8 @@ static int16_t getCreateComponentNodeMsgType(ENodeType type) {
 
 static int32_t translateCreateComponentNode(STranslateContext* pCxt, SCreateComponentNodeStmt* pStmt) {
   SMCreateQnodeReq createReq = {.dnodeId = pStmt->dnodeId};
-  return buildCmdMsg(pCxt, getCreateComponentNodeMsgType(nodeType(pStmt)), (FSerializeFunc)tSerializeSCreateDropMQSBNodeReq, &createReq);
+  return buildCmdMsg(pCxt, getCreateComponentNodeMsgType(nodeType(pStmt)),
+                     (FSerializeFunc)tSerializeSCreateDropMQSBNodeReq, &createReq);
 }
 
 static int16_t getDropComponentNodeMsgType(ENodeType type) {
@@ -2195,7 +2208,8 @@ static int16_t getDropComponentNodeMsgType(ENodeType type) {
 
 static int32_t translateDropComponentNode(STranslateContext* pCxt, SDropComponentNodeStmt* pStmt) {
   SDDropQnodeReq dropReq = {.dnodeId = pStmt->dnodeId};
-  return buildCmdMsg(pCxt, getDropComponentNodeMsgType(nodeType(pStmt)), (FSerializeFunc)tSerializeSCreateDropMQSBNodeReq, &dropReq);
+  return buildCmdMsg(pCxt, getDropComponentNodeMsgType(nodeType(pStmt)),
+                     (FSerializeFunc)tSerializeSCreateDropMQSBNodeReq, &dropReq);
 }
 
 static int32_t translateCreateTopic(STranslateContext* pCxt, SCreateTopicStmt* pStmt) {
@@ -2299,11 +2313,13 @@ static int32_t translateCreateStream(STranslateContext* pCxt, SCreateStreamStmt*
   }
 
   if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pOptions->pWatermark) {
-    code = (DEAL_RES_ERROR == translateValue(pCxt, (SValueNode*)pStmt->pOptions->pWatermark)) ? pCxt->errCode : TSDB_CODE_SUCCESS;
+    code = (DEAL_RES_ERROR == translateValue(pCxt, (SValueNode*)pStmt->pOptions->pWatermark)) ? pCxt->errCode
+                                                                                              : TSDB_CODE_SUCCESS;
   }
   if (TSDB_CODE_SUCCESS == code) {
     createReq.triggerType = pStmt->pOptions->triggerType;
-    createReq.watermark = (NULL != pStmt->pOptions->pWatermark ? ((SValueNode*)pStmt->pOptions->pWatermark)->datum.i : 0);
+    createReq.watermark =
+        (NULL != pStmt->pOptions->pWatermark ? ((SValueNode*)pStmt->pOptions->pWatermark)->datum.i : 0);
   }
 
   if (TSDB_CODE_SUCCESS == code) {
@@ -2455,9 +2471,7 @@ static int32_t extractSelectResultSchema(const SSelectStmt* pSelect, int32_t* nu
   return TSDB_CODE_SUCCESS;
 }
 
-static int8_t extractResultTsPrecision(const SSelectStmt* pSelect) {
+static int8_t extractResultTsPrecision(const SSelectStmt* pSelect) { return pSelect->precision; }
-  return pSelect->precision;
-}
 
 static int32_t extractExplainResultSchema(int32_t* numOfCols, SSchema** pSchema) {
   *numOfCols = 1;
@@ -2720,11 +2734,15 @@ typedef struct SVgroupTablesBatch {
   char               dbName[TSDB_DB_NAME_LEN];
 } SVgroupTablesBatch;
 
-static void toSchemaEx(const SColumnDefNode* pCol, col_id_t colId, SSchemaEx* pSchema) {
+static void toSchemaEx(const SColumnDefNode* pCol, col_id_t colId, SSchema* pSchema) {
+  int8_t flags = 0;
+  if (pCol->sma) {
+    flags |= SCHEMA_SMA_ON;
+  }
   pSchema->colId = colId;
   pSchema->type = pCol->dataType.type;
   pSchema->bytes = calcTypeBytes(pCol->dataType);
-  pSchema->sma = pCol->sma ? TSDB_BSMA_TYPE_LATEST : TSDB_BSMA_TYPE_NONE;
+  pSchema->flags = flags;
   strcpy(pSchema->name, pCol->colName);
 }
 
@@ -2769,7 +2787,7 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt*
   req.dbFName = strdup(dbFName);
   req.name = strdup(pStmt->tableName);
   req.ntbCfg.nCols = LIST_LENGTH(pStmt->pCols);
-  req.ntbCfg.pSchema = taosMemoryCalloc(req.ntbCfg.nCols, sizeof(SSchemaEx));
+  req.ntbCfg.pSchema = taosMemoryCalloc(req.ntbCfg.nCols, sizeof(SSchema));
   if (NULL == req.name || NULL == req.ntbCfg.pSchema) {
     destroyCreateTbReq(&req);
     return TSDB_CODE_OUT_OF_MEMORY;

source/libs/parser/test/parserTestUtil.h

@@ -13,4 +13,9 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef PARSER_TEST_UTIL_H
+#define PARSER_TEST_UTIL_H
+
 extern bool g_isDump;
+
+#endif  // PARSER_TEST_UTIL_H

source/libs/planner/src/planner.c

@@ -17,6 +17,31 @@
 
 #include "planInt.h"
 
+typedef struct SCollectPlaceholderValuesCxt {
+  int32_t errCode;
+  SNodeList* pValues;
+} SCollectPlaceholderValuesCxt;
+
+static EDealRes collectPlaceholderValuesImpl(SNode* pNode, void* pContext) {
+  if (QUERY_NODE_VALUE == nodeType(pNode) && ((SValueNode*)pNode)->placeholderNo > 0) {
+    SCollectPlaceholderValuesCxt* pCxt = pContext;
+    pCxt->errCode = nodesListMakeAppend(&pCxt->pValues, pNode);
+    return TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR;
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+static int32_t collectPlaceholderValues(SPlanContext* pCxt, SQueryPlan* pPlan) {
+  SCollectPlaceholderValuesCxt cxt = { .errCode = TSDB_CODE_SUCCESS, .pValues = NULL };
+  nodesWalkPhysiPlan((SNode*)pPlan, collectPlaceholderValuesImpl, &cxt);
+  if (TSDB_CODE_SUCCESS == cxt.errCode) {
+    pPlan->pPlaceholderValues = cxt.pValues;
+  } else {
+    nodesDestroyList(cxt.pValues);
+  }
+  return cxt.errCode;
+}
+
 int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNodeList) {
   SLogicNode* pLogicNode = NULL;
   SLogicSubplan* pLogicSubplan = NULL;
@@ -35,6 +60,9 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
   if (TSDB_CODE_SUCCESS == code) {
     code = createPhysiPlan(pCxt, pLogicPlan, pPlan, pExecNodeList);
   }
+  if (TSDB_CODE_SUCCESS == code && pCxt->isStmtQuery) {
+    code = collectPlaceholderValues(pCxt, *pPlan);
+  }
 
   nodesDestroyNode(pLogicNode);
   nodesDestroyNode(pLogicSubplan);
@@ -73,6 +101,82 @@ int32_t qSetSubplanExecutionNode(SSubplan* subplan, int32_t groupId, SDownstream
   return setSubplanExecutionNode(subplan->pNode, groupId, pSource);
 }
 
+static int32_t setValueByBindParam(SValueNode* pVal, TAOS_BIND_v2* pParam) {
+  if (1 == *(pParam->is_null)) {
+    pVal->node.resType.type = TSDB_DATA_TYPE_NULL;
+    pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
+    return TSDB_CODE_SUCCESS;
+  }
+  pVal->node.resType.type = pParam->buffer_type;
+  pVal->node.resType.bytes = *(pParam->length);
+  switch (pParam->buffer_type) {
+    case TSDB_DATA_TYPE_BOOL:
+      pVal->datum.b = *((bool*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      pVal->datum.i = *((int8_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      pVal->datum.i = *((int16_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_INT:
+      pVal->datum.i = *((int32_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      pVal->datum.i = *((int64_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      pVal->datum.d = *((float*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      pVal->datum.d = *((double*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_VARCHAR:
+    case TSDB_DATA_TYPE_VARBINARY:
+      pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
+      if (NULL == pVal->datum.p) {
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+      varDataSetLen(pVal->datum.p, pVal->node.resType.bytes);
+      strncpy(varDataVal(pVal->datum.p), (const char*)pParam->buffer, pVal->node.resType.bytes);
+      break;
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      pVal->datum.i = *((int64_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      pVal->datum.u = *((uint8_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      pVal->datum.u = *((uint16_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      pVal->datum.u = *((uint32_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      pVal->datum.u = *((uint64_t*)pParam->buffer);
+      break;
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_JSON:
+    case TSDB_DATA_TYPE_DECIMAL:
+    case TSDB_DATA_TYPE_BLOB:
+    case TSDB_DATA_TYPE_MEDIUMBLOB:
+      // todo
+    default:
+      break;
+  }
+  pVal->translate = true;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_BIND_v2* pParams) {
+  int32_t index = 0;
+  SNode* pNode = NULL;
+  FOREACH(pNode, pPlan->pPlaceholderValues) {
+    setValueByBindParam((SValueNode*)pNode, pParams + index);
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen) {
   if (SUBPLAN_TYPE_MODIFY == pSubplan->subplanType) {
     SDataInserterNode* insert = (SDataInserterNode*)pSubplan->pDataSink;

source/libs/planner/test/planStmtTest.cpp

@@ -0,0 +1,54 @@
+/*
+ * 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/>.
+ */
+
+#include "planTestUtil.h"
+#include "planner.h"
+
+using namespace std;
+
+class PlanStmtTest : public PlannerTestBase {
+public:
+  void prepare(const string& sql) {
+    run(sql);
+    // todo calloc pBindParams_
+  }
+
+  void bindParam(int32_t val) {
+    TAOS_BIND_v2* pBind = pBindParams_ + paramNo_++;
+    pBind->buffer_type = TSDB_DATA_TYPE_INT;
+    pBind->num = 1;
+    pBind->buffer_length = sizeof(int32_t);
+    pBind->buffer = taosMemoryCalloc(1, pBind->buffer_length);
+    pBind->length = (int32_t*)taosMemoryCalloc(1, sizeof(int32_t));
+    pBind->is_null = (char*)taosMemoryCalloc(1, sizeof(char));
+    *((int32_t*)pBind->buffer) = val;
+    *(pBind->length) = sizeof(int32_t);
+    *(pBind->is_null) = 0;
+  }
+
+  void exec() {
+    // todo
+  }
+
+private:
+  TAOS_BIND_v2* pBindParams_;
+  int32_t paramNo_;
+};
+
+TEST_F(PlanStmtTest, stmt) {
+  useDb("root", "test");
+
+  run("SELECT * FROM t1 where c1 = ?");
+}

source/libs/planner/test/planTestUtil.cpp

@@ -0,0 +1,205 @@
+/*
+ * 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/>.
+ */
+
+#include "planTestUtil.h"
+
+#include <algorithm>
+
+#include "cmdnodes.h"
+#include "parser.h"
+#include "planInt.h"
+
+using namespace std;
+using namespace testing;
+
+#define DO_WITH_THROW(func, ...) \
+  do { \
+    int32_t code__ = func(__VA_ARGS__); \
+    if (TSDB_CODE_SUCCESS != code__) { \
+      throw runtime_error("sql:[" + stmtEnv_.sql_ + "] " #func " code:" + to_string(code__) + ", strerror:" + string(tstrerror(code__)) + ", msg:" + string(stmtEnv_.msgBuf_.data())); \
+    } \
+  } while(0);
+
+class PlannerTestBaseImpl {
+public:
+  void useDb(const string& acctId, const string& db) {
+    caseEnv_.acctId_ = acctId;
+    caseEnv_.db_ = db;
+  }
+
+  void run(const string& sql) {
+    reset();
+    try {
+      SQuery* pQuery = nullptr;
+      doParseSql(sql, &pQuery);
+
+      SPlanContext cxt = {0};
+      setPlanContext(pQuery, &cxt);
+
+      SLogicNode* pLogicNode = nullptr;
+      doCreateLogicPlan(&cxt, &pLogicNode);
+
+      doOptimizeLogicPlan(&cxt, pLogicNode);
+
+      SLogicSubplan* pLogicSubplan = nullptr;
+      doSplitLogicPlan(&cxt, pLogicNode, &pLogicSubplan);
+
+      SQueryLogicPlan* pLogicPlan = nullptr;
+      doScaleOutLogicPlan(&cxt, pLogicSubplan, &pLogicPlan);
+
+      SQueryPlan* pPlan = nullptr;
+      doCreatePhysiPlan(&cxt, pLogicPlan, &pPlan, NULL);
+    } catch (...) {
+      dump();
+      throw;
+    }
+  }
+
+private:
+  struct caseEnv {
+    string acctId_;
+    string db_;
+  };
+
+  struct stmtEnv {
+    string sql_;
+    array<char, 1024> msgBuf_;
+  };
+
+  struct stmtRes {
+    string ast_;
+    string rawLogicPlan_;
+    string optimizedLogicPlan_;
+    string splitLogicPlan_;
+    string scaledLogicPlan_;
+    string physiPlan_;
+  };
+
+  void reset() {
+    stmtEnv_.sql_.clear();
+    stmtEnv_.msgBuf_.fill(0);
+
+    res_.ast_.clear();
+    res_.rawLogicPlan_.clear();
+    res_.optimizedLogicPlan_.clear();
+    res_.splitLogicPlan_.clear();
+    res_.scaledLogicPlan_.clear();
+    res_.physiPlan_.clear();
+  }
+
+  void dump() {
+    cout << "==========================================sql : [" << stmtEnv_.sql_ << "]" << endl;
+    cout << "syntax tree : " << endl;
+    cout << res_.ast_ << endl;
+    cout << "raw logic plan : " << endl;
+    cout << res_.rawLogicPlan_ << endl;
+    cout << "optimized logic plan : " << endl;
+    cout << res_.optimizedLogicPlan_ << endl;
+    cout << "split logic plan : " << endl;
+    cout << res_.splitLogicPlan_ << endl;
+    cout << "scaled logic plan : " << endl;
+    cout << res_.scaledLogicPlan_ << endl;
+    cout << "physical plan : " << endl;
+    cout << res_.physiPlan_ << endl;
+  }
+  
+  void doParseSql(const string& sql, SQuery** pQuery) {
+    stmtEnv_.sql_ = sql;
+    transform(stmtEnv_.sql_.begin(), stmtEnv_.sql_.end(), stmtEnv_.sql_.begin(), ::tolower);
+  
+    SParseContext cxt = {0};
+    cxt.acctId = atoi(caseEnv_.acctId_.c_str());
+    cxt.db = caseEnv_.db_.c_str();
+    cxt.pSql = stmtEnv_.sql_.c_str();
+    cxt.sqlLen = stmtEnv_.sql_.length();
+    cxt.pMsg = stmtEnv_.msgBuf_.data();
+    cxt.msgLen = stmtEnv_.msgBuf_.max_size();
+  
+    DO_WITH_THROW(qParseQuerySql, &cxt, pQuery);
+    res_.ast_ = toString((*pQuery)->pRoot);
+  }
+
+  void doCreateLogicPlan(SPlanContext* pCxt, SLogicNode** pLogicNode) {
+    DO_WITH_THROW(createLogicPlan, pCxt, pLogicNode);
+    res_.rawLogicPlan_ = toString((SNode*)(*pLogicNode));
+  }
+
+  void doOptimizeLogicPlan(SPlanContext* pCxt, SLogicNode* pLogicNode) {
+    DO_WITH_THROW(optimizeLogicPlan, pCxt, pLogicNode);
+    res_.optimizedLogicPlan_ = toString((SNode*)pLogicNode);
+  }
+
+  void doSplitLogicPlan(SPlanContext* pCxt, SLogicNode* pLogicNode, SLogicSubplan** pLogicSubplan) {
+    DO_WITH_THROW(splitLogicPlan, pCxt, pLogicNode, pLogicSubplan);
+    res_.splitLogicPlan_ = toString((SNode*)(*pLogicSubplan));
+  }
+
+  void doScaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan) {
+    DO_WITH_THROW(scaleOutLogicPlan, pCxt, pLogicSubplan, pLogicPlan);
+    res_.scaledLogicPlan_ = toString((SNode*)(*pLogicPlan));
+  }
+
+  void doCreatePhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList) {
+    DO_WITH_THROW(createPhysiPlan, pCxt, pLogicPlan, pPlan, pExecNodeList);
+    res_.physiPlan_ = toString((SNode*)(*pPlan));
+  }
+
+  void setPlanContext(SQuery* pQuery, SPlanContext* pCxt) {
+    if (QUERY_NODE_CREATE_TOPIC_STMT == nodeType(pQuery->pRoot)) {
+      pCxt->pAstRoot = ((SCreateTopicStmt*)pQuery->pRoot)->pQuery;
+      pCxt->topicQuery = true;
+    } else if (QUERY_NODE_CREATE_INDEX_STMT == nodeType(pQuery->pRoot)) {
+      SMCreateSmaReq req = {0};
+      tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req);
+      nodesStringToNode(req.ast, &pCxt->pAstRoot);
+      pCxt->streamQuery = true;
+    } else if (QUERY_NODE_CREATE_STREAM_STMT == nodeType(pQuery->pRoot)) {
+      SCreateStreamStmt* pStmt = (SCreateStreamStmt*)pQuery->pRoot;
+      pCxt->pAstRoot = pStmt->pQuery;
+      pCxt->streamQuery = true;
+      pCxt->triggerType = pStmt->pOptions->triggerType;
+      pCxt->watermark = (NULL != pStmt->pOptions->pWatermark ? ((SValueNode*)pStmt->pOptions->pWatermark)->datum.i : 0);
+    } else {
+      pCxt->pAstRoot = pQuery->pRoot;
+    }
+  }
+
+  string toString(const SNode* pRoot) {
+    char* pStr = NULL;
+    int32_t len = 0;
+    DO_WITH_THROW(nodesNodeToString, pRoot, false, &pStr, &len)
+    string str(pStr);
+    taosMemoryFreeClear(pStr);
+    return str;
+  }
+
+  caseEnv caseEnv_;
+  stmtEnv stmtEnv_;
+  stmtRes res_;
+};
+
+PlannerTestBase::PlannerTestBase() : impl_(new PlannerTestBaseImpl()) {
+}
+
+PlannerTestBase::~PlannerTestBase() {
+}
+
+void PlannerTestBase::useDb(const std::string& acctId, const std::string& db) {
+  impl_->useDb(acctId, db);
+}
+
+void PlannerTestBase::run(const std::string& sql) {
+  return impl_->run(sql);
+}

source/libs/planner/test/planTestUtil.h

@@ -0,0 +1,35 @@
+/*
+ * 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 PLAN_TEST_UTIL_H
+#define PLAN_TEST_UTIL_H
+
+#include <gtest/gtest.h>
+
+class PlannerTestBaseImpl;
+
+class PlannerTestBase : public testing::Test {
+public:
+  PlannerTestBase();
+  virtual ~PlannerTestBase();
+
+  void useDb(const std::string& acctId, const std::string& db);
+  void run(const std::string& sql);
+
+private:
+  std::unique_ptr<PlannerTestBaseImpl> impl_;
+};
+
+#endif  // PLAN_TEST_UTIL_H

source/libs/planner/test/plannerTest.cpp

@@ -90,17 +90,16 @@ protected:
       return false;
     }
 
-    SQueryPlan* pPlan = nullptr;
+    code = createPhysiPlan(&cxt, pLogicPlan, &plan_, NULL);
-    code = createPhysiPlan(&cxt, pLogicPlan, &pPlan, NULL);
     if (code != TSDB_CODE_SUCCESS) {
       cout << "sql:[" << cxt_.pSql << "] createPhysiPlan code:" << code << ", strerror:" << tstrerror(code) << endl;
       return false;
     }
   
     cout << "unformatted physical plan : " << endl;
-    cout << toString((const SNode*)pPlan, false) << endl;
+    cout << toString((const SNode*)plan_, false) << endl;
     SNode* pNode;
-    FOREACH(pNode, pPlan->pSubplans) {
+    FOREACH(pNode, plan_->pSubplans) {
       SNode* pSubplan;
       FOREACH(pSubplan, ((SNodeListNode*)pNode)->pNodeList) {
         cout << "unformatted physical subplan : " << endl;
@@ -160,6 +159,7 @@ private:
   string sqlBuf_;
   SParseContext cxt_;
   SQuery* query_;
+  SQueryPlan* plan_;
 };
 
 TEST_F(PlannerTest, selectBasic) {

source/libs/scalar/inc/sclvector.h

@@ -52,6 +52,9 @@ static FORCE_INLINE double getVectorDoubleValue_FLOAT(void *src, int32_t index)
 static FORCE_INLINE double getVectorDoubleValue_DOUBLE(void *src, int32_t index) {
   return (double)*((double *)src + index);
 }
+static FORCE_INLINE double getVectorDoubleValue_BOOL(void *src, int32_t index) {
+  return (double)*((bool *)src + index);
+}
 
 static FORCE_INLINE _getDoubleValue_fn_t getVectorDoubleValueFn(int32_t srcType) {
   _getDoubleValue_fn_t p = NULL;
@@ -77,6 +80,8 @@ static FORCE_INLINE _getDoubleValue_fn_t getVectorDoubleValueFn(int32_t srcType)
     p = getVectorDoubleValue_DOUBLE;
   } else if (srcType == TSDB_DATA_TYPE_TIMESTAMP) {
     p = getVectorDoubleValue_BIGINT;
+  } else if (srcType == TSDB_DATA_TYPE_BOOL) {
+    p = getVectorDoubleValue_BOOL;
   } else {
     assert(0);
   }

source/libs/scalar/src/scalar.c

@@ -440,8 +440,10 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
     return DEAL_RES_ERROR;
   }
 
+  if (colDataIsNull_s(output.columnData, 0)) {
+    res->node.resType.type = TSDB_DATA_TYPE_NULL;
+  } else {
     res->node.resType = node->node.resType;
-
     int32_t type = output.columnData->info.type;
     if (IS_VAR_DATA_TYPE(type)) {
       res->datum.p = output.columnData->pData;
@@ -449,6 +451,7 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
     } else {
       memcpy(nodesGetValueFromNode(res), output.columnData->pData, tDataTypes[type].bytes);
     }
+  }
 
   nodesDestroyNode(*pNode);
   *pNode = (SNode*)res;

source/libs/scalar/src/sclfunc.c

@@ -313,8 +313,8 @@ static int32_t doLengthFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t concatCopyHelper(const char *input, char *output, bool hasNcharCol, int32_t type, int16_t *dataLen) {
+static int32_t concatCopyHelper(const char *input, char *output, bool hasNchar, int32_t type, int16_t *dataLen) {
-  if (hasNcharCol && type == TSDB_DATA_TYPE_VARCHAR) {
+  if (hasNchar && type == TSDB_DATA_TYPE_VARCHAR) {
     TdUcs4 *newBuf = taosMemoryCalloc((varDataLen(input) + 1) * TSDB_NCHAR_SIZE, 1);
     bool ret = taosMbsToUcs4(varDataVal(input), varDataLen(input), newBuf, (varDataLen(input) + 1) * TSDB_NCHAR_SIZE, NULL);
     if (!ret) {
@@ -345,10 +345,6 @@ static int32_t getNumOfNullEntries(SColumnInfoData *pColumnInfoData, int32_t num
 }
 
 int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  if (inputNum < 2 || inputNum > 8) { // concat accpet 2-8 input strings
-    return TSDB_CODE_FAILED;
-  }
-
   SColumnInfoData **pInputData = taosMemoryCalloc(inputNum, sizeof(SColumnInfoData *));
   SColumnInfoData *pOutputData = pOutput->columnData;
   char **input = taosMemoryCalloc(inputNum, POINTER_BYTES);
@@ -356,15 +352,8 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
   int32_t inputLen = 0;
   int32_t numOfRows = 0;
-  bool hasNcharCol = false;
+  bool hasNchar = (GET_PARAM_TYPE(pOutput) == TSDB_DATA_TYPE_NCHAR) ? true : false;
   for (int32_t i = 0; i < inputNum; ++i) {
-    int32_t type = GET_PARAM_TYPE(&pInput[i]);
-    if (!IS_VAR_DATA_TYPE(type)) {
-      return TSDB_CODE_FAILED;
-    }
-    if (type == TSDB_DATA_TYPE_NCHAR) {
-      hasNcharCol = true;
-    }
     if (pInput[i].numOfRows > numOfRows) {
       numOfRows = pInput[i].numOfRows;
     }
@@ -373,7 +362,7 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
     pInputData[i] = pInput[i].columnData;
     input[i] = pInputData[i]->pData + pInputData[i]->varmeta.offset[0];
     int32_t factor = 1;
-    if (hasNcharCol && (GET_PARAM_TYPE(&pInput[i]) == TSDB_DATA_TYPE_VARCHAR)) {
+    if (hasNchar && (GET_PARAM_TYPE(&pInput[i]) == TSDB_DATA_TYPE_VARCHAR)) {
       factor = TSDB_NCHAR_SIZE;
     }
 
@@ -405,7 +394,7 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
     int16_t dataLen = 0;
     for (int32_t i = 0; i < inputNum; ++i) {
-      int32_t ret = concatCopyHelper(input[i], output, hasNcharCol, GET_PARAM_TYPE(&pInput[i]), &dataLen);
+      int32_t ret = concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen);
       if (ret != TSDB_CODE_SUCCESS) {
         return ret;
       }
@@ -428,10 +417,6 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
 
 int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  if (inputNum < 3 || inputNum > 9) { // concat accpet 3-9 input strings including the separator
-    return TSDB_CODE_FAILED;
-  }
-
   SColumnInfoData **pInputData = taosMemoryCalloc(inputNum, sizeof(SColumnInfoData *));
   SColumnInfoData *pOutputData = pOutput->columnData;
   char **input = taosMemoryCalloc(inputNum, POINTER_BYTES);
@@ -439,15 +424,8 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
 
   int32_t inputLen = 0;
   int32_t numOfRows = 0;
-  bool hasNcharCol = false;
+  bool hasNchar = (GET_PARAM_TYPE(pOutput) == TSDB_DATA_TYPE_NCHAR) ? true : false;
   for (int32_t i = 1; i < inputNum; ++i) {
-    int32_t type = GET_PARAM_TYPE(&pInput[i]);
-    if (!IS_VAR_DATA_TYPE(GET_PARAM_TYPE(&pInput[i]))) {
-      return TSDB_CODE_FAILED;
-    }
-    if (type == TSDB_DATA_TYPE_NCHAR) {
-      hasNcharCol = true;
-    }
     if (pInput[i].numOfRows > numOfRows) {
       numOfRows = pInput[i].numOfRows;
     }
@@ -456,7 +434,7 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
     pInputData[i] = pInput[i].columnData;
     input[i] = pInputData[i]->pData + pInputData[i]->varmeta.offset[0];
     int32_t factor = 1;
-    if (hasNcharCol && (GET_PARAM_TYPE(&pInput[i]) == TSDB_DATA_TYPE_VARCHAR)) {
+    if (hasNchar && (GET_PARAM_TYPE(&pInput[i]) == TSDB_DATA_TYPE_VARCHAR)) {
       factor = TSDB_NCHAR_SIZE;
     }
 
@@ -487,7 +465,7 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
         continue;
       }
 
-      int32_t ret = concatCopyHelper(input[i], output, hasNcharCol, GET_PARAM_TYPE(&pInput[i]), &dataLen);
+      int32_t ret = concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen);
       if (ret != TSDB_CODE_SUCCESS) {
         return ret;
       }
@@ -499,7 +477,7 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
       if (i < inputNum - 1) {
         //insert the separator
         char *sep = pInputData[0]->pData;
-        int32_t ret = concatCopyHelper(sep, output, hasNcharCol, GET_PARAM_TYPE(&pInput[0]), &dataLen);
+        int32_t ret = concatCopyHelper(sep, output, hasNchar, GET_PARAM_TYPE(&pInput[0]), &dataLen);
         if (ret != TSDB_CODE_SUCCESS) {
           return ret;
         }
@@ -817,13 +795,6 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
 
 int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int32_t type = GET_PARAM_TYPE(pInput);
-  if (type != TSDB_DATA_TYPE_BIGINT && type != TSDB_DATA_TYPE_TIMESTAMP) {
-    return TSDB_CODE_FAILED;
-  }
-
-  if (inputNum != 1) {
-    return TSDB_CODE_FAILED;
-  }
 
   char *input  = pInput[0].columnData->pData;
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
@@ -889,13 +860,6 @@ int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *
 int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int32_t type = GET_PARAM_TYPE(pInput);
   int32_t timePrec = GET_PARAM_PRECISON(pInput);
-  if (type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_NCHAR) {
-    return TSDB_CODE_FAILED;
-  }
-
-  if (inputNum != 1) {
-    return TSDB_CODE_FAILED;
-  }
 
   char *input = pInput[0].columnData->pData + pInput[0].columnData->varmeta.offset[0];
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
@@ -905,7 +869,11 @@ int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
     }
 
     int64_t timeVal = 0;
-    convertStringToTimestamp(type, input, timePrec, &timeVal);
+    int32_t ret = convertStringToTimestamp(type, input, timePrec, &timeVal);
+    if (ret != TSDB_CODE_SUCCESS) {
+      colDataAppendNULL(pOutput->columnData, i);
+      continue;
+    }
 
     colDataAppend(pOutput->columnData, i, (char *)&timeVal, false);
     input += varDataTLen(input);
@@ -919,18 +887,6 @@ int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
 int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int32_t type = GET_PARAM_TYPE(&pInput[0]);
   int32_t timePrec = GET_PARAM_PRECISON(&pInput[0]);
-  if (inputNum != 2) {
-    return TSDB_CODE_FAILED;
-  }
-
-  if (type != TSDB_DATA_TYPE_BIGINT && type != TSDB_DATA_TYPE_TIMESTAMP &&
-      type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_NCHAR) {
-    return TSDB_CODE_FAILED;
-  }
-
-  if (GET_PARAM_TYPE(&pInput[1]) != TSDB_DATA_TYPE_BIGINT) { //time_unit
-    return TSDB_CODE_FAILED;
-  }
 
   int64_t timeUnit, timeVal = 0;
   GET_TYPED_DATA(timeUnit, int64_t, GET_PARAM_TYPE(&pInput[1]), pInput[1].columnData->pData);
@@ -952,7 +908,11 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
     }
 
     if (IS_VAR_DATA_TYPE(type)) { /* datetime format strings */
-      convertStringToTimestamp(type, input, TSDB_TIME_PRECISION_NANO, &timeVal);
+      int32_t ret = convertStringToTimestamp(type, input, TSDB_TIME_PRECISION_NANO, &timeVal);
+      if (ret != TSDB_CODE_SUCCESS) {
+        colDataAppendNULL(pOutput->columnData, i);
+        continue;
+      }
       //If converted value is less than 10digits in second, use value in second instead
       int64_t timeValSec = timeVal / 1000000000;
       if (timeValSec < 1000000000) {
@@ -1118,16 +1078,9 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
 }
 
 int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  if (inputNum != 2 && inputNum != 3) {
-    return TSDB_CODE_FAILED;
-  }
-
   int32_t timePrec = GET_PARAM_PRECISON(&pInput[0]);
   int64_t timeUnit = -1, timeVal[2] = {0};
   if (inputNum == 3) {
-    if (GET_PARAM_TYPE(&pInput[2]) != TSDB_DATA_TYPE_BIGINT) {
-      return TSDB_CODE_FAILED;
-    }
     GET_TYPED_DATA(timeUnit, int64_t, GET_PARAM_TYPE(&pInput[2]), pInput[2].columnData->pData);
   }
 
@@ -1155,7 +1108,11 @@ int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
 
       int32_t type = GET_PARAM_TYPE(&pInput[k]);
       if (IS_VAR_DATA_TYPE(type)) { /* datetime format strings */
-        convertStringToTimestamp(type, input[k], TSDB_TIME_PRECISION_NANO, &timeVal[k]);
+        int32_t ret = convertStringToTimestamp(type, input[k], TSDB_TIME_PRECISION_NANO, &timeVal[k]);
+        if (ret != TSDB_CODE_SUCCESS) {
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
+        }
       } else if (type == TSDB_DATA_TYPE_BIGINT || type == TSDB_DATA_TYPE_TIMESTAMP) { /* unix timestamp or ts column*/
         GET_TYPED_DATA(timeVal[k], int64_t, type, input[k]);
         if (type == TSDB_DATA_TYPE_TIMESTAMP) {

source/libs/scalar/src/sclvector.c

@@ -57,6 +57,10 @@ int64_t getVectorBigintValue_FLOAT(void *src, int32_t index) {
 int64_t getVectorBigintValue_DOUBLE(void *src, int32_t index) {
   return (int64_t)*((double *)src + index);
 }
+int64_t getVectorBigintValue_BOOL(void *src, int32_t index) {
+  return (int64_t)*((bool *)src + index);
+}
+
 _getBigintValue_fn_t getVectorBigintValueFn(int32_t srcType) {
     _getBigintValue_fn_t p = NULL;
     if(srcType==TSDB_DATA_TYPE_TINYINT) {
@@ -81,6 +85,8 @@ _getBigintValue_fn_t getVectorBigintValueFn(int32_t srcType) {
         p = getVectorBigintValue_DOUBLE;
     }else if(srcType==TSDB_DATA_TYPE_TIMESTAMP) {
         p = getVectorBigintValue_BIGINT;
+    }else if(srcType==TSDB_DATA_TYPE_BOOL) {
+        p = getVectorBigintValue_BOOL;
     }else {
         assert(0);
     }
@@ -620,8 +626,10 @@ void vectorMathAdd(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut
   SColumnInfoData *pLeftCol   = doVectorConvert(pLeft, &leftConvert);
   SColumnInfoData *pRightCol  = doVectorConvert(pRight, &rightConvert);
 
-  if ((GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_TIMESTAMP && GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_BIGINT) ||
+  if ((GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_TIMESTAMP && IS_INTEGER_TYPE(GET_PARAM_TYPE(pRight))) ||
-      (GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_TIMESTAMP && GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_BIGINT)) { //timestamp plus duration
+      (GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_TIMESTAMP && IS_INTEGER_TYPE(GET_PARAM_TYPE(pLeft))) ||
+      (GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_TIMESTAMP && GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_BOOL) ||
+      (GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_TIMESTAMP && GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_BOOL)) { //timestamp plus duration
     int64_t *output = (int64_t *)pOutputCol->pData;
     _getBigintValue_fn_t getVectorBigintValueFnLeft  = getVectorBigintValueFn(pLeftCol->info.type);
     _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type);

source/os/src/osFile.c

@@ -772,6 +772,9 @@ int64_t taosGetLineFile(TdFilePtr pFile, char **__restrict ptrBuf) {
   if (pFile == NULL) {
     return -1;
   }
+  if (*ptrBuf != NULL) {
+    taosMemoryFreeClear(*ptrBuf);
+  }
   assert(pFile->fp != NULL);
 
   size_t len = 0;

source/os/src/osThread.c

@@ -77,34 +77,6 @@ int32_t taosThreadAttrSetStackSize(TdThreadAttr * attr, size_t stacksize) {
   return pthread_attr_setstacksize(attr, stacksize);
 }
 
-int32_t taosThreadBarrierDestroy(TdThreadBarrier * barrier) {
-  return pthread_barrier_destroy(barrier);
-}
-
-int32_t taosThreadBarrierInit(TdThreadBarrier * barrier, const TdThreadBarrierAttr * attr, uint32_t count) {
-  return pthread_barrier_init(barrier, attr, count);
-}
-
-int32_t taosThreadBarrierWait(TdThreadBarrier * barrier) {
-  return pthread_barrier_wait(barrier);
-}
-
-int32_t taosThreadBarrierAttrDestroy(TdThreadBarrierAttr * attr) {
-  return pthread_barrierattr_destroy(attr);
-}
-
-int32_t taosThreadBarrierAttrGetPshared(const TdThreadBarrierAttr * attr, int32_t *pshared) {
-  return pthread_barrierattr_getpshared(attr, pshared);
-}
-
-int32_t taosThreadBarrierAttrInit(TdThreadBarrierAttr * attr) {
-  return pthread_barrierattr_init(attr);
-}
-
-int32_t taosThreadBarrierAttrSetPshared(TdThreadBarrierAttr * attr, int32_t pshared) {
-  return pthread_barrierattr_setpshared(attr, pshared);
-}
-
 int32_t taosThreadCancel(TdThread thread) {
   return pthread_cancel(thread);
 }
@@ -322,23 +294,43 @@ int32_t taosThreadSetSpecific(TdThreadKey key, const void *value) {
 }
 
 int32_t taosThreadSpinDestroy(TdThreadSpinlock * lock) {
-  return pthread_spin_destroy(lock);
+#ifndef __USE_XOPEN2K
+  return pthread_mutex_destroy((pthread_mutex_t*)lock);
+#else
+  return pthread_spin_destroy((pthread_spinlock_t*)lock);
+#endif
 }
 
 int32_t taosThreadSpinInit(TdThreadSpinlock * lock, int32_t pshared) {
-  return pthread_spin_init(lock, pshared);
+#ifndef __USE_XOPEN2K
+  return pthread_mutex_init((pthread_mutex_t*)lock, pshared);
+#else
+  return pthread_spin_init((pthread_spinlock_t*)lock, pshared);
+#endif
 }
 
 int32_t taosThreadSpinLock(TdThreadSpinlock * lock) {
-  return pthread_spin_lock(lock);
+#ifndef __USE_XOPEN2K
+  return pthread_mutex_lock((pthread_mutex_t*)lock);
+#else
+  return pthread_spin_lock((pthread_spinlock_t*)lock);
+#endif
 }
 
 int32_t taosThreadSpinTrylock(TdThreadSpinlock * lock) {
-  return pthread_spin_trylock(lock);
+#ifndef __USE_XOPEN2K
+  return pthread_mutex_trylock((pthread_mutex_t*)lock);
+#else
+  return pthread_spin_trylock((pthread_spinlock_t*)lock);
+#endif
 }
 
 int32_t taosThreadSpinUnlock(TdThreadSpinlock * lock) {
-  return pthread_spin_unlock(lock);
+#ifndef __USE_XOPEN2K
+  return pthread_mutex_unlock((pthread_mutex_t*)lock);
+#else
+  return pthread_spin_unlock((pthread_spinlock_t*)lock);
+#endif
 }
 
 void taosThreadTestCancel(void) {

tests/script/tmp/data.sim

@@ -3,6 +3,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 sql connect
 
+return 
 sql create database db 
 sql create table db.tb (ts timestamp, i int)
 sql insert into db.tb values(now, 1)

tests/script/tsim/bnode/basic1.sim

@@ -24,7 +24,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 
@@ -71,7 +71,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 

tests/script/tsim/db/alter_option.sim

@@ -72,7 +72,7 @@ print rows: $rows
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 print $data10 $data11 $data12 $data13 $data14 $data15 $data16 $data17 $data18 $data19
 print ====> dataX_db
-print $data0_db $data1_db $data2_db $data3_db $data4_db $data5_db $data6_db $data7_db $data8_db $data9_db $data10_db $data11_db $data12_db $data13_db $data14_db $data15_db $data16_db $data17_db
+print $data(db)[0] $data(db)[1] $data2_db $data3_db $data4_db $data5_db $data6_db $data7_db $data8_db $data9_db $data10_db $data11_db $data12_db $data13_db $data14_db $data15_db $data16_db $data17_db
 
 if $rows != 3 then
   return -1

tests/script/tsim/db/basic6.sim

@@ -17,7 +17,6 @@ print =============== step1
 # quorum  presicion 
 sql create database $db vgroups 8 replica 1 days 2880 keep 3650 cache 32 blocks 12 minrows 80 maxrows 10000 wal 2 fsync 1000 comp 0 cachelast 2 precision 'us'
 sql show databases
-print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1 $data5_1  $data6_1  $data7_1  $data8_1  $data9_1
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 
 if $rows != 3 then

tests/script/tsim/dnode/basic1.sim

@@ -29,7 +29,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 
@@ -76,7 +76,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 

tests/script/tsim/mnode/basic1.sim

@@ -24,7 +24,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 
@@ -71,7 +71,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 

tests/script/tsim/qnode/basic1.sim

@@ -24,7 +24,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 
@@ -71,7 +71,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 

tests/script/tsim/query/explain.sim

@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c wallevel -v 2
 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
 
-print ========= start dnode1 as master
+print ========= start dnode1 as LEADER
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect

tests/script/tsim/query/session.sim

@@ -26,14 +26,6 @@ sql connect
 $vgroups  = 4
 $dbNamme  = d0
 
-print ====> create database d1 precision 'us' 
-sql create database d1 precision 'us'
-sql use d1
-sql create table dev_001 (ts timestamp ,i timestamp ,j int)
-sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
-sql create table secondts(ts timestamp,t2 timestamp,i int)
-sql insert into secondts values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
-
 print ====> create database $dbNamme vgroups $vgroups
 sql create database $dbNamme vgroups $vgroups
 sql show databases
@@ -296,11 +288,14 @@ sql_error select count(*) from dev_001 session(i,1y)
 sql_error select count(*) from dev_001 session(ts,1d) where ts <'2020-05-20 0:0:0'
 
 # vnode does not return the precision of the table
-#print ====> create database d1 precision 'us' 
+print ====> create database d1 precision 'us' 
-#sql create database d1 precision 'us'
+sql create database d1 precision 'us'
-#sql use d1
+sql use d1
-#sql create table dev_001 (ts timestamp ,i timestamp ,j int)
+sql create table dev_001 (ts timestamp ,i timestamp ,j int)
-#sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
+sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
+sql create table secondts(ts timestamp,t2 timestamp,i int)
+sql insert into secondts values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
+
 #print ====> select count(*) from dev_001 session(ts,1u)
 #sql select _wstartts, count(*) from dev_001 session(ts,1u)
 #print rows: $rows
@@ -312,14 +307,12 @@ sql_error select count(*) from dev_001 session(ts,1d) where ts <'2020-05-20 0:0:
 #  print expect 2, actual: $rows
 #  return -1
 #endi
-#
 #if $data01 != 1 then
 #  return -1
 #endi
 
-#sql_error select count(*) from dev_001 session(i,1s)
+sql_error select count(*) from dev_001 session(i,1s)
-sql create table secondts(ts timestamp,t2 timestamp,i int)
+sql_error select count(*) from secondts session(t2,2s)
-#sql_error select count(*) from secondts session(t2,2s)
 
 if $loop_test == 0 then
   print =============== stop and restart taosd

tests/script/tsim/query/time_process.sim

@@ -0,0 +1,133 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start
+
+$loop_cnt = 0
+check_dnode_ready:
+    $loop_cnt = $loop_cnt + 1
+    sleep 200
+    if $loop_cnt == 10 then
+        print ====> dnode not ready!
+        return -1
+    endi
+
+sql show dnodes
+print ===> $rows $data00 $data01 $data02 $data03 $data04 $data05
+if $data00 != 1 then
+  return -1
+endi
+if $data04 != ready then
+  goto check_dnode_ready
+endi
+
+sql connect
+
+print =============== create database
+sql create database db
+sql show databases
+if $rows != 3 then
+  return -1
+endi
+
+sql use db
+
+print =============== create super table and child table
+sql create table stb1 (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp) tags (t1 int)
+sql show stables
+print $rows $data00 $data01 $data02
+if $rows != 1 then
+  return -1
+endi
+
+sql create table ct1 using stb1 tags ( 1 )
+sql create table ct2 using stb1 tags ( 2 )
+sql create table ct3 using stb1 tags ( 3 )
+sql create table ct4 using stb1 tags ( 4 )
+sql show tables
+print $rows $data00 $data10 $data20
+if $rows != 4 then
+  return -1
+endi
+
+sql create table t1 (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
+
+print =============== insert data into child table ct1 (s)
+sql insert into ct1 values ( '2022-01-01 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now+1a )
+sql insert into ct1 values ( '2022-01-01 01:01:06.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now+2a )
+sql insert into ct1 values ( '2022-01-01 01:01:10.000', 3, 33333, 333, 33, 3.33, 33.33, 0, "binary3", "nchar3", now+3a )
+sql insert into ct1 values ( '2022-01-01 01:01:16.000', 4, 44444, 444, 44, 4.44, 44.44, 1, "binary4", "nchar4", now+4a )
+sql insert into ct1 values ( '2022-01-01 01:01:20.000', 5, 55555, 555, 55, 5.55, 55.55, 0, "binary5", "nchar5", now+5a )
+sql insert into ct1 values ( '2022-01-01 01:01:26.000', 6, 66666, 666, 66, 6.66, 66.66, 1, "binary6", "nchar6", now+6a )
+sql insert into ct1 values ( '2022-01-01 01:01:30.000', 7, 00000, 000, 00, 0.00, 00.00, 1, "binary7", "nchar7", now+7a )
+sql insert into ct1 values ( '2022-01-01 01:01:36.000', 8, -88888, -888, -88, -8.88, -88.88, 0, "binary8", "nchar8", now+8a )
+
+print =============== insert data into child table ct4 (y)
+sql insert into ct4 values ( '2019-01-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+sql insert into ct4 values ( '2019-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now+1a )
+sql insert into ct4 values ( '2019-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now+2a )
+sql insert into ct4 values ( '2020-01-01 01:01:06.000', 3, 33333, 333, 33, 3.33, 33.33, 0, "binary3", "nchar3", now+3a )
+sql insert into ct4 values ( '2020-05-07 01:01:10.000', 4, 44444, 444, 44, 4.44, 44.44, 1, "binary4", "nchar4", now+4a )
+sql insert into ct4 values ( '2020-09-30 01:01:16.000', 5, 55555, 555, 55, 5.55, 55.55, 0, "binary5", "nchar5", now+5a )
+sql insert into ct4 values ( '2020-12-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+sql insert into ct4 values ( '2021-02-01 01:01:20.000', 6, 66666, 666, 66, 6.66, 66.66, 1, "binary6", "nchar6", now+6a )
+sql insert into ct4 values ( '2021-10-28 01:01:26.000', 7, 00000, 000, 00, 0.00, 00.00, 1, "binary7", "nchar7", "1970-01-01 08:00:00.000" )
+sql insert into ct4 values ( '2021-12-01 01:01:30.000', 8, -88888, -888, -88, -8.88, -88.88, 0, "binary8", "nchar8", "1969-01-01 01:00:00.000" )
+sql insert into ct4 values ( '2022-02-31 01:01:36.000', 9, -99999999999999999, -999, -99, -9.99, -999999999999999999999.99, 1, "binary9", "nchar9", "1900-01-01 00:00:00.000" )
+sql insert into ct4 values ( '2022-05-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+
+print =============== insert data into child table t1
+sql insert into t1 values ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now+1a )
+sql insert into t1 values ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now+2a )
+sql insert into t1 values ( '2021-01-01 01:01:06.000', 3, 33333, 333, 33, 3.33, 33.33, 0, "binary3", "nchar3", now+3a )
+sql insert into t1 values ( '2021-05-07 01:01:10.000', 4, 44444, 444, 44, 4.44, 44.44, 1, "binary4", "nchar4", now+4a )
+sql insert into t1 values ( '2021-09-30 01:01:16.000', 5, 55555, 555, 55, 5.55, 55.55, 0, "binary5", "nchar5", now+5a )
+sql insert into t1 values ( '2022-02-01 01:01:20.000', 6, 66666, 666, 66, 6.66, 66.66, 1, "binary6", "nchar6", now+6a )
+sql insert into t1 values ( '2022-10-28 01:01:26.000', 7, 00000, 000, 00, 0.00, 00.00, 1, "binary7", "nchar7", "1970-01-01 08:00:00.000" )
+sql insert into t1 values ( '2022-12-01 01:01:30.000', 8, -88888, -888, -88, -8.88, -88.88, 0, "binary8", "nchar8", "1969-01-01 01:00:00.000" )
+sql insert into t1 values ( '2022-12-31 01:01:36.000', 9, -99999999999999999, -999, -99, -9.99, -999999999999999999999.99, 1, "binary9", "nchar9", "1900-01-01 00:00:00.000" )
+
+print ================ start query ======================
+
+print =============== step1
+print =====sql : select timediff(ts , c10) from ct4
+sql select cast(c1 as bigint) as b from ct4
+print ===> $rows
+if $rows != 1 then
+  return -1
+endi
+
+
+#=================================================
+print =============== stop and restart taosd
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode1 -s start
+
+$loop_cnt = 0
+check_dnode_ready_0:
+	  $loop_cnt = $loop_cnt + 1
+	  sleep 200
+	  if $loop_cnt == 10 then
+	      print ====> dnode not ready!
+		    return -1
+	  endi
+
+sql show dnodes
+print ===> $rows $data00 $data01 $data02 $data03 $data04 $data05
+if $data00 != 1 then
+    return -1
+endi
+if $data04 != ready then
+    goto check_dnode_ready_0
+endi
+
+print =============== step2 after wal
+
+
+print =============== clear
+sql drop database db
+sql show databases
+if $rows != 2 then
+  return -1
+endi
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/snode/basic1.sim

@@ -24,7 +24,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 
@@ -71,7 +71,7 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != master then 
+if $data02 != LEADER then 
   return -1
 endi
 

tests/script/tsim/user/basic1.sim

@@ -9,9 +9,9 @@ if $rows != 1 then
   return -1
 endi
 
-print $data00 $data01 $data02
+print $data[0][0] $data[0][1] $data[0][2]
-print $data10 $data11 $data22
+print $data[1][0] $data[1][1] $data[1][2]
-print $data20 $data11 $data22
+print $data[2][0] $data[1][2] $data[2][2]
 
 sql_error show accounts;
 sql_error create account a pass "a"
@@ -25,10 +25,10 @@ if $rows != 2 then
   return -1
 endi
 
-print $data00 $data01 $data02
+print $data[0][0] $data[0][1] $data[0][2]
-print $data10 $data11 $data12
+print $data[1][0] $data[1][1] $data[1][2]
-print $data20 $data11 $data22
+print $data[2][0] $data[1][2] $data[2][2]
-print $data30 $data31 $data32
+print $data[3][0] $data[3][1] $data[3][2]
 
 print =============== create user2
 sql create user user2 PASS 'user2'
@@ -37,10 +37,10 @@ if $rows != 3 then
   return -1
 endi
 
-print $data00 $data01 $data02
+print $data[0][0] $data[0][1] $data[0][2]
-print $data10 $data11 $data12
+print $data[1][0] $data[1][1] $data[1][2]
-print $data20 $data11 $data22
+print $data[2][0] $data[1][2] $data[2][2]
-print $data30 $data31 $data32
+print $data[3][0] $data[3][1] $data[3][2]
 print $data40 $data41 $data42
 
 print =============== drop user1
@@ -50,10 +50,10 @@ if $rows != 2 then
   return -1
 endi
 
-print $data00 $data01 $data02
+print $data[0][0] $data[0][1] $data[0][2]
-print $data10 $data11 $data22
+print $data[1][0] $data[1][1] $data[1][2]
-print $data20 $data11 $data22
+print $data[2][0] $data[1][2] $data[2][2]
-print $data30 $data31 $data32
+print $data[3][0] $data[3][1] $data[3][2]
 
 print =============== restart taosd
 system sh/exec.sh -n dnode1 -s stop
@@ -66,9 +66,9 @@ if $rows != 2 then
   return -1
 endi
 
-print $data00 $data01 $data02
+print $data[0][0] $data[0][1] $data[0][2]
-print $data10 $data11 $data22
+print $data[1][0] $data[1][1] $data[1][2]
-print $data20 $data11 $data22
+print $data[2][0] $data[1][2] $data[2][2]
-print $data30 $data31 $data32
+print $data[3][0] $data[3][1] $data[3][2]
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/system-test/2-query/between.py

@@ -0,0 +1,205 @@
+import taos
+import sys
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+
+
+
+class TDTestCase:
+
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor())
+
+    def run(self):  # sourcery skip: extract-duplicate-method
+        tdSql.prepare()
+
+        tdLog.printNoPrefix("==========step1:create table")
+        tdSql.execute(
+            '''create table if not exists supt
+            (ts timestamp, c1 int, c2 float, c3 bigint, c4 double, c5 smallint, c6 tinyint)
+            tags(location binary(64), type int, isused bool , family nchar(64))'''
+        )
+        tdSql.execute("create table t1 using supt tags('beijing', 1, 1, 'nchar1')")
+        tdSql.execute("create table t2 using supt tags('shanghai', 2, 0, 'nchar2')")
+
+        tdLog.printNoPrefix("==========step2:insert data")
+        for i in range(10):
+            tdSql.execute(
+                f"insert into t1 values (now()+{i}m, {32767+i}, {20.0+i/10}, {2**31+i}, {3.4*10**38+i/10}, {127+i}, {i})"
+            )
+            tdSql.execute(
+                f"insert into t2 values (now()-{i}m, {-32767-i}, {20.0-i/10}, {-i-2**31}, {-i/10-3.4*10**38}, {-127-i}, {-i})"
+            )
+        tdSql.execute(
+            f"insert into t1 values (now()+11m, {2**31-1}, {pow(10,37)*34}, {pow(2,63)-1}, {1.7*10**308}, 32767, 127)"
+        )
+        tdSql.execute(
+            f"insert into t2 values (now()-11m, {1-2**31}, {-3.4*10**38}, {1-2**63}, {-1.7*10**308}, -32767, -127)"
+        )
+        tdSql.execute(
+            f"insert into t2 values (now()-12m, null , {-3.4*10**38}, null , {-1.7*10**308}, null , null)"
+        )
+
+        tdLog.printNoPrefix("==========step3:query timestamp type")
+
+        # tdSql.query("select * from t1 where ts between now()-1m and now()+10m")
+        # tdSql.checkRows(10)
+        # tdSql.query("select * from t1 where ts between '2021-01-01 00:00:00.000' and '2121-01-01 00:00:00.000'")
+        # tdSql.checkRows(11)
+        # tdSql.query("select * from t1 where ts between '1969-01-01 00:00:00.000' and '1969-12-31 23:59:59.999'")
+        # tdSql.checkRows(0)
+        # tdSql.query("select * from t1 where ts between -2793600 and 31507199")
+        # tdSql.checkRows(0)
+        # tdSql.query("select * from t1 where ts between 1609430400000 and 4765104000000")
+        # tdSql.checkRows(11)
+
+        tdLog.printNoPrefix("==========step4:query int type")
+
+        tdSql.query("select * from t1 where c1 between 32767 and 32776")
+        tdSql.checkRows(10)
+        tdSql.query("select * from t1 where c1 between 32766.9 and 32776.1")
+        tdSql.checkRows(10)
+        tdSql.query("select * from t1 where c1 between 32776 and 32767")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c1 between 'a' and 'e'")
+        tdSql.checkRows(0)
+        # tdSql.query("select * from t1 where c1 between 0x64 and 0x69")
+        # tdSql.checkRows(6)
+        # tdSql.query("select * from t1 where c1 not between 100 and 106")
+        # tdSql.checkRows(11)
+        tdSql.query(f"select * from t1 where c1 between {2**31-2} and {2**31+1}")
+        tdSql.checkRows(1)
+        tdSql.error(f"select * from t2 where c1 between null and {1-2**31}")
+        # tdSql.checkRows(3)
+        tdSql.query(f"select * from t2 where c1 between {-2**31} and {1-2**31}")
+        tdSql.checkRows(1)
+
+        tdLog.printNoPrefix("==========step5:query float type")
+
+        tdSql.query("select * from t1 where c2 between 20.0 and 21.0")
+        tdSql.checkRows(10)
+        tdSql.query(f"select * from t1 where c2 between {-3.4*10**38-1} and {3.4*10**38+1}")
+        tdSql.checkRows(11)
+        tdSql.query("select * from t1 where c2 between 21.0 and 20.0")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c2 between 'DC3' and 'SYN'")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c2 not between 0.1 and 0.2")
+        # tdSql.checkRows(11)
+        tdSql.query(f"select * from t1 where c2 between {pow(10,38)*3.4} and {pow(10,38)*3.4+1}")
+        # tdSql.checkRows(1)
+        tdSql.query(f"select * from t2 where c2 between {-3.4*10**38-1} and {-3.4*10**38}")
+        # tdSql.checkRows(2)
+        tdSql.error(f"select * from t2 where c2 between null and {-3.4*10**38}")
+        # tdSql.checkRows(3)
+
+        tdLog.printNoPrefix("==========step6:query bigint type")
+
+        tdSql.query(f"select * from t1 where c3 between {2**31} and {2**31+10}")
+        tdSql.checkRows(10)
+        tdSql.query(f"select * from t1 where c3 between {-2**63} and {2**63}")
+        # tdSql.checkRows(11)
+        tdSql.query(f"select * from t1 where c3 between {2**31+10} and {2**31}")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c3 between 'a' and 'z'")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c3 not between 1 and 2")
+        # tdSql.checkRows(0)
+        tdSql.query(f"select * from t1 where c3 between {2**63-2} and {2**63-1}")
+        tdSql.checkRows(1)
+        tdSql.query(f"select * from t2 where c3 between {-2**63} and {1-2**63}")
+        # tdSql.checkRows(3)
+        tdSql.error(f"select * from t2 where c3 between null and {1-2**63}")
+        # tdSql.checkRows(2)
+
+        tdLog.printNoPrefix("==========step7:query double type")
+
+        tdSql.query(f"select * from t1 where c4 between {3.4*10**38} and {3.4*10**38+10}")
+        tdSql.checkRows(10)
+        tdSql.query(f"select * from t1 where c4 between {1.7*10**308+1} and {1.7*10**308+2}")
+        # 因为精度原因，在超出bigint边界后，数值不能进行准确的判断
+        # tdSql.checkRows(0)
+        tdSql.query(f"select * from t1 where c4 between {3.4*10**38+10} and {3.4*10**38}")
+        # tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c4 between 'a' and 'z'")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c4 not between 1 and 2")
+        # tdSql.checkRows(0)
+        tdSql.query(f"select * from t1 where c4 between {1.7*10**308} and {1.7*10**308+1}")
+        # tdSql.checkRows(1)
+        tdSql.query(f"select * from t2 where c4 between {-1.7*10**308-1} and {-1.7*10**308}")
+        # tdSql.checkRows(3)
+        tdSql.error(f"select * from t2 where c4 between null and {-1.7*10**308}")
+        # tdSql.checkRows(3)
+
+        tdLog.printNoPrefix("==========step8:query smallint type")
+
+        tdSql.query("select * from t1 where c5 between 127 and 136")
+        tdSql.checkRows(10)
+        tdSql.query("select * from t1 where c5 between 126.9 and 135.9")
+        tdSql.checkRows(9)
+        tdSql.query("select * from t1 where c5 between 136 and 127")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c5 between '~' and 'ˆ'")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c5 not between 1 and 2")
+        # tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c5 between 32767 and 32768")
+        tdSql.checkRows(1)
+        tdSql.query("select * from t2 where c5 between -32768 and -32767")
+        tdSql.checkRows(1)
+        tdSql.error("select * from t2 where c5 between null and -32767")
+        # tdSql.checkRows(1)
+
+        tdLog.printNoPrefix("==========step9:query tinyint type")
+
+        tdSql.query("select * from t1 where c6 between 0 and 9")
+        tdSql.checkRows(10)
+        tdSql.query("select * from t1 where c6 between -1.1 and 8.9")
+        tdSql.checkRows(9)
+        tdSql.query("select * from t1 where c6 between 9 and 0")
+        tdSql.checkRows(0)
+        tdSql.query("select * from t1 where c6 between 'NUL' and 'HT'")
+        tdSql.checkRows(1)
+        tdSql.query("select * from t1 where c6 not between 1 and 2")
+        # tdSql.checkRows(1)
+        tdSql.query("select * from t1 where c6 between 127 and 128")
+        tdSql.checkRows(1)
+        tdSql.query("select * from t2 where c6 between -128 and -127")
+        tdSql.checkRows(1)
+        tdSql.error("select * from t2 where c6 between null and -127")
+        # tdSql.checkRows(3)
+
+        tdLog.printNoPrefix("==========step10:invalid query type")
+
+        # tdSql.query("select * from supt where location between 'beijing' and 'shanghai'")
+        # tdSql.checkRows(23)
+        # # 非0值均解析为1，因此"between 负值 and o"解析为"between 1 and 0"
+        # tdSql.query("select * from supt where isused between 0 and 1")
+        # tdSql.checkRows(23)
+        # tdSql.query("select * from supt where isused between -1 and 0")
+        # tdSql.checkRows(0)
+        # tdSql.error("select * from supt where isused between false and true")
+        # tdSql.query("select * from supt where family between '拖拉机' and '自行车'")
+        # tdSql.checkRows(23)
+
+        tdLog.printNoPrefix("==========step11:query HEX/OCT/BIN type")
+
+        tdSql.error("select * from t1 where c6 between 0x7f and 0x80")      # check filter HEX
+        tdSql.error("select * from t1 where c6 between 0b1 and 0b11111")    # check filter BIN
+        tdSql.error("select * from t1 where c6 between 0b1 and 0x80")
+        tdSql.error("select * from t1 where c6=0b1")
+        tdSql.error("select * from t1 where c6=0x1")
+        # 八进制数据会按照十进制数据进行判定
+        tdSql.query("select * from t1 where c6 between 01 and 0200")        # check filter OCT
+        tdSql.checkRows(10)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/fulltest.sh

@@ -0,0 +1,17 @@
+python3 ./test.py -f 2-query/between.py
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tests/system-test/test.py

@@ -0,0 +1,198 @@
+#!/usr/bin/python
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+# install pip
+# pip install src/connector/python/
+
+# -*- coding: utf-8 -*-
+import sys
+import getopt
+import subprocess
+import time
+from distutils.log import warn as printf
+from fabric2 import Connection
+sys.path.append("../pytest")
+from util.log import *
+from util.dnodes import *
+from util.cases import *
+
+import taos
+
+
+if __name__ == "__main__":
+    
+    fileName = "all"
+    deployPath = ""
+    masterIp = ""
+    testCluster = False
+    valgrind = 0
+    logSql = True
+    stop = 0
+    restart = False
+    windows = 0
+    opts, args = getopt.gnu_getopt(sys.argv[1:], 'f:p:m:l:scghrw', [
+        'file=', 'path=', 'master', 'logSql', 'stop', 'cluster', 'valgrind', 'help', 'windows'])
+    for key, value in opts:
+        if key in ['-h', '--help']:
+            tdLog.printNoPrefix(
+                'A collection of test cases written using Python')
+            tdLog.printNoPrefix('-f Name of test case file written by Python')
+            tdLog.printNoPrefix('-p Deploy Path for Simulator')
+            tdLog.printNoPrefix('-m Master Ip for Simulator')
+            tdLog.printNoPrefix('-l <True:False> logSql Flag')
+            tdLog.printNoPrefix('-s stop All dnodes')
+            tdLog.printNoPrefix('-c Test Cluster Flag')
+            tdLog.printNoPrefix('-g valgrind Test Flag')
+            tdLog.printNoPrefix('-r taosd restart test')
+            tdLog.printNoPrefix('-w taos on windows')
+            sys.exit(0)
+
+        if key in ['-r', '--restart']: 
+            restart = True
+
+        if key in ['-f', '--file']:
+            fileName = value
+
+        if key in ['-p', '--path']:
+            deployPath = value
+
+        if key in ['-m', '--master']:
+            masterIp = value
+
+        if key in ['-l', '--logSql']:
+            if (value.upper() == "TRUE"):
+                logSql = True
+            elif (value.upper() == "FALSE"):
+                logSql = False
+            else:
+                tdLog.printNoPrefix("logSql value %s is invalid" % logSql)
+                sys.exit(0)
+
+        if key in ['-c', '--cluster']:
+            testCluster = True
+
+        if key in ['-g', '--valgrind']:
+            valgrind = 1
+
+        if key in ['-s', '--stop']:
+            stop = 1
+
+        if key in ['-w', '--windows']:
+            windows = 1
+
+    if (stop != 0):
+        if (valgrind == 0):
+            toBeKilled = "taosd"
+        else:
+            toBeKilled = "valgrind.bin"
+
+        killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1" % toBeKilled
+
+        psCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % toBeKilled
+        processID = subprocess.check_output(psCmd, shell=True)
+
+        while(processID):
+            os.system(killCmd)
+            time.sleep(1)
+            processID = subprocess.check_output(psCmd, shell=True)
+
+        for port in range(6030, 6041):
+            usePortPID = "lsof -i tcp:%d | grep LISTEn | awk '{print $2}'" % port
+            processID = subprocess.check_output(usePortPID, shell=True)
+
+            if processID:
+                killCmd = "kill -TERM %s" % processID
+                os.system(killCmd)
+            fuserCmd = "fuser -k -n tcp %d" % port
+            os.system(fuserCmd)
+        if valgrind:
+            time.sleep(2)
+
+        tdLog.info('stop All dnodes')
+    
+    if masterIp == "":
+        host = '127.0.0.1'
+    else:
+        host = masterIp
+
+    tdLog.info("Procedures for tdengine deployed in %s" % (host))
+    if windows:
+        tdCases.logSql(logSql)
+        tdLog.info("Procedures for testing self-deployment")
+        td_clinet = TDSimClient("C:\\TDengine")
+        td_clinet.deploy()
+        remote_conn = Connection("root@%s"%host)
+        with remote_conn.cd('/var/lib/jenkins/workspace/TDinternal/community/tests/pytest'):
+            remote_conn.run("python3 ./test.py")
+        conn = taos.connect(
+            host="%s"%(host),
+            config=td_clinet.cfgDir)
+        tdCases.runOneWindows(conn, fileName)
+    else:
+        tdDnodes.init(deployPath)
+        tdDnodes.setTestCluster(testCluster)
+        tdDnodes.setValgrind(valgrind)
+        tdDnodes.stopAll()
+        is_test_framework = 0
+        key_word = 'tdCases.addLinux'
+        try:
+            if key_word in open(fileName).read():
+                is_test_framework = 1
+        except:
+            pass
+        if is_test_framework:
+            moduleName = fileName.replace(".py", "").replace("/", ".")
+            uModule = importlib.import_module(moduleName)
+            try:
+                ucase = uModule.TDTestCase()
+                tdDnodes.deploy(1,ucase.updatecfgDict)
+            except :
+                tdDnodes.deploy(1,{})
+        else:
+            pass
+            tdDnodes.deploy(1,{})
+        tdDnodes.start(1)
+
+
+
+        tdCases.logSql(logSql)
+
+        if testCluster:
+            tdLog.info("Procedures for testing cluster")
+            if fileName == "all":
+                tdCases.runAllCluster()
+            else:
+                tdCases.runOneCluster(fileName)
+        else:
+            tdLog.info("Procedures for testing self-deployment")
+            conn = taos.connect(
+                host,
+                config=tdDnodes.getSimCfgPath())
+            if fileName == "all":
+                tdCases.runAllLinux(conn)
+            else:
+                tdCases.runOneLinux(conn, fileName)
+        if restart:
+            if fileName == "all":
+                tdLog.info("not need to query ")
+            else:    
+                sp = fileName.rsplit(".", 1)
+                if len(sp) == 2 and sp[1] == "py":
+                    tdDnodes.stopAll()
+                    tdDnodes.start(1)
+                    time.sleep(1)            
+                    conn = taos.connect( host, config=tdDnodes.getSimCfgPath())
+                    tdLog.info("Procedures for tdengine deployed in %s" % (host))
+                    tdLog.info("query test after taosd restart")
+                    tdCases.runOneLinux(conn, sp[0] + "_" + "restart.py")
+                else:
+                    tdLog.info("not need to query")
+    conn.close()

tests/tsim/inc/simInt.h

@@ -33,9 +33,9 @@
 #define MAX_BACKGROUND_SCRIPT_NUM 10
 #define MAX_FILE_NAME_LEN         256
 #define MAX_ERROR_LEN             1024
-#define MAX_QUERY_VALUE_LEN       10240
+#define MAX_QUERY_VALUE_LEN       1024
-#define MAX_QUERY_COL_NUM         20
+#define MAX_QUERY_COL_NUM         100
-#define MAX_QUERY_ROW_NUM         20
+#define MAX_QUERY_ROW_NUM         100
 #define MAX_SYSTEM_RESULT_LEN     2048
 #define MAX_VAR_LEN               100
 #define MAX_VAR_NAME_LEN          32

tests/tsim/src/simExe.c

@@ -49,6 +49,41 @@ char *simParseHostName(char *varName) {
   return hostName;
 }
 
+static void simFindFirstNum(const char *begin, int32_t beginLen, int32_t *num) {
+  if (beginLen <= 5) {
+    *num = 0;
+  } else {
+    *num = atoi(begin + 5);
+  }
+}
+
+static void simFindSecondNum(const char *begin, int32_t beginLen, int32_t *num) {
+  const char *number = strstr(begin, "][");
+  if (number == NULL) {
+    *num = 0;
+  } else {
+    *num = atoi(number + 2);
+  }
+}
+
+static void simFindFirstKeyVal(const char *begin, int32_t beginLen, char *key, int32_t keyLen) {
+  key[0] = 0;
+  for (int32_t i = 5; i < beginLen && i - 5 < keyLen; ++i) {
+    if (begin[i] != 0 && begin[i] != ']' && begin[i] != ')') {
+      key[i - 5] = begin[i];
+    }
+  }
+}
+
+static void simFindSecondKeyNum(const char *begin, int32_t beginLen, int32_t *num) {
+  const char *number = strstr(begin, ")[");
+  if (number == NULL) {
+    *num = 0;
+  } else {
+    *num = atoi(number + 2);
+  }
+}
+
 char *simGetVariable(SScript *script, char *varName, int32_t varLen) {
   if (strncmp(varName, "hostname", 8) == 0) {
     return simParseHostName(varName);
@@ -66,13 +101,40 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) {
 
   if (strncmp(varName, "system_content", varLen) == 0) return script->system_ret_content;
 
-  // variable like data2_192.168.0.1
   if (strncmp(varName, "data", 4) == 0) {
     if (varLen < 6) {
       return "null";
     }
 
-    if (varName[5] == '_') {
+    int32_t row = 0;
+    int32_t col = 0;
+    char    keyVal[1024] = {0};
+    int32_t keyLen = 1024;
+
+    if (varName[4] == '[') {
+      // $data[0][1]
+      simFindFirstNum(varName, varLen, &row);
+      simFindSecondNum(varName, varLen, &col);
+      if (row < 0 || row >= MAX_QUERY_ROW_NUM) {
+        return "null";
+      }
+      if (col < 0 || col >= MAX_QUERY_COL_NUM) {
+        return "null";
+      }
+      simDebug("script:%s, data[%d][%d]=%s", script->fileName, row, col, script->data[row][col]);
+      return script->data[row][col];
+    } else if (varName[4] == '(') {
+      // $data(db)[0]
+      simFindFirstKeyVal(varName, varLen, keyVal, keyLen);
+      simFindSecondKeyNum(varName, varLen, &col);
+      for (int32_t i = 0; i < MAX_QUERY_ROW_NUM; ++i) {
+        if (strncmp(keyVal, script->data[i][0], keyLen) == 0) {
+          simDebug("script:%s, keyName:%s, keyValue:%s", script->fileName, script->data[i][0], script->data[i][col]);
+          return script->data[i][col];
+        }
+      }
+    } else if (varName[5] == '_') {
+      // data2_db
       int32_t col = varName[4] - '0';
       if (col < 0 || col >= MAX_QUERY_COL_NUM) {
         return "null";
@@ -90,6 +152,7 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) {
       }
       return "null";
     } else if (varName[6] == '_') {
+      // data21_db
       int32_t col = (varName[4] - '0') * 10 + (varName[5] - '0');
       if (col < 0 || col >= MAX_QUERY_COL_NUM) {
         return "null";
@@ -107,6 +170,7 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) {
       }
       return "null";
     } else {
+      // $data00
       int32_t row = varName[4] - '0';
       int32_t col = varName[5] - '0';
       if (row < 0 || row >= MAX_QUERY_ROW_NUM) {
@@ -119,6 +183,8 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) {
       simDebug("script:%s, data[%d][%d]=%s", script->fileName, row, col, script->data[row][col]);
       return script->data[row][col];
     }
+
+    return "null";
   }
 
   for (int32_t i = 0; i < script->varLen; ++i) {
@@ -127,9 +193,6 @@ char *simGetVariable(SScript *script, char *varName, int32_t varLen) {
       continue;
     }
     if (strncmp(varName, var->varName, varLen) == 0) {
-      // if (strlen(var->varValue) != 0)
-      //  simDebug("script:%s, var:%s, value:%s", script->fileName,
-      //  var->varName, var->varValue);
       return var->varValue;
     }
   }

tools/shell/src/shellEngine.c

@@ -91,11 +91,6 @@ TAOS *shellInit(SShellArguments *_args) {
     _args->user = TSDB_DEFAULT_USER;
   }
 
-  SConfig *pCfg = cfgInit();
-  if (NULL == pCfg) return NULL;
-
-  if (0 != taosAddClientLogCfg(pCfg)) return NULL;
-
   // Connect to the database.
   TAOS *con = NULL;
   if (_args->auth == NULL) {