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

include/common/tmsg.h

@@ -56,9 +56,9 @@ extern int32_t tMsgDict[];
 #define TMSG_SEG_CODE(TYPE) (((TYPE)&0xff00) >> 8)
 #define TMSG_SEG_SEQ(TYPE)  ((TYPE)&0xff)
 #define TMSG_INFO(TYPE)                                                                                      \
-  ((TYPE) >= 0 &&                                                                                                   \
-   ((TYPE) < TDMT_DND_MAX_MSG || (TYPE) < TDMT_MND_MAX_MSG || (TYPE) < TDMT_VND_MAX_MSG || (TYPE) < TDMT_SCH_MAX_MSG || \
-    (TYPE) < TDMT_STREAM_MAX_MSG || (TYPE) < TDMT_MON_MAX_MSG || (TYPE) < TDMT_SYNC_MAX_MSG))                         \
+  ((TYPE) >= 0 && ((TYPE) < TDMT_DND_MAX_MSG || (TYPE) < TDMT_MND_MAX_MSG || (TYPE) < TDMT_VND_MAX_MSG ||    \
+                   (TYPE) < TDMT_SCH_MAX_MSG || (TYPE) < TDMT_STREAM_MAX_MSG || (TYPE) < TDMT_MON_MAX_MSG || \
+                   (TYPE) < TDMT_SYNC_MAX_MSG))                                                              \
       ? tMsgInfo[tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE)]                                         \
       : 0
 #define TMSG_INDEX(TYPE) (tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE))
@@ -815,6 +815,13 @@ typedef struct {
 int32_t tSerializeSDbCfgReq(void* buf, int32_t bufLen, SDbCfgReq* pReq);
 int32_t tDeserializeSDbCfgReq(void* buf, int32_t bufLen, SDbCfgReq* pReq);
 
+typedef struct {
+  char db[TSDB_DB_FNAME_LEN];
+} STrimDbReq;
+
+int32_t tSerializeSTrimDbReq(void* buf, int32_t bufLen, STrimDbReq* pReq);
+int32_t tDeserializeSTrimDbReq(void* buf, int32_t bufLen, STrimDbReq* pReq);
+
 typedef struct {
   int32_t numOfVgroups;
   int32_t numOfStables;

include/common/tmsgdef.h

@@ -116,6 +116,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_DB, "alter-db", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SYNC_DB, "sync-db", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_COMPACT_DB, "compact-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TRIM_DB, "trim-db", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_DB_CFG, "get-db-cfg", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_VGROUP_LIST, "vgroup-list", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_FUNC, "create-func", NULL, NULL)

include/common/ttokendef.h

@@ -74,201 +74,202 @@
 #define TK_DATABASE       56
 #define TK_USE            57
 #define TK_FLUSH          58
-#define TK_IF             59
-#define TK_NOT            60
-#define TK_EXISTS         61
-#define TK_BUFFER         62
-#define TK_CACHELAST      63
-#define TK_CACHELASTSIZE  64
-#define TK_COMP           65
-#define TK_DURATION       66
-#define TK_NK_VARIABLE    67
-#define TK_FSYNC          68
-#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_WAL            77
-#define TK_VGROUPS        78
-#define TK_SINGLE_STABLE  79
-#define TK_RETENTIONS     80
-#define TK_SCHEMALESS     81
-#define TK_NK_COLON       82
-#define TK_TABLE          83
-#define TK_NK_LP          84
-#define TK_NK_RP          85
-#define TK_STABLE         86
-#define TK_ADD            87
-#define TK_COLUMN         88
-#define TK_MODIFY         89
-#define TK_RENAME         90
-#define TK_TAG            91
-#define TK_SET            92
-#define TK_NK_EQ          93
-#define TK_USING          94
-#define TK_TAGS           95
-#define TK_COMMENT        96
-#define TK_BOOL           97
-#define TK_TINYINT        98
-#define TK_SMALLINT       99
-#define TK_INT            100
-#define TK_INTEGER        101
-#define TK_BIGINT         102
-#define TK_FLOAT          103
-#define TK_DOUBLE         104
-#define TK_BINARY         105
-#define TK_TIMESTAMP      106
-#define TK_NCHAR          107
-#define TK_UNSIGNED       108
-#define TK_JSON           109
-#define TK_VARCHAR        110
-#define TK_MEDIUMBLOB     111
-#define TK_BLOB           112
-#define TK_VARBINARY      113
-#define TK_DECIMAL        114
-#define TK_MAX_DELAY      115
-#define TK_WATERMARK      116
-#define TK_ROLLUP         117
-#define TK_TTL            118
-#define TK_SMA            119
-#define TK_FIRST          120
-#define TK_LAST           121
-#define TK_SHOW           122
-#define TK_DATABASES      123
-#define TK_TABLES         124
-#define TK_STABLES        125
-#define TK_MNODES         126
-#define TK_MODULES        127
-#define TK_QNODES         128
-#define TK_FUNCTIONS      129
-#define TK_INDEXES        130
-#define TK_ACCOUNTS       131
-#define TK_APPS           132
-#define TK_CONNECTIONS    133
-#define TK_LICENCE        134
-#define TK_GRANTS         135
-#define TK_QUERIES        136
-#define TK_SCORES         137
-#define TK_TOPICS         138
-#define TK_VARIABLES      139
-#define TK_BNODES         140
-#define TK_SNODES         141
-#define TK_CLUSTER        142
-#define TK_TRANSACTIONS   143
-#define TK_DISTRIBUTED    144
-#define TK_CONSUMERS      145
-#define TK_SUBSCRIPTIONS  146
-#define TK_LIKE           147
-#define TK_INDEX          148
-#define TK_FUNCTION       149
-#define TK_INTERVAL       150
-#define TK_TOPIC          151
-#define TK_AS             152
-#define TK_WITH           153
-#define TK_META           154
-#define TK_CONSUMER       155
-#define TK_GROUP          156
-#define TK_DESC           157
-#define TK_DESCRIBE       158
-#define TK_RESET          159
-#define TK_QUERY          160
-#define TK_CACHE          161
-#define TK_EXPLAIN        162
-#define TK_ANALYZE        163
-#define TK_VERBOSE        164
-#define TK_NK_BOOL        165
-#define TK_RATIO          166
-#define TK_NK_FLOAT       167
-#define TK_COMPACT        168
-#define TK_VNODES         169
-#define TK_IN             170
-#define TK_OUTPUTTYPE     171
-#define TK_AGGREGATE      172
-#define TK_BUFSIZE        173
-#define TK_STREAM         174
-#define TK_INTO           175
-#define TK_TRIGGER        176
-#define TK_AT_ONCE        177
-#define TK_WINDOW_CLOSE   178
-#define TK_IGNORE         179
-#define TK_EXPIRED        180
-#define TK_KILL           181
-#define TK_CONNECTION     182
-#define TK_TRANSACTION    183
-#define TK_BALANCE        184
-#define TK_VGROUP         185
-#define TK_MERGE          186
-#define TK_REDISTRIBUTE   187
-#define TK_SPLIT          188
-#define TK_SYNCDB         189
-#define TK_DELETE         190
-#define TK_INSERT         191
-#define TK_NULL           192
-#define TK_NK_QUESTION    193
-#define TK_NK_ARROW       194
-#define TK_ROWTS          195
-#define TK_TBNAME         196
-#define TK_QSTARTTS       197
-#define TK_QENDTS         198
-#define TK_WSTARTTS       199
-#define TK_WENDTS         200
-#define TK_WDURATION      201
-#define TK_CAST           202
-#define TK_NOW            203
-#define TK_TODAY          204
-#define TK_TIMEZONE       205
-#define TK_CLIENT_VERSION 206
-#define TK_SERVER_VERSION 207
-#define TK_SERVER_STATUS  208
-#define TK_CURRENT_USER   209
-#define TK_COUNT          210
-#define TK_LAST_ROW       211
-#define TK_BETWEEN        212
-#define TK_IS             213
-#define TK_NK_LT          214
-#define TK_NK_GT          215
-#define TK_NK_LE          216
-#define TK_NK_GE          217
-#define TK_NK_NE          218
-#define TK_MATCH          219
-#define TK_NMATCH         220
-#define TK_CONTAINS       221
-#define TK_JOIN           222
-#define TK_INNER          223
-#define TK_SELECT         224
-#define TK_DISTINCT       225
-#define TK_WHERE          226
-#define TK_PARTITION      227
-#define TK_BY             228
-#define TK_SESSION        229
-#define TK_STATE_WINDOW   230
-#define TK_SLIDING        231
-#define TK_FILL           232
-#define TK_VALUE          233
-#define TK_NONE           234
-#define TK_PREV           235
-#define TK_LINEAR         236
-#define TK_NEXT           237
-#define TK_HAVING         238
-#define TK_RANGE          239
-#define TK_EVERY          240
-#define TK_ORDER          241
-#define TK_SLIMIT         242
-#define TK_SOFFSET        243
-#define TK_LIMIT          244
-#define TK_OFFSET         245
-#define TK_ASC            246
-#define TK_NULLS          247
-#define TK_ID             248
-#define TK_NK_BITNOT      249
-#define TK_VALUES         250
-#define TK_IMPORT         251
-#define TK_NK_SEMI        252
-#define TK_FILE           253
+#define TK_TRIM           59
+#define TK_IF             60
+#define TK_NOT            61
+#define TK_EXISTS         62
+#define TK_BUFFER         63
+#define TK_CACHELAST      64
+#define TK_CACHELASTSIZE  65
+#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_NK_COLON       83
+#define TK_TABLE          84
+#define TK_NK_LP          85
+#define TK_NK_RP          86
+#define TK_STABLE         87
+#define TK_ADD            88
+#define TK_COLUMN         89
+#define TK_MODIFY         90
+#define TK_RENAME         91
+#define TK_TAG            92
+#define TK_SET            93
+#define TK_NK_EQ          94
+#define TK_USING          95
+#define TK_TAGS           96
+#define TK_COMMENT        97
+#define TK_BOOL           98
+#define TK_TINYINT        99
+#define TK_SMALLINT       100
+#define TK_INT            101
+#define TK_INTEGER        102
+#define TK_BIGINT         103
+#define TK_FLOAT          104
+#define TK_DOUBLE         105
+#define TK_BINARY         106
+#define TK_TIMESTAMP      107
+#define TK_NCHAR          108
+#define TK_UNSIGNED       109
+#define TK_JSON           110
+#define TK_VARCHAR        111
+#define TK_MEDIUMBLOB     112
+#define TK_BLOB           113
+#define TK_VARBINARY      114
+#define TK_DECIMAL        115
+#define TK_MAX_DELAY      116
+#define TK_WATERMARK      117
+#define TK_ROLLUP         118
+#define TK_TTL            119
+#define TK_SMA            120
+#define TK_FIRST          121
+#define TK_LAST           122
+#define TK_SHOW           123
+#define TK_DATABASES      124
+#define TK_TABLES         125
+#define TK_STABLES        126
+#define TK_MNODES         127
+#define TK_MODULES        128
+#define TK_QNODES         129
+#define TK_FUNCTIONS      130
+#define TK_INDEXES        131
+#define TK_ACCOUNTS       132
+#define TK_APPS           133
+#define TK_CONNECTIONS    134
+#define TK_LICENCE        135
+#define TK_GRANTS         136
+#define TK_QUERIES        137
+#define TK_SCORES         138
+#define TK_TOPICS         139
+#define TK_VARIABLES      140
+#define TK_BNODES         141
+#define TK_SNODES         142
+#define TK_CLUSTER        143
+#define TK_TRANSACTIONS   144
+#define TK_DISTRIBUTED    145
+#define TK_CONSUMERS      146
+#define TK_SUBSCRIPTIONS  147
+#define TK_LIKE           148
+#define TK_INDEX          149
+#define TK_FUNCTION       150
+#define TK_INTERVAL       151
+#define TK_TOPIC          152
+#define TK_AS             153
+#define TK_WITH           154
+#define TK_META           155
+#define TK_CONSUMER       156
+#define TK_GROUP          157
+#define TK_DESC           158
+#define TK_DESCRIBE       159
+#define TK_RESET          160
+#define TK_QUERY          161
+#define TK_CACHE          162
+#define TK_EXPLAIN        163
+#define TK_ANALYZE        164
+#define TK_VERBOSE        165
+#define TK_NK_BOOL        166
+#define TK_RATIO          167
+#define TK_NK_FLOAT       168
+#define TK_COMPACT        169
+#define TK_VNODES         170
+#define TK_IN             171
+#define TK_OUTPUTTYPE     172
+#define TK_AGGREGATE      173
+#define TK_BUFSIZE        174
+#define TK_STREAM         175
+#define TK_INTO           176
+#define TK_TRIGGER        177
+#define TK_AT_ONCE        178
+#define TK_WINDOW_CLOSE   179
+#define TK_IGNORE         180
+#define TK_EXPIRED        181
+#define TK_KILL           182
+#define TK_CONNECTION     183
+#define TK_TRANSACTION    184
+#define TK_BALANCE        185
+#define TK_VGROUP         186
+#define TK_MERGE          187
+#define TK_REDISTRIBUTE   188
+#define TK_SPLIT          189
+#define TK_SYNCDB         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_QSTARTTS       198
+#define TK_QENDTS         199
+#define TK_WSTARTTS       200
+#define TK_WENDTS         201
+#define TK_WDURATION      202
+#define TK_CAST           203
+#define TK_NOW            204
+#define TK_TODAY          205
+#define TK_TIMEZONE       206
+#define TK_CLIENT_VERSION 207
+#define TK_SERVER_VERSION 208
+#define TK_SERVER_STATUS  209
+#define TK_CURRENT_USER   210
+#define TK_COUNT          211
+#define TK_LAST_ROW       212
+#define TK_BETWEEN        213
+#define TK_IS             214
+#define TK_NK_LT          215
+#define TK_NK_GT          216
+#define TK_NK_LE          217
+#define TK_NK_GE          218
+#define TK_NK_NE          219
+#define TK_MATCH          220
+#define TK_NMATCH         221
+#define TK_CONTAINS       222
+#define TK_JOIN           223
+#define TK_INNER          224
+#define TK_SELECT         225
+#define TK_DISTINCT       226
+#define TK_WHERE          227
+#define TK_PARTITION      228
+#define TK_BY             229
+#define TK_SESSION        230
+#define TK_STATE_WINDOW   231
+#define TK_SLIDING        232
+#define TK_FILL           233
+#define TK_VALUE          234
+#define TK_NONE           235
+#define TK_PREV           236
+#define TK_LINEAR         237
+#define TK_NEXT           238
+#define TK_HAVING         239
+#define TK_RANGE          240
+#define TK_EVERY          241
+#define TK_ORDER          242
+#define TK_SLIMIT         243
+#define TK_SOFFSET        244
+#define TK_LIMIT          245
+#define TK_OFFSET         246
+#define TK_ASC            247
+#define TK_NULLS          248
+#define TK_ID             249
+#define TK_NK_BITNOT      250
+#define TK_VALUES         251
+#define TK_IMPORT         252
+#define TK_NK_SEMI        253
+#define TK_FILE           254
 
 #define TK_NK_SPACE   300
 #define TK_NK_COMMENT 301

include/libs/nodes/cmdnodes.h

@@ -103,6 +103,11 @@ typedef struct SFlushDatabaseStmt {
   char      dbName[TSDB_DB_NAME_LEN];
 } SFlushDatabaseStmt;
 
+typedef struct STrimDatabaseStmt {
+  ENodeType type;
+  char      dbName[TSDB_DB_NAME_LEN];
+} STrimDatabaseStmt;
+
 typedef struct STableOptions {
   ENodeType  type;
   bool       commentNull;

include/libs/nodes/nodes.h

@@ -112,6 +112,7 @@ typedef enum ENodeType {
   QUERY_NODE_DROP_DATABASE_STMT,
   QUERY_NODE_ALTER_DATABASE_STMT,
   QUERY_NODE_FLUSH_DATABASE_STMT,
+  QUERY_NODE_TRIM_DATABASE_STMT,
   QUERY_NODE_CREATE_TABLE_STMT,
   QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
   QUERY_NODE_CREATE_MULTI_TABLE_STMT,

source/common/src/tmsg.c

@@ -2647,6 +2647,31 @@ int32_t tDeserializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) {
   return 0;
 }
 
+int32_t tSerializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSTrimDbReq(void *buf, int32_t bufLen, STrimDbReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
 int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);

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

@@ -323,6 +323,11 @@ static bool filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader) {
 
     if ((asc && (win.ekey < pReader->window.skey)) || ((!asc) && (win.skey > pReader->window.ekey))) {
       pIter->index += step;
+
+      if ((asc && pIter->index >= pIter->numOfFiles) || ((!asc) && pIter->index < 0)) {
+        return false;
+      }
+
       continue;
     }
 

source/libs/executor/inc/executorimpl.h

@@ -551,6 +551,7 @@ typedef struct SFillOperatorInfo {
   bool              multigroupResult;
   STimeWindow       win;
   SNode*            pCondition;
+  SArray*           pColMatchColInfo;
 } SFillOperatorInfo;
 
 typedef struct SGroupbyOperatorInfo {

source/libs/executor/src/executorimpl.c

@@ -4001,11 +4001,16 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode*
       QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL == downstream->operatorType
             ? &((SMergeAlignedIntervalAggOperatorInfo*)downstream->info)->intervalAggOperatorInfo->interval
             : &((SIntervalAggOperatorInfo*)downstream->info)->interval;
+
   int32_t type = convertFillType(pPhyFillNode->mode);
 
   SResultInfo* pResultInfo = &pOperator->resultInfo;
   initResultSizeInfo(pOperator, 4096);
 
+  int32_t numOfOutputCols = 0;
+  SArray* pColMatchColInfo =
+      extractColMatchInfo(pPhyFillNode->pTargets, pPhyFillNode->node.pOutputDataBlockDesc, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID);
+
   int32_t code = initFillInfo(pInfo, pExprInfo, num, (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange,
                               pResultInfo->capacity, pTaskInfo->id.str, pInterval, type);
   if (code != TSDB_CODE_SUCCESS) {
@@ -4015,6 +4020,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode*
   pInfo->pRes                    = pResBlock;
   pInfo->multigroupResult        = multigroupResult;
   pInfo->pCondition              = pPhyFillNode->node.pConditions;
+  pInfo->pColMatchColInfo        = pColMatchColInfo;
   pOperator->name                = "FillOperator";
   pOperator->blocking            = false;
   pOperator->status              = OP_NOT_OPENED;

source/libs/executor/src/sortoperator.c

@@ -217,6 +217,7 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) {
       doSetOperatorCompleted(pOperator);
       break;
     }
+
     if (blockDataGetNumOfRows(pBlock) > 0) {
       break;
     }
@@ -601,8 +602,7 @@ SSDataBlock* getMultiwaySortedBlockData(SSortHandle* pHandle, SSDataBlock* pData
       break;
     }
 
-    if (pInfo->groupSort)
-    {
+    if (pInfo->groupSort) {
       uint64_t tupleGroupId = tsortGetGroupId(pTupleHandle);
       if (!pInfo->hasGroupId) {
         pInfo->groupId = tupleGroupId;

source/libs/executor/src/tfill.c

@@ -50,8 +50,11 @@ static void setTagsValue(SFillInfo* pFillInfo, void** data, int32_t genRows) {
 
 static void setNullRow(SSDataBlock* pBlock, int32_t numOfCol, int32_t rowIndex) {
   // the first are always the timestamp column, so start from the second column.
-  for (int32_t i = 1; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {
+  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {
     SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, i);
+    if (p->info.type == TSDB_DATA_TYPE_TIMESTAMP && i == 0) {
+      continue;
+    }
     colDataAppendNULL(p, rowIndex);
   }
 }

source/libs/function/src/functionMgt.c

@@ -139,7 +139,7 @@ bool fmIsAggFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MG
 
 bool fmIsScalarFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SCALAR_FUNC); }
 
-bool fmIsVectorFunc(int32_t funcId) { return !fmIsScalarFunc(funcId) && !fmIsScanPseudoColumnFunc(funcId); }
+bool fmIsVectorFunc(int32_t funcId) { return !fmIsScalarFunc(funcId) && !fmIsPseudoColumnFunc(funcId); }
 
 bool fmIsSelectFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SELECT_FUNC); }
 

source/libs/nodes/src/nodesUtilFuncs.c

@@ -105,6 +105,8 @@ SNode* nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SAlterDatabaseStmt));
     case QUERY_NODE_FLUSH_DATABASE_STMT:
       return makeNode(type, sizeof(SFlushDatabaseStmt));
+    case QUERY_NODE_TRIM_DATABASE_STMT:
+      return makeNode(type, sizeof(STrimDatabaseStmt));
     case QUERY_NODE_CREATE_TABLE_STMT:
       return makeNode(type, sizeof(SCreateTableStmt));
     case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:
@@ -548,6 +550,7 @@ void nodesDestroyNode(SNode* pNode) {
       nodesDestroyNode((SNode*)((SAlterDatabaseStmt*)pNode)->pOptions);
       break;
     case QUERY_NODE_FLUSH_DATABASE_STMT:  // no pointer field
+    case QUERY_NODE_TRIM_DATABASE_STMT:   // no pointer field
       break;
     case QUERY_NODE_CREATE_TABLE_STMT: {
       SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode;

source/libs/parser/inc/parAst.h

@@ -137,6 +137,7 @@ SNode* createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, STok
 SNode* createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken* pDbName);
 SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pOptions);
 SNode* createFlushDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
+SNode* createTrimDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
 SNode* createDefaultTableOptions(SAstCreateContext* pCxt);
 SNode* createAlterTableOptions(SAstCreateContext* pCxt);
 SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal);

source/libs/parser/inc/sql.y

@@ -158,6 +158,7 @@ cmd ::= DROP DATABASE exists_opt(A) db_name(B).
 cmd ::= USE db_name(A).                                                           { pCxt->pRootNode = createUseDatabaseStmt(pCxt, &A); }
 cmd ::= ALTER DATABASE db_name(A) alter_db_options(B).                            { pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &A, B); }
 cmd ::= FLUSH DATABASE db_name(A).                                                { pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &A); }
+cmd ::= TRIM DATABASE db_name(A).                                                 { pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &A); }
 
 %type not_exists_opt                                                              { bool }
 %destructor not_exists_opt                                                        { }
@@ -934,7 +935,11 @@ query_expression_body(A) ::=
 query_primary(A) ::= query_specification(B).                                      { A = B; }
 query_primary(A) ::=
   NK_LP query_expression_body(B) 
-    order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP.                 { A = B; }
+    order_by_clause_opt(C) slimit_clause_opt(D) limit_clause_opt(E) NK_RP.        { 
+                                                                                    A = addOrderByClause(pCxt, B, C);
+                                                                                    A = addSlimitClause(pCxt, A, D);
+                                                                                    A = addLimitClause(pCxt, A, E);
+                                                                                  }
 
 %type order_by_clause_opt                                                         { SNodeList* }
 %destructor order_by_clause_opt                                                   { nodesDestroyList($$); }

source/libs/parser/src/parAstCreater.c

@@ -665,6 +665,9 @@ SNode* addHavingClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pHaving) {
 
 SNode* addOrderByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList) {
   CHECK_PARSER_STATUS(pCxt);
+  if (NULL == pOrderByList) {
+    return pStmt;
+  }
   if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
     ((SSelectStmt*)pStmt)->pOrderByList = pOrderByList;
   } else {
@@ -675,6 +678,9 @@ SNode* addOrderByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrder
 
 SNode* addSlimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit) {
   CHECK_PARSER_STATUS(pCxt);
+  if (NULL == pSlimit) {
+    return pStmt;
+  }
   if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
     ((SSelectStmt*)pStmt)->pSlimit = (SLimitNode*)pSlimit;
   }
@@ -683,6 +689,9 @@ SNode* addSlimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit) {
 
 SNode* addLimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit) {
   CHECK_PARSER_STATUS(pCxt);
+  if (NULL == pLimit) {
+    return pStmt;
+  }
   if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
     ((SSelectStmt*)pStmt)->pLimit = (SLimitNode*)pLimit;
   } else {
@@ -922,7 +931,18 @@ SNode* createFlushDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) {
   if (!checkDbName(pCxt, pDbName, false)) {
     return NULL;
   }
-  SAlterDatabaseStmt* pStmt = (SAlterDatabaseStmt*)nodesMakeNode(QUERY_NODE_FLUSH_DATABASE_STMT);
+  SFlushDatabaseStmt* pStmt = (SFlushDatabaseStmt*)nodesMakeNode(QUERY_NODE_FLUSH_DATABASE_STMT);
+  CHECK_OUT_OF_MEM(pStmt);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
+  return (SNode*)pStmt;
+}
+
+SNode* createTrimDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) {
+  CHECK_PARSER_STATUS(pCxt);
+  if (!checkDbName(pCxt, pDbName, false)) {
+    return NULL;
+  }
+  STrimDatabaseStmt* pStmt = (STrimDatabaseStmt*)nodesMakeNode(QUERY_NODE_TRIM_DATABASE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
   return (SNode*)pStmt;

source/libs/parser/src/parTokenizer.c

@@ -216,6 +216,7 @@ static SKeyword keywordTable[] = {
     {"TRANSACTION",    TK_TRANSACTION},
     {"TRANSACTIONS",   TK_TRANSACTIONS},
     {"TRIGGER",        TK_TRIGGER},
+    {"TRIM",           TK_TRIM},
     {"TSERIES",        TK_TSERIES},
     {"TTL",            TK_TTL},
     {"UNION",          TK_UNION},

source/libs/parser/src/parTranslater.c

@@ -1189,7 +1189,7 @@ static void setFuncClassification(SNode* pCurrStmt, SFunctionNode* pFunc) {
     if (fmIsSelectFunc(pFunc->funcId)) {
       pSelect->hasSelectFunc = true;
       ++(pSelect->selectFuncNum);
-    } else if (fmIsAggFunc(pFunc->funcId) || fmIsIndefiniteRowsFunc(pFunc->funcId)) {
+    } else if (fmIsVectorFunc(pFunc->funcId)) {
       pSelect->hasOtherVectorFunc = true;
     }
     pSelect->hasUniqueFunc = pSelect->hasUniqueFunc ? true : (FUNCTION_TYPE_UNIQUE == pFunc->funcType);
@@ -1514,18 +1514,11 @@ static int32_t rewriteColsToSelectValFunc(STranslateContext* pCxt, SSelectStmt*
 typedef struct CheckAggColCoexistCxt {
   STranslateContext* pTranslateCxt;
   bool               existCol;
-  int32_t            selectFuncNum;
-  bool               existOtherVectorFunc;
 } CheckAggColCoexistCxt;
 
 static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) {
   CheckAggColCoexistCxt* pCxt = (CheckAggColCoexistCxt*)pContext;
   if (isVectorFunc(*pNode)) {
-    if (isSelectFunc(*pNode)) {
-      ++(pCxt->selectFuncNum);
-    } else {
-      pCxt->existOtherVectorFunc = true;
-    }
     return DEAL_RES_IGNORE_CHILD;
   }
   SNode* pPartKey = NULL;
@@ -1542,16 +1535,15 @@ static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) {
 
 static int32_t checkAggColCoexist(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (NULL != pSelect->pGroupByList || NULL != pSelect->pWindow ||
-      (!pSelect->hasAggFuncs && !pSelect->hasIndefiniteRowsFunc)) {
+      (!pSelect->hasAggFuncs && !pSelect->hasIndefiniteRowsFunc && !pSelect->hasInterpFunc)) {
     return TSDB_CODE_SUCCESS;
   }
-  CheckAggColCoexistCxt cxt = {
-      .pTranslateCxt = pCxt, .existCol = false, .selectFuncNum = 0, .existOtherVectorFunc = false};
+  CheckAggColCoexistCxt cxt = {.pTranslateCxt = pCxt, .existCol = false};
   nodesRewriteExprs(pSelect->pProjectionList, doCheckAggColCoexist, &cxt);
   if (!pSelect->isDistinct) {
     nodesRewriteExprs(pSelect->pOrderByList, doCheckAggColCoexist, &cxt);
   }
-  if (1 == cxt.selectFuncNum && !cxt.existOtherVectorFunc) {
+  if (1 == pSelect->selectFuncNum && !pSelect->hasOtherVectorFunc) {
     return rewriteColsToSelectValFunc(pCxt, pSelect);
   }
   if (cxt.existCol) {
@@ -3152,6 +3144,14 @@ static int32_t translateAlterDatabase(STranslateContext* pCxt, SAlterDatabaseStm
   return buildCmdMsg(pCxt, TDMT_MND_ALTER_DB, (FSerializeFunc)tSerializeSAlterDbReq, &alterReq);
 }
 
+static int32_t translateTrimDatabase(STranslateContext* pCxt, STrimDatabaseStmt* pStmt) {
+  STrimDbReq req = {0};
+  SName      name = {0};
+  tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName));
+  tNameGetFullDbName(&name, req.db);
+  return buildCmdMsg(pCxt, TDMT_MND_TRIM_DB, (FSerializeFunc)tSerializeSTrimDbReq, &req);
+}
+
 static int32_t columnDefNodeToField(SNodeList* pList, SArray** pArray) {
   *pArray = taosArrayInit(LIST_LENGTH(pList), sizeof(SField));
   SNode* pNode;
@@ -4584,6 +4584,9 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
     case QUERY_NODE_ALTER_DATABASE_STMT:
       code = translateAlterDatabase(pCxt, (SAlterDatabaseStmt*)pNode);
       break;
+    case QUERY_NODE_TRIM_DATABASE_STMT:
+      code = translateTrimDatabase(pCxt, (STrimDatabaseStmt*)pNode);
+      break;
     case QUERY_NODE_CREATE_TABLE_STMT:
       code = translateCreateSuperTable(pCxt, (SCreateTableStmt*)pNode);
       break;

source/libs/parser/test/parSelectTest.cpp

@@ -245,13 +245,21 @@ TEST_F(ParserSelectTest, orderBy) {
 TEST_F(ParserSelectTest, distinct) {
   useDb("root", "test");
 
-  // run("SELECT distinct c1, c2 FROM t1 WHERE c1 > 0 order by c1");
+  run("SELECT distinct c1, c2 FROM t1 WHERE c1 > 0 order by c1");
 
-  // run("SELECT distinct c1 + 10, c2 FROM t1 WHERE c1 > 0 order by c1 + 10, c2");
+  run("SELECT distinct c1 + 10, c2 FROM t1 WHERE c1 > 0 order by c1 + 10, c2");
 
-  // run("SELECT distinct c1 + 10 cc1, c2 cc2 FROM t1 WHERE c1 > 0 order by cc1, c2");
+  run("SELECT distinct c1 + 10 cc1, c2 cc2 FROM t1 WHERE c1 > 0 order by cc1, c2");
 
-  // run("SELECT distinct COUNT(c2) FROM t1 WHERE c1 > 0 GROUP BY c1 order by COUNT(c2)");
+  run("SELECT distinct COUNT(c2) FROM t1 WHERE c1 > 0 GROUP BY c1 order by COUNT(c2)");
+}
+
+TEST_F(ParserSelectTest, limit) {
+  useDb("root", "test");
+
+  run("SELECT c1, c2 FROM t1 LIMIT 10");
+
+  run("(SELECT c1, c2 FROM t1 LIMIT 10)");
 }
 
 // INTERVAL(interval_val [, interval_offset]) [SLIDING (sliding_val)] [FILL(fill_mod_and_val)]

source/libs/parser/test/parShowToUse.cpp

@@ -222,6 +222,25 @@ TEST_F(ParserShowToUseTest, splitVgroup) {
   run("SPLIT VGROUP 15");
 }
 
+TEST_F(ParserShowToUseTest, trimDatabase) {
+  useDb("root", "test");
+
+  STrimDbReq expect = {0};
+
+  auto setTrimDbReq = [&](const char* pDb) { snprintf(expect.db, sizeof(expect.db), "0.%s", pDb); };
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_TRIM_DATABASE_STMT);
+    ASSERT_EQ(pQuery->pCmdMsg->msgType, TDMT_MND_TRIM_DB);
+    STrimDbReq req = {0};
+    ASSERT_EQ(tDeserializeSTrimDbReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
+    ASSERT_EQ(std::string(req.db), std::string(expect.db));
+  });
+
+  setTrimDbReq("wxy_db");
+  run("TRIM DATABASE wxy_db");
+}
+
 TEST_F(ParserShowToUseTest, useDatabase) {
   useDb("root", "test");