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

include/common/ttokendef.h

@@ -84,20 +84,20 @@
 #define TK_COMP                 66
 #define TK_DURATION             67
 #define TK_NK_VARIABLE          68
-#define TK_FSYNC                69
-#define TK_MAXROWS              70
-#define TK_MINROWS              71
-#define TK_KEEP                 72
-#define TK_PAGES                73
-#define TK_PAGESIZE             74
-#define TK_PRECISION            75
-#define TK_REPLICA              76
-#define TK_STRICT               77
-#define TK_WAL                  78
-#define TK_VGROUPS              79
-#define TK_SINGLE_STABLE        80
-#define TK_RETENTIONS           81
-#define TK_SCHEMALESS           82
+#define TK_MAXROWS              69
+#define TK_MINROWS              70
+#define TK_KEEP                 71
+#define TK_PAGES                72
+#define TK_PAGESIZE             73
+#define TK_PRECISION            74
+#define TK_REPLICA              75
+#define TK_STRICT               76
+#define TK_VGROUPS              77
+#define TK_SINGLE_STABLE        78
+#define TK_RETENTIONS           79
+#define TK_SCHEMALESS           80
+#define TK_WAL_LEVEL            81
+#define TK_WAL_FSYNC_PERIOD     82
 #define TK_WAL_RETENTION_PERIOD 83
 #define TK_WAL_RETENTION_SIZE   84
 #define TK_WAL_ROLL_PERIOD      85
@@ -188,93 +188,90 @@
 #define TK_NK_BOOL              170
 #define TK_RATIO                171
 #define TK_NK_FLOAT             172
-#define TK_COMPACT              173
-#define TK_VNODES               174
-#define TK_IN                   175
-#define TK_OUTPUTTYPE           176
-#define TK_AGGREGATE            177
-#define TK_BUFSIZE              178
-#define TK_STREAM               179
-#define TK_INTO                 180
-#define TK_TRIGGER              181
-#define TK_AT_ONCE              182
-#define TK_WINDOW_CLOSE         183
-#define TK_IGNORE               184
-#define TK_EXPIRED              185
-#define TK_KILL                 186
-#define TK_CONNECTION           187
-#define TK_TRANSACTION          188
-#define TK_BALANCE              189
-#define TK_VGROUP               190
-#define TK_MERGE                191
-#define TK_REDISTRIBUTE         192
-#define TK_SPLIT                193
-#define TK_SYNCDB               194
-#define TK_DELETE               195
-#define TK_INSERT               196
-#define TK_NULL                 197
-#define TK_NK_QUESTION          198
-#define TK_NK_ARROW             199
-#define TK_ROWTS                200
-#define TK_TBNAME               201
-#define TK_QSTART               202
-#define TK_QEND                 203
-#define TK_QDURATION            204
-#define TK_WSTART               205
-#define TK_WEND                 206
-#define TK_WDURATION            207
-#define TK_CAST                 208
-#define TK_NOW                  209
-#define TK_TODAY                210
-#define TK_TIMEZONE             211
-#define TK_CLIENT_VERSION       212
-#define TK_SERVER_VERSION       213
-#define TK_SERVER_STATUS        214
-#define TK_CURRENT_USER         215
-#define TK_COUNT                216
-#define TK_LAST_ROW             217
-#define TK_BETWEEN              218
-#define TK_IS                   219
-#define TK_NK_LT                220
-#define TK_NK_GT                221
-#define TK_NK_LE                222
-#define TK_NK_GE                223
-#define TK_NK_NE                224
-#define TK_MATCH                225
-#define TK_NMATCH               226
-#define TK_CONTAINS             227
-#define TK_JOIN                 228
-#define TK_INNER                229
-#define TK_SELECT               230
-#define TK_DISTINCT             231
-#define TK_WHERE                232
-#define TK_PARTITION            233
-#define TK_BY                   234
-#define TK_SESSION              235
-#define TK_STATE_WINDOW         236
-#define TK_SLIDING              237
-#define TK_FILL                 238
-#define TK_VALUE                239
-#define TK_NONE                 240
-#define TK_PREV                 241
-#define TK_LINEAR               242
-#define TK_NEXT                 243
-#define TK_HAVING               244
-#define TK_RANGE                245
-#define TK_EVERY                246
-#define TK_ORDER                247
-#define TK_SLIMIT               248
-#define TK_SOFFSET              249
-#define TK_LIMIT                250
-#define TK_OFFSET               251
-#define TK_ASC                  252
-#define TK_NULLS                253
-#define TK_ID                   254
-#define TK_NK_BITNOT            255
-#define TK_VALUES               256
-#define TK_IMPORT               257
-#define TK_NK_SEMI              258
-#define TK_FILE                 259
+#define TK_OUTPUTTYPE           173
+#define TK_AGGREGATE            174
+#define TK_BUFSIZE              175
+#define TK_STREAM               176
+#define TK_INTO                 177
+#define TK_TRIGGER              178
+#define TK_AT_ONCE              179
+#define TK_WINDOW_CLOSE         180
+#define TK_IGNORE               181
+#define TK_EXPIRED              182
+#define TK_KILL                 183
+#define TK_CONNECTION           184
+#define TK_TRANSACTION          185
+#define TK_BALANCE              186
+#define TK_VGROUP               187
+#define TK_MERGE                188
+#define TK_REDISTRIBUTE         189
+#define TK_SPLIT                190
+#define TK_DELETE               191
+#define TK_INSERT               192
+#define TK_NULL                 193
+#define TK_NK_QUESTION          194
+#define TK_NK_ARROW             195
+#define TK_ROWTS                196
+#define TK_TBNAME               197
+#define TK_QSTART               198
+#define TK_QEND                 199
+#define TK_QDURATION            200
+#define TK_WSTART               201
+#define TK_WEND                 202
+#define TK_WDURATION            203
+#define TK_CAST                 204
+#define TK_NOW                  205
+#define TK_TODAY                206
+#define TK_TIMEZONE             207
+#define TK_CLIENT_VERSION       208
+#define TK_SERVER_VERSION       209
+#define TK_SERVER_STATUS        210
+#define TK_CURRENT_USER         211
+#define TK_COUNT                212
+#define TK_LAST_ROW             213
+#define TK_BETWEEN              214
+#define TK_IS                   215
+#define TK_NK_LT                216
+#define TK_NK_GT                217
+#define TK_NK_LE                218
+#define TK_NK_GE                219
+#define TK_NK_NE                220
+#define TK_MATCH                221
+#define TK_NMATCH               222
+#define TK_CONTAINS             223
+#define TK_IN                   224
+#define TK_JOIN                 225
+#define TK_INNER                226
+#define TK_SELECT               227
+#define TK_DISTINCT             228
+#define TK_WHERE                229
+#define TK_PARTITION            230
+#define TK_BY                   231
+#define TK_SESSION              232
+#define TK_STATE_WINDOW         233
+#define TK_SLIDING              234
+#define TK_FILL                 235
+#define TK_VALUE                236
+#define TK_NONE                 237
+#define TK_PREV                 238
+#define TK_LINEAR               239
+#define TK_NEXT                 240
+#define TK_HAVING               241
+#define TK_RANGE                242
+#define TK_EVERY                243
+#define TK_ORDER                244
+#define TK_SLIMIT               245
+#define TK_SOFFSET              246
+#define TK_LIMIT                247
+#define TK_OFFSET               248
+#define TK_ASC                  249
+#define TK_NULLS                250
+#define TK_ID                   251
+#define TK_NK_BITNOT            252
+#define TK_VALUES               253
+#define TK_IMPORT               254
+#define TK_NK_SEMI              255
+#define TK_FILE                 256
 
 #define TK_NK_SPACE   300
 #define TK_NK_COMMENT 301

include/libs/nodes/plannodes.h

@@ -328,6 +328,7 @@ typedef struct STableScanPhysiNode {
   int8_t         triggerType;
   int64_t        watermark;
   int8_t         igExpired;
+  bool           assignBlockUid;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;

include/util/taoserror.h

@@ -513,7 +513,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_ONLY_ONE_JSON_TAG         TAOS_DEF_ERROR_CODE(0, 0x2633)
 #define TSDB_CODE_PAR_INCORRECT_NUM_OF_COL      TAOS_DEF_ERROR_CODE(0, 0x2634)
 #define TSDB_CODE_PAR_INCORRECT_TIMESTAMP_VAL   TAOS_DEF_ERROR_CODE(0, 0x2635)
-#define TSDB_CODE_PAR_INVALID_DAYS_VALUE        TAOS_DEF_ERROR_CODE(0, 0x2636)
 #define TSDB_CODE_PAR_OFFSET_LESS_ZERO          TAOS_DEF_ERROR_CODE(0, 0x2637)
 #define TSDB_CODE_PAR_SLIMIT_LEAK_PARTITION_BY  TAOS_DEF_ERROR_CODE(0, 0x2638)
 #define TSDB_CODE_PAR_INVALID_TOPIC_QUERY       TAOS_DEF_ERROR_CODE(0, 0x2639)

source/common/src/systable.c

@@ -89,8 +89,8 @@ static const SSysDbTableSchema userDBSchema[] = {
     {.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "retention", .bytes = 60 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "single_stable", .bytes = 1, .type = TSDB_DATA_TYPE_BOOL},
-    {.name = "cache_model", .bytes = TSDB_CACHE_MODEL_STR_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
-    {.name = "cache_size", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
+    {.name = "cachemodel", .bytes = TSDB_CACHE_MODEL_STR_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
+    {.name = "cachesize", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
     {.name = "wal_level", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT},
     {.name = "wal_fsync_period", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
     {.name = "wal_retention_period", .bytes = 4, .type = TSDB_DATA_TYPE_INT},

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

@@ -431,6 +431,12 @@ static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, STsd
 
   pSup->tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;
 
+  code = tBlockDataInit(&pReader->status.fileBlockData);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = code;
+    goto _end;
+  }
+
   pReader->pResBlock = createResBlock(pCond, pReader->capacity);
   if (pReader->pResBlock == NULL) {
     code = terrno;
@@ -1200,8 +1206,9 @@ static int32_t buildDataBlockFromBuf(STsdbReader* pReader, STableBlockScanInfo*
 }
 
 static int32_t doMergeBufAndFileRows(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, TSDBROW* pRow,
-                                     STSRow* pTSRow, SIterInfo* pIter, int64_t key) {
+                                     SIterInfo* pIter, int64_t key) {
   SRowMerger          merge = {0};
+  STSRow*             pTSRow = NULL;
   SBlockData*         pBlockData = &pReader->status.fileBlockData;
   SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo;
 
@@ -1250,6 +1257,8 @@ static int32_t doMergeBufAndFileRows(STsdbReader* pReader, STableBlockScanInfo*
 
   tRowMergerClear(&merge);
   doAppendOneRow(pReader->pResBlock, pReader, pTSRow);
+
+  taosMemoryFree(pTSRow);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1411,8 +1420,6 @@ static int32_t buildComposedDataBlockImpl(STsdbReader* pReader, STableBlockScanI
   SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo;
   SBlockData*         pBlockData = &pReader->status.fileBlockData;
 
-  STSRow*    pTSRow = NULL;
-
   int64_t  key = pBlockData->aTSKEY[pDumpInfo->rowIndex];
   TSDBROW* pRow = getValidRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader);
   TSDBROW* piRow = getValidRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader);
@@ -1422,23 +1429,27 @@ static int32_t buildComposedDataBlockImpl(STsdbReader* pReader, STableBlockScanI
   } else {
     // imem + file
     if (pBlockScanInfo->iiter.hasVal) {
-      return doMergeBufAndFileRows(pReader, pBlockScanInfo, piRow, pTSRow, &pBlockScanInfo->iiter, key);
+      return doMergeBufAndFileRows(pReader, pBlockScanInfo, piRow, &pBlockScanInfo->iiter, key);
     }
 
     // mem + file
     if (pBlockScanInfo->iter.hasVal) {
-      return doMergeBufAndFileRows(pReader, pBlockScanInfo, pRow, pTSRow, &pBlockScanInfo->iter, key);
+      return doMergeBufAndFileRows(pReader, pBlockScanInfo, pRow, &pBlockScanInfo->iter, key);
     }
 
     // imem & mem are all empty, only file exist
     TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);
 
+    STSRow*    pTSRow = NULL;
     SRowMerger merge = {0};
+
     tRowMergerInit(&merge, &fRow, pReader->pSchema);
     doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pReader, &merge);
     tRowMergerGetRow(&merge, &pTSRow);
     doAppendOneRow(pReader->pResBlock, pReader, pTSRow);
 
+    taosMemoryFree(pTSRow);
+    tRowMergerClear(&merge);
     return TSDB_CODE_SUCCESS;
   }
 }
@@ -1716,7 +1727,8 @@ static int32_t doBuildDataBlock(STsdbReader* pReader) {
 
   TSDBKEY key = getCurrentKeyInBuf(pBlockIter, pReader);
   if (fileBlockShouldLoad(pReader, pFBlock, pBlock, pScanInfo, key)) {
-    tBlockDataInit(&pStatus->fileBlockData);
+    tBlockDataReset(&pStatus->fileBlockData);
+    tBlockDataClearData(&pStatus->fileBlockData);
     code = doLoadFileBlockData(pReader, pBlockIter, pScanInfo, &pStatus->fileBlockData);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -2160,6 +2172,8 @@ static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanIn
     setFileBlockActiveInBlockIter(pBlockIter, neighborIndex, step);
 
     // 3. load the neighbor block, and set it to be the currently accessed file data block
+    tBlockDataReset(&pStatus->fileBlockData);
+    tBlockDataClearData(&pStatus->fileBlockData);
     int32_t code = doLoadFileBlockData(pReader, pBlockIter, pScanInfo, &pStatus->fileBlockData);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -2563,6 +2577,7 @@ void tsdbReaderClose(STsdbReader* pReader) {
     }
   }
   taosMemoryFree(pSupInfo->buildBuf);
+  tBlockDataClear(&pReader->status.fileBlockData, true);
 
   cleanupDataBlockIterator(&pReader->status.blockIter);
 
@@ -2760,13 +2775,9 @@ static SArray* doRetrieveDataBlock(STsdbReader* pReader) {
   SFileDataBlockInfo*  pFBlock = getCurrentBlockInfo(&pStatus->blockIter);
   STableBlockScanInfo* pBlockScanInfo = taosHashGet(pStatus->pTableMap, &pFBlock->uid, sizeof(pFBlock->uid));
 
-  int32_t code = tBlockDataInit(&pStatus->fileBlockData);
-  if (code != TSDB_CODE_SUCCESS) {
-    terrno = code;
-    return NULL;
-  }
-
-  code = doLoadFileBlockData(pReader, &pStatus->blockIter, pBlockScanInfo, &pStatus->fileBlockData);
+  tBlockDataReset(&pStatus->fileBlockData);
+  tBlockDataClearData(&pStatus->fileBlockData);
+  int32_t code = doLoadFileBlockData(pReader, &pStatus->blockIter, pBlockScanInfo, &pStatus->fileBlockData);
   if (code != TSDB_CODE_SUCCESS) {
     tBlockDataClear(&pStatus->fileBlockData, 1);
 
@@ -2775,7 +2786,6 @@ static SArray* doRetrieveDataBlock(STsdbReader* pReader) {
   }
 
   copyBlockDataToSDataBlock(pReader, pBlockScanInfo);
-  tBlockDataClear(&pStatus->fileBlockData, 1);
   return pReader->pResBlock->pDataBlock;
 }
 
@@ -2872,9 +2882,7 @@ int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTa
 
   while (true) {
     if (hasNext) {
-      SFileDataBlockInfo*  pFBlock = getCurrentBlockInfo(pBlockIter);
-      STableBlockScanInfo* pScanInfo = taosHashGet(pStatus->pTableMap, &pFBlock->uid, sizeof(pFBlock->uid));
-      SBlock*              pBlock = taosArrayGet(pScanInfo->pBlockList, pFBlock->tbBlockIdx);
+      SBlock* pBlock = getCurrentBlock(pBlockIter);
 
       int32_t numOfRows = pBlock->nRow;
       pTableBlockInfo->totalRows += numOfRows;
@@ -2895,7 +2903,6 @@ int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTa
       pTableBlockInfo->blockRowsHisto[bucketIndex]++;
 
       hasNext = blockIteratorNext(&pStatus->blockIter);
-
     } else {
       code = initForFirstBlockInFile(pReader, pBlockIter);
       if ((code != TSDB_CODE_SUCCESS) || (pReader->status.loadFromFile == false)) {

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

@@ -1022,6 +1022,10 @@ void tBlockDataClear(SBlockData *pBlockData, int8_t deepClear) {
   tFree((uint8_t *)pBlockData->aTSKEY);
   taosArrayDestroy(pBlockData->aIdx);
   taosArrayDestroyEx(pBlockData->aColData, deepClear ? tColDataClear : NULL);
+  pBlockData->aColData = NULL;
+  pBlockData->aIdx = NULL;
+  pBlockData->aTSKEY = NULL;
+  pBlockData->aVersion = NULL;
 }
 
 int32_t tBlockDataSetSchema(SBlockData *pBlockData, STSchema *pTSchema) {

source/libs/executor/src/executorimpl.c

@@ -3209,9 +3209,8 @@ static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo* pInfo, SResultInf
   if (taosFillHasMoreResults(pInfo->pFillInfo)) {
     int32_t numOfResultRows = pResultInfo->capacity - pInfo->pRes->info.rows;
     taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pRes, numOfResultRows);
-    if (pInfo->pRes->info.rows > pResultInfo->threshold) {
-      return;
-    }
+    pInfo->pRes->info.groupId = pInfo->curGroupId;
+    return;
   }
 
   // handle the cached new group data block
@@ -3230,7 +3229,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
   blockDataCleanup(pResBlock);
 
   doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, pTaskInfo);
-  if (pResBlock->info.rows > pResultInfo->threshold || pResBlock->info.rows > 0) {
+  if (pResBlock->info.rows > 0) {
     pResBlock->info.groupId = pInfo->curGroupId;
     return pResBlock;
   }

source/libs/executor/src/joinoperator.c

@@ -83,8 +83,6 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t
   } else if (pJoinNode->inputTsOrder == ORDER_DESC) {
     pInfo->inputTsOrder = TSDB_ORDER_DESC;
   }
-  //TODO: remove this when JoinNode inputTsOrder is ready
-  pInfo->inputTsOrder = TSDB_ORDER_ASC;
 
   pOperator->fpSet =
       createOperatorFpSet(operatorDummyOpenFn, doMergeJoin, NULL, NULL, destroyMergeJoinOperator, NULL, NULL, NULL);
@@ -116,7 +114,9 @@ void destroyMergeJoinOperator(void* param, int32_t numOfOutput) {
 
   taosMemoryFreeClear(param);
 }
-static void doJoinOneRow(struct SOperatorInfo* pOperator, SSDataBlock* pRes, int32_t currRow) {
+
+static void mergeJoinJoinLeftRight(struct SOperatorInfo* pOperator, SSDataBlock* pRes, int32_t currRow,
+                            SSDataBlock* pLeftBlock, int32_t leftPos, SSDataBlock* pRightBlock, int32_t rightPos) {
   SJoinOperatorInfo* pJoinInfo = pOperator->info;
 
   for (int32_t i = 0; i < pOperator->exprSupp.numOfExprs; ++i) {
@@ -130,11 +130,11 @@ static void doJoinOneRow(struct SOperatorInfo* pOperator, SSDataBlock* pRes, int
 
     SColumnInfoData* pSrc = NULL;
     if (pJoinInfo->pLeft->info.blockId == blockId) {
-      pSrc = taosArrayGet(pJoinInfo->pLeft->pDataBlock, slotId);
-      rowIndex = pJoinInfo->leftPos;
+      pSrc = taosArrayGet(pLeftBlock->pDataBlock, slotId);
+      rowIndex = leftPos;
     } else {
-      pSrc = taosArrayGet(pJoinInfo->pRight->pDataBlock, slotId);
-      rowIndex = pJoinInfo->rightPos;
+      pSrc = taosArrayGet(pRightBlock->pDataBlock, slotId);
+      rowIndex = rightPos;
     }
 
     if (colDataIsNull_s(pSrc, rowIndex)) {
@@ -146,60 +146,74 @@ static void doJoinOneRow(struct SOperatorInfo* pOperator, SSDataBlock* pRes, int
   }
 
 }
-static void doMergeJoinImpl(struct SOperatorInfo* pOperator, SSDataBlock* pRes) {
+
+static bool mergeJoinGetNextTimestamp(SOperatorInfo* pOperator, int64_t* pLeftTs, int64_t* pRightTs) {
   SJoinOperatorInfo* pJoinInfo = pOperator->info;
 
-  int32_t nrows = pRes->info.rows;
+  if (pJoinInfo->pLeft == NULL || pJoinInfo->leftPos >= pJoinInfo->pLeft->info.rows) {
+    SOperatorInfo* ds1 = pOperator->pDownstream[0];
+    pJoinInfo->pLeft = ds1->fpSet.getNextFn(ds1);
 
-  bool asc = (pJoinInfo->inputTsOrder == TSDB_ORDER_ASC) ? true : false;
-
-  while (1) {
-    // todo extract method
-    if (pJoinInfo->pLeft == NULL || pJoinInfo->leftPos >= pJoinInfo->pLeft->info.rows) {
-      SOperatorInfo* ds1 = pOperator->pDownstream[0];
-      pJoinInfo->pLeft = ds1->fpSet.getNextFn(ds1);
-
-      pJoinInfo->leftPos = 0;
-      if (pJoinInfo->pLeft == NULL) {
-        setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED);
-        break;
-      }
+    pJoinInfo->leftPos = 0;
+    if (pJoinInfo->pLeft == NULL) {
+      setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED);
+      return false;
     }
+  }
 
-    if (pJoinInfo->pRight == NULL || pJoinInfo->rightPos >= pJoinInfo->pRight->info.rows) {
-      SOperatorInfo* ds2 = pOperator->pDownstream[1];
-      pJoinInfo->pRight = ds2->fpSet.getNextFn(ds2);
+  if (pJoinInfo->pRight == NULL || pJoinInfo->rightPos >= pJoinInfo->pRight->info.rows) {
+    SOperatorInfo* ds2 = pOperator->pDownstream[1];
+    pJoinInfo->pRight = ds2->fpSet.getNextFn(ds2);
 
-      pJoinInfo->rightPos = 0;
-      if (pJoinInfo->pRight == NULL) {
-        setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED);
-        break;
-      }
+    pJoinInfo->rightPos = 0;
+    if (pJoinInfo->pRight == NULL) {
+      setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED);
+      return false;
     }
+  }
+  // only the timestamp match support for ordinary table
+  SColumnInfoData* pLeftCol = taosArrayGet(pJoinInfo->pLeft->pDataBlock, pJoinInfo->leftCol.slotId);
+  char*            pLeftVal = colDataGetData(pLeftCol, pJoinInfo->leftPos);
+  *pLeftTs = *(int64_t*)pLeftVal;
+
+  SColumnInfoData* pRightCol = taosArrayGet(pJoinInfo->pRight->pDataBlock, pJoinInfo->rightCol.slotId);
+  char*            pRightVal = colDataGetData(pRightCol, pJoinInfo->rightPos);
+  *pRightTs = *(int64_t*)pRightVal;
+
+  ASSERT(pLeftCol->info.type == TSDB_DATA_TYPE_TIMESTAMP);
+  ASSERT(pRightCol->info.type == TSDB_DATA_TYPE_TIMESTAMP);
+  return true;
+}
+
+static void doMergeJoinImpl(struct SOperatorInfo* pOperator, SSDataBlock* pRes) {
+  SJoinOperatorInfo* pJoinInfo = pOperator->info;
 
-    SColumnInfoData* pLeftCol = taosArrayGet(pJoinInfo->pLeft->pDataBlock, pJoinInfo->leftCol.slotId);
-    char*            pLeftVal = colDataGetData(pLeftCol, pJoinInfo->leftPos);
+  int32_t nrows = pRes->info.rows;
 
-    SColumnInfoData* pRightCol = taosArrayGet(pJoinInfo->pRight->pDataBlock, pJoinInfo->rightCol.slotId);
-    char*            pRightVal = colDataGetData(pRightCol, pJoinInfo->rightPos);
+  bool asc = (pJoinInfo->inputTsOrder == TSDB_ORDER_ASC) ? true : false;
+
+  while (1) {
+    int64_t leftTs = 0;
+    int64_t rightTs = 0;
+    bool hasNextTs = mergeJoinGetNextTimestamp(pOperator, &leftTs, &rightTs);
+    if (!hasNextTs) {
+      break;
+    }
 
-    // only the timestamp match support for ordinary table
-    ASSERT(pLeftCol->info.type == TSDB_DATA_TYPE_TIMESTAMP);
-    if (*(int64_t*)pLeftVal == *(int64_t*)pRightVal) {
-      doJoinOneRow(pOperator, pRes, nrows);
+    if (leftTs == rightTs) {
+      mergeJoinJoinLeftRight(pOperator, pRes, nrows,
+                      pJoinInfo->pLeft, pJoinInfo->leftPos, pJoinInfo->pRight, pJoinInfo->rightPos);
       pJoinInfo->leftPos += 1;
       pJoinInfo->rightPos += 1;
 
       nrows += 1;
-    } else if (asc && *(int64_t*)pLeftVal < *(int64_t*)pRightVal ||
-               !asc && *(int64_t*)pLeftVal > *(int64_t*)pRightVal) {
+    } else if (asc && leftTs < rightTs || !asc && leftTs > rightTs) {
       pJoinInfo->leftPos += 1;
 
       if (pJoinInfo->leftPos >= pJoinInfo->pLeft->info.rows) {
         continue;
       }
-    } else if (asc && *(int64_t*)pLeftVal > *(int64_t*)pRightVal ||
-               !asc && *(int64_t*)pLeftVal < *(int64_t*)pRightVal) {
+    } else if (asc && leftTs > rightTs || !asc && leftTs < rightTs) {
       pJoinInfo->rightPos += 1;
       if (pJoinInfo->rightPos >= pJoinInfo->pRight->info.rows) {
         continue;

source/libs/executor/src/projectoperator.c

@@ -292,7 +292,9 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
 
       // do apply filter
       doFilter(pProjectInfo->pFilterNode, pFinalRes, NULL);
-      if (pFinalRes->info.rows > 0 || pRes->info.rows == 0) {
+
+      // when apply the limit/offset for each group, pRes->info.rows may be 0, due to limit constraint.
+      if (pFinalRes->info.rows > 0 || (pOperator->status == OP_EXEC_DONE)) {
         break;
       }
     } else {

source/libs/executor/src/scanoperator.c

@@ -1526,6 +1526,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
   pInfo->pDeleteDataRes = createSpecialDataBlock(STREAM_DELETE_DATA);
   pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};
   pInfo->pUpdateDataRes = createSpecialDataBlock(STREAM_CLEAR);
+  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;
 
   pOperator->name = "StreamScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN;

source/libs/nodes/src/nodesCodeFuncs.c

@@ -1712,6 +1712,7 @@ static int32_t jsonToPhysiProjectNode(const SJson* pJson, void* pObj) {
 }
 
 static const char* jkJoinPhysiPlanJoinType = "JoinType";
+static const char* jkJoinPhysiPlanInputTsOrder = "InputTsOrder";
 static const char* jkJoinPhysiPlanMergeCondition = "MergeCondition";
 static const char* jkJoinPhysiPlanOnConditions = "OnConditions";
 static const char* jkJoinPhysiPlanTargets = "Targets";
@@ -1723,6 +1724,9 @@ static int32_t physiJoinNodeToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanJoinType, pNode->joinType);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanInputTsOrder, pNode->inputTsOrder);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddObject(pJson, jkJoinPhysiPlanMergeCondition, nodeToJson, pNode->pMergeCondition);
   }
@@ -1742,7 +1746,9 @@ static int32_t jsonToPhysiJoinNode(const SJson* pJson, void* pObj) {
   int32_t code = jsonToPhysicPlanNode(pJson, pObj);
   if (TSDB_CODE_SUCCESS == code) {
     tjsonGetNumberValue(pJson, jkJoinPhysiPlanJoinType, pNode->joinType, code);
-    ;
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    tjsonGetNumberValue(pJson, jkJoinPhysiPlanInputTsOrder, pNode->inputTsOrder, code);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = jsonToNodeObject(pJson, jkJoinPhysiPlanOnConditions, &pNode->pOnConditions);

source/libs/parser/inc/sql.y

@@ -176,7 +176,6 @@ db_options(A) ::= db_options(B) CACHESIZE NK_INTEGER(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) DURATION NK_INTEGER(C).                           { A = setDatabaseOption(pCxt, B, DB_OPTION_DAYS, &C); }
 db_options(A) ::= db_options(B) DURATION 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); }
@@ -186,11 +185,12 @@ db_options(A) ::= db_options(B) PAGESIZE NK_INTEGER(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_STRING(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); }
 db_options(A) ::= db_options(B) SCHEMALESS NK_INTEGER(C).                         { A = setDatabaseOption(pCxt, B, DB_OPTION_SCHEMALESS, &C); }
+db_options(A) ::= db_options(B) WAL_LEVEL NK_INTEGER(C).                          { A = setDatabaseOption(pCxt, B, DB_OPTION_WAL, &C); }
+db_options(A) ::= db_options(B) WAL_FSYNC_PERIOD NK_INTEGER(C).                   { A = setDatabaseOption(pCxt, B, DB_OPTION_FSYNC, &C); }
 db_options(A) ::= db_options(B) WAL_RETENTION_PERIOD NK_INTEGER(C).               { A = setDatabaseOption(pCxt, B, DB_OPTION_WAL_RETENTION_PERIOD, &C); }
 db_options(A) ::= db_options(B) WAL_RETENTION_PERIOD NK_MINUS(D) NK_INTEGER(C).   { 
                                                                                     SToken t = D;
@@ -214,13 +214,13 @@ alter_db_options(A) ::= alter_db_options(B) alter_db_option(C).
 //alter_db_option(A) ::= BUFFER NK_INTEGER(B).                                      { A.type = DB_OPTION_BUFFER; A.val = B; }
 alter_db_option(A) ::= CACHEMODEL NK_STRING(B).                                   { A.type = DB_OPTION_CACHEMODEL; A.val = B; }
 alter_db_option(A) ::= CACHESIZE NK_INTEGER(B).                                   { A.type = DB_OPTION_CACHESIZE; A.val = B; }
-alter_db_option(A) ::= FSYNC NK_INTEGER(B).                                       { A.type = DB_OPTION_FSYNC; A.val = B; }
+alter_db_option(A) ::= WAL_FSYNC_PERIOD 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) ::= 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_STRING(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; }
+alter_db_option(A) ::= WAL_LEVEL NK_INTEGER(B).                                   { A.type = DB_OPTION_WAL; A.val = B; }
 
 %type integer_list                                                                { SNodeList* }
 %destructor integer_list                                                          { nodesDestroyList($$); }
@@ -476,7 +476,7 @@ explain_options(A) ::= explain_options(B) VERBOSE NK_BOOL(C).
 explain_options(A) ::= explain_options(B) RATIO NK_FLOAT(C).                      { A = setExplainRatio(pCxt, B, &C); }
 
 /************************************************ compact *************************************************************/
-cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP.                               { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
+//cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP.                               { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
 
 /************************************************ create/drop function ************************************************/
 cmd ::= CREATE agg_func_opt(A) FUNCTION not_exists_opt(F) function_name(B) 
@@ -525,7 +525,7 @@ dnode_list(A) ::= DNODE NK_INTEGER(B).
 dnode_list(A) ::= dnode_list(B) DNODE NK_INTEGER(C).                              { A = addNodeToList(pCxt, B, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C)); }
 
 /************************************************ syncdb **************************************************************/
-cmd ::= SYNCDB db_name(A) REPLICA.                                                { pCxt->pRootNode = createSyncdbStmt(pCxt, &A); }
+//cmd ::= SYNCDB db_name(A) REPLICA.                                                { pCxt->pRootNode = createSyncdbStmt(pCxt, &A); }
 
 /************************************************ syncdb **************************************************************/
 cmd ::= DELETE FROM full_table_name(A) where_clause_opt(B).                       { pCxt->pRootNode = createDeleteStmt(pCxt, A, B); }

source/libs/parser/src/parTokenizer.c

@@ -29,291 +29,224 @@ typedef struct SKeyword {
 // clang-format off
 // keywords in sql string
 static SKeyword keywordTable[] = {
-    {"ACCOUNT",        TK_ACCOUNT},
-    {"ACCOUNTS",       TK_ACCOUNTS},
-    {"ADD",            TK_ADD},
-    {"AGGREGATE",      TK_AGGREGATE},
-    {"ALL",            TK_ALL},
-    {"ALTER",          TK_ALTER},
-    {"ANALYZE",        TK_ANALYZE},
-    {"AND",            TK_AND},
-    {"APPS",           TK_APPS},
-    {"AS",             TK_AS},
-    {"ASC",            TK_ASC},
-    {"AT_ONCE",        TK_AT_ONCE},
-    {"BALANCE",        TK_BALANCE},
-    {"BETWEEN",        TK_BETWEEN},
-    {"BINARY",         TK_BINARY},
-    {"BIGINT",         TK_BIGINT},
-    {"BNODE",          TK_BNODE},
-    {"BNODES",         TK_BNODES},
-    {"BOOL",           TK_BOOL},
-    {"BUFFER",         TK_BUFFER},
-    {"BUFSIZE",        TK_BUFSIZE},
-    {"BY",             TK_BY},
-    {"CACHE",          TK_CACHE},
-    {"CACHEMODEL",     TK_CACHEMODEL},
-    {"CACHESIZE",      TK_CACHESIZE},
-    {"CAST",           TK_CAST},
-    {"CLIENT_VERSION", TK_CLIENT_VERSION},
-    {"CLUSTER",        TK_CLUSTER},
-    {"COLUMN",         TK_COLUMN},
-    {"COMMENT",        TK_COMMENT},
-    {"COMP",           TK_COMP},
-    {"COMPACT",        TK_COMPACT},
-    {"CONNS",          TK_CONNS},
-    {"CONNECTION",     TK_CONNECTION},
-    {"CONNECTIONS",    TK_CONNECTIONS},
-    {"CONSUMER",       TK_CONSUMER},
-    {"CONSUMERS",      TK_CONSUMERS},
-    {"CONTAINS",       TK_CONTAINS},
-    {"COUNT",          TK_COUNT},
-    {"CREATE",         TK_CREATE},
-    {"CURRENT_USER",   TK_CURRENT_USER},
-    {"DATABASE",       TK_DATABASE},
-    {"DATABASES",      TK_DATABASES},
-    {"DBS",            TK_DBS},
-    {"DELETE",         TK_DELETE},
-    {"DESC",           TK_DESC},
-    {"DESCRIBE",       TK_DESCRIBE},
-    {"DISTINCT",       TK_DISTINCT},
-    {"DISTRIBUTED",    TK_DISTRIBUTED},
-    {"DNODE",          TK_DNODE},
-    {"DNODES",         TK_DNODES},
-    {"DOUBLE",         TK_DOUBLE},
-    {"DROP",           TK_DROP},
-    {"DURATION",       TK_DURATION},
-    {"ENABLE",         TK_ENABLE},
-    {"EXISTS",         TK_EXISTS},
-    {"EXPIRED",        TK_EXPIRED},
-    {"EXPLAIN",        TK_EXPLAIN},
-    {"EVERY",          TK_EVERY},
-    {"FILE",           TK_FILE},
-    {"FILL",           TK_FILL},
-    {"FIRST",          TK_FIRST},
-    {"FLOAT",          TK_FLOAT},
-    {"FLUSH",          TK_FLUSH},
-    {"FROM",           TK_FROM},
-    {"FSYNC",          TK_FSYNC},
-    {"FUNCTION",       TK_FUNCTION},
-    {"FUNCTIONS",      TK_FUNCTIONS},
-    {"GRANT",          TK_GRANT},
-    {"GRANTS",         TK_GRANTS},
-    {"GROUP",          TK_GROUP},
-    {"HAVING",         TK_HAVING},
-    {"IF",             TK_IF},
-    {"IGNORE",         TK_IGNORE},
-    {"IMPORT",         TK_IMPORT},
-    {"IN",             TK_IN},
-    {"INDEX",          TK_INDEX},
-    {"INDEXES",        TK_INDEXES},
-    {"INNER",          TK_INNER},
-    {"INT",            TK_INT},
-    {"INSERT",         TK_INSERT},
-    {"INTEGER",        TK_INTEGER},
-    {"INTERVAL",       TK_INTERVAL},
-    {"INTO",           TK_INTO},
-    {"IS",             TK_IS},
-    {"JOIN",           TK_JOIN},
-    {"JSON",           TK_JSON},
-    {"KEEP",           TK_KEEP},
-    {"KILL",           TK_KILL},
-    {"LAST",           TK_LAST},
-    {"LAST_ROW",       TK_LAST_ROW},
-    {"LICENCE",        TK_LICENCE},
-    {"LIKE",           TK_LIKE},
-    {"LIMIT",          TK_LIMIT},
-    {"LINEAR",         TK_LINEAR},
-    {"LOCAL",          TK_LOCAL},
-    {"MATCH",          TK_MATCH},
-    {"MAXROWS",        TK_MAXROWS},
-    {"MAX_DELAY",      TK_MAX_DELAY},
-    {"MERGE",          TK_MERGE},
-    {"META",           TK_META},
-    {"MINROWS",        TK_MINROWS},
-    {"MINUS",          TK_MINUS},
-    {"MNODE",          TK_MNODE},
-    {"MNODES",         TK_MNODES},
-    {"MODIFY",         TK_MODIFY},
-    {"MODULES",        TK_MODULES},
-    {"NCHAR",          TK_NCHAR},
-    {"NEXT",           TK_NEXT},
-    {"NMATCH",         TK_NMATCH},
-    {"NONE",           TK_NONE},
-    {"NOT",            TK_NOT},
-    {"NOW",            TK_NOW},
-    {"NULL",           TK_NULL},
-    {"NULLS",          TK_NULLS},
-    {"OFFSET",         TK_OFFSET},
-    {"ON",             TK_ON},
-    {"OR",             TK_OR},
-    {"ORDER",          TK_ORDER},
-    {"OUTPUTTYPE",     TK_OUTPUTTYPE},
-    {"PARTITION",      TK_PARTITION},
-    {"PASS",           TK_PASS},
-    {"PAGES",          TK_PAGES},
-    {"PAGESIZE",       TK_PAGESIZE},
-    {"PORT",           TK_PORT},
-    {"PPS",            TK_PPS},
-    {"PRECISION",      TK_PRECISION},
-    // {"PRIVILEGE",      TK_PRIVILEGE},
-    {"PREV",           TK_PREV},
-    {"QNODE",          TK_QNODE},
-    {"QNODES",         TK_QNODES},
-    {"QTIME",          TK_QTIME},
-    {"QUERIES",        TK_QUERIES},
-    {"QUERY",          TK_QUERY},
-    {"RANGE",          TK_RANGE},
-    {"RATIO",          TK_RATIO},
-    {"READ",           TK_READ},
-    {"REDISTRIBUTE",   TK_REDISTRIBUTE},
-    {"RENAME",         TK_RENAME},
-    {"REPLICA",        TK_REPLICA},
-    {"RESET",          TK_RESET},
-    {"RETENTIONS",     TK_RETENTIONS},
-    {"REVOKE",         TK_REVOKE},
-    {"ROLLUP",         TK_ROLLUP},
-    {"SCHEMALESS",     TK_SCHEMALESS},
-    {"SCORES",         TK_SCORES},
-    {"SELECT",         TK_SELECT},
-    {"SERVER_STATUS",  TK_SERVER_STATUS},
-    {"SERVER_VERSION", TK_SERVER_VERSION},
-    {"SESSION",        TK_SESSION},
-    {"SET",            TK_SET},
-    {"SHOW",           TK_SHOW},
-    {"SINGLE_STABLE",  TK_SINGLE_STABLE},
-    {"SLIDING",        TK_SLIDING},
-    {"SLIMIT",         TK_SLIMIT},
-    {"SMA",            TK_SMA},
-    {"SMALLINT",       TK_SMALLINT},
-    {"SNODE",          TK_SNODE},
-    {"SNODES",         TK_SNODES},
-    {"SOFFSET",        TK_SOFFSET},
-    {"SPLIT",          TK_SPLIT},
-    {"STABLE",         TK_STABLE},
-    {"STABLES",        TK_STABLES},
-    {"STATE",          TK_STATE},
-    {"STATE_WINDOW",   TK_STATE_WINDOW},
-    {"STORAGE",        TK_STORAGE},
-    {"STREAM",         TK_STREAM},
-    {"STREAMS",        TK_STREAMS},
-    {"STRICT",         TK_STRICT},
-    {"SUBSCRIPTIONS",  TK_SUBSCRIPTIONS},
-    {"SYNCDB",         TK_SYNCDB},
-    {"SYSINFO",        TK_SYSINFO},
-    {"TABLE",          TK_TABLE},
-    {"TABLES",         TK_TABLES},
-    {"TAG",            TK_TAG},
-    {"TAGS",           TK_TAGS},
-    {"TBNAME",         TK_TBNAME},
-    {"TIMESTAMP",      TK_TIMESTAMP},
-    {"TIMEZONE",       TK_TIMEZONE},
-    {"TINYINT",        TK_TINYINT},
-    {"TO",             TK_TO},
-    {"TODAY",          TK_TODAY},
-    {"TOPIC",          TK_TOPIC},
-    {"TOPICS",         TK_TOPICS},
-    {"TRANSACTION",    TK_TRANSACTION},
-    {"TRANSACTIONS",   TK_TRANSACTIONS},
-    {"TRIGGER",        TK_TRIGGER},
-    {"TRIM",           TK_TRIM},
-    {"TSERIES",        TK_TSERIES},
-    {"TTL",            TK_TTL},
-    {"UNION",          TK_UNION},
-    {"UNSIGNED",       TK_UNSIGNED},
-    {"USE",            TK_USE},
-    {"USER",           TK_USER},
-    {"USERS",          TK_USERS},
-    {"USING",          TK_USING},
-    {"VALUE",          TK_VALUE},
-    {"VALUES",         TK_VALUES},
-    {"VARCHAR",        TK_VARCHAR},
-    {"VARIABLES",      TK_VARIABLES},
-    {"VERBOSE",        TK_VERBOSE},
-    {"VGROUP",         TK_VGROUP},
-    {"VGROUPS",        TK_VGROUPS},
-    {"VNODES",         TK_VNODES},
-    {"WAL",            TK_WAL},
+    {"ACCOUNT",              TK_ACCOUNT},
+    {"ACCOUNTS",             TK_ACCOUNTS},
+    {"ADD",                  TK_ADD},
+    {"AGGREGATE",            TK_AGGREGATE},
+    {"ALL",                  TK_ALL},
+    {"ALTER",                TK_ALTER},
+    {"ANALYZE",              TK_ANALYZE},
+    {"AND",                  TK_AND},
+    {"APPS",                 TK_APPS},
+    {"AS",                   TK_AS},
+    {"ASC",                  TK_ASC},
+    {"AT_ONCE",              TK_AT_ONCE},
+    {"BALANCE",              TK_BALANCE},
+    {"BETWEEN",              TK_BETWEEN},
+    {"BINARY",               TK_BINARY},
+    {"BIGINT",               TK_BIGINT},
+    {"BNODE",                TK_BNODE},
+    {"BNODES",               TK_BNODES},
+    {"BOOL",                 TK_BOOL},
+    {"BUFFER",               TK_BUFFER},
+    {"BUFSIZE",              TK_BUFSIZE},
+    {"BY",                   TK_BY},
+    {"CACHE",                TK_CACHE},
+    {"CACHEMODEL",           TK_CACHEMODEL},
+    {"CACHESIZE",            TK_CACHESIZE},
+    {"CAST",                 TK_CAST},
+    {"CLIENT_VERSION",       TK_CLIENT_VERSION},
+    {"CLUSTER",              TK_CLUSTER},
+    {"COLUMN",               TK_COLUMN},
+    {"COMMENT",              TK_COMMENT},
+    {"COMP",                 TK_COMP},
+    {"CONNS",                TK_CONNS},
+    {"CONNECTION",           TK_CONNECTION},
+    {"CONNECTIONS",          TK_CONNECTIONS},
+    {"CONSUMER",             TK_CONSUMER},
+    {"CONSUMERS",            TK_CONSUMERS},
+    {"CONTAINS",             TK_CONTAINS},
+    {"COUNT",                TK_COUNT},
+    {"CREATE",               TK_CREATE},
+    {"CURRENT_USER",         TK_CURRENT_USER},
+    {"DATABASE",             TK_DATABASE},
+    {"DATABASES",            TK_DATABASES},
+    {"DBS",                  TK_DBS},
+    {"DELETE",               TK_DELETE},
+    {"DESC",                 TK_DESC},
+    {"DESCRIBE",             TK_DESCRIBE},
+    {"DISTINCT",             TK_DISTINCT},
+    {"DISTRIBUTED",          TK_DISTRIBUTED},
+    {"DNODE",                TK_DNODE},
+    {"DNODES",               TK_DNODES},
+    {"DOUBLE",               TK_DOUBLE},
+    {"DROP",                 TK_DROP},
+    {"DURATION",             TK_DURATION},
+    {"ENABLE",               TK_ENABLE},
+    {"EXISTS",               TK_EXISTS},
+    {"EXPIRED",              TK_EXPIRED},
+    {"EXPLAIN",              TK_EXPLAIN},
+    {"EVERY",                TK_EVERY},
+    {"FILE",                 TK_FILE},
+    {"FILL",                 TK_FILL},
+    {"FIRST",                TK_FIRST},
+    {"FLOAT",                TK_FLOAT},
+    {"FLUSH",                TK_FLUSH},
+    {"FROM",                 TK_FROM},
+    {"FUNCTION",             TK_FUNCTION},
+    {"FUNCTIONS",            TK_FUNCTIONS},
+    {"GRANT",                TK_GRANT},
+    {"GRANTS",               TK_GRANTS},
+    {"GROUP",                TK_GROUP},
+    {"HAVING",               TK_HAVING},
+    {"IF",                   TK_IF},
+    {"IGNORE",               TK_IGNORE},
+    {"IMPORT",               TK_IMPORT},
+    {"IN",                   TK_IN},
+    {"INDEX",                TK_INDEX},
+    {"INDEXES",              TK_INDEXES},
+    {"INNER",                TK_INNER},
+    {"INT",                  TK_INT},
+    {"INSERT",               TK_INSERT},
+    {"INTEGER",              TK_INTEGER},
+    {"INTERVAL",             TK_INTERVAL},
+    {"INTO",                 TK_INTO},
+    {"IS",                   TK_IS},
+    {"JOIN",                 TK_JOIN},
+    {"JSON",                 TK_JSON},
+    {"KEEP",                 TK_KEEP},
+    {"KILL",                 TK_KILL},
+    {"LAST",                 TK_LAST},
+    {"LAST_ROW",             TK_LAST_ROW},
+    {"LICENCE",              TK_LICENCE},
+    {"LIKE",                 TK_LIKE},
+    {"LIMIT",                TK_LIMIT},
+    {"LINEAR",               TK_LINEAR},
+    {"LOCAL",                TK_LOCAL},
+    {"MATCH",                TK_MATCH},
+    {"MAXROWS",              TK_MAXROWS},
+    {"MAX_DELAY",            TK_MAX_DELAY},
+    {"MERGE",                TK_MERGE},
+    {"META",                 TK_META},
+    {"MINROWS",              TK_MINROWS},
+    {"MINUS",                TK_MINUS},
+    {"MNODE",                TK_MNODE},
+    {"MNODES",               TK_MNODES},
+    {"MODIFY",               TK_MODIFY},
+    {"MODULES",              TK_MODULES},
+    {"NCHAR",                TK_NCHAR},
+    {"NEXT",                 TK_NEXT},
+    {"NMATCH",               TK_NMATCH},
+    {"NONE",                 TK_NONE},
+    {"NOT",                  TK_NOT},
+    {"NOW",                  TK_NOW},
+    {"NULL",                 TK_NULL},
+    {"NULLS",                TK_NULLS},
+    {"OFFSET",               TK_OFFSET},
+    {"ON",                   TK_ON},
+    {"OR",                   TK_OR},
+    {"ORDER",                TK_ORDER},
+    {"OUTPUTTYPE",           TK_OUTPUTTYPE},
+    {"PARTITION",            TK_PARTITION},
+    {"PASS",                 TK_PASS},
+    {"PAGES",                TK_PAGES},
+    {"PAGESIZE",             TK_PAGESIZE},
+    {"PORT",                 TK_PORT},
+    {"PPS",                  TK_PPS},
+    {"PRECISION",            TK_PRECISION},
+    {"PREV",                 TK_PREV},
+    {"QNODE",                TK_QNODE},
+    {"QNODES",               TK_QNODES},
+    {"QTIME",                TK_QTIME},
+    {"QUERIES",              TK_QUERIES},
+    {"QUERY",                TK_QUERY},
+    {"RANGE",                TK_RANGE},
+    {"RATIO",                TK_RATIO},
+    {"READ",                 TK_READ},
+    {"REDISTRIBUTE",         TK_REDISTRIBUTE},
+    {"RENAME",               TK_RENAME},
+    {"REPLICA",              TK_REPLICA},
+    {"RESET",                TK_RESET},
+    {"RETENTIONS",           TK_RETENTIONS},
+    {"REVOKE",               TK_REVOKE},
+    {"ROLLUP",               TK_ROLLUP},
+    {"SCHEMALESS",           TK_SCHEMALESS},
+    {"SCORES",               TK_SCORES},
+    {"SELECT",               TK_SELECT},
+    {"SERVER_STATUS",        TK_SERVER_STATUS},
+    {"SERVER_VERSION",       TK_SERVER_VERSION},
+    {"SESSION",              TK_SESSION},
+    {"SET",                  TK_SET},
+    {"SHOW",                 TK_SHOW},
+    {"SINGLE_STABLE",        TK_SINGLE_STABLE},
+    {"SLIDING",              TK_SLIDING},
+    {"SLIMIT",               TK_SLIMIT},
+    {"SMA",                  TK_SMA},
+    {"SMALLINT",             TK_SMALLINT},
+    {"SNODE",                TK_SNODE},
+    {"SNODES",               TK_SNODES},
+    {"SOFFSET",              TK_SOFFSET},
+    {"SPLIT",                TK_SPLIT},
+    {"STABLE",               TK_STABLE},
+    {"STABLES",              TK_STABLES},
+    {"STATE",                TK_STATE},
+    {"STATE_WINDOW",         TK_STATE_WINDOW},
+    {"STORAGE",              TK_STORAGE},
+    {"STREAM",               TK_STREAM},
+    {"STREAMS",              TK_STREAMS},
+    {"STRICT",               TK_STRICT},
+    {"SUBSCRIPTIONS",        TK_SUBSCRIPTIONS},
+    {"SYSINFO",              TK_SYSINFO},
+    {"TABLE",                TK_TABLE},
+    {"TABLES",               TK_TABLES},
+    {"TAG",                  TK_TAG},
+    {"TAGS",                 TK_TAGS},
+    {"TBNAME",               TK_TBNAME},
+    {"TIMESTAMP",            TK_TIMESTAMP},
+    {"TIMEZONE",             TK_TIMEZONE},
+    {"TINYINT",              TK_TINYINT},
+    {"TO",                   TK_TO},
+    {"TODAY",                TK_TODAY},
+    {"TOPIC",                TK_TOPIC},
+    {"TOPICS",               TK_TOPICS},
+    {"TRANSACTION",          TK_TRANSACTION},
+    {"TRANSACTIONS",         TK_TRANSACTIONS},
+    {"TRIGGER",              TK_TRIGGER},
+    {"TRIM",                 TK_TRIM},
+    {"TSERIES",              TK_TSERIES},
+    {"TTL",                  TK_TTL},
+    {"UNION",                TK_UNION},
+    {"UNSIGNED",             TK_UNSIGNED},
+    {"USE",                  TK_USE},
+    {"USER",                 TK_USER},
+    {"USERS",                TK_USERS},
+    {"USING",                TK_USING},
+    {"VALUE",                TK_VALUE},
+    {"VALUES",               TK_VALUES},
+    {"VARCHAR",              TK_VARCHAR},
+    {"VARIABLES",            TK_VARIABLES},
+    {"VERBOSE",              TK_VERBOSE},
+    {"VGROUP",               TK_VGROUP},
+    {"VGROUPS",              TK_VGROUPS},
+    {"WAL_FSYNC_PERIOD",     TK_WAL_FSYNC_PERIOD},
+    {"WAL_LEVEL",            TK_WAL_LEVEL},
     {"WAL_RETENTION_PERIOD", TK_WAL_RETENTION_PERIOD},
     {"WAL_RETENTION_SIZE",   TK_WAL_RETENTION_SIZE},
     {"WAL_ROLL_PERIOD",      TK_WAL_ROLL_PERIOD},
     {"WAL_SEGMENT_SIZE",     TK_WAL_SEGMENT_SIZE},
-    {"WATERMARK",      TK_WATERMARK},
-    {"WHERE",          TK_WHERE},
-    {"WINDOW_CLOSE",   TK_WINDOW_CLOSE},
-    {"WITH",           TK_WITH},
-    {"WRITE",          TK_WRITE},
-    {"_C0",            TK_ROWTS},
-    {"_QDURATION",     TK_QDURATION},
-    {"_QEND",          TK_QEND},
-    {"_QSTART",        TK_QSTART},
-    {"_ROWTS",         TK_ROWTS},
-    {"_WDURATION",     TK_WDURATION},
-    {"_WEND",          TK_WEND},
-    {"_WSTART",        TK_WSTART},
-    // {"ID",           TK_ID},
-    // {"STRING",       TK_STRING},
-    // {"EQ",           TK_EQ},
-    // {"NE",           TK_NE},
-    // {"ISNULL",       TK_ISNULL},
-    // {"NOTNULL",      TK_NOTNULL},
-    // {"GLOB",         TK_GLOB},
-    // {"GT",           TK_GT},
-    // {"GE",           TK_GE},
-    // {"LT",           TK_LT},
-    // {"LE",           TK_LE},
-    // {"BITAND",       TK_BITAND},
-    // {"BITOR",        TK_BITOR},
-    // {"LSHIFT",       TK_LSHIFT},
-    // {"RSHIFT",       TK_RSHIFT},
-    // {"PLUS",         TK_PLUS},
-    // {"DIVIDE",       TK_DIVIDE},
-    // {"TIMES",        TK_TIMES},
-    // {"STAR",         TK_STAR},
-    // {"SLASH",        TK_SLASH},
-    // {"REM ",         TK_REM},
-    // {"||",           TK_CONCAT},
-    // {"UMINUS",       TK_UMINUS},
-    // {"UPLUS",        TK_UPLUS},
-    // {"BITNOT",       TK_BITNOT},
-    // {"DOT",          TK_DOT},
-    // {"CTIME",        TK_CTIME},
-    // {"LP",           TK_LP},
-    // {"RP",           TK_RP},
-    // {"COMMA",        TK_COMMA},
-    // {"VARIABLE",     TK_VARIABLE},
-    // {"UPDATE",       TK_UPDATE},
-    // {"CHANGE",       TK_CHANGE},
-    // {"COLON",        TK_COLON},
-    // {"ABORT",        TK_ABORT},
-    // {"AFTER",        TK_AFTER},
-    // {"ATTACH",       TK_ATTACH},
-    // {"BEFORE",       TK_BEFORE},
-    // {"BEGIN",        TK_BEGIN},
-    // {"CASCADE",      TK_CASCADE},
-    // {"CONFLICT",     TK_CONFLICT},
-    // {"COPY",         TK_COPY},
-    // {"DEFERRED",     TK_DEFERRED},
-    // {"DELIMITERS",   TK_DELIMITERS},
-    // {"DETACH",       TK_DETACH},
-    // {"EACH",         TK_EACH},
-    // {"END",          TK_END},
-    // {"FAIL",         TK_FAIL},
-    // {"FOR",          TK_FOR},
-    // {"IMMEDIATE",    TK_IMMEDIATE},
-    // {"INITIALLY",    TK_INITIALLY},
-    // {"INSTEAD",      TK_INSTEAD},
-    // {"KEY",          TK_KEY},
-    // {"OF",           TK_OF},
-    // {"RAISE",        TK_RAISE},
-    // {"REPLACE",      TK_REPLACE},
-    // {"RESTRICT",     TK_RESTRICT},
-    // {"ROW",          TK_ROW},
-    // {"STATEMENT",    TK_STATEMENT},
-    // {"VIEW",         TK_VIEW},
-    // {"SEMI",         TK_SEMI},
-    // {"PARTITIONS",   TK_PARTITIONS},
-    // {"MODE",         TK_MODE},
+    {"WATERMARK",            TK_WATERMARK},
+    {"WHERE",                TK_WHERE},
+    {"WINDOW_CLOSE",         TK_WINDOW_CLOSE},
+    {"WITH",                 TK_WITH},
+    {"WRITE",                TK_WRITE},
+    {"_C0",                  TK_ROWTS},
+    {"_QDURATION",           TK_QDURATION},
+    {"_QEND",                TK_QEND},
+    {"_QSTART",              TK_QSTART},
+    {"_ROWTS",               TK_ROWTS},
+    {"_WDURATION",           TK_WDURATION},
+    {"_WEND",                TK_WEND},
+    {"_WSTART",              TK_WSTART},
 };
 // clang-format on
 

source/libs/parser/src/parTranslater.c

@@ -3190,7 +3190,8 @@ static int32_t checkOptionsDependency(STranslateContext* pCxt, const char* pDbNa
     daysToKeep0 = (-1 == daysToKeep0 ? dbCfg.daysToKeep0 : daysToKeep0);
   }
   if (daysPerFile > daysToKeep0) {
-    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_DAYS_VALUE);
+    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_DB_OPTION,
+                                   "Invalid duration value, should be keep2 >= keep1 >= keep0 >= duration");
   }
   return TSDB_CODE_SUCCESS;
 }

source/libs/parser/src/parUtil.c

@@ -99,8 +99,6 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Query block has incorrect number of result columns";
     case TSDB_CODE_PAR_INCORRECT_TIMESTAMP_VAL:
       return "Incorrect TIMESTAMP value: %s";
-    case TSDB_CODE_PAR_INVALID_DAYS_VALUE:
-      return "Invalid days value, should be keep2 >= keep1 >= keep0 >= days";
     case TSDB_CODE_PAR_OFFSET_LESS_ZERO:
       return "soffset/offset can not be less than 0";
     case TSDB_CODE_PAR_SLIMIT_LEAK_PARTITION_BY:

source/libs/parser/test/parAlterToBalanceTest.cpp

@@ -82,12 +82,12 @@ TEST_F(ParserInitialATest, alterDnode) {
  *     BUFFER int_value                                          -- todo: range [3, 16384], default 96, unit MB
  *   | CACHEMODEL {'none' | 'last_row' | 'last_value' | 'both'}  -- default 'none'
  *   | CACHESIZE int_value                                       -- range [1, 65536], default 1, unit MB
- *   | FSYNC int_value                                           -- rang [0, 180000], default 3000, unit ms
+ *   | WAL_FSYNC_PERIOD int_value                                -- rang [0, 180000], default 3000, unit ms
  *   | KEEP {int_value | duration_value}                         -- rang [1, 365000], default 3650, unit day
  *   | PAGES int_value                                           -- todo: rang [64, +oo), default 256, unit page
  *   | REPLICA int_value                                         -- todo: enum 1, 3, default 1, unit replica
  *   | STRICT {'off' | 'on'}                                     -- todo: default 'off'
- *   | WAL int_value                                             -- enum 1, 2, default 1
+ *   | WAL_LEVEL int_value                                       -- enum 1, 2, default 1
  * }
  */
 TEST_F(ParserInitialATest, alterDatabase) {
@@ -157,7 +157,7 @@ TEST_F(ParserInitialATest, alterDatabase) {
   setAlterDbFsync(200);
   setAlterDbWal(1);
   setAlterDbCacheModel(TSDB_CACHE_MODEL_LAST_ROW);
-  run("ALTER DATABASE test CACHEMODEL 'last_row' CACHESIZE 32 FSYNC 200 KEEP 10 WAL 1");
+  run("ALTER DATABASE test CACHEMODEL 'last_row' CACHESIZE 32 WAL_FSYNC_PERIOD 200 KEEP 10 WAL_LEVEL 1");
   clearAlterDbReq();
 
   initAlterDb("test");
@@ -182,11 +182,11 @@ TEST_F(ParserInitialATest, alterDatabase) {
 
   initAlterDb("test");
   setAlterDbFsync(0);
-  run("ALTER DATABASE test FSYNC 0");
+  run("ALTER DATABASE test WAL_FSYNC_PERIOD 0");
   setAlterDbFsync(1000);
-  run("ALTER DATABASE test FSYNC 1000");
+  run("ALTER DATABASE test WAL_FSYNC_PERIOD 1000");
   setAlterDbFsync(180000);
-  run("ALTER DATABASE test FSYNC 180000");
+  run("ALTER DATABASE test WAL_FSYNC_PERIOD 180000");
   clearAlterDbReq();
 
   initAlterDb("test");
@@ -210,9 +210,9 @@ TEST_F(ParserInitialATest, alterDatabase) {
 
   initAlterDb("test");
   setAlterDbWal(1);
-  run("ALTER DATABASE test WAL 1");
+  run("ALTER DATABASE test WAL_LEVEL 1");
   setAlterDbWal(2);
-  run("ALTER DATABASE test WAL 2");
+  run("ALTER DATABASE test WAL_LEVEL 2");
   clearAlterDbReq();
 }
 
@@ -223,16 +223,16 @@ TEST_F(ParserInitialATest, alterDatabaseSemanticCheck) {
   run("ALTER DATABASE test CACHESIZE 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
   run("ALTER DATABASE test CACHESIZE 65537", TSDB_CODE_PAR_INVALID_DB_OPTION);
   // The syntax limits it to only positive numbers
-  run("ALTER DATABASE test FSYNC -1", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
-  run("ALTER DATABASE test FSYNC 180001", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test WAL_FSYNC_PERIOD -1", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
+  run("ALTER DATABASE test WAL_FSYNC_PERIOD 180001", TSDB_CODE_PAR_INVALID_DB_OPTION);
   run("ALTER DATABASE test KEEP 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
   run("ALTER DATABASE test KEEP 365001", TSDB_CODE_PAR_INVALID_DB_OPTION);
   run("ALTER DATABASE test KEEP 1000000000s", TSDB_CODE_PAR_INVALID_DB_OPTION);
   run("ALTER DATABASE test KEEP 1w", TSDB_CODE_PAR_INVALID_DB_OPTION);
-  run("ALTER DATABASE test WAL 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
-  run("ALTER DATABASE test WAL 3", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test WAL_LEVEL 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test WAL_LEVEL 3", TSDB_CODE_PAR_INVALID_DB_OPTION);
   // Regardless of the specific sentence
-  run("ALTER DATABASE db WAL 0     # td-14436", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
+  run("ALTER DATABASE db WAL_LEVEL 0     # td-14436", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
 }
 
 /*

source/libs/parser/test/parInitialCTest.cpp

@@ -21,12 +21,6 @@ namespace ParserTest {
 
 class ParserInitialCTest : public ParserDdlTest {};
 
-TEST_F(ParserInitialCTest, compact) {
-  useDb("root", "test");
-
-  run("COMPACT VNODES IN (1, 2)", TSDB_CODE_PAR_EXPRIE_STATEMENT, PARSER_STAGE_PARSE);
-}
-
 TEST_F(ParserInitialCTest, createAccount) {
   useDb("root", "test");
 
@@ -64,7 +58,7 @@ TEST_F(ParserInitialCTest, createBnode) {
  *   | CACHESIZE value
  *   | COMP {0 | 1 | 2}
  *   | DURATION value
- *   | FSYNC value
+ *   | WAL_FSYNC_PERIOD value
  *   | MAXROWS value
  *   | MINROWS value
  *   | KEEP value
@@ -74,7 +68,7 @@ TEST_F(ParserInitialCTest, createBnode) {
  *   | REPLICA value
  *   | RETENTIONS ingestion_duration:keep_duration ...
  *   | STRICT {'off' | 'on'}
- *   | WAL value
+ *   | WAL_LEVEL value
  *   | VGROUPS value
  *   | SINGLE_STABLE {0 | 1}
  *   | WAL_RETENTION_PERIOD value
@@ -241,7 +235,7 @@ TEST_F(ParserInitialCTest, createDatabase) {
       "CACHESIZE 20 "
       "COMP 1 "
       "DURATION 100 "
-      "FSYNC 100 "
+      "WAL_FSYNC_PERIOD 100 "
       "MAXROWS 1000 "
       "MINROWS 100 "
       "KEEP 1440 "
@@ -251,7 +245,7 @@ TEST_F(ParserInitialCTest, createDatabase) {
       "REPLICA 3 "
       "RETENTIONS 15s:7d,1m:21d,15m:500d "
       "STRICT 'on' "
-      "WAL 2 "
+      "WAL_LEVEL 2 "
       "VGROUPS 100 "
       "SINGLE_STABLE 1 "
       "SCHEMALESS 1 "

source/libs/planner/src/planPhysiCreater.c

@@ -553,6 +553,7 @@ static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubp
   pTableScan->triggerType = pScanLogicNode->triggerType;
   pTableScan->watermark = pScanLogicNode->watermark;
   pTableScan->igExpired = pScanLogicNode->igExpired;
+  pTableScan->assignBlockUid = pCxt->pPlanCxt->rSmaQuery ? true : false;
 
   return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pTableScan, pPhyNode);
 }
@@ -632,6 +633,7 @@ static int32_t createJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren
   int32_t             code = TSDB_CODE_SUCCESS;
 
   pJoin->joinType = pJoinLogicNode->joinType;
+  pJoin->inputTsOrder = pJoinLogicNode->inputTsOrder;
   setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pMergeCondition,
                 &pJoin->pMergeCondition);
   if (TSDB_CODE_SUCCESS == code) {

source/libs/transport/src/transCli.c

@@ -60,6 +60,7 @@ typedef struct SCliThrd {
   int64_t     pid;     // pid
   uv_loop_t*  loop;
   SAsyncPool* asyncPool;
+  uv_idle_t*  idle;
   uv_timer_t  timer;
   void*       pool;  // conn pool
 
@@ -116,6 +117,7 @@ static void cliSendCb(uv_write_t* req, int status);
 // callback after conn  to server
 static void cliConnCb(uv_connect_t* req, int status);
 static void cliAsyncCb(uv_async_t* handle);
+static void cliIdleCb(uv_idle_t* handle);
 
 static int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg);
 
@@ -962,6 +964,10 @@ static void cliAsyncCb(uv_async_t* handle) {
   }
   if (pThrd->stopMsg != NULL) cliHandleQuit(pThrd->stopMsg, pThrd);
 }
+static void cliIdleCb(uv_idle_t* handle) {
+  SCliThrd* thrd = handle->data;
+  tTrace("do idle work");
+}
 
 static void* cliWorkThread(void* arg) {
   SCliThrd* pThrd = (SCliThrd*)arg;
@@ -1024,6 +1030,11 @@ static SCliThrd* createThrdObj() {
   uv_timer_init(pThrd->loop, &pThrd->timer);
   pThrd->timer.data = pThrd;
 
+  // pThrd->idle = taosMemoryCalloc(1, sizeof(uv_idle_t));
+  // uv_idle_init(pThrd->loop, pThrd->idle);
+  // pThrd->idle->data = pThrd;
+  //  uv_idle_start(pThrd->idle, cliIdleCb);
+
   pThrd->pool = createConnPool(4);
   transDQCreate(pThrd->loop, &pThrd->delayQueue);
 
@@ -1045,6 +1056,8 @@ static void destroyThrdObj(SCliThrd* pThrd) {
 
   transDQDestroy(pThrd->delayQueue, destroyCmsg);
   transDQDestroy(pThrd->timeoutQueue, NULL);
+
+  taosMemoryFree(pThrd->idle);
   taosMemoryFree(pThrd->loop);
   taosMemoryFree(pThrd);
 }

source/libs/transport/src/transComm.c

@@ -152,16 +152,18 @@ int transDumpFromBuffer(SConnBuffer* connBuf, char** buf) {
 
 int transResetBuffer(SConnBuffer* connBuf) {
   SConnBuffer* p = connBuf;
-  if (p->total <= p->len) {
+  if (p->total < p->len) {
     int left = p->len - p->total;
     memmove(p->buf, p->buf + p->total, left);
     p->left = -1;
     p->total = 0;
     p->len = left;
-  } else {
+  } else if (p->total == p->len) {
     p->left = -1;
     p->total = 0;
     p->len = 0;
+  } else {
+    assert(0);
   }
   return 0;
 }

source/libs/transport/src/transSvr.c

@@ -238,7 +238,7 @@ static void uvHandleReq(SSvrConn* pConn) {
   transMsg.msgType = pHead->msgType;
   transMsg.code = pHead->code;
 
-  transClearBuffer(&pConn->readBuf);
+  // transClearBuffer(&pConn->readBuf);
 
   pConn->inType = pHead->msgType;
   if (pConn->status == ConnNormal) {

source/util/src/tcache.c

@@ -266,6 +266,7 @@ static void pushfrontNodeInEntryList(SCacheEntry *pEntry, SCacheNode *pNode) {
   pNode->pNext = pEntry->next;
   pEntry->next = pNode;
   pEntry->num += 1;
+  ASSERT((pEntry->next && pEntry->num > 0) || (NULL == pEntry->next && pEntry->num == 0));
 }
 
 static void removeNodeInEntryList(SCacheEntry *pe, SCacheNode *prev, SCacheNode *pNode) {
@@ -278,6 +279,7 @@ static void removeNodeInEntryList(SCacheEntry *pe, SCacheNode *prev, SCacheNode
 
   pNode->pNext = NULL;
   pe->num -= 1;
+  ASSERT((pe->next && pe->num > 0) || (NULL == pe->next && pe->num == 0));  
 }
 
 static FORCE_INLINE SCacheEntry *doFindEntry(SCacheObj *pCacheObj, const void *key, size_t keyLen) {
@@ -657,15 +659,18 @@ void doTraverseElems(SCacheObj *pCacheObj, bool (*fp)(void *param, SCacheNode *p
 
     taosWLockLatch(&pEntry->latch);
 
+    SCacheNode **pPre = &pEntry->next;
     SCacheNode *pNode = pEntry->next;
     while (pNode != NULL) {
       SCacheNode *next = pNode->pNext;
 
       if (fp(pSup, pNode)) {
+        pPre = &pNode->pNext;
         pNode = pNode->pNext;
       } else {
-        pEntry->next = next;
+        *pPre = next;
         pEntry->num -= 1;
+        ASSERT((pEntry->next && pEntry->num > 0) || (NULL == pEntry->next && pEntry->num == 0));
 
         atomic_sub_fetch_ptr(&pCacheObj->numOfElems, 1);
         pNode = next;

source/util/src/terror.c

@@ -517,7 +517,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_SLIDING_TOO_SMALL,   "sliding value can no
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_ONLY_ONE_JSON_TAG,         "Only one tag if there is a json tag")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INCORRECT_NUM_OF_COL,      "Query block has incorrect number of result columns")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INCORRECT_TIMESTAMP_VAL,   "Incorrect TIMESTAMP value")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DAYS_VALUE,        "Invalid days value, should be keep2 >= keep1 >= keep0 >= days")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_OFFSET_LESS_ZERO,          "soffset/offset can not be less than 0")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_SLIMIT_LEAK_PARTITION_BY,  "slimit/soffset only available for PARTITION BY query")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TOPIC_QUERY,        "Invalid topic query")

tests/pytest/alter/alter_create_exception.py

@@ -47,16 +47,16 @@ class TDTestCase:
         tdSql.error('create database db comp "1.4"')
         tdSql.error("create database db blocks '10'")
         tdSql.error('create database db keep "3650"')
-        tdSql.error('create database db fsync "3650"')
+        tdSql.error('create database db wal_fsync_period "3650"')
         tdSql.execute('create database db precision "us"')
         tdSql.query('show databases')
         tdSql.checkData(0,16,'us')
         tdSql.execute('drop database if exists db')
 
         #checking float input exception for create
-        tdSql.error("create database db fsync 7.3")
-        tdSql.error("create database db fsync 0.0")
-        tdSql.error("create database db fsync -5.32")
+        tdSql.error("create database db wal_fsync_period 7.3")
+        tdSql.error("create database db wal_fsync_period 0.0")
+        tdSql.error("create database db wal_fsync_period -5.32")
         tdSql.error('create database db comp 7.2')
         tdSql.error("create database db blocks 5.87")
         tdSql.error('create database db keep 15.4')

tests/pytest/perfbenchmark/bug3433.py

@@ -77,7 +77,7 @@ class TDTestCase:
             "walLevel": 1,
             "cachelast": 0,
             "quorum": 1,
-            "fsync": 3000,
+            "wal_fsync_period": 3000,
             "update": 0
         }
 

tests/pytest/perfbenchmark/joinPerformance.py

@@ -92,7 +92,7 @@ class JoinPerf:
             "walLevel": 1,
             "cachelast": 0,
             "quorum": 1,
-            "fsync": 3000,
+            "wal_fsync_period": 3000,
             "update": 0
         }
 

tests/pytest/perfbenchmark/taosdemoInsert.py

@@ -86,7 +86,7 @@ class Taosdemo:
             "walLevel": 1,
             "cachelast": 0,
             "quorum": 1,
-            "fsync": 3000,
+            "wal_fsync_period": 3000,
             "update": 0
         }
 

tests/pytest/query/query1970YearsAf.py

@@ -68,7 +68,7 @@ class TDTestCase:
             "walLevel": 1,
             "cachelast": 0,
             "quorum": 1,
-            "fsync": 3000,
+            "wal_fsync_period": 3000,
             "update": 0
         }
 

tests/script/jenkins/basic.txt

@@ -110,7 +110,7 @@
 ./test.sh -f tsim/parser/fill.sim
 ./test.sh -f tsim/parser/first_last.sim
 ./test.sh -f tsim/parser/fourArithmetic-basic.sim
-# TD-17659 ./test.sh -f tsim/parser/function.sim
+./test.sh -f tsim/parser/function.sim
 ./test.sh -f tsim/parser/groupby-basic.sim
 ./test.sh -f tsim/parser/groupby.sim
 ./test.sh -f tsim/parser/having_child.sim
@@ -145,7 +145,7 @@
 ./test.sh -f tsim/parser/select_across_vnodes.sim
 ./test.sh -f tsim/parser/select_distinct_tag.sim
 ./test.sh -f tsim/parser/select_from_cache_disk.sim
-# TD-17659 ./test.sh -f tsim/parser/select_with_tags.sim
+# TD-17832 ./test.sh -f tsim/parser/select_with_tags.sim
 ./test.sh -f tsim/parser/selectResNum.sim
 ./test.sh -f tsim/parser/set_tag_vals.sim
 ./test.sh -f tsim/parser/single_row_in_tb.sim

tests/script/tsim/db/alter_option.sim

@@ -41,12 +41,12 @@ print ============= create database
 #  | BUFFER value       [3~16384, default: 96]
 #  | PAGES value        [64~16384, default: 256]
 #  | CACHEMODEL value   ['node', 'last_row', 'last_value', 'both']
-#  | FSYNC value        [0 ~ 180000 ms]
+#  | WAL_FSYNC_PERIOD value        [0 ~ 180000 ms]
 #  | KEEP value         [duration, 365000]
 #  | REPLICA value      [1 | 3]
-#  | WAL value          [1 | 2]
+#  | WAL_LEVEL value          [1 | 2]
 
-sql create database db CACHEMODEL 'both' COMP 0 DURATION 240 FSYNC 1000 MAXROWS 8000 MINROWS 10 KEEP 1000 PRECISION 'ns' REPLICA 3 WAL 2 VGROUPS 6 SINGLE_STABLE 1
+sql create database db CACHEMODEL 'both' COMP 0 DURATION 240 WAL_FSYNC_PERIOD 1000 MAXROWS 8000 MINROWS 10 KEEP 1000 PRECISION 'ns' REPLICA 3 WAL_LEVEL 2 VGROUPS 6 SINGLE_STABLE 1
 sql show databases
 print rows: $rows
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
@@ -99,16 +99,16 @@ endi
 if $data14_db != ns then  # precision
   return -1
 endi
-if $data18_db != both then  # cache_model
+if $data18_db != both then  # cachemodel
   return -1
 endi
 if $data19_db != 1 then  # cash_size
   return -1
 endi
-if $data20_db != 2 then  # wal level
+if $data20_db != 2 then  # wal_level level
   return -1
 endi
-if $data21_db != 1000 then  # wal fsyncperiod
+if $data21_db != 1000 then  # wal_level fsyncperiod
   return -1
 endi
 if $data22_db != 0 then  # 
@@ -296,46 +296,46 @@ sql_error alter database db maxrows 2000
 sql_error alter database db maxrows 11  # equal minrows
 sql_error alter database db maxrows 10  # little than minrows
 
-print ============== step wal
-sql alter database db wal 1
+print ============== step wal_level
+sql alter database db wal_level 1
 sql show databases
-print wal $data20_db
+print wal_level $data20_db
 if $data20_db != 1 then 
   return -1
 endi
-sql alter database db wal 2
+sql alter database db wal_level 2
 sql show databases
-print wal $data20_db
+print wal_level $data20_db
 if $data20_db != 2 then 
   return -1
 endi
 
-sql_error alter database db wal 0     # TD-14436
-sql_error alter database db wal 3
-sql_error alter database db wal 100
-sql_error alter database db wal -1
+sql_error alter database db wal_level 0     # TD-14436
+sql_error alter database db wal_level 3
+sql_error alter database db wal_level 100
+sql_error alter database db wal_level -1
 
-print ============== modify fsync
-sql alter database db fsync 2000
+print ============== modify wal_fsync_period
+sql alter database db wal_fsync_period 2000
 sql show databases
-print fsync $data21_db
+print wal_fsync_period $data21_db
 if $data21_db != 2000 then 
   return -1
 endi
-sql alter database db fsync 500
+sql alter database db wal_fsync_period 500
 sql show databases
-print fsync $data21_db
+print wal_fsync_period $data21_db
 if $data21_db != 500 then 
   return -1
 endi
-sql alter database db fsync 0
+sql alter database db wal_fsync_period 0
 sql show databases
-print fsync $data21_db
+print wal_fsync_period $data21_db
 if $data21_db != 0 then 
   return -1
 endi
-sql_error alter database db fsync 180001
-sql_error alter database db fsync -1
+sql_error alter database db wal_fsync_period 180001
+sql_error alter database db wal_fsync_period -1
 
 print ============== modify comp
 sql_error alter database db comp 1

tests/script/tsim/db/basic6.sim

@@ -15,7 +15,7 @@ $tb = $tbPrefix . $i
 
 print =============== step1
 # quorum  presicion 
-sql create database $db vgroups 8 replica 1 duration 2 keep 10 minrows 80 maxrows 10000 wal 2 fsync 1000 comp 0 cachemodel 'last_value' precision 'us'
+sql create database $db vgroups 8 replica 1 duration 2 keep 10 minrows 80 maxrows 10000 wal_level 2 wal_fsync_period 1000 comp 0 cachemodel 'last_value' precision 'us'
 sql show databases
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 

tests/script/tsim/db/create_all_options.sim

@@ -43,13 +43,13 @@ print ============= create database with all options
 #  | CACHEMODEL value   ['node', 'last_row', 'last_value', 'both', default: 'node']
 #  | COMP               [0 | 1 | 2, default: 2]
 #  | DURATION value         [60m ~ min(3650d,keep), default: 10d, unit may be minut/hour/day]
-#  | FSYNC value        [0 ~ 180000 ms, default: 3000]
+#  | WAL_FSYNC_PERIOD value        [0 ~ 180000 ms, default: 3000]
 #  | MAXROWS value      [200~10000, default: 4096]
 #  | MINROWS value      [10~1000, default: 100]
 #  | KEEP value         [max(1d ~ 365000d), default: 1d, unit may be minut/hour/day]
 #  | PRECISION          ['ms' | 'us' | 'ns', default: ms]
 #  | REPLICA value      [1 | 3, default: 1]
-#  | WAL value          [1 | 2, default: 1]
+#  | WAL_LEVEL value          [1 | 2, default: 1]
 #  | VGROUPS value      [default: 2]
 #  | SINGLE_STABLE      [0 | 1, default: ]
 #
@@ -62,7 +62,7 @@ print ============= create database with all options
 #$data7_db  : keep
 #$data10_db : minrows
 #$data11_db : maxrows
-#$data12_db : wal
+#$data12_db : wal_level
 #$data13_db : fsync
 #$data14_db : comp
 #$data15_db : cachelast
@@ -122,10 +122,10 @@ endi
 if $data18_db != none then  # cachelast
   return -1
 endi
-if $data20_db != 1 then  # wal
+if $data20_db != 1 then  # wal_level
   return -1
 endi
-if $data21_db != 3000 then  # fsync
+if $data21_db != 3000 then  # wal_fsync_period
   return -1
 endi
 
@@ -254,8 +254,8 @@ sql_error create database db COMP -1
 #sql_error create database db KEEP 525600001m
 #sql_error create database db KEEP 365001d
 
-print ====> FSYNC value [0 ~ 180000 ms, default: 3000]
-sql create database db FSYNC 0
+print ====> WAL_FSYNC_PERIOD value [0 ~ 180000 ms, default: 3000]
+sql create database db WAL_FSYNC_PERIOD 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 $data21_db != 0 then
@@ -263,15 +263,15 @@ if $data21_db != 0 then
 endi
 sql drop database db
 
-sql create database db FSYNC 180000
+sql create database db WAL_FSYNC_PERIOD 180000
 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 $data21_db != 180000 then
   return -1
 endi
 sql drop database db
-sql_error create database db FSYNC 180001
-sql_error create database db FSYNC -1
+sql_error create database db WAL_FSYNC_PERIOD 180001
+sql_error create database db WAL_FSYNC_PERIOD -1
 
 print ====> MAXROWS value [200~10000, default: 4096], MINROWS value [10~1000, default: 100]
 sql create database db MAXROWS 10000 MINROWS 1000
@@ -386,8 +386,8 @@ sql_error create database db REPLICA 4
 #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
+print ====> WAL_LEVEL value [1 | 2, default: 1]
+sql create database db WAL_LEVEL 2
 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 $data20_db != 2 then
@@ -395,16 +395,16 @@ if $data20_db != 2 then
 endi
 sql drop database db
 
-sql create database db WAL 1
+sql create database db WAL_LEVEL 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 $data20_db != 1 then
   return -1
 endi
 sql drop database db
-sql_error create database db WAL 3
-sql_error create database db WAL -1
-sql_error create database db WAL 0
+sql_error create database db WAL_LEVEL 3
+sql_error create database db WAL_LEVEL -1
+sql_error create database db WAL_LEVEL 0
 
 print ====> VGROUPS value [1~4096, default: 2]
 sql create database db VGROUPS 1

tests/script/tsim/parser/create_db.sim

@@ -107,7 +107,7 @@ $ctime = 36000 # 10 hours
 $wal = 1 # valid value is 1, 2
 $comp = 1 # max=32, automatically trimmed when exceeding
 
-sql create database $db replica $replica duration $duration keep $keep maxrows $rows_db wal $wal comp $comp
+sql create database $db replica $replica duration $duration keep $keep maxrows $rows_db wal_level $wal comp $comp
 sql show databases
 if $rows != 3 then
   return -1
@@ -225,13 +225,13 @@ sql_error create database $db ctime 29
 sql_error create database $db ctime 40961
 
 # wal {0, 2}
-sql_error create database testwal wal 0
+sql_error create database testwal wal_level 0
 sql show databases
 if $rows != 2 then
   return -1
 endi
 
-sql create database testwal wal 1
+sql create database testwal wal_level 1
 sql show databases
 if $rows != 3 then
   return -1
@@ -243,7 +243,7 @@ if $data13_testwal != 1 then
 endi
 sql drop database testwal
 
-sql create database testwal wal 2
+sql create database testwal wal_level 2
 sql show databases
 if $rows != 3 then
   return -1
@@ -254,8 +254,8 @@ if $data13_testwal != 2 then
 endi
 sql drop database testwal
 
-sql_error create database $db wal -1
-sql_error create database $db wal 3
+sql_error create database $db wal_level -1
+sql_error create database $db wal_level 3
 
 # comp {0, 1, 2}
 sql_error create database $db comp -1

tests/script/tsim/parser/function.sim

@@ -826,7 +826,7 @@ sql select derivative(k, 200a, 0) from tm0;
 sql select derivative(k, 999a, 0) from tm0;
 sql_error select derivative(k, 20s, -12) from tm0;
 
-sql select derivative(k, 1s, 0) from tm0
+sql select ts, derivative(k, 1s, 0) from tm0
 if $rows != 5 then
   return -1
 endi
@@ -858,7 +858,7 @@ if $data31 != -0.000236111 then
   return -1
 endi
 
-sql select derivative(k, 6m, 0) from tm0;
+sql select ts ,derivative(k, 6m, 0) from tm0;
 if $rows != 5 then
   return -1
 endi
@@ -888,7 +888,7 @@ if $data31 != -0.085000000 then
   return -1
 endi
 
-sql select derivative(k, 12m, 0) from tm0;
+sql select ts, derivative(k, 12m, 0) from tm0;
 if $rows != 5 then
   return -1
 endi
@@ -938,44 +938,17 @@ sql insert into t1 values('2020-1-1 1:1:6', 200);
 sql insert into t1 values('2020-1-1 1:1:8', 2000);
 sql insert into t1 values('2020-1-1 1:1:10', 20000);
 
-sql_error select derivative(k, 1s, 0) from m1;
+sql select derivative(k, 1s, 0) from m1;
 sql_error select derivative(k, 1s, 0) from m1 group by a;
 sql_error select derivative(f1, 1s, 0) from (select k from t1);
 
-sql select derivative(k, 1s, 0) from m1 group by tbname
-if $rows != 12 then
-  return -1
-endi
-if $data00 != @20-01-01 01:01:03.000@ then
-  return -1
-endi
-if $data01 != 1.000000000 then
-  return -1
-endi
-if $data02 != @t0@ then
-  return -1
-endi
-if $data10 != @20-01-01 01:02:04.000@ then
-  return -1
-endi
-if $data11 != 0.016393443 then
-  return -1
-endi
-if $data12 != t0 then
-  return -1
-endi
-if $data90 != @20-01-01 01:01:06.000@ then
-  return -1
-endi
-if $data91 != 90.000000000 then
-  return -1
-endi
-if $data92 != t1 then
+sql select ts, derivative(k, 1s, 0) from m1
+if $rows != 13 then
   return -1
 endi
 
 print =========================>TD-5190
-sql select stddev(f1) from st1 where ts>'2021-07-01 1:1:1' and ts<'2021-07-30 00:00:00' interval(1d) fill(NULL);
+sql select _wstart, stddev(f1) from st1 where ts>'2021-07-01 1:1:1' and ts<'2021-07-30 00:00:00' interval(1d) fill(NULL);
 if $rows != 29 then
   return -1
 endi
@@ -986,7 +959,7 @@ if $data01 != NULL then
   return -1
 endi
 
-sql select derivative(test_column_alias_name, 1s, 0) from (select avg(k) test_column_alias_name from t1 interval(1s));
+sql select derivative(test_column_alias_name, 1s, 0) from (select _wstart, avg(k) test_column_alias_name from t1 interval(1s));
 
 sql create table smeters (ts timestamp, current float, voltage int) tags (t1 int);
 sql create table smeter1 using smeters tags (1);
@@ -994,7 +967,7 @@ sql insert into smeter1 values ('2021-08-08 10:10:10', 10, 2);
 sql insert into smeter1 values ('2021-08-08 10:10:12', 10, 2);
 sql insert into smeter1 values ('2021-08-08 10:10:14', 20, 1);
 
-sql select stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000'  and current=10 interval(1000a);
+sql select _wstart, stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000'  and current=10 interval(1000a);
 if $rows != 2 then
   return -1
 endi
@@ -1018,4 +991,3 @@ endi
 if $data00 != 0.000000000 then
   return -1
 endi
-

tests/script/tsim/parser/lastrow_query.sim

@@ -131,7 +131,7 @@ if $rows != 172798 then
 endi
 
 sql select t1,t1,count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1s) fill(NULL) slimit 1 soffset 0 limit 250000 offset 1
-if $rows != 85648 then
+if $rows != 86399 then
   return -1
 endi
 
@@ -146,7 +146,7 @@ if $rows != 4 then
 endi
 
 sql select t1,t1,count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1s) fill(NULL) slimit 1 soffset 1 limit 250000 offset 1
-if $rows != 87150 then
+if $rows != 86399 then
   return -1
 endi
 

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

@@ -49,35 +49,35 @@ class TDTestCase:
                 fsync_index = i
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 wal 1")
+        tdSql.execute("create database db1 wal_level 1")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, wal_index, 1)
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 wal 2")
+        tdSql.execute("create database db1 wal_level 2")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, wal_index, 2)
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 fsync 0")
+        tdSql.execute("create database db1 wal_fsync_period 0")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 0)
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 fsync 3000")
+        tdSql.execute("create database db1 wal_fsync_period 3000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 3000)
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 fsync 180000")
+        tdSql.execute("create database db1 wal_fsync_period 180000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
@@ -85,7 +85,7 @@ class TDTestCase:
 
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 wal 1 fsync 6000")
+        tdSql.execute("create database db1 wal_level 1 wal_fsync_period 6000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
@@ -93,49 +93,49 @@ class TDTestCase:
                 tdSql.checkData(i, wal_index, 1)
 
         tdSql.execute("drop database if exists db1")
-        tdSql.execute("create database db1 wal 2 fsync 3000")
+        tdSql.execute("create database db1 wal_level 2 wal_fsync_period 3000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 3000)
                 tdSql.checkData(i, wal_index, 2)
 
-        tdSql.execute("alter database db1 wal 1")
+        tdSql.execute("alter database db1 wal_level 1")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 3000)
                 tdSql.checkData(i, wal_index, 1)
 
-        tdSql.execute("alter database db1 wal 2")
+        tdSql.execute("alter database db1 wal_level 2")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 3000)
                 tdSql.checkData(i, wal_index, 2)
 
-        tdSql.execute("alter database db1 fsync 0")
+        tdSql.execute("alter database db1 wal_fsync_period 0")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 0)
                 tdSql.checkData(i, wal_index, 2)
 
-        tdSql.execute("alter database db1 fsync 3000")
+        tdSql.execute("alter database db1 wal_fsync_period 3000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 3000)
                 tdSql.checkData(i, wal_index, 2)
 
-        tdSql.execute("alter database db1 fsync 18000")
+        tdSql.execute("alter database db1 wal_fsync_period 18000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
                 tdSql.checkData(i, fsync_index, 18000)
                 tdSql.checkData(i, wal_index, 2)
 
-        tdSql.execute("alter database db1 wal 1 fsync 3000")
+        tdSql.execute("alter database db1 wal_level 1 wal_fsync_period 3000")
         tdSql.query("show databases")
         for i in range(tdSql.queryRows):
             if tdSql.queryResult[i][0] == "db1":
@@ -147,29 +147,29 @@ class TDTestCase:
     @property
     def fsync_create_err(self):
         return [
-            "create database db1 wal 0",
-            "create database db1 wal 3",
-            "create database db1 wal null",
-            "create database db1 wal true",
-            "create database db1 wal 1.1",
-            "create database db1 fsync -1",
-            "create database db1 fsync 180001",
-            "create database db1 fsync 10.111",
-            "create database db1 fsync true",
+            "create database db1 wal_level 0",
+            "create database db1 wal_level 3",
+            "create database db1 wal_level null",
+            "create database db1 wal_level true",
+            "create database db1 wal_level 1.1",
+            "create database db1 wal_fsync_period -1",
+            "create database db1 wal_fsync_period 180001",
+            "create database db1 wal_fsync_period 10.111",
+            "create database db1 wal_fsync_period true",
         ]
 
     @property
     def fsync_alter_err(self):
         return [
-            "alter database db1 wal 0",
-            "alter database db1 wal 3",
-            "alter database db1 wal null",
-            "alter database db1 wal true",
-            "alter database db1 wal 1.1",
-            "alter database db1 fsync -1",
-            "alter database db1 fsync 180001",
-            "alter database db1 fsync 10.111",
-            "alter database db1 fsync true",
+            "alter database db1 wal_level 0",
+            "alter database db1 wal_level 3",
+            "alter database db1 wal_level null",
+            "alter database db1 wal_level true",
+            "alter database db1 wal_level 1.1",
+            "alter database db1 wal_fsync_period -1",
+            "alter database db1 wal_fsync_period 180001",
+            "alter database db1 wal_fsync_period 10.111",
+            "alter database db1 wal_fsync_period true",
         ]
 
     def test_fsync_err(self):
@@ -290,7 +290,7 @@ class TDTestCase:
 
         # tdSql.execute("use db")
 
-        tdLog.printNoPrefix("==========step4:after wal, all check again ")
+        tdLog.printNoPrefix("==========step4:after wal_level, all check again ")
         self.all_test()
 
     def stop(self):