Merge branch '3.0' of github.com:taosdata/TDengine into feature/udf

include/common/taosdef.h

@@ -82,6 +82,8 @@ extern char *qtypeStr[];
 
 #define TSDB_PORT_HTTP      11
 
+#undef TD_DEBUG_PRINT_ROW
+
 #ifdef __cplusplus
 }
 #endif

include/common/trow.h

@@ -214,6 +214,7 @@ STSRow *tdRowDup(STSRow *row);
 static FORCE_INLINE SKvRowIdx *tdKvRowColIdxAt(STSRow *pRow, col_id_t idx) {
   return (SKvRowIdx *)TD_ROW_COL_IDX(pRow) + idx;
 }
+
 static FORCE_INLINE int16_t tdKvRowColIdAt(STSRow *pRow, col_id_t idx) {
   ASSERT(idx >= 0);
   if (idx == 0) {
@@ -222,6 +223,7 @@ static FORCE_INLINE int16_t tdKvRowColIdAt(STSRow *pRow, col_id_t idx) {
 
   return ((SKvRowIdx *)TD_ROW_COL_IDX(pRow) + idx - 1)->colId;
 }
+
 static FORCE_INLINE void *tdKVRowColVal(STSRow *pRow, SKvRowIdx *pIdx) { return POINTER_SHIFT(pRow, pIdx->offset); }
 
 #define TD_ROW_OFFSET(p) ((p)->toffset);  // During ParseInsert when without STSchema, how to get the offset for STpRow?
@@ -1117,7 +1119,7 @@ static FORCE_INLINE bool tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId,
   }
 
   if (!colFound) {
-    if(colId <= pIter->maxColId) {
+    if (colId <= pIter->maxColId) {
       pVal->valType = TD_VTYPE_NONE;
       return true;
     } else {
@@ -1367,14 +1369,14 @@ static void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
   }
 }
 
-static void tdSRowPrint(STSRow *row, STSchema *pSchema) {
+static void tdSRowPrint(STSRow *row, STSchema *pSchema, const char* tag) {
   STSRowIter iter = {0};
   tdSTSRowIterInit(&iter, pSchema);
   tdSTSRowIterReset(&iter, row);
-  printf(">>>");
+  printf("%s >>>", tag);
   for (int i = 0; i < pSchema->numOfCols; ++i) {
     STColumn *stCol = pSchema->columns + i;
-    SCellVal  sVal = { 255, NULL};
+    SCellVal  sVal = {.valType = 255, .val = NULL};
     if (!tdSTSRowIterNext(&iter, stCol->colId, stCol->type, &sVal)) {
       break;
     }

include/common/ttokendef.h

@@ -67,101 +67,101 @@
 #define TK_IF            49
 #define TK_NOT           50
 #define TK_EXISTS        51
-#define TK_BLOCKS                          52
-#define TK_CACHE                           53
-#define TK_CACHELAST                       54
-#define TK_COMP                            55
-#define TK_DAYS                            56
-#define TK_NK_VARIABLE                     57
-#define TK_FSYNC                           58
-#define TK_MAXROWS                         59
-#define TK_MINROWS                         60
-#define TK_KEEP                            61
-#define TK_PRECISION                       62
-#define TK_QUORUM                          63
+#define TK_BUFFER        52
+#define TK_CACHELAST     53
+#define TK_COMP          54
+#define TK_DAYS          55
+#define TK_NK_VARIABLE   56
+#define TK_FSYNC         57
+#define TK_MAXROWS       58
+#define TK_MINROWS       59
+#define TK_KEEP          60
+#define TK_PAGES         61
+#define TK_PAGESIZE      62
+#define TK_PRECISION     63
 #define TK_REPLICA       64
-#define TK_TTL                             65
+#define TK_STRICT        65
 #define TK_WAL           66
 #define TK_VGROUPS       67
 #define TK_SINGLE_STABLE 68
-#define TK_STREAM_MODE                     69
-#define TK_RETENTIONS                      70
-#define TK_STRICT                          71
-#define TK_NK_COMMA                        72
-#define TK_NK_COLON                        73
-#define TK_TABLE                           74
-#define TK_NK_LP                           75
-#define TK_NK_RP                           76
-#define TK_STABLE                          77
-#define TK_ADD                             78
-#define TK_COLUMN                          79
-#define TK_MODIFY                          80
-#define TK_RENAME                          81
-#define TK_TAG                             82
-#define TK_SET                             83
-#define TK_NK_EQ                           84
-#define TK_USING                           85
-#define TK_TAGS                            86
-#define TK_NK_DOT                          87
-#define TK_COMMENT                         88
-#define TK_BOOL                            89
-#define TK_TINYINT                         90
-#define TK_SMALLINT                        91
-#define TK_INT                             92
-#define TK_INTEGER                         93
-#define TK_BIGINT                          94
-#define TK_FLOAT                           95
-#define TK_DOUBLE                          96
-#define TK_BINARY                          97
-#define TK_TIMESTAMP                       98
-#define TK_NCHAR                           99
-#define TK_UNSIGNED                       100
-#define TK_JSON                           101
-#define TK_VARCHAR                        102
-#define TK_MEDIUMBLOB                     103
-#define TK_BLOB                           104
-#define TK_VARBINARY                      105
-#define TK_DECIMAL                        106
-#define TK_SMA                            107
+#define TK_RETENTIONS    69
+#define TK_NK_COMMA      70
+#define TK_NK_COLON      71
+#define TK_TABLE         72
+#define TK_NK_LP         73
+#define TK_NK_RP         74
+#define TK_STABLE        75
+#define TK_ADD           76
+#define TK_COLUMN        77
+#define TK_MODIFY        78
+#define TK_RENAME        79
+#define TK_TAG           80
+#define TK_SET           81
+#define TK_NK_EQ         82
+#define TK_USING         83
+#define TK_TAGS          84
+#define TK_NK_DOT        85
+#define TK_COMMENT       86
+#define TK_BOOL          87
+#define TK_TINYINT       88
+#define TK_SMALLINT      89
+#define TK_INT           90
+#define TK_INTEGER       91
+#define TK_BIGINT        92
+#define TK_FLOAT         93
+#define TK_DOUBLE        94
+#define TK_BINARY        95
+#define TK_TIMESTAMP     96
+#define TK_NCHAR         97
+#define TK_UNSIGNED      98
+#define TK_JSON          99
+#define TK_VARCHAR       100
+#define TK_MEDIUMBLOB    101
+#define TK_BLOB          102
+#define TK_VARBINARY     103
+#define TK_DECIMAL       104
+#define TK_DELAY         105
+#define TK_FILE_FACTOR   106
+#define TK_NK_FLOAT      107
 #define TK_ROLLUP        108
-#define TK_FILE_FACTOR                    109
-#define TK_NK_FLOAT                       110
-#define TK_DELAY                          111
-#define TK_SHOW                           112
-#define TK_DATABASES                      113
-#define TK_TABLES                         114
-#define TK_STABLES                        115
-#define TK_MNODES                         116
-#define TK_MODULES                        117
-#define TK_QNODES                         118
-#define TK_FUNCTIONS                      119
-#define TK_INDEXES                        120
-#define TK_FROM                           121
-#define TK_ACCOUNTS                       122
-#define TK_APPS                           123
-#define TK_CONNECTIONS                    124
-#define TK_LICENCE                        125
-#define TK_GRANTS                         126
-#define TK_QUERIES                        127
-#define TK_SCORES                         128
-#define TK_TOPICS                         129
-#define TK_VARIABLES                      130
-#define TK_BNODES                         131
-#define TK_SNODES                         132
-#define TK_CLUSTER                        133
-#define TK_LIKE                           134
-#define TK_INDEX                          135
-#define TK_FULLTEXT                       136
-#define TK_FUNCTION                       137
-#define TK_INTERVAL                       138
-#define TK_TOPIC                          139
-#define TK_AS                             140
-#define TK_WITH                           141
-#define TK_SCHEMA                         142
-#define TK_DESC                           143
-#define TK_DESCRIBE                       144
-#define TK_RESET                          145
-#define TK_QUERY                          146
+#define TK_TTL           109
+#define TK_SMA           110
+#define TK_SHOW          111
+#define TK_DATABASES     112
+#define TK_TABLES        113
+#define TK_STABLES       114
+#define TK_MNODES        115
+#define TK_MODULES       116
+#define TK_QNODES        117
+#define TK_FUNCTIONS     118
+#define TK_INDEXES       119
+#define TK_FROM          120
+#define TK_ACCOUNTS      121
+#define TK_APPS          122
+#define TK_CONNECTIONS   123
+#define TK_LICENCE       124
+#define TK_GRANTS        125
+#define TK_QUERIES       126
+#define TK_SCORES        127
+#define TK_TOPICS        128
+#define TK_VARIABLES     129
+#define TK_BNODES        130
+#define TK_SNODES        131
+#define TK_CLUSTER       132
+#define TK_LIKE          133
+#define TK_INDEX         134
+#define TK_FULLTEXT      135
+#define TK_FUNCTION      136
+#define TK_INTERVAL      137
+#define TK_TOPIC         138
+#define TK_AS            139
+#define TK_WITH          140
+#define TK_SCHEMA        141
+#define TK_DESC          142
+#define TK_DESCRIBE      143
+#define TK_RESET         144
+#define TK_QUERY         145
+#define TK_CACHE         146
 #define TK_EXPLAIN       147
 #define TK_ANALYZE       148
 #define TK_VERBOSE       149

include/libs/nodes/cmdnodes.h

@@ -30,24 +30,25 @@ extern "C" {
 
 typedef struct SDatabaseOptions {
   ENodeType   type;
-  SValueNode* pNumOfBlocks;
-  SValueNode* pCacheBlockSize;
-  SValueNode* pCachelast;
-  SValueNode* pCompressionLevel;
+  int32_t     buffer;
+  int8_t      cachelast;
+  int8_t      compressionLevel;
+  int32_t     daysPerFile;
   SValueNode* pDaysPerFile;
-  SValueNode* pFsyncPeriod;
-  SValueNode* pMaxRowsPerBlock;
-  SValueNode* pMinRowsPerBlock;
+  int32_t     fsyncPeriod;
+  int32_t     maxRowsPerBlock;
+  int32_t     minRowsPerBlock;
   SNodeList*  pKeep;
-  SValueNode* pPrecision;
-  SValueNode* pQuorum;
-  SValueNode* pReplica;
-  SValueNode* pTtl;
-  SValueNode* pWalLevel;
-  SValueNode* pNumOfVgroups;
-  SValueNode* pSingleStable;
-  SValueNode* pStreamMode;
-  SValueNode* pStrict;
+  int32_t     keep[3];
+  int32_t     pages;
+  int32_t     pagesize;
+  char        precisionStr[3];
+  int8_t      precision;
+  int8_t      replica;
+  int8_t      strict;
+  int8_t      walLevel;
+  int32_t     numOfVgroups;
+  int8_t      singleStable;
   SNodeList*  pRetentions;
 } SDatabaseOptions;
 
@@ -77,13 +78,12 @@ typedef struct SAlterDatabaseStmt {
 
 typedef struct STableOptions {
   ENodeType  type;
-  SNodeList* pKeep;
-  SValueNode* pTtl;
-  SValueNode* pComments;
+  char       comment[TSDB_STB_COMMENT_LEN];
+  int32_t    delay;
+  float      filesFactor;
+  SNodeList* pRollupFuncs;
+  int32_t    ttl;
   SNodeList* pSma;
-  SNodeList* pFuncs;
-  SValueNode* pFilesFactor;
-  SValueNode* pDelay;
 } STableOptions;
 
 typedef struct SColumnDefNode {
@@ -201,10 +201,7 @@ typedef struct SShowCreatStmt {
   char      tableName[TSDB_TABLE_NAME_LEN];
 } SShowCreatStmt;
 
-typedef enum EIndexType {
-  INDEX_TYPE_SMA = 1,
-  INDEX_TYPE_FULLTEXT
-} EIndexType;
+typedef enum EIndexType { INDEX_TYPE_SMA = 1, INDEX_TYPE_FULLTEXT } EIndexType;
 
 typedef struct SIndexOptions {
   ENodeType  type;

include/libs/nodes/plannodes.h

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

include/libs/parser/parser.h

@@ -73,6 +73,7 @@ typedef struct SQuery {
   SArray* pDbList;
   SArray* pTableList;
   bool showRewrite;
+  int32_t placeholderNum;
 } SQuery;
 
 int32_t qParseQuerySql(SParseContext* pCxt, SQuery** pQuery);

include/libs/planner/planner.h

@@ -34,7 +34,7 @@ typedef struct SPlanContext {
   bool showRewrite;
   int8_t triggerType;
   int64_t watermark;
-  bool isStmtQuery;
+  int32_t placeholderNum;
   void* pTransporter;
   struct SCatalog* pCatalog;
   char* pMsg;
@@ -50,7 +50,7 @@ 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);
 
-int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx);
+int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx, uint64_t queryId);
 
 // Convert to subplan to string for the scheduler to send to the executor
 int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen);

include/libs/stream/tstreamUpdate.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _TSTREAMUPDATE_H_
+#define _TSTREAMUPDATE_H_
+
+#include "taosdef.h"
+#include "tarray.h"
+#include "tmsg.h"
+#include "tscalablebf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SUpdateInfo {
+  SArray *pTsBuckets;
+  uint64_t numBuckets;
+  SArray *pTsSBFs;
+  uint64_t numSBFs;
+  int64_t interval;
+  int64_t watermark;
+  TSKEY minTS;
+} SUpdateInfo;
+
+SUpdateInfo *updateInfoInitP(SInterval* pInterval, int64_t watermark);
+SUpdateInfo *updateInfoInit(int64_t interval, int32_t precision, int64_t watermark);
+bool isUpdated(SUpdateInfo *pInfo, tb_uid_t tableId, TSKEY ts);
+void updateInfoDestroy(SUpdateInfo *pInfo);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _TSTREAMUPDATE_H_ */
\ No newline at end of file

include/util/taoserror.h

@@ -586,7 +586,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_RANGE_OPTION      TAOS_DEF_ERROR_CODE(0, 0x2619)
 #define TSDB_CODE_PAR_INVALID_STR_OPTION        TAOS_DEF_ERROR_CODE(0, 0x261A)
 #define TSDB_CODE_PAR_INVALID_ENUM_OPTION       TAOS_DEF_ERROR_CODE(0, 0x261B)
-#define TSDB_CODE_PAR_INVALID_TTL_OPTION        TAOS_DEF_ERROR_CODE(0, 0x261C)
 #define TSDB_CODE_PAR_INVALID_KEEP_NUM          TAOS_DEF_ERROR_CODE(0, 0x261D)
 #define TSDB_CODE_PAR_INVALID_KEEP_ORDER        TAOS_DEF_ERROR_CODE(0, 0x261E)
 #define TSDB_CODE_PAR_INVALID_KEEP_VALUE        TAOS_DEF_ERROR_CODE(0, 0x261F)

include/util/tarray.h

@@ -218,6 +218,13 @@ void taosArrayClear(SArray* pArray);
  */
 void taosArrayClearEx(SArray* pArray, void (*fp)(void*));
 
+/**
+ * clear the array (remove all element)
+ * @param pArray
+ * @param fp
+ */
+void taosArrayClearP(SArray* pArray, FDelete fp);
+
 void* taosArrayDestroy(SArray* pArray);
 void  taosArrayDestroyP(SArray* pArray, FDelete fp);
 void  taosArrayDestroyEx(SArray* pArray, FDelete fp);

include/util/tbloomfilter.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_UTIL_BLOOMFILTER_H_
+#define _TD_UTIL_BLOOMFILTER_H_
+
+#include "os.h"
+#include "thash.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SBloomFilter {
+  uint32_t hashFunctions;
+  uint64_t expectedEntries;
+  uint64_t numUnits;
+  uint64_t numBits;
+  uint64_t size;
+  _hash_fn_t hashFn1;
+  _hash_fn_t hashFn2;
+  void *buffer;
+  double errorRate;
+} SBloomFilter;
+
+SBloomFilter *tBloomFilterInit(uint64_t expectedEntries, double errorRate);
+int32_t tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len);
+int32_t tBloomFilterNoContain(const SBloomFilter *pBF, const void *keyBuf,
+                              uint32_t len);
+void tBloomFilterDestroy(SBloomFilter *pBF);
+void tBloomFilterDump(const SBloomFilter *pBF);
+bool tBloomFilterIsFull(const SBloomFilter *pBF);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_UTIL_BLOOMFILTER_H_*/
\ No newline at end of file

include/util/tdef.h

@@ -350,8 +350,6 @@ typedef enum ELogicConditionType {
 #define TSDB_MIN_FSYNC_PERIOD           0
 #define TSDB_MAX_FSYNC_PERIOD           180000  // millisecond
 #define TSDB_DEFAULT_FSYNC_PERIOD       3000    // three second
-#define TSDB_MIN_DB_TTL               1
-#define TSDB_DEFAULT_DB_TTL           1
 #define TSDB_MIN_WAL_LEVEL              1
 #define TSDB_MAX_WAL_LEVEL              2
 #define TSDB_DEFAULT_WAL_LEVEL          1
@@ -379,13 +377,23 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_SINGLE_STABLE_ON        0
 #define TSDB_DB_SINGLE_STABLE_OFF       1
 #define TSDB_DEFAULT_DB_SINGLE_STABLE   0
+#define TSDB_MIN_BUFFER_PER_VNODE       3  // unit MB
+#define TSDB_DEFAULT_BUFFER_PER_VNODE   96
+#define TSDB_MIN_PAGES_PER_VNODE        64
+#define TSDB_DEFAULT_PAGES_PER_VNODE    256
+#define TSDB_MIN_PAGESIZE_PER_VNODE     1  // unit KB
+#define TSDB_MAX_PAGESIZE_PER_VNODE     16384
+#define TSDB_DEFAULT_PAGESIZE_PER_VNODE 4
+
+#define TSDB_MIN_ROLLUP_FILE_FACTOR     0
+#define TSDB_MAX_ROLLUP_FILE_FACTOR     1
+#define TSDB_DEFAULT_ROLLUP_FILE_FACTOR 0.1
+#define TSDB_MIN_ROLLUP_DELAY           1
+#define TSDB_MAX_ROLLUP_DELAY           10
+#define TSDB_DEFAULT_ROLLUP_DELAY       2
+#define TSDB_MIN_TABLE_TTL              0
+#define TSDB_DEFAULT_TABLE_TTL          0
 
-#define TSDB_MIN_DB_FILE_FACTOR     0
-#define TSDB_MAX_DB_FILE_FACTOR     1
-#define TSDB_DEFAULT_DB_FILE_FACTOR 0.1
-#define TSDB_MIN_DB_DELAY           1
-#define TSDB_MAX_DB_DELAY           10
-#define TSDB_DEFAULT_DB_DELAY       2
 #define TSDB_MIN_EXPLAIN_RATIO     0
 #define TSDB_MAX_EXPLAIN_RATIO     1
 #define TSDB_DEFAULT_EXPLAIN_RATIO 0.001

include/util/tscalablebf.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_UTIL_SCALABLEBF_H_
+#define _TD_UTIL_SCALABLEBF_H_
+
+#include "tbloomfilter.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SScalableBf {
+  SArray *bfArray; // array of bloom filters
+  uint32_t growth;
+  uint64_t numBits;
+} SScalableBf;
+
+SScalableBf *tScalableBfInit(uint64_t expectedEntries, double errorRate);
+int32_t tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len);
+int32_t tScalableBfNoContain(const SScalableBf *pSBf, const void *keyBuf,
+                             uint32_t len);
+void tScalableBfDestroy(SScalableBf *pSBf);
+void tScalableBfDump(const SScalableBf *pSBf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_UTIL_SCALABLEBF_H_*/
\ No newline at end of file

source/client/inc/clientStmt.h

@@ -46,6 +46,12 @@ typedef struct SStmtTableCache {
   void*             boundTags;
 } SStmtTableCache;
 
+typedef struct SQueryFields {
+  TAOS_FIELD*    fields;
+  TAOS_FIELD*    userFields;
+  uint32_t       numOfCols;
+} SQueryFields;
+
 typedef struct SStmtBindInfo {
   bool         needParse;
   uint64_t     tbUid;
@@ -76,6 +82,7 @@ typedef struct SStmtSQLInfo {
   int32_t       sqlLen;
   SArray*       nodeList;
   SQueryPlan*   pQueryPlan;
+  SQueryFields  fields;
 } SStmtSQLInfo;
 
 typedef struct STscStmt {

source/client/src/clientImpl.c

@@ -234,7 +234,8 @@ int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArra
                       .showRewrite = pQuery->showRewrite,
                       .pTransporter = pRequest->pTscObj->pAppInfo->pTransporter,
                       .pMsg = pRequest->msgBuf,
-                      .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE};
+                      .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE,
+                      .placeholderNum = pQuery->placeholderNum};
   int32_t      code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &cxt.pCatalog);
   if (TSDB_CODE_SUCCESS == code) {
     code = qCreateQueryPlan(&cxt, pPlan, pNodeList);

source/client/src/clientStmt.c

@@ -73,6 +73,22 @@ int32_t stmtGetTbName(TAOS_STMT *stmt, char **tbName) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t stmtBackupQueryFields(STscStmt* pStmt) {
+  SQueryFields *pFields = &pStmt->sql.fields;
+  int32_t size = pFields->numOfCols * sizeof(TAOS_FIELD);
+  
+  pFields->numOfCols = pStmt->exec.pRequest->body.resInfo.numOfCols;
+  pFields->fields = taosMemoryMalloc(size);
+  pFields->userFields = taosMemoryMalloc(size);
+  if (NULL == pFields->fields || NULL == pFields->userFields) {
+    STMT_ERR_RET(TSDB_CODE_TSC_OUT_OF_MEMORY);
+  }
+  memcpy(pFields->fields, pStmt->exec.pRequest->body.resInfo.fields, size);
+  memcpy(pFields->userFields, pStmt->exec.pRequest->body.resInfo.userFields, size);
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t stmtSetBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
@@ -258,37 +274,42 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
   STableMeta *pTableMeta = NULL;
   SEpSet ep = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
   STMT_ERR_RET(catalogGetTableMeta(pStmt->pCatalog, pStmt->taos->pAppInfo->pTransporter, &ep, &pStmt->bInfo.sname, &pTableMeta));
+  uint64_t uid = pTableMeta->uid;
+  uint64_t suid = pTableMeta->suid;
+  int8_t tableType = pTableMeta->tableType;
+  taosMemoryFree(pTableMeta);
   
-  if (pTableMeta->uid == pStmt->bInfo.tbUid) {
+  if (uid == pStmt->bInfo.tbUid) {
     pStmt->bInfo.needParse = false;
 
     return TSDB_CODE_SUCCESS;
   }
 
-  if (taosHashGet(pStmt->exec.pBlockHash, &pTableMeta->uid, sizeof(pTableMeta->uid))) {
-    SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &pTableMeta->uid, sizeof(pTableMeta->uid));
+  if (taosHashGet(pStmt->exec.pBlockHash, &uid, sizeof(uid))) {
+    SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &uid, sizeof(uid));
     if (NULL == pCache) {
-      tscError("table uid %" PRIx64 "found in exec blockHash, but not in sql blockHash", pTableMeta->uid);
+      tscError("table uid %" PRIx64 "found in exec blockHash, but not in sql blockHash", uid);
+      
       STMT_ERR_RET(TSDB_CODE_TSC_APP_ERROR);
     }
     
     pStmt->bInfo.needParse = false;
     
-    pStmt->bInfo.tbUid = pTableMeta->uid;
-    pStmt->bInfo.tbSuid = pTableMeta->suid;
-    pStmt->bInfo.tbType = pTableMeta->tableType;
+    pStmt->bInfo.tbUid = uid;
+    pStmt->bInfo.tbSuid = suid;
+    pStmt->bInfo.tbType = tableType;
     pStmt->bInfo.boundTags = pCache->boundTags;
 
     return TSDB_CODE_SUCCESS;
   }
 
-  SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &pTableMeta->uid, sizeof(pTableMeta->uid));
+  SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &uid, sizeof(uid));
   if (pCache) {
     pStmt->bInfo.needParse = false;
 
-    pStmt->bInfo.tbUid = pTableMeta->uid;
-    pStmt->bInfo.tbSuid = pTableMeta->suid;
-    pStmt->bInfo.tbType = pTableMeta->tableType;
+    pStmt->bInfo.tbUid = uid;
+    pStmt->bInfo.tbSuid = suid;
+    pStmt->bInfo.tbType = tableType;
     pStmt->bInfo.boundTags = pCache->boundTags;
 
     STableDataBlocks* pNewBlock = NULL;
@@ -475,9 +496,10 @@ int stmtBindBatch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int32_t colIdx) {
       STMT_ERR_RET(getQueryPlan(pStmt->exec.pRequest, pStmt->sql.pQuery, &pStmt->sql.nodeList));
       pStmt->sql.pQueryPlan = pStmt->exec.pRequest->body.pDag;
       pStmt->exec.pRequest->body.pDag = NULL;
+      STMT_ERR_RET(stmtBackupQueryFields(pStmt));
     }
     
-    STMT_RET(qStmtBindParam(pStmt->sql.pQueryPlan, bind, colIdx));
+    STMT_RET(qStmtBindParam(pStmt->sql.pQueryPlan, bind, colIdx, pStmt->exec.pRequest->requestId));
   }
   
   STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, (const char*)&pStmt->bInfo.tbUid, sizeof(pStmt->bInfo.tbUid));
@@ -549,6 +571,8 @@ int stmtClose(TAOS_STMT *stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
   STMT_RET(stmtCleanSQLInfo(pStmt));
+
+  taosMemoryFree(stmt);
 }
 
 const char *stmtErrstr(TAOS_STMT *stmt) {
@@ -601,7 +625,7 @@ int stmtGetParamNum(TAOS_STMT *stmt, int *nums) {
       pStmt->exec.pRequest->body.pDag = NULL;
     }
 
-    *nums = (pStmt->sql.pQueryPlan->pPlaceholderValues) ? pStmt->sql.pQueryPlan->pPlaceholderValues->length : 0;
+    *nums = taosArrayGetSize(pStmt->sql.pQueryPlan->pPlaceholderValues);
   } else {
     STMT_ERR_RET(stmtFetchColFields(stmt, nums, NULL));
   }

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -107,7 +107,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
 
   pCfg->vgId = pCreate->vgId;
   strcpy(pCfg->dbname, pCreate->db);
-  pCfg->szBuf = pCreate->cacheBlockSize * 1024 * 1024;
+  // pCfg->szBuf = pCreate->cacheBlockSize * 1024 * 1024;
   pCfg->streamMode = pCreate->streamMode;
   pCfg->isWeak = true;
   pCfg->tsdbCfg.days = 10;

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

@@ -268,8 +268,10 @@ static int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {
 
 static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   if (pCfg->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pCfg->numOfVgroups > TSDB_MAX_VNODES_PER_DB) return -1;
+  /*
   if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) return -1;
   if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) return -1;
+  */
   if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return -1;
   if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return -1;
   if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return -1;
@@ -282,7 +284,7 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   if (pCfg->minRows > pCfg->maxRows) return -1;
   if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) return -1;
   if (pCfg->fsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->fsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return -1;
-  if (pCfg->ttl < TSDB_MIN_DB_TTL) return -1;
+  // if (pCfg->ttl < TSDB_MIN_TABLE_TTL) return -1;
   if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return -1;
   if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return -1;
   if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return -1;
@@ -310,7 +312,7 @@ static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAXROWS_FBLOCK;
   if (pCfg->commitTime < 0) pCfg->commitTime = TSDB_DEFAULT_COMMIT_TIME;
   if (pCfg->fsyncPeriod < 0) pCfg->fsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;
-  if (pCfg->ttl < 0) pCfg->ttl = TSDB_DEFAULT_DB_TTL;
+  if (pCfg->ttl < 0) pCfg->ttl = TSDB_DEFAULT_TABLE_TTL;
   if (pCfg->walLevel < 0) pCfg->walLevel = TSDB_DEFAULT_WAL_LEVEL;
   if (pCfg->precision < 0) pCfg->precision = TSDB_DEFAULT_PRECISION;
   if (pCfg->compression < 0) pCfg->compression = TSDB_DEFAULT_COMP_LEVEL;

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

@@ -1490,6 +1490,10 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
     pSchema1 = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), uid, TD_ROW_SVER(row1));
   }
 
+#ifdef TD_DEBUG_PRINT_ROW
+  tdSRowPrint(row1, pSchema1, __func__);
+#endif
+
   if (isRow1DataRow) {
     numOfColsOfRow1 = schemaNCols(pSchema1);
   } else {

source/libs/nodes/src/nodesTraverseFuncs.c

@@ -423,6 +423,9 @@ static EDealRes dispatchPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalk
   EDealRes res = DEAL_RES_CONTINUE;
 
   switch (nodeType(pNode)) {
+    case QUERY_NODE_NODE_LIST:
+      res = walkPhysiPlans(((SNodeListNode*)pNode)->pNodeList, order, walker, pContext);
+      break;
     case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
       res = walkScanPhysi((SScanPhysiNode*)pNode, order, walker, pContext);
       break;
@@ -534,10 +537,7 @@ static EDealRes dispatchPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalk
       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);
       }

source/libs/nodes/src/nodesUtilFuncs.c

@@ -389,21 +389,25 @@ void nodesDestroyNode(SNodeptr pNode) {
     case QUERY_NODE_COLUMN_DEF:         // no pointer field
     case QUERY_NODE_DOWNSTREAM_SOURCE:  // no pointer field
       break;
-    case QUERY_NODE_DATABASE_OPTIONS:
-      nodesDestroyList(((SDatabaseOptions*)pNode)->pRetentions);
+    case QUERY_NODE_DATABASE_OPTIONS: {
+      SDatabaseOptions* pOptions = (SDatabaseOptions*)pNode;
+      nodesDestroyNode(pOptions->pDaysPerFile);
+      nodesDestroyList(pOptions->pKeep);
+      nodesDestroyList(pOptions->pRetentions);
       break;
+    }
     case QUERY_NODE_TABLE_OPTIONS: {
-      STableOptions* pStmt = (STableOptions*)pNode;
-      nodesDestroyList(pStmt->pSma);
-      nodesDestroyList(pStmt->pFuncs);
+      STableOptions* pOptions = (STableOptions*)pNode;
+      nodesDestroyList(pOptions->pSma);
+      nodesDestroyList(pOptions->pRollupFuncs);
       break;
     }
     case QUERY_NODE_INDEX_OPTIONS: {
-      SIndexOptions* pStmt = (SIndexOptions*)pNode;
-      nodesDestroyList(pStmt->pFuncs);
-      nodesDestroyNode(pStmt->pInterval);
-      nodesDestroyNode(pStmt->pOffset);
-      nodesDestroyNode(pStmt->pSliding);
+      SIndexOptions* pOptions = (SIndexOptions*)pNode;
+      nodesDestroyList(pOptions->pFuncs);
+      nodesDestroyNode(pOptions->pInterval);
+      nodesDestroyNode(pOptions->pOffset);
+      nodesDestroyNode(pOptions->pSliding);
       break;
     }
     case QUERY_NODE_SET_OPERATOR: {

source/libs/parser/inc/parAst.h

@@ -36,8 +36,7 @@ typedef struct SAstCreateContext {
 } SAstCreateContext;
 
 typedef enum EDatabaseOptionType {
-  DB_OPTION_BLOCKS = 1,
-  DB_OPTION_CACHE,
+  DB_OPTION_BUFFER = 1,
   DB_OPTION_CACHELAST,
   DB_OPTION_COMP,
   DB_OPTION_DAYS,
@@ -45,30 +44,29 @@ typedef enum EDatabaseOptionType {
   DB_OPTION_MAXROWS,
   DB_OPTION_MINROWS,
   DB_OPTION_KEEP,
+  DB_OPTION_PAGES,
+  DB_OPTION_PAGESIZE,
   DB_OPTION_PRECISION,
-  DB_OPTION_QUORUM,
   DB_OPTION_REPLICA,
-  DB_OPTION_TTL,
+  DB_OPTION_STRICT,
   DB_OPTION_WAL,
   DB_OPTION_VGROUPS,
   DB_OPTION_SINGLE_STABLE,
-  DB_OPTION_STREAM_MODE,
-  DB_OPTION_STRICT,
   DB_OPTION_RETENTIONS
 } EDatabaseOptionType;
 
 typedef enum ETableOptionType {
-  TABLE_OPTION_KEEP = 1,
-  TABLE_OPTION_TTL,
-  TABLE_OPTION_COMMENT,
-  TABLE_OPTION_SMA,
+  TABLE_OPTION_COMMENT = 1,
+  TABLE_OPTION_DELAY,
   TABLE_OPTION_FILE_FACTOR,
-  TABLE_OPTION_DELAY
+  TABLE_OPTION_ROLLUP,
+  TABLE_OPTION_TTL,
+  TABLE_OPTION_SMA
 } ETableOptionType;
 
 typedef struct SAlterOption {
   int32_t    type;
-  SValueNode* pVal;
+  SToken     val;
   SNodeList* pList;
 } SAlterOption;
 
@@ -121,25 +119,29 @@ SNode* addLimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit);
 SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable);
 SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight);
 
-SNode*    createDatabaseOptions(SAstCreateContext* pCxt);
-SNode*    setDatabaseAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
+SDataType createDataType(uint8_t type);
+SDataType createVarLenDataType(uint8_t type, const SToken* pLen);
+
+SNode* createDefaultDatabaseOptions(SAstCreateContext* pCxt);
+SNode* createAlterDatabaseOptions(SAstCreateContext* pCxt);
+SNode* setDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, EDatabaseOptionType type, void* pVal);
+SNode* setAlterDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
 SNode* createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken* pDbName, SNode* pOptions);
 SNode* createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken* pDbName);
 SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pOptions);
-SNode*    createTableOptions(SAstCreateContext* pCxt);
-SNode*    setTableAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
+SNode* createDefaultTableOptions(SAstCreateContext* pCxt);
+SNode* createAlterTableOptions(SAstCreateContext* pCxt);
+SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal);
 SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, const SToken* pComment);
-SDataType createDataType(uint8_t type);
-SDataType createVarLenDataType(uint8_t type, const SToken* pLen);
 SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNodeList* pCols,
                              SNodeList* pTags, SNode* pOptions);
 SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable,
-                                  SNodeList* pSpecificTags, SNodeList* pValsOfTags);
+                                  SNodeList* pSpecificTags, SNodeList* pValsOfTags, SNode* pOptions);
 SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables);
 SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable);
 SNode* createDropTableStmt(SAstCreateContext* pCxt, SNodeList* pTables);
 SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable);
-SNode* createAlterTableOption(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions);
+SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions);
 SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType,
                                     const SToken* pColName, SDataType dataType);
 SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, const SToken* pColName);

source/libs/parser/inc/sql.y

@@ -137,43 +137,41 @@ not_exists_opt(A) ::= .
 exists_opt(A) ::= IF EXISTS.                                                      { A = true; }
 exists_opt(A) ::= .                                                               { A = false; }
 
-db_options(A) ::= .                                                               { A = createDatabaseOptions(pCxt); }
-db_options(A) ::= db_options(B) BLOCKS NK_INTEGER(C).                             { ((SDatabaseOptions*)B)->pNumOfBlocks = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) CACHE NK_INTEGER(C).                              { ((SDatabaseOptions*)B)->pCacheBlockSize = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) CACHELAST NK_INTEGER(C).                          { ((SDatabaseOptions*)B)->pCachelast = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) COMP NK_INTEGER(C).                               { ((SDatabaseOptions*)B)->pCompressionLevel = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) DAYS NK_INTEGER(C).                               { ((SDatabaseOptions*)B)->pDaysPerFile = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) DAYS NK_VARIABLE(C).                              { ((SDatabaseOptions*)B)->pDaysPerFile = (SValueNode*)createDurationValueNode(pCxt, &C); A = B; }
-db_options(A) ::= db_options(B) FSYNC NK_INTEGER(C).                              { ((SDatabaseOptions*)B)->pFsyncPeriod = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) MAXROWS NK_INTEGER(C).                            { ((SDatabaseOptions*)B)->pMaxRowsPerBlock = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) MINROWS NK_INTEGER(C).                            { ((SDatabaseOptions*)B)->pMinRowsPerBlock = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) KEEP integer_list(C).                             { ((SDatabaseOptions*)B)->pKeep = C; A = B; }
-db_options(A) ::= db_options(B) KEEP variable_list(C).                            { ((SDatabaseOptions*)B)->pKeep = C; A = B; }
-db_options(A) ::= db_options(B) PRECISION NK_STRING(C).                           { ((SDatabaseOptions*)B)->pPrecision = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &C); A = B; }
-db_options(A) ::= db_options(B) QUORUM NK_INTEGER(C).                             { ((SDatabaseOptions*)B)->pQuorum = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) REPLICA NK_INTEGER(C).                            { ((SDatabaseOptions*)B)->pReplica = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) TTL NK_INTEGER(C).                                { ((SDatabaseOptions*)B)->pTtl = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) WAL NK_INTEGER(C).                                { ((SDatabaseOptions*)B)->pWalLevel = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) VGROUPS NK_INTEGER(C).                            { ((SDatabaseOptions*)B)->pNumOfVgroups = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) SINGLE_STABLE NK_INTEGER(C).                      { ((SDatabaseOptions*)B)->pSingleStable = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) STREAM_MODE NK_INTEGER(C).                        { ((SDatabaseOptions*)B)->pStreamMode = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-db_options(A) ::= db_options(B) RETENTIONS retention_list(C).                     { ((SDatabaseOptions*)B)->pRetentions = C; A = B; }
-db_options(A) ::= db_options(B) STRICT NK_INTEGER(C).                             { ((SDatabaseOptions*)B)->pStrict = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-
-alter_db_options(A) ::= alter_db_option(B).                                       { A = createDatabaseOptions(pCxt); A = setDatabaseAlterOption(pCxt, A, &B); }
-alter_db_options(A) ::= alter_db_options(B) alter_db_option(C).                   { A = setDatabaseAlterOption(pCxt, B, &C); }
+db_options(A) ::= .                                                               { A = createDefaultDatabaseOptions(pCxt); }
+db_options(A) ::= db_options(B) BUFFER NK_INTEGER(C).                             { A = setDatabaseOption(pCxt, B, DB_OPTION_BUFFER, &C); }
+db_options(A) ::= db_options(B) CACHELAST NK_INTEGER(C).                          { A = setDatabaseOption(pCxt, B, DB_OPTION_CACHELAST, &C); }
+db_options(A) ::= db_options(B) COMP NK_INTEGER(C).                               { A = setDatabaseOption(pCxt, B, DB_OPTION_COMP, &C); }
+db_options(A) ::= db_options(B) DAYS NK_INTEGER(C).                               { A = setDatabaseOption(pCxt, B, DB_OPTION_DAYS, &C); }
+db_options(A) ::= db_options(B) DAYS NK_VARIABLE(C).                              { A = setDatabaseOption(pCxt, B, DB_OPTION_DAYS, &C); }
+db_options(A) ::= db_options(B) FSYNC NK_INTEGER(C).                              { A = setDatabaseOption(pCxt, B, DB_OPTION_FSYNC, &C); }
+db_options(A) ::= db_options(B) MAXROWS NK_INTEGER(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_MAXROWS, &C); }
+db_options(A) ::= db_options(B) MINROWS NK_INTEGER(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_MINROWS, &C); }
+db_options(A) ::= db_options(B) KEEP integer_list(C).                             { A = setDatabaseOption(pCxt, B, DB_OPTION_KEEP, C); }
+db_options(A) ::= db_options(B) KEEP variable_list(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_KEEP, C); }
+db_options(A) ::= db_options(B) PAGES NK_INTEGER(C).                              { A = setDatabaseOption(pCxt, B, DB_OPTION_PAGES, &C); }
+db_options(A) ::= db_options(B) PAGESIZE NK_INTEGER(C).                           { A = setDatabaseOption(pCxt, B, DB_OPTION_PAGESIZE, &C); }
+db_options(A) ::= db_options(B) PRECISION NK_STRING(C).                           { A = setDatabaseOption(pCxt, B, DB_OPTION_PRECISION, &C); }
+db_options(A) ::= db_options(B) REPLICA NK_INTEGER(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_REPLICA, &C); }
+db_options(A) ::= db_options(B) STRICT NK_INTEGER(C).                             { A = setDatabaseOption(pCxt, B, DB_OPTION_STRICT, &C); }
+db_options(A) ::= db_options(B) WAL NK_INTEGER(C).                                { A = setDatabaseOption(pCxt, B, DB_OPTION_WAL, &C); }
+db_options(A) ::= db_options(B) VGROUPS NK_INTEGER(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_VGROUPS, &C); }
+db_options(A) ::= db_options(B) SINGLE_STABLE NK_INTEGER(C).                      { A = setDatabaseOption(pCxt, B, DB_OPTION_SINGLE_STABLE, &C); }
+db_options(A) ::= db_options(B) RETENTIONS retention_list(C).                     { A = setDatabaseOption(pCxt, B, DB_OPTION_RETENTIONS, C); }
+
+alter_db_options(A) ::= alter_db_option(B).                                       { A = createAlterDatabaseOptions(pCxt); A = setAlterDatabaseOption(pCxt, A, &B); }
+alter_db_options(A) ::= alter_db_options(B) alter_db_option(C).                   { A = setAlterDatabaseOption(pCxt, B, &C); }
 
 %type alter_db_option                                                             { SAlterOption }
 %destructor alter_db_option                                                       { }
-alter_db_option(A) ::= BLOCKS NK_INTEGER(B).                                      { A.type = DB_OPTION_BLOCKS; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
-alter_db_option(A) ::= FSYNC NK_INTEGER(B).                                       { A.type = DB_OPTION_FSYNC; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
+alter_db_option(A) ::= BUFFER NK_INTEGER(B).                                      { A.type = DB_OPTION_BUFFER; A.val = B; }
+alter_db_option(A) ::= CACHELAST NK_INTEGER(B).                                   { A.type = DB_OPTION_CACHELAST; A.val = B; }
+alter_db_option(A) ::= FSYNC NK_INTEGER(B).                                       { A.type = DB_OPTION_FSYNC; A.val = B; }
 alter_db_option(A) ::= KEEP integer_list(B).                                      { A.type = DB_OPTION_KEEP; A.pList = B; }
 alter_db_option(A) ::= KEEP variable_list(B).                                     { A.type = DB_OPTION_KEEP; A.pList = B; }
-alter_db_option(A) ::= WAL NK_INTEGER(B).                                         { A.type = DB_OPTION_WAL; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
-alter_db_option(A) ::= QUORUM NK_INTEGER(B).                                      { A.type = DB_OPTION_QUORUM; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
-alter_db_option(A) ::= CACHELAST NK_INTEGER(B).                                   { A.type = DB_OPTION_CACHELAST; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
-alter_db_option(A) ::= REPLICA NK_INTEGER(B).                                     { A.type = DB_OPTION_REPLICA; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
-alter_db_option(A) ::= STRICT NK_INTEGER(B).                                      { A.type = DB_OPTION_STRICT; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
+alter_db_option(A) ::= PAGES NK_INTEGER(B).                                       { A.type = DB_OPTION_PAGES; A.val = B; }
+alter_db_option(A) ::= REPLICA NK_INTEGER(B).                                     { A.type = DB_OPTION_REPLICA; A.val = B; }
+alter_db_option(A) ::= STRICT NK_INTEGER(B).                                      { A.type = DB_OPTION_STRICT; A.val = B; }
+alter_db_option(A) ::= WAL NK_INTEGER(B).                                         { A.type = DB_OPTION_WAL; A.val = B; }
 
 %type integer_list                                                                { SNodeList* }
 %destructor integer_list                                                          { nodesDestroyList($$); }
@@ -204,7 +202,7 @@ cmd ::= DROP STABLE exists_opt(A) full_table_name(B).
 cmd ::= ALTER TABLE alter_table_clause(A).                                        { pCxt->pRootNode = A; }
 cmd ::= ALTER STABLE alter_table_clause(A).                                       { pCxt->pRootNode = A; }
 
-alter_table_clause(A) ::= full_table_name(B) alter_table_options(C).              { A = createAlterTableOption(pCxt, B, C); }
+alter_table_clause(A) ::= full_table_name(B) alter_table_options(C).              { A = createAlterTableModifyOptions(pCxt, B, C); }
 alter_table_clause(A) ::=
   full_table_name(B) ADD COLUMN column_name(C) type_name(D).                      { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_ADD_COLUMN, &C, D); }
 alter_table_clause(A) ::= full_table_name(B) DROP COLUMN column_name(C).          { A = createAlterTableDropCol(pCxt, B, TSDB_ALTER_TABLE_DROP_COLUMN, &C); }
@@ -229,7 +227,7 @@ multi_create_clause(A) ::= multi_create_clause(B) create_subtable_clause(C).
 
 create_subtable_clause(A) ::=
   not_exists_opt(B) full_table_name(C) USING full_table_name(D)
-  specific_tags_opt(E) TAGS NK_LP literal_list(F) NK_RP.                          { A = createCreateSubTableClause(pCxt, B, C, D, E, F); }
+  specific_tags_opt(E) TAGS NK_LP literal_list(F) NK_RP table_options(G).         { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); }
 
 %type multi_drop_clause                                                           { SNodeList* }
 %destructor multi_drop_clause                                                     { nodesDestroyList($$); }
@@ -289,25 +287,21 @@ tags_def_opt(A) ::= tags_def(B).
 %destructor tags_def                                                              { nodesDestroyList($$); }
 tags_def(A) ::= TAGS NK_LP column_def_list(B) NK_RP.                              { A = B; }
 
-table_options(A) ::= .                                                            { A = createTableOptions(pCxt); }
-table_options(A) ::= table_options(B) COMMENT NK_STRING(C).                       { ((STableOptions*)B)->pComments = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &C); A = B; }
-table_options(A) ::= table_options(B) KEEP integer_list(C).                       { ((STableOptions*)B)->pKeep = C; A = B; }
-table_options(A) ::= table_options(B) KEEP variable_list(C).                      { ((STableOptions*)B)->pKeep = C; A = B; }
-table_options(A) ::= table_options(B) TTL NK_INTEGER(C).                          { ((STableOptions*)B)->pTtl = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
-table_options(A) ::= table_options(B) SMA NK_LP col_name_list(C) NK_RP.           { ((STableOptions*)B)->pSma = C; A = B; }
-table_options(A) ::= table_options(B) ROLLUP NK_LP func_name_list(C) NK_RP.       { ((STableOptions*)B)->pFuncs = C; A = B; }
-table_options(A) ::= table_options(B) FILE_FACTOR NK_FLOAT(C).                    { ((STableOptions*)B)->pFilesFactor = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &C); A = B; }
-table_options(A) ::= table_options(B) DELAY NK_INTEGER(C).                        { ((STableOptions*)B)->pDelay = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
+table_options(A) ::= .                                                            { A = createDefaultTableOptions(pCxt); }
+table_options(A) ::= table_options(B) COMMENT NK_STRING(C).                       { A = setTableOption(pCxt, B, TABLE_OPTION_COMMENT, &C); }
+table_options(A) ::= table_options(B) DELAY NK_INTEGER(C).                        { A = setTableOption(pCxt, B, TABLE_OPTION_DELAY, &C); }
+table_options(A) ::= table_options(B) FILE_FACTOR NK_FLOAT(C).                    { A = setTableOption(pCxt, B, TABLE_OPTION_FILE_FACTOR, &C); }
+table_options(A) ::= table_options(B) ROLLUP NK_LP func_name_list(C) NK_RP.       { A = setTableOption(pCxt, B, TABLE_OPTION_ROLLUP, C); }
+table_options(A) ::= table_options(B) TTL NK_INTEGER(C).                          { A = setTableOption(pCxt, B, TABLE_OPTION_TTL, &C); }
+table_options(A) ::= table_options(B) SMA NK_LP col_name_list(C) NK_RP.           { A = setTableOption(pCxt, B, TABLE_OPTION_SMA, C); }
 
-alter_table_options(A) ::= alter_table_option(B).                                 { A = createTableOptions(pCxt); A = setTableAlterOption(pCxt, A, &B); }
-alter_table_options(A) ::= alter_table_options(B) alter_table_option(C).          { A = setTableAlterOption(pCxt, B, &C); }
+alter_table_options(A) ::= alter_table_option(B).                                 { A = createAlterTableOptions(pCxt); A = setTableOption(pCxt, A, B.type, &B.val); }
+alter_table_options(A) ::= alter_table_options(B) alter_table_option(C).          { A = setTableOption(pCxt, B, C.type, &C.val); }
 
 %type alter_table_option                                                          { SAlterOption }
 %destructor alter_table_option                                                    { }
-alter_table_option(A) ::= COMMENT NK_STRING(B).                                   { A.type = TABLE_OPTION_COMMENT; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &B); }
-alter_table_option(A) ::= KEEP integer_list(B).                                   { A.type = TABLE_OPTION_KEEP; A.pList = B; }
-alter_table_option(A) ::= KEEP variable_list(B).                                  { A.type = TABLE_OPTION_KEEP; A.pList = B; }
-alter_table_option(A) ::= TTL NK_INTEGER(B).                                      { A.type = TABLE_OPTION_TTL; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
+alter_table_option(A) ::= COMMENT NK_STRING(B).                                   { A.type = TABLE_OPTION_COMMENT; A.val = B; }
+alter_table_option(A) ::= TTL NK_INTEGER(B).                                      { A.type = TABLE_OPTION_TTL; A.val = B; }
 
 %type col_name_list                                                               { SNodeList* }
 %destructor col_name_list                                                         { nodesDestroyList($$); }

source/libs/parser/src/parAstCreater.c

@@ -44,7 +44,13 @@ void initAstCreateContext(SParseContext* pParseCxt, SAstCreateContext* pCxt) {
   pCxt->notSupport = false;
   pCxt->valid = true;
   pCxt->pRootNode = NULL;
-  pCxt->placeholderNo = 1;
+  pCxt->placeholderNo = 0;
+}
+
+static void copyStringFormStringToken(SToken* pToken, char* pBuf, int32_t len) {
+  if (pToken->n > 2) {
+    strncpy(pBuf, pToken->z + 1, TMIN(pToken->n - 2, len - 1));
+  }
 }
 
 static void trimEscape(SToken* pName) {
@@ -309,7 +315,7 @@ SNode* createPlaceholderValueNode(SAstCreateContext* pCxt, const SToken* pLitera
   CHECK_OUT_OF_MEM(val);
   val->literal = strndup(pLiteral->z, pLiteral->n);
   CHECK_OUT_OF_MEM(val->literal);
-  val->placeholderNo = pCxt->placeholderNo++;
+  val->placeholderNo = ++pCxt->placeholderNo;
   return (SNode*)val;
 }
 
@@ -374,6 +380,11 @@ SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType d
   CHECK_OUT_OF_MEM(func);
   strcpy(func->functionName, "cast");
   func->node.resType = dt;
+  if (TSDB_DATA_TYPE_BINARY == dt.type) {
+     func->node.resType.bytes += 2;
+  } else if (TSDB_DATA_TYPE_NCHAR == dt.type) {
+    func->node.resType.bytes = func->node.resType.bytes * TSDB_NCHAR_SIZE + 2;
+  }  
   nodesListMakeAppend(&func->pParameterList, pExpr);
   return (SNode*)func;
 }
@@ -604,64 +615,113 @@ SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode*
   return (SNode*)setOp;
 }
 
-SNode* createDatabaseOptions(SAstCreateContext* pCxt) {
+SNode* createDefaultDatabaseOptions(SAstCreateContext* pCxt) {
   SDatabaseOptions* pOptions = nodesMakeNode(QUERY_NODE_DATABASE_OPTIONS);
   CHECK_OUT_OF_MEM(pOptions);
+  pOptions->buffer = TSDB_DEFAULT_BUFFER_PER_VNODE;
+  pOptions->cachelast = TSDB_DEFAULT_CACHE_LAST_ROW;
+  pOptions->compressionLevel = TSDB_DEFAULT_COMP_LEVEL;
+  pOptions->daysPerFile = TSDB_DEFAULT_DAYS_PER_FILE;
+  pOptions->fsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;
+  pOptions->maxRowsPerBlock = TSDB_DEFAULT_MAXROWS_FBLOCK;
+  pOptions->minRowsPerBlock = TSDB_DEFAULT_MINROWS_FBLOCK;
+  pOptions->keep[0] = TSDB_DEFAULT_KEEP;
+  pOptions->keep[1] = TSDB_DEFAULT_KEEP;
+  pOptions->keep[2] = TSDB_DEFAULT_KEEP;
+  pOptions->pages = TSDB_DEFAULT_PAGES_PER_VNODE;
+  pOptions->pagesize = TSDB_DEFAULT_PAGESIZE_PER_VNODE;
+  pOptions->precision = TSDB_DEFAULT_PRECISION;
+  pOptions->replica = TSDB_DEFAULT_DB_REPLICA;
+  pOptions->strict = TSDB_DEFAULT_DB_STRICT;
+  pOptions->walLevel = TSDB_DEFAULT_WAL_LEVEL;
+  pOptions->numOfVgroups = TSDB_DEFAULT_VN_PER_DB;
+  pOptions->singleStable = TSDB_DEFAULT_DB_SINGLE_STABLE;
   return (SNode*)pOptions;
 }
 
-SNode* setDatabaseAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption) {
-  switch (pAlterOption->type) {
-    case DB_OPTION_BLOCKS:
-      ((SDatabaseOptions*)pOptions)->pNumOfBlocks = pAlterOption->pVal;
-      break;
-    case DB_OPTION_CACHE:
-      ((SDatabaseOptions*)pOptions)->pCacheBlockSize = pAlterOption->pVal;
+SNode* createAlterDatabaseOptions(SAstCreateContext* pCxt) {
+  SDatabaseOptions* pOptions = nodesMakeNode(QUERY_NODE_DATABASE_OPTIONS);
+  CHECK_OUT_OF_MEM(pOptions);
+  pOptions->buffer = -1;
+  pOptions->cachelast = -1;
+  pOptions->compressionLevel = -1;
+  pOptions->daysPerFile = -1;
+  pOptions->fsyncPeriod = -1;
+  pOptions->maxRowsPerBlock = -1;
+  pOptions->minRowsPerBlock = -1;
+  pOptions->keep[0] = -1;
+  pOptions->keep[1] = -1;
+  pOptions->keep[2] = -1;
+  pOptions->pages = -1;
+  pOptions->pagesize = -1;
+  pOptions->precision = -1;
+  pOptions->replica = -1;
+  pOptions->strict = -1;
+  pOptions->walLevel = -1;
+  pOptions->numOfVgroups = -1;
+  pOptions->singleStable = -1;
+  return (SNode*)pOptions;
+}
+
+SNode* setDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, EDatabaseOptionType type, void* pVal) {
+  switch (type) {
+    case DB_OPTION_BUFFER:
+      ((SDatabaseOptions*)pOptions)->buffer = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_CACHELAST:
-      ((SDatabaseOptions*)pOptions)->pCachelast = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->cachelast = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_COMP:
-      ((SDatabaseOptions*)pOptions)->pCompressionLevel = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->compressionLevel = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
-    case DB_OPTION_DAYS:
-      ((SDatabaseOptions*)pOptions)->pDaysPerFile = pAlterOption->pVal;
+    case DB_OPTION_DAYS: {
+      SToken* pToken = pVal;
+      if (TK_NK_INTEGER == pToken->type) {
+        ((SDatabaseOptions*)pOptions)->daysPerFile = strtol(pToken->z, NULL, 10);
+      } else {
+        ((SDatabaseOptions*)pOptions)->pDaysPerFile = (SValueNode*)createDurationValueNode(pCxt, pToken);
+      }
       break;
+    }
     case DB_OPTION_FSYNC:
-      ((SDatabaseOptions*)pOptions)->pFsyncPeriod = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->fsyncPeriod = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_MAXROWS:
-      ((SDatabaseOptions*)pOptions)->pMaxRowsPerBlock = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->maxRowsPerBlock = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_MINROWS:
-      ((SDatabaseOptions*)pOptions)->pMinRowsPerBlock = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->minRowsPerBlock = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_KEEP:
-      ((SDatabaseOptions*)pOptions)->pKeep = pAlterOption->pList;
+      ((SDatabaseOptions*)pOptions)->pKeep = pVal;
+      break;
+    case DB_OPTION_PAGES:
+      ((SDatabaseOptions*)pOptions)->pages = strtol(((SToken*)pVal)->z, NULL, 10);
+      break;
+    case DB_OPTION_PAGESIZE:
+      ((SDatabaseOptions*)pOptions)->pagesize = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_PRECISION:
-      ((SDatabaseOptions*)pOptions)->pPrecision = pAlterOption->pVal;
+      copyStringFormStringToken((SToken*)pVal, ((SDatabaseOptions*)pOptions)->precisionStr,
+                                sizeof(((SDatabaseOptions*)pOptions)->precisionStr));
       break;
     case DB_OPTION_REPLICA:
-      ((SDatabaseOptions*)pOptions)->pReplica = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->replica = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
-    case DB_OPTION_TTL:
-      ((SDatabaseOptions*)pOptions)->pTtl = pAlterOption->pVal;
+    case DB_OPTION_STRICT:
+      ((SDatabaseOptions*)pOptions)->strict = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_WAL:
-      ((SDatabaseOptions*)pOptions)->pWalLevel = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->walLevel = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_VGROUPS:
-      ((SDatabaseOptions*)pOptions)->pNumOfVgroups = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->numOfVgroups = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_SINGLE_STABLE:
-      ((SDatabaseOptions*)pOptions)->pSingleStable = pAlterOption->pVal;
-      break;
-    case DB_OPTION_STREAM_MODE:
-      ((SDatabaseOptions*)pOptions)->pStreamMode = pAlterOption->pVal;
+      ((SDatabaseOptions*)pOptions)->singleStable = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_RETENTIONS:
-      ((SDatabaseOptions*)pOptions)->pRetentions = pAlterOption->pList;
+      ((SDatabaseOptions*)pOptions)->pRetentions = pVal;
       break;
     default:
       break;
@@ -669,6 +729,17 @@ SNode* setDatabaseAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOp
   return pOptions;
 }
 
+SNode* setAlterDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption) {
+  switch (pAlterOption->type) {
+    case DB_OPTION_KEEP:
+    case DB_OPTION_RETENTIONS:
+      return setDatabaseOption(pCxt, pOptions, pAlterOption->type, pAlterOption->pList);
+    default:
+      break;
+  }
+  return setDatabaseOption(pCxt, pOptions, pAlterOption->type, &pAlterOption->val);
+}
+
 SNode* createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken* pDbName, SNode* pOptions) {
   if (!checkDbName(pCxt, pDbName, false)) {
     return NULL;
@@ -703,31 +774,44 @@ SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode*
   return (SNode*)pStmt;
 }
 
-SNode* createTableOptions(SAstCreateContext* pCxt) {
+SNode* createDefaultTableOptions(SAstCreateContext* pCxt) {
   STableOptions* pOptions = nodesMakeNode(QUERY_NODE_TABLE_OPTIONS);
   CHECK_OUT_OF_MEM(pOptions);
+  pOptions->delay = TSDB_DEFAULT_ROLLUP_DELAY;
+  pOptions->filesFactor = TSDB_DEFAULT_ROLLUP_FILE_FACTOR;
+  pOptions->ttl = TSDB_DEFAULT_TABLE_TTL;
   return (SNode*)pOptions;
 }
 
-SNode* setTableAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption) {
-  switch (pAlterOption->type) {
-    case TABLE_OPTION_KEEP:
-      ((STableOptions*)pOptions)->pKeep = pAlterOption->pList;
-      break;
-    case TABLE_OPTION_TTL:
-      ((STableOptions*)pOptions)->pTtl = pAlterOption->pVal;
-      break;
+SNode* createAlterTableOptions(SAstCreateContext* pCxt) {
+  STableOptions* pOptions = nodesMakeNode(QUERY_NODE_TABLE_OPTIONS);
+  CHECK_OUT_OF_MEM(pOptions);
+  pOptions->delay = -1;
+  pOptions->filesFactor = -1;
+  pOptions->ttl = -1;
+  return (SNode*)pOptions;
+}
+
+SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal) {
+  switch (type) {
     case TABLE_OPTION_COMMENT:
-      ((STableOptions*)pOptions)->pComments = pAlterOption->pVal;
+      copyStringFormStringToken((SToken*)pVal, ((STableOptions*)pOptions)->comment,
+                                sizeof(((STableOptions*)pOptions)->comment));
       break;
-    case TABLE_OPTION_SMA:
-      ((STableOptions*)pOptions)->pSma = pAlterOption->pList;
+    case TABLE_OPTION_DELAY:
+      ((STableOptions*)pOptions)->delay = strtol(((SToken*)pVal)->z, NULL, 10);
       break;
     case TABLE_OPTION_FILE_FACTOR:
-      ((STableOptions*)pOptions)->pFilesFactor = pAlterOption->pVal;
+      ((STableOptions*)pOptions)->filesFactor = strtod(((SToken*)pVal)->z, NULL);
       break;
-    case TABLE_OPTION_DELAY:
-      ((STableOptions*)pOptions)->pDelay = pAlterOption->pVal;
+    case TABLE_OPTION_ROLLUP:
+      ((STableOptions*)pOptions)->pRollupFuncs = pVal;
+      break;
+    case TABLE_OPTION_TTL:
+      ((STableOptions*)pOptions)->ttl = strtol(((SToken*)pVal)->z, NULL, 10);
+      break;
+    case TABLE_OPTION_SMA:
+      ((STableOptions*)pOptions)->pSma = pVal;
       break;
     default:
       break;
@@ -778,7 +862,7 @@ SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode*
 }
 
 SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable,
-                                  SNodeList* pSpecificTags, SNodeList* pValsOfTags) {
+                                  SNodeList* pSpecificTags, SNodeList* pValsOfTags, SNode* pOptions) {
   if (NULL == pRealTable) {
     return NULL;
   }
@@ -833,7 +917,7 @@ SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool ignoreNotExists, S
   return (SNode*)pStmt;
 }
 
-SNode* createAlterTableOption(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions) {
+SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions) {
   if (NULL == pRealTable) {
     return NULL;
   }

source/libs/parser/src/parAstParser.c

@@ -80,6 +80,7 @@ abort_parse:
       return TSDB_CODE_OUT_OF_MEMORY;
     }
     (*pQuery)->pRoot = cxt.pRootNode;
+    (*pQuery)->placeholderNum = cxt.placeholderNo;
   }
   return cxt.valid ? TSDB_CODE_SUCCESS : TSDB_CODE_FAILED;
 }

source/libs/parser/src/parInsert.c

@@ -937,6 +937,11 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
     }
 
     *gotRow = true;
+#ifdef TD_DEBUG_PRINT_ROW
+    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&schema, spd->numOfCols);
+    tdSRowPrint(row, pSTSchema, __func__);
+    taosMemoryFree(pSTSchema);
+#endif
   }
 
   // *len = pBuilder->extendedRowSize;
@@ -1328,10 +1333,6 @@ int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, in
     for (int c = 0; c < spd->numOfBound; ++c) {
       SSchema* pColSchema = &pSchema[spd->boundColumns[c] - 1];
 
-      if (bind[c].buffer_type != pColSchema->type) {
-        return buildInvalidOperationMsg(&pBuf, "column type mis-match with buffer type");
-      }
-
       if (bind[c].num != rowNum) {
         return buildInvalidOperationMsg(&pBuf, "row number in each bind param should be the same");
       }
@@ -1346,6 +1347,10 @@ int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, in
 
         CHECK_CODE(MemRowAppend(&pBuf, NULL, 0, &param));
       } else {
+        if (bind[c].buffer_type != pColSchema->type) {
+          return buildInvalidOperationMsg(&pBuf, "column type mis-match with buffer type");
+        }
+
         int32_t colLen = pColSchema->bytes;
         if (IS_VAR_DATA_TYPE(pColSchema->type)) {
           colLen = bind[c].length[r];
@@ -1359,7 +1364,6 @@ int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, in
         checkTimestamp(pDataBlock, (const char*)&tsKey);
       }
     }
-
     // set the null value for the columns that do not assign values
     if ((spd->numOfBound < spd->numOfCols) && TD_IS_TP_ROW(row)) {
       for (int32_t i = 0; i < spd->numOfCols; ++i) {
@@ -1369,6 +1373,11 @@ int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, in
         }
       }
     }
+#ifdef TD_DEBUG_PRINT_ROW
+    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&pSchema, spd->numOfCols);
+    tdSRowPrint(row, pSTSchema, __func__);
+    taosMemoryFree(pSTSchema);
+#endif
 
     pDataBlock->size += extendedRowSize;
   }
@@ -1447,6 +1456,14 @@ int32_t qBindStmtSingleColValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBu
         }
       }
     }
+
+#ifdef TD_DEBUG_PRINT_ROW
+    if(rowEnd) {
+      STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&pSchema, spd->numOfCols);
+      tdSRowPrint(row, pSTSchema, __func__);
+      taosMemoryFree(pSTSchema);
+    }
+#endif
   }
 
   if (rowEnd) {

source/libs/parser/src/parTokenizer.c

@@ -43,7 +43,7 @@ static SKeyword keywordTable[] = {
     {"BETWEEN", TK_BETWEEN},
     {"BINARY", TK_BINARY},
     {"BIGINT", TK_BIGINT},
-    {"BLOCKS", TK_BLOCKS},
+    // {"BLOCKS", TK_BLOCKS},
     {"BNODE", TK_BNODE},
     {"BNODES", TK_BNODES},
     {"BOOL", TK_BOOL},
@@ -142,7 +142,7 @@ static SKeyword keywordTable[] = {
     {"QTIME", TK_QTIME},
     {"QUERIES", TK_QUERIES},
     {"QUERY", TK_QUERY},
-    {"QUORUM", TK_QUORUM},
+    // {"QUORUM", TK_QUORUM},
     {"RATIO", TK_RATIO},
     {"REPLICA", TK_REPLICA},
     {"RESET", TK_RESET},
@@ -169,7 +169,7 @@ static SKeyword keywordTable[] = {
     {"STORAGE", TK_STORAGE},
     {"STREAM", TK_STREAM},
     {"STREAMS", TK_STREAMS},
-    {"STREAM_MODE", TK_STREAM_MODE},
+    // {"STREAM_MODE", TK_STREAM_MODE},
     {"STRICT", TK_STRICT},
     {"SYNCDB", TK_SYNCDB},
     {"TABLE", TK_TABLE},

source/libs/parser/src/parUtil.c

@@ -68,8 +68,6 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Invalid option %s: %s";
     case TSDB_CODE_PAR_INVALID_ENUM_OPTION:
       return "Invalid option %s: %" PRId64 ", only %d, %d allowed";
-    case TSDB_CODE_PAR_INVALID_TTL_OPTION:
-      return "Invalid option ttl: %" PRId64 ", should be greater than or equal to %d";
     case TSDB_CODE_PAR_INVALID_KEEP_NUM:
       return "Invalid number of keep options";
     case TSDB_CODE_PAR_INVALID_KEEP_ORDER:
@@ -89,7 +87,7 @@ static char* getSyntaxErrFormat(int32_t errCode) {
     case TSDB_CODE_PAR_INVALID_OPTION_UNIT:
       return "Invalid option %s unit: %c, only m, h, d allowed";
     case TSDB_CODE_PAR_INVALID_KEEP_UNIT:
-      return "Invalid option keep unit: %c, %c, %c, only m, h, d allowed";
+      return "Invalid option keep unit: %c, only m, h, d allowed";
     case TSDB_CODE_PAR_AGG_FUNC_NESTING:
       return "Aggregate functions do not support nesting";
     case TSDB_CODE_PAR_INVALID_STATE_WIN_TYPE:

source/libs/parser/test/parserTestUtil.h → source/libs/parser/test/parAlterTest.cpp

@@ -13,9 +13,14 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef PARSER_TEST_UTIL_H
-#define PARSER_TEST_UTIL_H
+#include "parTestUtil.h"
 
-extern bool g_isDump;
+using namespace std;
 
-#endif  // PARSER_TEST_UTIL_H
+class ParserAlterTest : public ParserTestBase {};
+
+TEST_F(ParserAlterTest, stmt) {
+  useDb("root", "test");
+
+  run("create database db1");
+}

source/libs/parser/test/parserTestMain.cpp → source/libs/parser/test/parTestMain.cpp

@@ -13,23 +13,22 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <getopt.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 
-#include <getopt.h>
 #include <gtest/gtest.h>
 
 #ifdef WINDOWS
 #define TD_USE_WINSOCK
 #endif
+
 #include "functionMgt.h"
 #include "mockCatalog.h"
 #include "os.h"
+#include "parTestUtil.h"
 #include "parToken.h"
-#include "parserTestUtil.h"
-
-bool g_isDump = false;
 
 class ParserEnv : public testing::Environment {
  public:

source/libs/parser/test/parTestUtil.cpp

+/*
+ * 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 "parTestUtil.h"
+
+#include <algorithm>
+#include <array>
+
+#include "parInt.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);
+
+bool g_isDump = false;
+
+class ParserTestBaseImpl {
+ public:
+  void useDb(const string& acctId, const string& db) {
+    caseEnv_.acctId_ = acctId;
+    caseEnv_.db_ = db;
+  }
+
+  void run(const string& sql) {
+    reset();
+    try {
+      SParseContext cxt = {0};
+      setParseContext(sql, &cxt);
+
+      SQuery* pQuery = nullptr;
+      doParse(&cxt, &pQuery);
+
+      doTranslate(&cxt, pQuery);
+
+      doCalculateConstant(&cxt, pQuery);
+
+      if (g_isDump) {
+        dump();
+      }
+    } catch (...) {
+      dump();
+      throw;
+    }
+  }
+
+ private:
+  struct caseEnv {
+    string acctId_;
+    string db_;
+  };
+
+  struct stmtEnv {
+    string            sql_;
+    array<char, 1024> msgBuf_;
+  };
+
+  struct stmtRes {
+    string parsedAst_;
+    string translatedAst_;
+    string calcConstAst_;
+  };
+
+  void reset() {
+    stmtEnv_.sql_.clear();
+    stmtEnv_.msgBuf_.fill(0);
+
+    res_.parsedAst_.clear();
+    res_.translatedAst_.clear();
+    res_.calcConstAst_.clear();
+  }
+
+  void dump() {
+    cout << "==========================================sql : [" << stmtEnv_.sql_ << "]" << endl;
+    cout << "raw syntax tree : " << endl;
+    cout << res_.parsedAst_ << endl;
+    cout << "translated syntax tree : " << endl;
+    cout << res_.translatedAst_ << endl;
+    cout << "optimized syntax tree : " << endl;
+    cout << res_.calcConstAst_ << endl;
+  }
+
+  void setParseContext(const string& sql, SParseContext* pCxt) {
+    stmtEnv_.sql_ = sql;
+    transform(stmtEnv_.sql_.begin(), stmtEnv_.sql_.end(), stmtEnv_.sql_.begin(), ::tolower);
+
+    pCxt->acctId = atoi(caseEnv_.acctId_.c_str());
+    pCxt->db = caseEnv_.db_.c_str();
+    pCxt->pSql = stmtEnv_.sql_.c_str();
+    pCxt->sqlLen = stmtEnv_.sql_.length();
+    pCxt->pMsg = stmtEnv_.msgBuf_.data();
+    pCxt->msgLen = stmtEnv_.msgBuf_.max_size();
+  }
+
+  void doParse(SParseContext* pCxt, SQuery** pQuery) {
+    DO_WITH_THROW(parse, pCxt, pQuery);
+    res_.parsedAst_ = toString((*pQuery)->pRoot);
+  }
+
+  void doTranslate(SParseContext* pCxt, SQuery* pQuery) {
+    DO_WITH_THROW(translate, pCxt, pQuery);
+    res_.translatedAst_ = toString(pQuery->pRoot);
+  }
+
+  void doCalculateConstant(SParseContext* pCxt, SQuery* pQuery) {
+    DO_WITH_THROW(calculateConstant, pCxt, pQuery);
+    res_.calcConstAst_ = toString(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_;
+};
+
+ParserTestBase::ParserTestBase() : impl_(new ParserTestBaseImpl()) {}
+
+ParserTestBase::~ParserTestBase() {}
+
+void ParserTestBase::useDb(const std::string& acctId, const std::string& db) { impl_->useDb(acctId, db); }
+
+void ParserTestBase::run(const std::string& sql) { return impl_->run(sql); }

source/libs/parser/test/parTestUtil.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PARSER_TEST_UTIL_H
+#define PARSER_TEST_UTIL_H
+
+#include <gtest/gtest.h>
+
+class ParserTestBaseImpl;
+
+class ParserTestBase : public testing::Test {
+ public:
+  ParserTestBase();
+  virtual ~ParserTestBase();
+
+  void useDb(const std::string& acctId, const std::string& db);
+  void run(const std::string& sql);
+
+ private:
+  std::unique_ptr<ParserTestBaseImpl> impl_;
+};
+
+extern bool g_isDump;
+
+#endif  // PARSER_TEST_UTIL_H

source/libs/parser/test/parserAstTest.cpp

@@ -19,7 +19,7 @@
 #include <gtest/gtest.h>
 
 #include "parInt.h"
-#include "parserTestUtil.h"
+#include "parTestUtil.h"
 
 using namespace std;
 using namespace testing;

source/libs/planner/src/planner.c

@@ -19,26 +19,23 @@
 
 typedef struct SCollectPlaceholderValuesCxt {
   int32_t    errCode;
-  SNodeList* pValues;
+  SArray* 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);
+    taosArrayInsert(pCxt->pValues, ((SValueNode*)pNode)->placeholderNo - 1, &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};
+  pPlan->pPlaceholderValues = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
+
+  SCollectPlaceholderValuesCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pValues = pPlan->pPlaceholderValues};
   nodesWalkPhysiPlan((SNode*)pPlan, collectPlaceholderValuesImpl, &cxt);
-  if (TSDB_CODE_SUCCESS == cxt.errCode) {
-    pPlan->pPlaceholderValues = cxt.pValues;
-  } else {
-    nodesDestroyList(cxt.pValues);
-  }
   return cxt.errCode;
 }
 
@@ -60,7 +57,7 @@ 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) {
+  if (TSDB_CODE_SUCCESS == code && pCxt->placeholderNum > 0) {
     code = collectPlaceholderValues(pCxt, *pPlan);
   }
 
@@ -108,7 +105,7 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
     return TSDB_CODE_SUCCESS;
   }
   pVal->node.resType.type = pParam->buffer_type;
-  pVal->node.resType.bytes = *(pParam->length);
+  pVal->node.resType.bytes = NULL != pParam->length ? *(pParam->length) : tDataTypes[pParam->buffer_type].bytes;
   switch (pParam->buffer_type) {
     case TSDB_DATA_TYPE_BOOL:
       pVal->datum.b = *((bool*)pParam->buffer);
@@ -133,6 +130,7 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
       break;
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
+    case TSDB_DATA_TYPE_NCHAR:
       pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
       if (NULL == pVal->datum.p) {
         return TSDB_CODE_OUT_OF_MEMORY;
@@ -155,7 +153,6 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
     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:
@@ -168,18 +165,35 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx) {
-  if (colIdx < 0) {
-    int32_t index = 0;
-    SNode* pNode = NULL;
+static EDealRes updatePlanQueryId(SNode* pNode, void* pContext) {
+  int64_t queryId = *(uint64_t *)pContext;
+  
+  if (QUERY_NODE_PHYSICAL_PLAN == nodeType(pNode)) {
+    SQueryPlan* planNode = (SQueryPlan*)pNode;
+    planNode->queryId = queryId;
+  } else if (QUERY_NODE_PHYSICAL_SUBPLAN == nodeType(pNode)) {
+    SSubplan* subplanNode = (SSubplan*)pNode;
+    subplanNode->id.queryId = queryId;
+  }
 
-    FOREACH(pNode, pPlan->pPlaceholderValues) {
-      setValueByBindParam((SValueNode*)pNode, pParams + index);
-      ++index;
+  return DEAL_RES_CONTINUE;
+}
+
+int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx, uint64_t queryId) {
+  int32_t size = taosArrayGetSize(pPlan->pPlaceholderValues);
+
+  if (colIdx < 0) {
+    for (int32_t i = 0; i < size; ++i) {
+      setValueByBindParam((SValueNode*)taosArrayGetP(pPlan->pPlaceholderValues, i), pParams + i);
     }
   } else {
-    setValueByBindParam((SValueNode*)nodesListGetNode(pPlan->pPlaceholderValues, colIdx), pParams);
+    setValueByBindParam((SValueNode*)taosArrayGetP(pPlan->pPlaceholderValues, colIdx), pParams);
+  }
+
+  if (colIdx < 0 || ((colIdx + 1) == size)) {
+    nodesWalkPhysiPlan((SNode*)pPlan, updatePlanQueryId, &queryId);
   }
+  
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/planner/test/planTestUtil.cpp

@@ -14,9 +14,9 @@
  */
 
 #include "planTestUtil.h"
-#include <array>
 
 #include <algorithm>
+#include <array>
 
 #include "cmdnodes.h"
 #include "parser.h"

source/libs/scalar/inc/sclInt.h

@@ -34,7 +34,7 @@ typedef struct SScalarCtx {
 
 #define SCL_IS_CONST_NODE(_node) ((NULL == (_node)) || (QUERY_NODE_VALUE == (_node)->type) || (QUERY_NODE_NODE_LIST == (_node)->type))
 #define SCL_IS_CONST_CALC(_ctx) (NULL == (_ctx)->pBlockList)
-#define SCL_IS_NULL_VALUE_NODE(_node) ((QUERY_NODE_VALUE == nodeType(_node)) && (TSDB_DATA_TYPE_NULL == ((SValueNode *)_node)->node.resType.type))
+#define SCL_IS_NULL_VALUE_NODE(_node) ((QUERY_NODE_VALUE == nodeType(_node)) && (TSDB_DATA_TYPE_NULL == ((SValueNode *)_node)->node.resType.type) && (((SValueNode *)_node)->placeholderNo <= 0))
 
 #define sclFatal(...)  qFatal(__VA_ARGS__)
 #define sclError(...)  qError(__VA_ARGS__)

source/libs/scalar/src/filter.c

@@ -3541,11 +3541,16 @@ EDealRes fltReviseRewriter(SNode** pNode, void* pContext) {
   }
 
   if (QUERY_NODE_VALUE == nodeType(*pNode)) {
+    SValueNode *valueNode = (SValueNode *)*pNode;
+    if (valueNode->placeholderNo >= 1) {
+      stat->scalarMode = true;
+      return DEAL_RES_CONTINUE;
+    }
+    
     if (!FILTER_GET_FLAG(stat->info->options, FLT_OPTION_TIMESTAMP)) {
       return DEAL_RES_CONTINUE;
     }
     
-    SValueNode *valueNode = (SValueNode *)*pNode;
     if (TSDB_DATA_TYPE_BINARY != valueNode->node.resType.type && TSDB_DATA_TYPE_NCHAR != valueNode->node.resType.type) {
       return DEAL_RES_CONTINUE;
     }
@@ -3587,7 +3592,7 @@ EDealRes fltReviseRewriter(SNode** pNode, void* pContext) {
       return DEAL_RES_CONTINUE;
     }
 
-    if (node->opType == OP_TYPE_NOT_IN || node->opType == OP_TYPE_NOT_LIKE || node->opType > OP_TYPE_IS_NOT_NULL) {
+    if (node->opType == OP_TYPE_NOT_IN || node->opType == OP_TYPE_NOT_LIKE || node->opType > OP_TYPE_IS_NOT_NULL || node->opType == OP_TYPE_NOT_EQUAL) {
       stat->scalarMode = true;
       return DEAL_RES_CONTINUE;
     }

source/libs/scalar/src/scalar.c

@@ -504,6 +504,7 @@ EDealRes sclRewriteBasedOnOptr(SNode** pNode, SScalarCtx *ctx, EOperatorType opT
     }
     
     res->node.resType.type = TSDB_DATA_TYPE_BOOL;
+    res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
     res->datum.b = false;
     
     nodesDestroyNode(*pNode);
@@ -519,14 +520,14 @@ EDealRes sclRewriteOperatorForNullValue(SNode** pNode, SScalarCtx *ctx) {
 
   if (node->pLeft && (QUERY_NODE_VALUE == nodeType(node->pLeft))) {
     SValueNode *valueNode = (SValueNode *)node->pLeft;
-    if (TSDB_DATA_TYPE_NULL == valueNode->node.resType.type && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)) {
+    if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)) {
       return sclRewriteBasedOnOptr(pNode, ctx, node->opType);
     }
   }
 
   if (node->pRight && (QUERY_NODE_VALUE == nodeType(node->pRight))) {
     SValueNode *valueNode = (SValueNode *)node->pRight;
-    if (TSDB_DATA_TYPE_NULL == valueNode->node.resType.type && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)) {
+    if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)) {
       return sclRewriteBasedOnOptr(pNode, ctx, node->opType);
     }
   }
@@ -588,7 +589,10 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
   if (colDataIsNull_s(output.columnData, 0)) {
     res->node.resType.type = TSDB_DATA_TYPE_NULL;
   } else {
-    res->node.resType = node->node.resType;
+    res->node.resType.type = output.columnData->info.type;
+    res->node.resType.bytes = output.columnData->info.bytes;
+    res->node.resType.scale = output.columnData->info.scale;
+    res->node.resType.precision = output.columnData->info.precision;
     int32_t type = output.columnData->info.type;
     if (IS_VAR_DATA_TYPE(type)) {
       res->datum.p = taosMemoryCalloc(res->node.resType.bytes + VARSTR_HEADER_SIZE + 1, 1);

source/libs/scalar/src/sclfunc.c

@@ -658,11 +658,6 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
   int16_t outputType = GET_PARAM_TYPE(&pOutput[0]);
   int64_t outputLen  = GET_PARAM_BYTES(&pOutput[0]);
 
-  if (IS_VAR_DATA_TYPE(outputType)) {
-    int32_t factor = (TSDB_DATA_TYPE_NCHAR == outputType) ? TSDB_NCHAR_SIZE : 1;
-    outputLen = outputLen * factor + VARSTR_HEADER_SIZE;
-  }
-
   char *outputBuf = taosMemoryCalloc(outputLen * pInput[0].numOfRows, 1);
   char *output = outputBuf;
 

source/libs/stream/src/tstreamUpdate.c

+/*
+ * 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 "tstreamUpdate.h"
+#include "ttime.h"
+
+#define DEFAULT_FALSE_POSITIVE 0.01
+#define DEFAULT_BUCKET_SIZE 1024
+#define ROWS_PER_MILLISECOND 1
+#define MAX_NUM_SCALABLE_BF 120
+#define MIN_NUM_SCALABLE_BF 10
+#define DEFAULT_PREADD_BUCKET 1
+#define MAX_INTERVAL MILLISECOND_PER_MINUTE
+#define MIN_INTERVAL (MILLISECOND_PER_SECOND * 10)
+
+static void windowSBfAdd(SUpdateInfo *pInfo, uint64_t count) {
+  if (pInfo->numSBFs < count ) {
+    count = pInfo->numSBFs;
+  }
+  for (uint64_t i = 0; i < count; ++i) {
+    SScalableBf *tsSBF = tScalableBfInit(pInfo->interval * ROWS_PER_MILLISECOND,
+                                         DEFAULT_FALSE_POSITIVE);
+    taosArrayPush(pInfo->pTsSBFs, &tsSBF);
+  }
+}
+
+static void windowSBfDelete(SUpdateInfo *pInfo, uint64_t count) {
+  if (count < pInfo->numSBFs - 1) {
+    for (uint64_t i = 0; i < count; ++i) {
+      SScalableBf *pTsSBFs = taosArrayGetP(pInfo->pTsSBFs, i);
+      tScalableBfDestroy(pTsSBFs);
+      taosArrayRemove(pInfo->pTsSBFs, i);
+    }
+  } else {
+    taosArrayClearP(pInfo->pTsSBFs, (FDelete)tScalableBfDestroy);
+  }
+  pInfo->minTS += pInfo->interval * count;
+}
+
+static int64_t adjustInterval(int64_t interval, int32_t precision) {
+  int64_t val = interval;
+  if (precision != TSDB_TIME_PRECISION_MILLI) {
+    val = convertTimePrecision(interval, precision, TSDB_TIME_PRECISION_MILLI);
+  }
+  if (val < MIN_INTERVAL) {
+    val = MIN_INTERVAL;
+  } else if (val > MAX_INTERVAL) {
+    val = MAX_INTERVAL;
+  }
+  val = convertTimePrecision(val, TSDB_TIME_PRECISION_MILLI, precision);
+  return val;
+}
+
+SUpdateInfo *updateInfoInitP(SInterval* pInterval, int64_t watermark) {
+  return updateInfoInit(pInterval->interval, pInterval->precision, watermark);
+}
+
+SUpdateInfo *updateInfoInit(int64_t interval, int32_t precision, int64_t watermark) {
+  SUpdateInfo *pInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo));
+  if (pInfo == NULL) {
+    return NULL;
+  }
+  pInfo->pTsBuckets = NULL;
+  pInfo->pTsSBFs = NULL;
+  pInfo->minTS = -1;
+  pInfo->interval = adjustInterval(interval, precision);
+  pInfo->watermark = watermark;
+
+  uint64_t bfSize = (uint64_t)(watermark / pInfo->interval);
+  if (bfSize < MIN_NUM_SCALABLE_BF) {
+    bfSize = MIN_NUM_SCALABLE_BF;
+  } else if (bfSize > MAX_NUM_SCALABLE_BF) {
+    bfSize = MAX_NUM_SCALABLE_BF;
+  }
+
+  pInfo->pTsSBFs = taosArrayInit(bfSize, sizeof(SScalableBf));
+  if (pInfo->pTsSBFs == NULL) {
+    updateInfoDestroy(pInfo);
+    return NULL;
+  }
+  pInfo->numSBFs = bfSize;
+  windowSBfAdd(pInfo, bfSize);
+
+  pInfo->pTsBuckets = taosArrayInit(DEFAULT_BUCKET_SIZE, sizeof(TSKEY));
+  if (pInfo->pTsBuckets == NULL) {
+    updateInfoDestroy(pInfo);
+    return NULL;
+  }
+
+  TSKEY dumy = 0;
+  for(uint64_t i=0; i < DEFAULT_BUCKET_SIZE; ++i) {
+    taosArrayPush(pInfo->pTsBuckets, &dumy);
+  }
+  pInfo->numBuckets = DEFAULT_BUCKET_SIZE;
+  return pInfo;
+}
+
+static SScalableBf* getSBf(SUpdateInfo *pInfo, TSKEY ts) {
+  if (ts <= 0) {
+    return NULL;
+  }
+  if (pInfo->minTS < 0) {
+    pInfo->minTS = (TSKEY)(ts / pInfo->interval * pInfo->interval);
+  }
+  uint64_t index = (uint64_t)((ts - pInfo->minTS) / pInfo->interval);
+  if (index >= pInfo->numSBFs) {
+    uint64_t count = index + 1 - pInfo->numSBFs;
+    windowSBfDelete(pInfo, count);
+    windowSBfAdd(pInfo, count);
+    index = pInfo->numSBFs - 1;
+  }
+  SScalableBf *res = taosArrayGetP(pInfo->pTsSBFs, index);
+  if (res == NULL) {
+    res = tScalableBfInit(pInfo->interval * ROWS_PER_MILLISECOND,
+                          DEFAULT_FALSE_POSITIVE);
+    taosArrayPush(pInfo->pTsSBFs, &res);
+  }
+  return res;
+}
+
+bool isUpdated(SUpdateInfo *pInfo, tb_uid_t tableId, TSKEY ts) {
+  int32_t res = TSDB_CODE_FAILED;
+  uint64_t index = ((uint64_t)tableId) % pInfo->numBuckets;
+  SScalableBf* pSBf = getSBf(pInfo, ts);
+  // pSBf may be a null pointer
+  if (pSBf) {
+    res = tScalableBfPut(pSBf, &ts, sizeof(TSKEY));
+  }
+
+  TSKEY maxTs = *(TSKEY *)taosArrayGet(pInfo->pTsBuckets, index);
+  if (maxTs < ts ) {
+    taosArraySet(pInfo->pTsBuckets, index, &ts);
+    return false;
+  }
+
+  if (ts < pInfo->minTS) {
+    return true;
+  } else if (res == TSDB_CODE_SUCCESS) {
+    return false;
+  }
+
+  //check from tsdb api
+  return true;
+}
+
+void updateInfoDestroy(SUpdateInfo *pInfo) {
+  if (pInfo == NULL) {
+    return;
+  }
+  taosArrayDestroy(pInfo->pTsBuckets);
+
+  uint64_t size = taosArrayGetSize(pInfo->pTsSBFs);
+  for (uint64_t i = 0; i < size; i++) {
+    SScalableBf *pSBF = taosArrayGetP(pInfo->pTsSBFs, i);
+    tScalableBfDestroy(pSBF);
+  }
+  
+  taosArrayDestroy(pInfo->pTsSBFs);
+  taosMemoryFree(pInfo);
+}
\ No newline at end of file

source/libs/stream/test/CMakeLists.txt

+
+MESSAGE(STATUS "build stream unit test")
+
+# GoogleTest requires at least C++11
+SET(CMAKE_CXX_STANDARD 11)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+# bloomFilterTest
+ADD_EXECUTABLE(streamUpdateTest "tstreamUpdateTest.cpp")
+
+TARGET_LINK_LIBRARIES(
+        streamUpdateTest
+        PUBLIC os util common gtest stream
+)
+
+TARGET_INCLUDE_DIRECTORIES(
+        streamUpdateTest
+        PUBLIC "${TD_SOURCE_DIR}/include/libs/stream/"
+        PRIVATE "${TD_SOURCE_DIR}/source/libs/stream/inc"
+)
\ No newline at end of file

source/libs/stream/test/tstreamUpdateTest.cpp

+#include <gtest/gtest.h>
+
+#include "tstreamUpdate.h"
+#include "ttime.h"
+
+using namespace std;
+
+TEST(TD_STREAM_UPDATE_TEST, update) {
+  int64_t interval = 20 * 1000;
+  int64_t watermark = 10 * 60 * 1000;
+  SUpdateInfo *pSU = updateInfoInit(interval, TSDB_TIME_PRECISION_MILLI, watermark);
+  GTEST_ASSERT_EQ(isUpdated(pSU,1, 0), true);
+  GTEST_ASSERT_EQ(isUpdated(pSU,1, -1), true);
+
+  for(int i=0; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,i, 1), false);
+  }
+  for(int i=0; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,i, 1), true);
+  }
+
+  for(int i=0; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,i, 2), false);
+  }
+  for(int i=0; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,i, 2), true);
+  }
+
+  for(int i=0; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,i, 1), true);
+  }
+
+  for(int i=3; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,0, i), false);
+  }
+  GTEST_ASSERT_EQ(*(int64_t*)taosArrayGet(pSU->pTsBuckets,0), 1023);
+
+  for(int i=3; i < 1024; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU,0, i), true);
+  }
+  GTEST_ASSERT_EQ(*(int64_t*)taosArrayGet(pSU->pTsBuckets,0), 1023);
+
+  SUpdateInfo *pSU1 = updateInfoInit(interval, TSDB_TIME_PRECISION_MILLI, watermark);
+  for(int i=1; i <= watermark / interval; i++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU1, 1, i * interval + 5), false);
+    GTEST_ASSERT_EQ(pSU1->minTS, interval);
+    GTEST_ASSERT_EQ(pSU1->numSBFs, watermark / interval);
+  }
+  for(int i=0; i < pSU1->numSBFs; i++) {
+    SScalableBf *pSBF = (SScalableBf *)taosArrayGetP(pSU1->pTsSBFs, i);
+    SBloomFilter *pBF = (SBloomFilter *)taosArrayGetP(pSBF->bfArray, 0);
+    GTEST_ASSERT_EQ(pBF->size, 1);
+  }
+
+  for(int i= watermark / interval + 1, j = 2 ; i <= watermark / interval + 10; i++,j++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU1, 1, i * interval + 5), false);
+    GTEST_ASSERT_EQ(pSU1->minTS, interval*j);
+    GTEST_ASSERT_EQ(pSU1->numSBFs, watermark / interval);
+    SScalableBf *pSBF = (SScalableBf *)taosArrayGetP(pSU1->pTsSBFs, pSU1->numSBFs - 1);
+    SBloomFilter *pBF = (SBloomFilter *)taosArrayGetP(pSBF->bfArray, 0);
+    GTEST_ASSERT_EQ(pBF->size, 1);
+  }
+  
+  for(int i= watermark / interval * 100, j = 0; j < 10; i+= (watermark / interval * 2), j++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU1, 1, i * interval + 5), false);
+    GTEST_ASSERT_EQ(pSU1->minTS, (i-(pSU1->numSBFs-1))*interval);
+    GTEST_ASSERT_EQ(pSU1->numSBFs, watermark / interval);
+  }
+
+  SUpdateInfo *pSU2 = updateInfoInit(interval, TSDB_TIME_PRECISION_MILLI, watermark);
+  GTEST_ASSERT_EQ(isUpdated(pSU2, 1, 1 * interval + 5), false);
+  GTEST_ASSERT_EQ(pSU2->minTS, interval);
+  for(int i= watermark / interval * 100, j = 0; j < 10; i+= (watermark / interval * 10), j++) {
+    GTEST_ASSERT_EQ(isUpdated(pSU2, 1, i * interval + 5), false);
+    GTEST_ASSERT_EQ(pSU2->minTS, (i-(pSU2->numSBFs-1))*interval);
+    GTEST_ASSERT_EQ(pSU2->numSBFs, watermark / interval);
+    GTEST_ASSERT_EQ(*(int64_t*)taosArrayGet(pSU2->pTsBuckets,1), i * interval + 5);
+  }
+  
+  SUpdateInfo *pSU3 = updateInfoInit(interval, TSDB_TIME_PRECISION_MILLI, watermark);
+  for(int j = 1; j < 100; j++) {
+    for(int i = 0; i < pSU3->numSBFs; i++) {
+      GTEST_ASSERT_EQ(isUpdated(pSU3, i, i * interval + 5 * j), false);
+      GTEST_ASSERT_EQ(pSU3->minTS, 0);
+      GTEST_ASSERT_EQ(pSU3->numSBFs, watermark / interval);
+      GTEST_ASSERT_EQ(*(int64_t*)taosArrayGet(pSU3->pTsBuckets, i), i * interval + 5 * j);
+      SScalableBf *pSBF = (SScalableBf *)taosArrayGetP(pSU3->pTsSBFs, i);
+      SBloomFilter *pBF = (SBloomFilter *)taosArrayGetP(pSBF->bfArray, 0);
+      GTEST_ASSERT_EQ(pBF->size, j);
+    }
+  }
+
+
+  updateInfoDestroy(pSU);
+  updateInfoDestroy(pSU1);
+  updateInfoDestroy(pSU2);
+  updateInfoDestroy(pSU3);
+}
+
+int main(int argc, char* argv[]) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
\ No newline at end of file

source/libs/transport/inc/transComm.h

@@ -28,6 +28,7 @@ extern "C" {
 #include "taoserror.h"
 #include "tglobal.h"
 #include "thash.h"
+#include "theap.h"
 #include "tidpool.h"
 #include "tmd5.h"
 #include "tmempool.h"
@@ -328,10 +329,38 @@ void transQueueClear(STransQueue* queue);
  */
 void transQueueDestroy(STransQueue* queue);
 
+/*
+ * delay queue based on uv loop and uv timer, and only used in retry
+ */
+typedef struct STaskArg {
+  void* param1;
+  void* param2;
+} STaskArg;
+
+typedef struct SDelayTask {
+  void (*func)(void* arg);
+  void*    arg;
+  uint64_t execTime;
+  HeapNode node;
+} SDelayTask;
+
+typedef struct SDelayQueue {
+  uv_timer_t* timer;
+  Heap*       heap;
+  uv_loop_t*  loop;
+} SDelayQueue;
+
+int transDQCreate(uv_loop_t* loop, SDelayQueue** queue);
+
+void transDQDestroy(SDelayQueue* queue);
+
+int transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs);
+
 /*
  * init global func
  */
 void transThreadOnce();
+
 #ifdef __cplusplus
 }
 #endif

source/libs/transport/src/transCli.c

@@ -60,7 +60,7 @@ typedef struct SCliThrdObj {
   // msg queue
   queue         msg;
   TdThreadMutex msgMtx;
-
+  SDelayQueue*  delayQueue;
   uint64_t      nextTimeout;  // next timeout
   void*         pTransInst;   //
   bool          quit;
@@ -161,8 +161,7 @@ static void cliWalkCb(uv_handle_t* handle, void* arg);
         transUnrefCliHandle(conn);                                                       \
       }                                                                                  \
       if (T_REF_VAL_GET(conn) == 1) {                                                    \
-        SCliThrdObj* thrd = conn->hostThrd;                                              \
-        addConnToPool(thrd->pool, conn);                                                 \
+        transUnrefCliHandle(conn);                                                       \
       }                                                                                  \
       destroyCmsg(pMsg);                                                                 \
       return;                                                                            \
@@ -838,12 +837,13 @@ static SCliThrdObj* createThrdObj() {
   uv_loop_init(pThrd->loop);
 
   pThrd->asyncPool = transCreateAsyncPool(pThrd->loop, 5, pThrd, cliAsyncCb);
-
   uv_timer_init(pThrd->loop, &pThrd->timer);
   pThrd->timer.data = pThrd;
 
   pThrd->pool = createConnPool(4);
 
+  transDQCreate(pThrd->loop, &pThrd->delayQueue);
+
   pThrd->quit = false;
   return pThrd;
 }
@@ -851,12 +851,13 @@ static void destroyThrdObj(SCliThrdObj* pThrd) {
   if (pThrd == NULL) {
     return;
   }
+
   taosThreadJoin(pThrd->thread, NULL);
   CLI_RELEASE_UV(pThrd->loop);
   taosThreadMutexDestroy(&pThrd->msgMtx);
   transDestroyAsyncPool(pThrd->asyncPool);
 
-  uv_timer_stop(&pThrd->timer);
+  transDQDestroy(pThrd->delayQueue);
   taosMemoryFree(pThrd->loop);
   taosMemoryFree(pThrd);
 }
@@ -885,6 +886,16 @@ int cliRBChoseIdx(STrans* pTransInst) {
   }
   return index % pTransInst->numOfThreads;
 }
+static void doDelayTask(void* param) {
+  STaskArg* arg = param;
+
+  SCliMsg*     pMsg = arg->param1;
+  SCliThrdObj* pThrd = arg->param2;
+
+  cliHandleReq(pMsg, pThrd);
+
+  taosMemoryFree(arg);
+}
 int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
   SCliThrdObj* pThrd = pConn->hostThrd;
   STrans*      pTransInst = pThrd->pTransInst;
@@ -908,20 +919,28 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
     if (msgType == TDMT_MND_CONNECT && pResp->code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
       if (pCtx->retryCount < pEpSet->numOfEps) {
         pEpSet->inUse = (++pEpSet->inUse) % pEpSet->numOfEps;
-        cliHandleReq(pMsg, pThrd);
+
+        STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg));
+        arg->param1 = pMsg;
+        arg->param2 = pThrd;
+        transDQSched(pThrd->delayQueue, doDelayTask, arg, TRANS_RETRY_INTERVAL);
+
         cliDestroy((uv_handle_t*)pConn->stream);
         return -1;
       }
     } else if (pCtx->retryCount < TRANS_RETRY_COUNT_LIMIT) {
       if (pResp->contLen == 0) {
-        pEpSet->inUse = (pEpSet->inUse++) % pEpSet->numOfEps;
+        pEpSet->inUse = (++pEpSet->inUse) % pEpSet->numOfEps;
       } else {
         SMEpSet emsg = {0};
         tDeserializeSMEpSet(pResp->pCont, pResp->contLen, &emsg);
         pCtx->epSet = emsg.epSet;
       }
-      cliHandleReq(pMsg, pThrd);
-      // release pConn
+      STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg));
+      arg->param1 = pMsg;
+      arg->param2 = pThrd;
+
+      transDQSched(pThrd->delayQueue, doDelayTask, arg, TRANS_RETRY_INTERVAL);
       addConnToPool(pThrd, pConn);
       return -1;
     }

source/libs/transport/src/transComm.c

@@ -358,4 +358,81 @@ void transQueueDestroy(STransQueue* queue) {
   transQueueClear(queue);
   taosArrayDestroy(queue->q);
 }
+
+static int32_t timeCompare(const HeapNode* a, const HeapNode* b) {
+  SDelayTask* arg1 = container_of(a, SDelayTask, node);
+  SDelayTask* arg2 = container_of(b, SDelayTask, node);
+  if (arg1->execTime > arg2->execTime) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+static void transDQTimeout(uv_timer_t* timer) {
+  SDelayQueue* queue = timer->data;
+  tTrace("timer %p timeout", timer);
+  uint64_t timeout = 0;
+  do {
+    HeapNode* minNode = heapMin(queue->heap);
+    if (minNode == NULL) break;
+    SDelayTask* task = container_of(minNode, SDelayTask, node);
+    if (task->execTime <= taosGetTimestampMs()) {
+      heapRemove(queue->heap, minNode);
+      task->func(task->arg);
+      taosMemoryFree(task);
+      timeout = 0;
+    } else {
+      timeout = task->execTime - taosGetTimestampMs();
+      break;
+    }
+  } while (1);
+  if (timeout != 0) {
+    uv_timer_start(queue->timer, transDQTimeout, timeout, 0);
+  }
+}
+int transDQCreate(uv_loop_t* loop, SDelayQueue** queue) {
+  uv_timer_t* timer = taosMemoryCalloc(1, sizeof(uv_timer_t));
+  uv_timer_init(loop, timer);
+
+  Heap* heap = heapCreate(timeCompare);
+
+  SDelayQueue* q = taosMemoryCalloc(1, sizeof(SDelayQueue));
+  q->heap = heap;
+  q->timer = timer;
+  q->loop = loop;
+  q->timer->data = q;
+
+  *queue = q;
+  return 0;
+}
+
+void transDQDestroy(SDelayQueue* queue) {
+  taosMemoryFree(queue->timer);
+
+  while (heapSize(queue->heap) > 0) {
+    HeapNode* minNode = heapMin(queue->heap);
+    if (minNode == NULL) {
+      return;
+    }
+    heapRemove(queue->heap, minNode);
+
+    SDelayTask* task = container_of(minNode, SDelayTask, node);
+    taosMemoryFree(task);
+  }
+  heapDestroy(queue->heap);
+  taosMemoryFree(queue);
+}
+
+int transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs) {
+  SDelayTask* task = taosMemoryCalloc(1, sizeof(SDelayTask));
+  task->func = func;
+  task->arg = arg;
+  task->execTime = taosGetTimestampMs() + timeoutMs;
+
+  tTrace("timer %p put task into queue, timeoutMs: %" PRIu64 "", queue->timer, timeoutMs);
+  heapInsert(queue->heap, &task->node);
+  uv_timer_start(queue->timer, transDQTimeout, timeoutMs, 0);
+  return 0;
+}
 #endif

source/util/src/tarray.c

@@ -318,6 +318,20 @@ void taosArrayClearEx(SArray* pArray, void (*fp)(void*)) {
   pArray->size = 0;
 }
 
+void taosArrayClearP(SArray* pArray, FDelete fp) {
+  if (pArray == NULL) return;
+  if (fp == NULL) {
+    pArray->size = 0;
+    return;
+  }
+
+  for (int32_t i = 0; i < pArray->size; ++i) {
+    fp(*(void**)TARRAY_GET_ELEM(pArray, i));
+  }
+
+  pArray->size = 0;
+}
+
 void* taosArrayDestroy(SArray* pArray) {
   if (pArray) {
     taosMemoryFree(pArray->pData);

source/util/src/tbloomfilter.c

+/*
+ * 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/>.
+ */
+
+#define _DEFAULT_SOURCE
+
+#include "tbloomfilter.h"
+#include "taos.h"
+#include "taoserror.h"
+
+#define UNIT_NUM_BITS 64
+#define UNIT_ADDR_NUM_BITS 6
+
+static FORCE_INLINE bool setBit(uint64_t *buf, uint64_t index) {
+  uint64_t unitIndex = index >> UNIT_ADDR_NUM_BITS;
+  uint64_t mask = 1 << (index % UNIT_NUM_BITS);
+  uint64_t old = buf[unitIndex];
+  buf[unitIndex] |= mask;
+  return buf[unitIndex] != old;
+}
+
+static FORCE_INLINE bool getBit(uint64_t *buf, uint64_t index) {
+  uint64_t unitIndex = index >> UNIT_ADDR_NUM_BITS;
+  uint64_t mask = 1 << (index % UNIT_NUM_BITS);
+  return buf[unitIndex] & mask;
+}
+
+SBloomFilter *tBloomFilterInit(uint64_t expectedEntries, double errorRate) {
+  if (expectedEntries < 1 || errorRate <= 0 || errorRate >= 1.0) {
+    return NULL;
+  }
+  SBloomFilter *pBF = taosMemoryCalloc(1, sizeof(SBloomFilter));
+  if (pBF == NULL) {
+    return NULL;
+  }
+  pBF->expectedEntries = expectedEntries;
+  pBF->errorRate = errorRate;
+
+  double lnRate = fabs(log(errorRate));
+  // ln(2)^2 = 0.480453013918201
+  // m = - n * ln(P) / ( ln(2) )^2
+  // m is the size of bloom filter, n is expected entries, P is false positive probability
+  pBF->numUnits = (uint64_t) ceil(expectedEntries * lnRate / 0.480453013918201 / UNIT_NUM_BITS);
+  pBF->numBits = pBF->numUnits * 64;
+  pBF->size = 0;
+
+  // ln(2) = 0.693147180559945
+  pBF->hashFunctions = (uint32_t) ceil(lnRate / 0.693147180559945);
+  pBF->hashFn1 = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP);
+  pBF->hashFn2 = taosGetDefaultHashFunction(TSDB_DATA_TYPE_NCHAR);
+  pBF->buffer = taosMemoryCalloc(pBF->numUnits, sizeof(uint64_t));
+  if (pBF->buffer == NULL) {
+    tBloomFilterDestroy(pBF);
+    return NULL;
+  }
+  return pBF;
+}
+
+int32_t tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len) {
+  ASSERT(!tBloomFilterIsFull(pBF));
+  uint64_t h1 = (uint64_t)pBF->hashFn1(keyBuf, len);
+  uint64_t h2 = (uint64_t)pBF->hashFn2(keyBuf, len);
+  bool hasChange = false;
+  const register uint64_t size = pBF->numBits;
+  uint64_t cbHash = h1;
+  for (uint64_t i = 0; i < pBF->hashFunctions; ++i) {
+    hasChange |= setBit(pBF->buffer, cbHash % size);
+    cbHash += h2;
+  }
+  if (hasChange) {
+    pBF->size++;
+    return TSDB_CODE_SUCCESS;
+  }
+  return TSDB_CODE_FAILED;
+}
+
+int32_t tBloomFilterNoContain(const SBloomFilter *pBF, const void *keyBuf,
+                              uint32_t len) {
+  uint64_t h1 = (uint64_t)pBF->hashFn1(keyBuf, len);
+  uint64_t h2 = (uint64_t)pBF->hashFn2(keyBuf, len);
+  const register uint64_t size = pBF->numBits;
+  uint64_t cbHash = h1;
+  for (uint64_t i = 0; i < pBF->hashFunctions; ++i) {
+    if (!getBit(pBF->buffer, cbHash % size)) {
+      return TSDB_CODE_SUCCESS;
+    }
+    cbHash += h2;
+  }
+  return TSDB_CODE_FAILED;
+}
+
+void tBloomFilterDestroy(SBloomFilter *pBF) {
+  if (pBF == NULL) {
+    return;
+  }
+  taosMemoryFree(pBF->buffer);
+  taosMemoryFree(pBF);
+}
+
+void tBloomFilterDump(const struct SBloomFilter *pBF) {
+// ToDo
+}
+
+bool tBloomFilterIsFull(const SBloomFilter *pBF) {
+  return pBF->size >= pBF->expectedEntries;
+}
\ No newline at end of file

source/util/src/tscalablebf.c

+/*
+ * 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/>.
+ */
+
+#define _DEFAULT_SOURCE
+
+#include "tscalablebf.h"
+#include "taoserror.h"
+
+#define DEFAULT_GROWTH 2
+#define DEFAULT_TIGHTENING_RATIO 0.5
+
+static SBloomFilter *tScalableBfAddFilter(SScalableBf *pSBf, uint64_t expectedEntries,
+                                   double errorRate);
+
+SScalableBf *tScalableBfInit(uint64_t expectedEntries, double errorRate) {
+  const uint32_t defaultSize = 8;
+  if (expectedEntries < 1 || errorRate <= 0 || errorRate >= 1.0) {
+    return NULL;
+  }
+  SScalableBf *pSBf = taosMemoryCalloc(1, sizeof(SScalableBf));
+  if (pSBf == NULL) {
+    return NULL;
+  }
+  pSBf->numBits = 0;
+  pSBf->bfArray = taosArrayInit(defaultSize, sizeof(void *));
+  if (tScalableBfAddFilter(pSBf, expectedEntries, errorRate * DEFAULT_TIGHTENING_RATIO) == NULL ) {
+    tScalableBfDestroy(pSBf);
+    return NULL;
+  }
+  pSBf->growth = DEFAULT_GROWTH;
+  return pSBf;
+}
+
+int32_t tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len) {
+  int32_t size = taosArrayGetSize(pSBf->bfArray);
+  for (int32_t i = size - 2; i >= 0; --i) {
+    if (tBloomFilterNoContain(taosArrayGetP(pSBf->bfArray, i),
+                              keyBuf, len) != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_FAILED;
+    }
+  }
+
+  SBloomFilter *pNormalBf = taosArrayGetP(pSBf->bfArray, size - 1);
+  ASSERT(pNormalBf);
+  if (tBloomFilterIsFull(pNormalBf)) {
+    pNormalBf = tScalableBfAddFilter(pSBf,
+                                     pNormalBf->expectedEntries * pSBf->growth,
+                                     pNormalBf->errorRate * DEFAULT_TIGHTENING_RATIO);
+    if (pNormalBf == NULL) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+  return tBloomFilterPut(pNormalBf, keyBuf, len);
+}
+
+int32_t tScalableBfNoContain(const SScalableBf *pSBf, const void *keyBuf,
+                             uint32_t len) {
+  int32_t size = taosArrayGetSize(pSBf->bfArray);
+  for (int32_t i = size - 1; i >= 0; --i) {
+    if (tBloomFilterNoContain(taosArrayGetP(pSBf->bfArray, i),
+                              keyBuf, len) != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_FAILED;
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static SBloomFilter *tScalableBfAddFilter(SScalableBf *pSBf, uint64_t expectedEntries,
+                                   double errorRate) {
+  SBloomFilter *pNormalBf = tBloomFilterInit(expectedEntries, errorRate);
+  if (pNormalBf == NULL) {
+    return NULL;
+  }
+  if(taosArrayPush(pSBf->bfArray, &pNormalBf) == NULL) {
+    tBloomFilterDestroy(pNormalBf);
+    return NULL;
+  }
+  pSBf->numBits += pNormalBf->numBits;
+  return pNormalBf;
+}
+
+void tScalableBfDestroy(SScalableBf *pSBf) {
+  if (pSBf == NULL) {
+    return;
+  }
+  if (pSBf->bfArray != NULL) {
+    taosArrayDestroyP(pSBf->bfArray, (FDelete)tBloomFilterDestroy);
+  }
+  taosMemoryFree(pSBf);
+}
+
+void tScalableBfDump(const SScalableBf *pSBf) {
+  // Todo;
+}
\ No newline at end of file

source/util/test/CMakeLists.txt

@@ -60,3 +60,11 @@ add_test(
     NAME cfgTest
     COMMAND cfgTest
 )
+
+# bloomFilterTest
+add_executable(bloomFilterTest "bloomFilterTest.cpp")
+target_link_libraries(bloomFilterTest os util gtest_main)   
+add_test(
+    NAME bloomFilterTest
+    COMMAND bloomFilterTest
+)
\ No newline at end of file

source/util/test/bloomFilterTest.cpp

+#include <gtest/gtest.h>
+
+#include "tscalablebf.h"
+#include "taoserror.h"
+
+using namespace std;
+
+TEST(TD_UTIL_BLOOMFILTER_TEST, normal_bloomFilter) {
+  int64_t ts1 = 1650803518000;
+
+  GTEST_ASSERT_EQ(NULL, tBloomFilterInit(100, 0));
+  GTEST_ASSERT_EQ(NULL, tBloomFilterInit(100, 1));
+  GTEST_ASSERT_EQ(NULL, tBloomFilterInit(100, -0.1));
+  GTEST_ASSERT_EQ(NULL, tBloomFilterInit(0, 0.01));
+
+  SBloomFilter *pBF1 = tBloomFilterInit(100, 0.005);
+  GTEST_ASSERT_EQ(pBF1->numBits, 1152);
+  GTEST_ASSERT_EQ(pBF1->numUnits, 1152/64);
+  int64_t count = 0;
+  for(int64_t i = 0; count < 100; i++) {
+    int64_t ts = i + ts1;
+    if(tBloomFilterPut(pBF1, &ts, sizeof(int64_t)) == TSDB_CODE_SUCCESS ) {
+      count++;
+    }
+  }
+  ASSERT_TRUE(tBloomFilterIsFull(pBF1));
+
+  SBloomFilter *pBF2 = tBloomFilterInit(1000*10000, 0.1);
+  GTEST_ASSERT_EQ(pBF2->numBits, 47925312);
+  GTEST_ASSERT_EQ(pBF2->numUnits, 47925312/64);
+
+  SBloomFilter *pBF3 = tBloomFilterInit(10000*10000, 0.001);
+  GTEST_ASSERT_EQ(pBF3->numBits, 1437758784);
+  GTEST_ASSERT_EQ(pBF3->numUnits, 1437758784/64);
+  
+  int64_t size = 10000;
+  SBloomFilter *pBF4 = tBloomFilterInit(size, 0.001);
+  for(int64_t i = 0; i < 1000; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tBloomFilterPut(pBF4, &ts, sizeof(int64_t)), TSDB_CODE_SUCCESS);
+  }
+  ASSERT_TRUE(!tBloomFilterIsFull(pBF4));
+
+  for(int64_t i = 0; i < 1000; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tBloomFilterNoContain(pBF4, &ts, sizeof(int64_t)), TSDB_CODE_FAILED);
+  }
+
+  for(int64_t i = 2000; i < 3000; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tBloomFilterNoContain(pBF4, &ts, sizeof(int64_t)), TSDB_CODE_SUCCESS);
+  }
+
+  tBloomFilterDestroy(pBF1);
+  tBloomFilterDestroy(pBF2);
+  tBloomFilterDestroy(pBF3);
+  tBloomFilterDestroy(pBF4);
+
+}
+
+TEST(TD_UTIL_BLOOMFILTER_TEST, scalable_bloomFilter) {
+  int64_t ts1 = 1650803518000;
+
+  GTEST_ASSERT_EQ(NULL, tScalableBfInit(100, 0));
+  GTEST_ASSERT_EQ(NULL, tScalableBfInit(100, 1));
+  GTEST_ASSERT_EQ(NULL, tScalableBfInit(100, -0.1));
+  GTEST_ASSERT_EQ(NULL, tScalableBfInit(0, 0.01));
+
+  SScalableBf *pSBF1 = tScalableBfInit(100, 0.01);
+  GTEST_ASSERT_EQ(pSBF1->numBits, 1152);
+  int64_t count = 0;
+  int64_t index = 0;
+  for( ; count < 100; index++) {
+    int64_t ts = index + ts1;
+    if(tScalableBfPut(pSBF1, &ts, sizeof(int64_t)) == TSDB_CODE_SUCCESS ) {
+      count++;
+    }
+  }
+  GTEST_ASSERT_EQ(pSBF1->numBits, 1152);
+
+  for( ; count < 300; index++) {
+    int64_t ts = index + ts1;
+    if(tScalableBfPut(pSBF1, &ts, sizeof(int64_t)) == TSDB_CODE_SUCCESS ) {
+      count++;
+    }
+  }
+  GTEST_ASSERT_EQ(pSBF1->numBits, 1152+2496);
+
+  for( ; count < 700; index++) {
+    int64_t ts = index + ts1;
+    if(tScalableBfPut(pSBF1, &ts, sizeof(int64_t)) == TSDB_CODE_SUCCESS ) {
+      count++;
+    }
+  }
+  GTEST_ASSERT_EQ(pSBF1->numBits, 1152+2496+5568);
+
+  for( ; count < 1500; index++) {
+    int64_t ts = index + ts1;
+    if(tScalableBfPut(pSBF1, &ts, sizeof(int64_t)) == TSDB_CODE_SUCCESS ) {
+      count++;
+    }
+  }
+  GTEST_ASSERT_EQ(pSBF1->numBits, 1152+2496+5568+12288);
+  
+  int32_t aSize = taosArrayGetSize(pSBF1->bfArray);
+  int64_t totalBits = 0;
+  for(int64_t i = 0; i < aSize; i++) {
+    SBloomFilter *pBF = (SBloomFilter *)taosArrayGetP(pSBF1->bfArray, i);
+    ASSERT_TRUE(tBloomFilterIsFull(pBF)); 
+    totalBits += pBF->numBits;
+  }
+  GTEST_ASSERT_EQ(pSBF1->numBits, totalBits);
+
+  for(int64_t i = 0; i < index; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tScalableBfNoContain(pSBF1, &ts, sizeof(int64_t)), TSDB_CODE_FAILED);
+  }
+
+
+  int64_t size = 10000;
+  SScalableBf *pSBF4 = tScalableBfInit(size, 0.001);
+  for(int64_t i = 0; i < 1000; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tScalableBfPut(pSBF4, &ts, sizeof(int64_t)), TSDB_CODE_SUCCESS);
+  }
+
+  for(int64_t i = 0; i < 1000; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tScalableBfNoContain(pSBF4, &ts, sizeof(int64_t)), TSDB_CODE_FAILED);
+  }
+
+  for(int64_t i = 2000; i < 3000; i++) {
+    int64_t ts = i + ts1;
+    GTEST_ASSERT_EQ(tScalableBfNoContain(pSBF4, &ts, sizeof(int64_t)), TSDB_CODE_SUCCESS);
+  }
+
+  tScalableBfDestroy(pSBF1);
+  tScalableBfDestroy(pSBF4);
+
+}
\ No newline at end of file

tests/script/tsim/db/alter_option.sim

@@ -66,7 +66,7 @@ print ============= create database
 #  | REPLICA value      [1 | 3]
 #  | WAL value          [1 | 2]
 
-sql create database db BLOCKS 7 CACHE 3 CACHELAST 3 COMP 0 DAYS 345600 FSYNC 1000 MAXROWS 8000 MINROWS 10 KEEP 1440000 PRECISION 'ns' REPLICA 1 TTL 7 WAL 2 VGROUPS 6 SINGLE_STABLE 1 STREAM_MODE 1
+sql create database db CACHELAST 3 COMP 0 DAYS 345600 FSYNC 1000 MAXROWS 8000 MINROWS 10 KEEP 1440000 PRECISION 'ns' REPLICA 1 WAL 2 VGROUPS 6 SINGLE_STABLE 1
 sql show databases
 print rows: $rows
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
@@ -98,12 +98,12 @@ endi
 if $data7_db != 1440000,1440000,1440000 then # keep
   return -1
 endi
-if $data8_db != 3 then  # cache
-  return -1
-endi
-if $data9_db != 7 then  # blocks
-  return -1
-endi
+#if $data8_db != 3 then  # cache
+#  return -1
+#endi
+#if $data9_db != 7 then  # blocks
+#  return -1
+#endi
 if $data10_db != 10 then  # minrows
   return -1
 endi
@@ -250,41 +250,41 @@ sql_error alter database db keep 0
 sql_error alter database db keep -1
 #sql_error alter database db keep 365001
 
-print ============== modify cache
-sql_error alter database db cache 12
-sql_error alter database db cache 1
-sql_error alter database db cache 60
-sql_error alter database db cache 50
-sql_error alter database db cache 20
-sql_error alter database db cache 3
-sql_error alter database db cache 129
-sql_error alter database db cache 300
-sql_error alter database db cache 0
-sql_error alter database db cache -1
+#print ============== modify cache
+#sql_error alter database db cache 12
+#sql_error alter database db cache 1
+#sql_error alter database db cache 60
+#sql_error alter database db cache 50
+#sql_error alter database db cache 20
+#sql_error alter database db cache 3
+#sql_error alter database db cache 129
+#sql_error alter database db cache 300
+#sql_error alter database db cache 0
+#sql_error alter database db cache -1
 
-print ============== modify blocks
-sql alter database db blocks 3
-sql show databases
-print blocks $data9_db
-if $data9_db != 3 then 
-  return -1
-endi
-sql alter database db blocks 11
-sql show databases
-print blocks $data9_db
-if $data9_db != 11 then 
-  return -1
-endi
+#print ============== modify blocks
+#sql alter database db blocks 3
+#sql show databases
+#print blocks $data9_db
+#if $data9_db != 3 then 
+#  return -1
+#endi
+#sql alter database db blocks 11
+#sql show databases
+#print blocks $data9_db
+#if $data9_db != 11 then 
+#  return -1
+#endi
 
-sql alter database db blocks 40
-sql alter database db blocks 30
-sql alter database db blocks 20
-sql alter database db blocks 10
-sql_error alter database db blocks 2
-sql_error alter database db blocks 1
-sql_error alter database db blocks 0
-sql_error alter database db blocks -1
-sql_error alter database db blocks 10001
+#sql alter database db blocks 40
+#sql alter database db blocks 30
+#sql alter database db blocks 20
+#sql alter database db blocks 10
+#sql_error alter database db blocks 2
+#sql_error alter database db blocks 1
+#sql_error alter database db blocks 0
+#sql_error alter database db blocks -1
+#sql_error alter database db blocks 10001
 
 print ============== modify minrows
 sql_error alter database db minrows 8

tests/script/tsim/db/basic6.sim

@@ -15,7 +15,8 @@ $tb = $tbPrefix . $i
 
 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 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 create database $db vgroups 8 replica 1 days 2880 keep 3650 minrows 80 maxrows 10000 wal 2 fsync 1000 comp 0 cachelast 2 precision 'us'
 sql show databases
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 
@@ -40,12 +41,12 @@ endi
 if $data27 != 3650,3650,3650 then
   return -1
 endi
-if $data28 != 32 then
-  return -1
-endi
-if $data29 != 12 then
-  return -1
-endi
+#if $data28 != 32 then
+#  return -1
+#endi
+#if $data29 != 12 then
+#  return -1
+#endi
  
 print =============== step2
 sql_error create database $db

tests/script/tsim/db/create_all_options.sim

@@ -124,12 +124,12 @@ endi
 if $data7_db != 5256000,5256000,5256000 then # keep
   return -1
 endi
-if $data8_db != 16 then  # cache
-  return -1
-endi
-if $data9_db != 6 then  # blocks
-  return -1
-endi
+#if $data8_db != 16 then  # cache
+#  return -1
+#endi
+#if $data9_db != 6 then  # blocks
+#  return -1
+#endi
 if $data10_db != 100 then  # minrows
   return -1
 endi
@@ -153,42 +153,42 @@ if $data16_db != ms then  # precision
 endi
 sql drop database db
 
-print ====> BLOCKS value       [3~1000, default: 6]
-sql create database db BLOCKS 3
-sql show databases
-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
-if $data9_db != 3 then
-  return -1
-endi
-sql drop database db
+#print ====> BLOCKS value       [3~1000, default: 6]
+#sql create database db BLOCKS 3
+#sql show databases
+#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
+#if $data9_db != 3 then
+#  return -1
+#endi
+#sql drop database db
 
-sql create database db BLOCKS 1000
-sql show databases
-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
-if $data9_db != 1000 then
-  return -1
-endi
-sql drop database db
-sql_error create database db BLOCKS 2
-sql_error create database db BLOCKS 0
-sql_error create database db BLOCKS -1
+#sql create database db BLOCKS 1000
+#sql show databases
+#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
+#if $data9_db != 1000 then
+#  return -1
+#endi
+#sql drop database db
+#sql_error create database db BLOCKS 2
+#sql_error create database db BLOCKS 0
+#sql_error create database db BLOCKS -1
 
-print ====> CACHE value [default: 16]
-sql create database db CACHE 1
-sql show databases
-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
-if $data8_db != 1 then
-  return -1
-endi
-sql drop database db
+#print ====> CACHE value [default: 16]
+#sql create database db CACHE 1
+#sql show databases
+#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
+#if $data8_db != 1 then
+#  return -1
+#endi
+#sql drop database db
 
-sql create database db CACHE 128
-sql show databases
-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
-if $data8_db != 128 then
-  return -1
-endi
-sql drop database db
+#sql create database db CACHE 128
+#sql show databases
+#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
+#if $data8_db != 128 then
+#  return -1
+#endi
+#sql drop database db
 
 print ====> CACHELAST value [0, 1, 2, 3, default: 0]
 sql create database db CACHELAST 1
@@ -387,24 +387,24 @@ sql_error create database db REPLICA 0
 sql_error create database db REPLICA -1
 sql_error create database db REPLICA 4
 
-print ====> TTL value [1d ~ , default: 1]
-sql create database db TTL 1
-sql show databases
-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 ====> TTL value [1d ~ , default: 1]
+#sql create database db TTL 1
+#sql show databases
+#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
 #if $dataXX_db != 1 then
 #  return -1
 #endi
-sql drop database db
+#sql drop database db
 
-sql create database db TTL 10
-sql show databases
-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
+#sql create database db TTL 10
+#sql show databases
+#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
 #if $dataXX_db != 10 then
 #  return -1
 #endi
-sql drop database db
-sql_error create database db TTL 0
-sql_error create database db TTL -1
+#sql drop database db
+#sql_error create database db TTL 0
+#sql_error create database db TTL -1
 
 print ====> WAL value [1 | 2, default: 1]
 sql create database db WAL 2
@@ -465,24 +465,24 @@ sql drop database db
 sql_error create database db SINGLE_STABLE 2
 sql_error create database db SINGLE_STABLE -1
 
-print ====> STREAM_MODE [0 | 1, default: ]
-sql create database db STREAM_MODE 1
-sql show databases
-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 ====> STREAM_MODE [0 | 1, default: ]
+#sql create database db STREAM_MODE 1
+#sql show databases
+#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
 #if $dataXXX_db != 1 then
 #  return -1
 #endi
-sql drop database db
+#sql drop database db
 
-sql create database db STREAM_MODE 0
-sql show databases
-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
+#sql create database db STREAM_MODE 0
+#sql show databases
+#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
 #if $dataXXX_db != 0 then
 #  return -1
 #endi
-sql drop database db
-sql_error create database db STREAM_MODE 2
-sql_error create database db STREAM_MODE -1
+#sql drop database db
+#sql_error create database db STREAM_MODE 2
+#sql_error create database db STREAM_MODE -1
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode2 -s stop -x SIGINT

tests/system-test/0-others/taosShell.py

@@ -11,13 +11,15 @@ from util.sql import *
 from util.cases import *
 from util.dnodes import *
 
-def taos_command (key, value, expectString, cfgDir, sqlString='', key1='', value1=''):
+def taos_command (buildPath, key, value, expectString, cfgDir, sqlString='', key1='', value1=''):
     if len(key) == 0:
         tdLog.exit("taos test key is null!")
     
+    taosCmd = buildPath + '/build/bin/taos '
     if len(cfgDir) != 0:
-        taosCmd = 'taos -c ' + cfgDir + ' -' + key
+        taosCmd = taosCmd + '-c ' + cfgDir
 
+    taosCmd = taosCmd + ' -' + key
     if len(value) != 0:
         if key == 'p':
             taosCmd = taosCmd + value
@@ -134,7 +136,7 @@ class TDTestCase:
         tdLog.printNoPrefix("================================ parameter: -h")
         newDbName="dbh"
         sqlString = 'create database ' + newDbName + ';'
-        retCode = taos_command("h", keyDict['h'], "taos>", keyDict['c'], sqlString)
+        retCode = taos_command(buildPath, "h", keyDict['h'], "taos>", keyDict['c'], sqlString)
         if retCode != "TAOS_OK":
             tdLog.exit("taos -h %s fail"%keyDict['h'])
         else:
@@ -157,7 +159,7 @@ class TDTestCase:
         #keyDict['P'] = 6030
         newDbName = "dbpp"
         sqlString = 'create database ' + newDbName + ';'
-        retCode = taos_command("P", keyDict['P'], "taos>", keyDict['c'], sqlString)
+        retCode = taos_command(buildPath, "P", keyDict['P'], "taos>", keyDict['c'], sqlString)
         if retCode != "TAOS_OK":
             tdLog.exit("taos -P %s fail"%keyDict['P'])
         else:
@@ -173,7 +175,7 @@ class TDTestCase:
         tdLog.printNoPrefix("================================ parameter: -u")
         newDbName="dbu"
         sqlString = 'create database ' + newDbName + ';'
-        retCode = taos_command("u", keyDict['u'], "taos>", keyDict['c'], sqlString, "p", keyDict['p'])
+        retCode = taos_command(buildPath, "u", keyDict['u'], "taos>", keyDict['c'], sqlString, "p", keyDict['p'])
         if retCode != "TAOS_OK":
             tdLog.exit("taos -u %s -p%s fail"%(keyDict['u'], keyDict['p']))
         else:
@@ -188,12 +190,12 @@ class TDTestCase:
 
         tdLog.printNoPrefix("================================ parameter: -A")
         newDbName="dbaa"
-        retCode, retVal = taos_command("p", keyDict['p'], "taos>", keyDict['c'], '', "A", '')
+        retCode, retVal = taos_command(buildPath, "p", keyDict['p'], "taos>", keyDict['c'], '', "A", '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -A fail")
                 
         sqlString = 'create database ' + newDbName + ';'
-        retCode = taos_command("u", keyDict['u'], "taos>", keyDict['c'], sqlString, 'a', retVal)
+        retCode = taos_command(buildPath, "u", keyDict['u'], "taos>", keyDict['c'], sqlString, 'a', retVal)
         if retCode != "TAOS_OK":
             tdLog.exit("taos -u %s -a %s"%(keyDict['u'], retVal))
 
@@ -209,7 +211,7 @@ class TDTestCase:
         tdLog.printNoPrefix("================================ parameter: -s")
         newDbName="dbss"
         keyDict['s'] = "\"create database " + newDbName + "\""
-        retCode = taos_command("s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -s fail")
 
@@ -222,17 +224,17 @@ class TDTestCase:
             tdLog.exit("create db fail after taos -s %s fail"%(keyDict['s']))
 
         keyDict['s'] = "\"create table " + newDbName + ".stb (ts timestamp, c int) tags (t int)\""
-        retCode = taos_command("s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -s create table fail")
 
         keyDict['s'] = "\"create table " + newDbName + ".ctb0 using " + newDbName + ".stb tags (0) " + newDbName + ".ctb1 using " + newDbName + ".stb tags (1)\""
-        retCode = taos_command("s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -s create table fail")
 
         keyDict['s'] = "\"insert into " + newDbName + ".ctb0 values('2021-04-01 08:00:00.000', 10)('2021-04-01 08:00:01.000', 20) " + newDbName + ".ctb1 values('2021-04-01 08:00:00.000', 11)('2021-04-01 08:00:01.000', 21)\""
-        retCode = taos_command("s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "Query OK", keyDict['c'], '', '', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -s insert data fail")
 
@@ -250,18 +252,18 @@ class TDTestCase:
         tdSql.checkData(1, 1, 21)
         
         keyDict['s'] = "\"select * from " + newDbName + ".ctb0\""
-        retCode = taos_command("s", keyDict['s'], "2021-04-01 08:00:01.000", keyDict['c'], '', '', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "2021-04-01 08:00:01.000", keyDict['c'], '', '', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -r show fail")
         
         tdLog.printNoPrefix("================================ parameter: -r")
         keyDict['s'] = "\"select * from " + newDbName + ".ctb0\""
-        retCode = taos_command("s", keyDict['s'], "1617235200000", keyDict['c'], '', 'r', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "1617235200000", keyDict['c'], '', 'r', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -r show fail")
 
         keyDict['s'] = "\"select * from " + newDbName + ".ctb1\""
-        retCode = taos_command("s", keyDict['s'], "1617235201000", keyDict['c'], '', 'r', '')
+        retCode = taos_command(buildPath, "s", keyDict['s'], "1617235201000", keyDict['c'], '', 'r', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -r show fail")
         
@@ -283,7 +285,7 @@ class TDTestCase:
         os.system(sql5)
 
         keyDict['f'] = pwd + "/0-others/sql.txt"
-        retCode = taos_command("f", keyDict['f'], 'performance_schema', keyDict['c'], '', '', '')
+        retCode = taos_command(buildPath, "f", keyDict['f'], 'performance_schema', keyDict['c'], '', '', '')
         print("============ ret code: ", retCode)
         if retCode != "TAOS_OK":
             tdLog.exit("taos -s fail")
@@ -310,7 +312,7 @@ class TDTestCase:
 
         tdLog.printNoPrefix("================================ parameter: -C")
         newDbName="dbcc"
-        retCode, retVal = taos_command("C", keyDict['C'], "buildinfo", keyDict['c'], '', '', '')
+        retCode, retVal = taos_command(buildPath, "C", keyDict['C'], "buildinfo", keyDict['c'], '', '', '')
         if retCode != "TAOS_OK":
             tdLog.exit("taos -C fail")
 

tests/system-test/fulltest.sh

 #!/bin/bash
 set -e
 
-#python3 ./test.py -f 0-others/taosShell.py
+python3 ./test.py -f 0-others/taosShell.py
 
 
 #python3 ./test.py -f 2-query/between.py