Merge branch 'enh/3.0' into enh/triggerCheckPoint2

include/common/tdatablock.h

@@ -179,6 +179,8 @@ int32_t getJsonValueLen(const char* data);
 int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull);
 int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx, const char* pData);
 int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, uint32_t numOfRows, bool trimValue);
+int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData,
+                            uint32_t numOfRows, bool isNull);
 int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity,
                         const SColumnInfoData* pSource, int32_t numOfRow2);
 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows,

include/common/tmsg.h

@@ -212,6 +212,215 @@ typedef enum _mgmt_table {
 #define TD_REQ_FROM_APP  0
 #define TD_REQ_FROM_TAOX 1
 
+typedef enum ENodeType {
+  // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN,
+  // VALUE, OPERATOR, FUNCTION and so on.
+  QUERY_NODE_COLUMN = 1,
+  QUERY_NODE_VALUE,
+  QUERY_NODE_OPERATOR,
+  QUERY_NODE_LOGIC_CONDITION,
+  QUERY_NODE_FUNCTION,
+  QUERY_NODE_REAL_TABLE,
+  QUERY_NODE_TEMP_TABLE,
+  QUERY_NODE_JOIN_TABLE,
+  QUERY_NODE_GROUPING_SET,
+  QUERY_NODE_ORDER_BY_EXPR,
+  QUERY_NODE_LIMIT,
+  QUERY_NODE_STATE_WINDOW,
+  QUERY_NODE_SESSION_WINDOW,
+  QUERY_NODE_INTERVAL_WINDOW,
+  QUERY_NODE_NODE_LIST,
+  QUERY_NODE_FILL,
+  QUERY_NODE_RAW_EXPR,  // Only be used in parser module.
+  QUERY_NODE_TARGET,
+  QUERY_NODE_DATABLOCK_DESC,
+  QUERY_NODE_SLOT_DESC,
+  QUERY_NODE_COLUMN_DEF,
+  QUERY_NODE_DOWNSTREAM_SOURCE,
+  QUERY_NODE_DATABASE_OPTIONS,
+  QUERY_NODE_TABLE_OPTIONS,
+  QUERY_NODE_INDEX_OPTIONS,
+  QUERY_NODE_EXPLAIN_OPTIONS,
+  QUERY_NODE_STREAM_OPTIONS,
+  QUERY_NODE_LEFT_VALUE,
+  QUERY_NODE_COLUMN_REF,
+  QUERY_NODE_WHEN_THEN,
+  QUERY_NODE_CASE_WHEN,
+  QUERY_NODE_EVENT_WINDOW,
+  QUERY_NODE_HINT,
+
+  // Statement nodes are used in parser and planner module.
+  QUERY_NODE_SET_OPERATOR = 100,
+  QUERY_NODE_SELECT_STMT,
+  QUERY_NODE_VNODE_MODIFY_STMT,
+  QUERY_NODE_CREATE_DATABASE_STMT,
+  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_TABLES_STMT,
+  QUERY_NODE_DROP_TABLE_CLAUSE,
+  QUERY_NODE_DROP_TABLE_STMT,
+  QUERY_NODE_DROP_SUPER_TABLE_STMT,
+  QUERY_NODE_ALTER_TABLE_STMT,
+  QUERY_NODE_ALTER_SUPER_TABLE_STMT,
+  QUERY_NODE_CREATE_USER_STMT,
+  QUERY_NODE_ALTER_USER_STMT,
+  QUERY_NODE_DROP_USER_STMT,
+  QUERY_NODE_USE_DATABASE_STMT,
+  QUERY_NODE_CREATE_DNODE_STMT,
+  QUERY_NODE_DROP_DNODE_STMT,
+  QUERY_NODE_ALTER_DNODE_STMT,
+  QUERY_NODE_CREATE_INDEX_STMT,
+  QUERY_NODE_DROP_INDEX_STMT,
+  QUERY_NODE_CREATE_QNODE_STMT,
+  QUERY_NODE_DROP_QNODE_STMT,
+  QUERY_NODE_CREATE_BNODE_STMT,
+  QUERY_NODE_DROP_BNODE_STMT,
+  QUERY_NODE_CREATE_SNODE_STMT,
+  QUERY_NODE_DROP_SNODE_STMT,
+  QUERY_NODE_CREATE_MNODE_STMT,
+  QUERY_NODE_DROP_MNODE_STMT,
+  QUERY_NODE_CREATE_TOPIC_STMT,
+  QUERY_NODE_DROP_TOPIC_STMT,
+  QUERY_NODE_DROP_CGROUP_STMT,
+  QUERY_NODE_ALTER_LOCAL_STMT,
+  QUERY_NODE_EXPLAIN_STMT,
+  QUERY_NODE_DESCRIBE_STMT,
+  QUERY_NODE_RESET_QUERY_CACHE_STMT,
+  QUERY_NODE_COMPACT_DATABASE_STMT,
+  QUERY_NODE_CREATE_FUNCTION_STMT,
+  QUERY_NODE_DROP_FUNCTION_STMT,
+  QUERY_NODE_CREATE_STREAM_STMT,
+  QUERY_NODE_DROP_STREAM_STMT,
+  QUERY_NODE_BALANCE_VGROUP_STMT,
+  QUERY_NODE_MERGE_VGROUP_STMT,
+  QUERY_NODE_REDISTRIBUTE_VGROUP_STMT,
+  QUERY_NODE_SPLIT_VGROUP_STMT,
+  QUERY_NODE_SYNCDB_STMT,
+  QUERY_NODE_GRANT_STMT,
+  QUERY_NODE_REVOKE_STMT,
+  QUERY_NODE_SHOW_DNODES_STMT,
+  QUERY_NODE_SHOW_MNODES_STMT,
+  QUERY_NODE_SHOW_MODULES_STMT,
+  QUERY_NODE_SHOW_QNODES_STMT,
+  QUERY_NODE_SHOW_SNODES_STMT,
+  QUERY_NODE_SHOW_BNODES_STMT,
+  QUERY_NODE_SHOW_CLUSTER_STMT,
+  QUERY_NODE_SHOW_DATABASES_STMT,
+  QUERY_NODE_SHOW_FUNCTIONS_STMT,
+  QUERY_NODE_SHOW_INDEXES_STMT,
+  QUERY_NODE_SHOW_STABLES_STMT,
+  QUERY_NODE_SHOW_STREAMS_STMT,
+  QUERY_NODE_SHOW_TABLES_STMT,
+  QUERY_NODE_SHOW_TAGS_STMT,
+  QUERY_NODE_SHOW_USERS_STMT,
+  QUERY_NODE_SHOW_LICENCES_STMT,
+  QUERY_NODE_SHOW_VGROUPS_STMT,
+  QUERY_NODE_SHOW_TOPICS_STMT,
+  QUERY_NODE_SHOW_CONSUMERS_STMT,
+  QUERY_NODE_SHOW_CONNECTIONS_STMT,
+  QUERY_NODE_SHOW_QUERIES_STMT,
+  QUERY_NODE_SHOW_APPS_STMT,
+  QUERY_NODE_SHOW_VARIABLES_STMT,
+  QUERY_NODE_SHOW_DNODE_VARIABLES_STMT,
+  QUERY_NODE_SHOW_TRANSACTIONS_STMT,
+  QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT,
+  QUERY_NODE_SHOW_VNODES_STMT,
+  QUERY_NODE_SHOW_USER_PRIVILEGES_STMT,
+  QUERY_NODE_SHOW_CREATE_DATABASE_STMT,
+  QUERY_NODE_SHOW_CREATE_TABLE_STMT,
+  QUERY_NODE_SHOW_CREATE_STABLE_STMT,
+  QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT,
+  QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT,
+  QUERY_NODE_SHOW_SCORES_STMT,
+  QUERY_NODE_SHOW_TABLE_TAGS_STMT,
+  QUERY_NODE_KILL_CONNECTION_STMT,
+  QUERY_NODE_KILL_QUERY_STMT,
+  QUERY_NODE_KILL_TRANSACTION_STMT,
+  QUERY_NODE_DELETE_STMT,
+  QUERY_NODE_INSERT_STMT,
+  QUERY_NODE_QUERY,
+  QUERY_NODE_SHOW_DB_ALIVE_STMT,
+  QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT,
+  QUERY_NODE_BALANCE_VGROUP_LEADER_STMT,
+  QUERY_NODE_RESTORE_DNODE_STMT,
+  QUERY_NODE_RESTORE_QNODE_STMT,
+  QUERY_NODE_RESTORE_MNODE_STMT,
+  QUERY_NODE_RESTORE_VNODE_STMT,
+  QUERY_NODE_PAUSE_STREAM_STMT,
+  QUERY_NODE_RESUME_STREAM_STMT,
+
+  // logic plan node
+  QUERY_NODE_LOGIC_PLAN_SCAN = 1000,
+  QUERY_NODE_LOGIC_PLAN_JOIN,
+  QUERY_NODE_LOGIC_PLAN_AGG,
+  QUERY_NODE_LOGIC_PLAN_PROJECT,
+  QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY,
+  QUERY_NODE_LOGIC_PLAN_EXCHANGE,
+  QUERY_NODE_LOGIC_PLAN_MERGE,
+  QUERY_NODE_LOGIC_PLAN_WINDOW,
+  QUERY_NODE_LOGIC_PLAN_FILL,
+  QUERY_NODE_LOGIC_PLAN_SORT,
+  QUERY_NODE_LOGIC_PLAN_PARTITION,
+  QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC,
+  QUERY_NODE_LOGIC_PLAN_INTERP_FUNC,
+  QUERY_NODE_LOGIC_SUBPLAN,
+  QUERY_NODE_LOGIC_PLAN,
+  QUERY_NODE_LOGIC_PLAN_GROUP_CACHE,
+  QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL,
+
+  // physical plan node
+  QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN = 1100,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_PROJECT,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN,
+  QUERY_NODE_PHYSICAL_PLAN_HASH_AGG,
+  QUERY_NODE_PHYSICAL_PLAN_EXCHANGE,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE,
+  QUERY_NODE_PHYSICAL_PLAN_SORT,
+  QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT,
+  QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_FILL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE,
+  QUERY_NODE_PHYSICAL_PLAN_PARTITION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION,
+  QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC,
+  QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC,
+  QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
+  QUERY_NODE_PHYSICAL_PLAN_INSERT,
+  QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT,
+  QUERY_NODE_PHYSICAL_PLAN_DELETE,
+  QUERY_NODE_PHYSICAL_SUBPLAN,
+  QUERY_NODE_PHYSICAL_PLAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT,
+  QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN,
+  QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE,
+  QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL  
+} ENodeType;
+
+
 typedef struct {
   int32_t vgId;
   char*   dbFName;
@@ -743,6 +952,10 @@ typedef struct STimeWindow {
   TSKEY ekey;
 } STimeWindow;
 
+typedef struct SQueryHint {
+  bool batchScan;
+} SQueryHint;
+
 typedef struct {
   int32_t tsOffset;       // offset value in current msg body, NOTE: ts list is compressed
   int32_t tsLen;          // total length of ts comp block
@@ -761,12 +974,18 @@ typedef struct {
   int64_t offset;
 } SInterval;
 
-typedef struct {
-  int32_t code;
+
+typedef struct STbVerInfo {
   char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t sversion;
   int32_t tversion;
+} STbVerInfo;
+
+
+typedef struct {
+  int32_t code;
   int64_t affectedRows;
+  SArray* tbVerInfo;  // STbVerInfo
 } SQueryTableRsp;
 
 int32_t tSerializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);
@@ -1836,12 +2055,26 @@ typedef struct {
   int32_t tversion;
 } SResReadyRsp;
 
+
+typedef struct SOperatorParam {
+  int32_t             opType;
+  int32_t             downstreamIdx;
+  void*               value;
+  SArray*             pChildren; //SArray<SOperatorParam*>
+} SOperatorParam;
+
+typedef struct STableScanOperatorParam {
+  bool                tableSeq;
+  SArray*             pUidList;
+} STableScanOperatorParam;
+
 typedef struct {
-  SMsgHead header;
-  uint64_t sId;
-  uint64_t queryId;
-  uint64_t taskId;
-  int32_t  execId;
+  SMsgHead        header;
+  uint64_t        sId;
+  uint64_t        queryId;
+  uint64_t        taskId;
+  int32_t         execId;
+  SOperatorParam* pOpParam;
 } SResFetchReq;
 
 int32_t tSerializeSResFetchReq(void* buf, int32_t bufLen, SResFetchReq* pReq);

include/common/ttokendef.h

@@ -276,90 +276,98 @@
 #define TK_JOIN                           258
 #define TK_INNER                          259
 #define TK_SELECT                         260
-#define TK_DISTINCT                       261
-#define TK_WHERE                          262
-#define TK_PARTITION                      263
-#define TK_BY                             264
-#define TK_SESSION                        265
-#define TK_STATE_WINDOW                   266
-#define TK_EVENT_WINDOW                   267
-#define TK_SLIDING                        268
-#define TK_FILL                           269
-#define TK_VALUE                          270
-#define TK_VALUE_F                        271
-#define TK_NONE                           272
-#define TK_PREV                           273
-#define TK_NULL_F                         274
-#define TK_LINEAR                         275
-#define TK_NEXT                           276
-#define TK_HAVING                         277
-#define TK_RANGE                          278
-#define TK_EVERY                          279
-#define TK_ORDER                          280
-#define TK_SLIMIT                         281
-#define TK_SOFFSET                        282
-#define TK_LIMIT                          283
-#define TK_OFFSET                         284
-#define TK_ASC                            285
-#define TK_NULLS                          286
-#define TK_ABORT                          287
-#define TK_AFTER                          288
-#define TK_ATTACH                         289
-#define TK_BEFORE                         290
-#define TK_BEGIN                          291
-#define TK_BITAND                         292
-#define TK_BITNOT                         293
-#define TK_BITOR                          294
-#define TK_BLOCKS                         295
-#define TK_CHANGE                         296
-#define TK_COMMA                          297
-#define TK_CONCAT                         298
-#define TK_CONFLICT                       299
-#define TK_COPY                           300
-#define TK_DEFERRED                       301
-#define TK_DELIMITERS                     302
-#define TK_DETACH                         303
-#define TK_DIVIDE                         304
-#define TK_DOT                            305
-#define TK_EACH                           306
-#define TK_FAIL                           307
-#define TK_FILE                           308
-#define TK_FOR                            309
-#define TK_GLOB                           310
-#define TK_ID                             311
-#define TK_IMMEDIATE                      312
-#define TK_IMPORT                         313
-#define TK_INITIALLY                      314
-#define TK_INSTEAD                        315
-#define TK_ISNULL                         316
-#define TK_KEY                            317
-#define TK_MODULES                        318
-#define TK_NK_BITNOT                      319
-#define TK_NK_SEMI                        320
-#define TK_NOTNULL                        321
-#define TK_OF                             322
-#define TK_PLUS                           323
-#define TK_PRIVILEGE                      324
-#define TK_RAISE                          325
-#define TK_RESTRICT                       326
-#define TK_ROW                            327
-#define TK_SEMI                           328
-#define TK_STAR                           329
-#define TK_STATEMENT                      330
-#define TK_STRICT                         331
-#define TK_STRING                         332
-#define TK_TIMES                          333
-#define TK_VALUES                         334
-#define TK_VARIABLE                       335
-#define TK_VIEW                           336
-#define TK_WAL                            337
+#define TK_NK_HINT                        261
+#define TK_DISTINCT                       262
+#define TK_WHERE                          263
+#define TK_PARTITION                      264
+#define TK_BY                             265
+#define TK_SESSION                        266
+#define TK_STATE_WINDOW                   267
+#define TK_EVENT_WINDOW                   268
+#define TK_SLIDING                        269
+#define TK_FILL                           270
+#define TK_VALUE                          271
+#define TK_VALUE_F                        272
+#define TK_NONE                           273
+#define TK_PREV                           274
+#define TK_NULL_F                         275
+#define TK_LINEAR                         276
+#define TK_NEXT                           277
+#define TK_HAVING                         278
+#define TK_RANGE                          279
+#define TK_EVERY                          280
+#define TK_ORDER                          281
+#define TK_SLIMIT                         282
+#define TK_SOFFSET                        283
+#define TK_LIMIT                          284
+#define TK_OFFSET                         285
+#define TK_ASC                            286
+#define TK_NULLS                          287
+#define TK_ABORT                          288
+#define TK_AFTER                          289
+#define TK_ATTACH                         290
+#define TK_BEFORE                         291
+#define TK_BEGIN                          292
+#define TK_BITAND                         293
+#define TK_BITNOT                         294
+#define TK_BITOR                          295
+#define TK_BLOCKS                         296
+#define TK_CHANGE                         297
+#define TK_COMMA                          298
+#define TK_CONCAT                         299
+#define TK_CONFLICT                       300
+#define TK_COPY                           301
+#define TK_DEFERRED                       302
+#define TK_DELIMITERS                     303
+#define TK_DETACH                         304
+#define TK_DIVIDE                         305
+#define TK_DOT                            306
+#define TK_EACH                           307
+#define TK_FAIL                           308
+#define TK_FILE                           309
+#define TK_FOR                            310
+#define TK_GLOB                           311
+#define TK_ID                             312
+#define TK_IMMEDIATE                      313
+#define TK_IMPORT                         314
+#define TK_INITIALLY                      315
+#define TK_INSTEAD                        316
+#define TK_ISNULL                         317
+#define TK_KEY                            318
+#define TK_MODULES                        319
+#define TK_NK_BITNOT                      320
+#define TK_NK_SEMI                        321
+#define TK_NOTNULL                        322
+#define TK_OF                             323
+#define TK_PLUS                           324
+#define TK_PRIVILEGE                      325
+#define TK_RAISE                          326
+#define TK_RESTRICT                       327
+#define TK_ROW                            328
+#define TK_SEMI                           329
+#define TK_STAR                           330
+#define TK_STATEMENT                      331
+#define TK_STRICT                         332
+#define TK_STRING                         333
+#define TK_TIMES                          334
+#define TK_VALUES                         335
+#define TK_VARIABLE                       336
+#define TK_VIEW                           337
+#define TK_WAL                            338
+
+
+
+
+
+#define TK_NK_SPACE         600
+#define TK_NK_COMMENT       601
+#define TK_NK_ILLEGAL       602
+#define TK_NK_HEX           603  // hex number  0x123
+#define TK_NK_OCT           604  // oct number
+#define TK_NK_BIN           605  // bin format data 0b111
+#define TK_BATCH_SCAN       606
+#define TK_NO_BATCH_SCAN    607
 
-#define TK_NK_SPACE   600
-#define TK_NK_COMMENT 601
-#define TK_NK_ILLEGAL 602
-#define TK_NK_HEX     603  // hex number  0x123
-#define TK_NK_OCT     604  // oct number
-#define TK_NK_BIN     605  // bin format data 0b111
 
 #define TK_NK_NIL 65535
 

include/libs/executor/dataSinkMgt.h

@@ -97,6 +97,8 @@ int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, bool* pC
 
 void dsEndPut(DataSinkHandle handle, uint64_t useconds);
 
+void dsReset(DataSinkHandle handle);
+
 /**
  * Get the length of the data returned by the next call to dsGetDataBlock.
  * @param handle

include/libs/executor/executor.h

@@ -125,6 +125,10 @@ int32_t qSetSMAInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks,
  */
 int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableIdList, bool isAdd);
 
+bool   qIsDynamicExecTask(qTaskInfo_t tinfo);
+
+void   qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam);
+
 /**
  * Create the exec task object according to task json
  * @param readHandle
@@ -145,7 +149,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
  * @return
  */
 int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
-                                    int32_t* tversion);
+                                    int32_t* tversion, int32_t idx);
 
 /**
  * The main task execution function, including query on both table and multiple tables,

include/libs/function/functionMgt.h

@@ -122,6 +122,8 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_IROWTS,
   FUNCTION_TYPE_ISFILLED,
   FUNCTION_TYPE_TAGS,
+  FUNCTION_TYPE_TBUID,
+  FUNCTION_TYPE_VGID,
 
   // internal function
   FUNCTION_TYPE_SELECT_VALUE = 3750,

include/libs/nodes/nodes.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "tdef.h"
+#include "tmsg.h"
 
 #define nodeType(nodeptr)              (((const SNode*)(nodeptr))->type)
 #define setNodeType(nodeptr, nodetype) (((SNode*)(nodeptr))->type = (nodetype))
@@ -78,208 +79,6 @@ extern "C" {
     (list) = NULL;             \
   } while (0)
 
-typedef enum ENodeType {
-  // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN,
-  // VALUE, OPERATOR, FUNCTION and so on.
-  QUERY_NODE_COLUMN = 1,
-  QUERY_NODE_VALUE,
-  QUERY_NODE_OPERATOR,
-  QUERY_NODE_LOGIC_CONDITION,
-  QUERY_NODE_FUNCTION,
-  QUERY_NODE_REAL_TABLE,
-  QUERY_NODE_TEMP_TABLE,
-  QUERY_NODE_JOIN_TABLE,
-  QUERY_NODE_GROUPING_SET,
-  QUERY_NODE_ORDER_BY_EXPR,
-  QUERY_NODE_LIMIT,
-  QUERY_NODE_STATE_WINDOW,
-  QUERY_NODE_SESSION_WINDOW,
-  QUERY_NODE_INTERVAL_WINDOW,
-  QUERY_NODE_NODE_LIST,
-  QUERY_NODE_FILL,
-  QUERY_NODE_RAW_EXPR,  // Only be used in parser module.
-  QUERY_NODE_TARGET,
-  QUERY_NODE_DATABLOCK_DESC,
-  QUERY_NODE_SLOT_DESC,
-  QUERY_NODE_COLUMN_DEF,
-  QUERY_NODE_DOWNSTREAM_SOURCE,
-  QUERY_NODE_DATABASE_OPTIONS,
-  QUERY_NODE_TABLE_OPTIONS,
-  QUERY_NODE_INDEX_OPTIONS,
-  QUERY_NODE_EXPLAIN_OPTIONS,
-  QUERY_NODE_STREAM_OPTIONS,
-  QUERY_NODE_LEFT_VALUE,
-  QUERY_NODE_COLUMN_REF,
-  QUERY_NODE_WHEN_THEN,
-  QUERY_NODE_CASE_WHEN,
-  QUERY_NODE_EVENT_WINDOW,
-
-  // Statement nodes are used in parser and planner module.
-  QUERY_NODE_SET_OPERATOR = 100,
-  QUERY_NODE_SELECT_STMT,
-  QUERY_NODE_VNODE_MODIFY_STMT,
-  QUERY_NODE_CREATE_DATABASE_STMT,
-  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_TABLES_STMT,
-  QUERY_NODE_DROP_TABLE_CLAUSE,
-  QUERY_NODE_DROP_TABLE_STMT,
-  QUERY_NODE_DROP_SUPER_TABLE_STMT,
-  QUERY_NODE_ALTER_TABLE_STMT,
-  QUERY_NODE_ALTER_SUPER_TABLE_STMT,
-  QUERY_NODE_CREATE_USER_STMT,
-  QUERY_NODE_ALTER_USER_STMT,
-  QUERY_NODE_DROP_USER_STMT,
-  QUERY_NODE_USE_DATABASE_STMT,
-  QUERY_NODE_CREATE_DNODE_STMT,
-  QUERY_NODE_DROP_DNODE_STMT,
-  QUERY_NODE_ALTER_DNODE_STMT,
-  QUERY_NODE_CREATE_INDEX_STMT,
-  QUERY_NODE_DROP_INDEX_STMT,
-  QUERY_NODE_CREATE_QNODE_STMT,
-  QUERY_NODE_DROP_QNODE_STMT,
-  QUERY_NODE_CREATE_BNODE_STMT,
-  QUERY_NODE_DROP_BNODE_STMT,
-  QUERY_NODE_CREATE_SNODE_STMT,
-  QUERY_NODE_DROP_SNODE_STMT,
-  QUERY_NODE_CREATE_MNODE_STMT,
-  QUERY_NODE_DROP_MNODE_STMT,
-  QUERY_NODE_CREATE_TOPIC_STMT,
-  QUERY_NODE_DROP_TOPIC_STMT,
-  QUERY_NODE_DROP_CGROUP_STMT,
-  QUERY_NODE_ALTER_LOCAL_STMT,
-  QUERY_NODE_EXPLAIN_STMT,
-  QUERY_NODE_DESCRIBE_STMT,
-  QUERY_NODE_RESET_QUERY_CACHE_STMT,
-  QUERY_NODE_COMPACT_DATABASE_STMT,
-  QUERY_NODE_CREATE_FUNCTION_STMT,
-  QUERY_NODE_DROP_FUNCTION_STMT,
-  QUERY_NODE_CREATE_STREAM_STMT,
-  QUERY_NODE_DROP_STREAM_STMT,
-  QUERY_NODE_BALANCE_VGROUP_STMT,
-  QUERY_NODE_MERGE_VGROUP_STMT,
-  QUERY_NODE_REDISTRIBUTE_VGROUP_STMT,
-  QUERY_NODE_SPLIT_VGROUP_STMT,
-  QUERY_NODE_SYNCDB_STMT,
-  QUERY_NODE_GRANT_STMT,
-  QUERY_NODE_REVOKE_STMT,
-  QUERY_NODE_SHOW_DNODES_STMT,
-  QUERY_NODE_SHOW_MNODES_STMT,
-//  QUERY_NODE_SHOW_MODULES_STMT,
-  QUERY_NODE_SHOW_QNODES_STMT,
-  QUERY_NODE_SHOW_SNODES_STMT,
-  QUERY_NODE_SHOW_BNODES_STMT,
-  QUERY_NODE_SHOW_CLUSTER_STMT,
-  QUERY_NODE_SHOW_DATABASES_STMT,
-  QUERY_NODE_SHOW_FUNCTIONS_STMT,
-  QUERY_NODE_SHOW_INDEXES_STMT,
-  QUERY_NODE_SHOW_STABLES_STMT,
-  QUERY_NODE_SHOW_STREAMS_STMT,
-  QUERY_NODE_SHOW_TABLES_STMT,
-  QUERY_NODE_SHOW_TAGS_STMT,
-  QUERY_NODE_SHOW_USERS_STMT,
-  QUERY_NODE_SHOW_LICENCES_STMT,
-  QUERY_NODE_SHOW_VGROUPS_STMT,
-  QUERY_NODE_SHOW_TOPICS_STMT,
-  QUERY_NODE_SHOW_CONSUMERS_STMT,
-  QUERY_NODE_SHOW_CONNECTIONS_STMT,
-  QUERY_NODE_SHOW_QUERIES_STMT,
-  QUERY_NODE_SHOW_APPS_STMT,
-  QUERY_NODE_SHOW_VARIABLES_STMT,
-  QUERY_NODE_SHOW_DNODE_VARIABLES_STMT,
-  QUERY_NODE_SHOW_TRANSACTIONS_STMT,
-  QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT,
-  QUERY_NODE_SHOW_VNODES_STMT,
-  QUERY_NODE_SHOW_USER_PRIVILEGES_STMT,
-  QUERY_NODE_SHOW_CREATE_DATABASE_STMT,
-  QUERY_NODE_SHOW_CREATE_TABLE_STMT,
-  QUERY_NODE_SHOW_CREATE_STABLE_STMT,
-  QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT,
-  QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT,
-  QUERY_NODE_SHOW_SCORES_STMT,
-  QUERY_NODE_SHOW_TABLE_TAGS_STMT,
-  QUERY_NODE_KILL_CONNECTION_STMT,
-  QUERY_NODE_KILL_QUERY_STMT,
-  QUERY_NODE_KILL_TRANSACTION_STMT,
-  QUERY_NODE_DELETE_STMT,
-  QUERY_NODE_INSERT_STMT,
-  QUERY_NODE_QUERY,
-  QUERY_NODE_SHOW_DB_ALIVE_STMT,
-  QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT,
-  QUERY_NODE_BALANCE_VGROUP_LEADER_STMT,
-  QUERY_NODE_RESTORE_DNODE_STMT,
-  QUERY_NODE_RESTORE_QNODE_STMT,
-  QUERY_NODE_RESTORE_MNODE_STMT,
-  QUERY_NODE_RESTORE_VNODE_STMT,
-  QUERY_NODE_PAUSE_STREAM_STMT,
-  QUERY_NODE_RESUME_STREAM_STMT,
-
-  // logic plan node
-  QUERY_NODE_LOGIC_PLAN_SCAN = 1000,
-  QUERY_NODE_LOGIC_PLAN_JOIN,
-  QUERY_NODE_LOGIC_PLAN_AGG,
-  QUERY_NODE_LOGIC_PLAN_PROJECT,
-  QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY,
-  QUERY_NODE_LOGIC_PLAN_EXCHANGE,
-  QUERY_NODE_LOGIC_PLAN_MERGE,
-  QUERY_NODE_LOGIC_PLAN_WINDOW,
-  QUERY_NODE_LOGIC_PLAN_FILL,
-  QUERY_NODE_LOGIC_PLAN_SORT,
-  QUERY_NODE_LOGIC_PLAN_PARTITION,
-  QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC,
-  QUERY_NODE_LOGIC_PLAN_INTERP_FUNC,
-  QUERY_NODE_LOGIC_SUBPLAN,
-  QUERY_NODE_LOGIC_PLAN,
-
-  // physical plan node
-  QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN = 1100,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_PROJECT,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN,
-  QUERY_NODE_PHYSICAL_PLAN_HASH_AGG,
-  QUERY_NODE_PHYSICAL_PLAN_EXCHANGE,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE,
-  QUERY_NODE_PHYSICAL_PLAN_SORT,
-  QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT,
-  QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_FILL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE,
-  QUERY_NODE_PHYSICAL_PLAN_PARTITION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION,
-  QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC,
-  QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC,
-  QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
-  QUERY_NODE_PHYSICAL_PLAN_INSERT,
-  QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT,
-  QUERY_NODE_PHYSICAL_PLAN_DELETE,
-  QUERY_NODE_PHYSICAL_SUBPLAN,
-  QUERY_NODE_PHYSICAL_PLAN,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT
-} ENodeType;
-
 /**
  * The first field of a node of any type is guaranteed to be the ENodeType.
  * Hence the type of any node can be gotten by casting it to SNode.

include/libs/nodes/plannodes.h

@@ -42,10 +42,13 @@ typedef enum EGroupAction {
 
 typedef struct SLogicNode {
   ENodeType          type;
+  bool               dynamicOp;
+  bool               stmtRoot;
   SNodeList*         pTargets;  // SColumnNode
   SNode*             pConditions;
   SNodeList*         pChildren;
   struct SLogicNode* pParent;
+  SNodeList*         pHint;
   int32_t            optimizedFlag;
   uint8_t            precision;
   SNode*             pLimit;
@@ -111,12 +114,17 @@ typedef struct SScanLogicNode {
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
-  SLogicNode node;
-  EJoinType  joinType;
-  SNode*     pMergeCondition;
-  SNode*     pOnConditions;
-  bool       isSingleTableJoin;
-  SNode*     pColEqualOnConditions;
+  SLogicNode     node;
+  EJoinType      joinType;
+  EJoinAlgorithm joinAlgo;
+  SNode*         pPrimKeyEqCond;
+  SNode*         pColEqCond;
+  SNode*         pTagEqCond;
+  SNode*         pTagOnCond;
+  SNode*         pOtherOnCond;
+  bool           isSingleTableJoin;
+  bool           hasSubQuery;
+  bool           isLowLevelJoin;
 } SJoinLogicNode;
 
 typedef struct SAggLogicNode {
@@ -155,6 +163,28 @@ typedef struct SInterpFuncLogicNode {
   SNode*      pTimeSeries;  // SColumnNode
 } SInterpFuncLogicNode;
 
+typedef struct SGroupCacheLogicNode {
+  SLogicNode  node;
+  bool        grpColsMayBeNull;  
+  bool        grpByUid;
+  bool        globalGrp;
+  bool        batchFetch;
+  SNodeList*  pGroupCols;
+} SGroupCacheLogicNode;
+
+typedef struct SDynQueryCtrlStbJoin {
+  bool          batchFetch;
+  SNodeList*    pVgList;
+  SNodeList*    pUidList;
+  bool          srcScan[2];
+} SDynQueryCtrlStbJoin;
+
+typedef struct SDynQueryCtrlLogicNode {
+  SLogicNode           node;
+  EDynQueryType        qType;
+  SDynQueryCtrlStbJoin stbJoin;
+} SDynQueryCtrlLogicNode;
+
 typedef enum EModifyTableType { MODIFY_TABLE_TYPE_INSERT = 1, MODIFY_TABLE_TYPE_DELETE } EModifyTableType;
 
 typedef struct SVnodeModifyLogicNode {
@@ -313,6 +343,7 @@ typedef struct SDataBlockDescNode {
 
 typedef struct SPhysiNode {
   ENodeType           type;
+  bool                dynamicOp;
   EOrder              inputTsOrder;
   EOrder              outputTsOrder;
   SDataBlockDescNode* pOutputDataBlockDesc;
@@ -414,12 +445,50 @@ typedef struct SInterpFuncPhysiNode {
 typedef struct SSortMergeJoinPhysiNode {
   SPhysiNode node;
   EJoinType  joinType;
-  SNode*     pMergeCondition;
-  SNode*     pOnConditions;
+  SNode*     pPrimKeyCond;
+  SNode*     pColEqCond;
+  SNode*     pOtherOnCond;
   SNodeList* pTargets;
-  SNode*     pColEqualOnConditions;
 } SSortMergeJoinPhysiNode;
 
+typedef struct SHashJoinPhysiNode {
+  SPhysiNode node;
+  EJoinType  joinType;
+  SNodeList* pOnLeft;
+  SNodeList* pOnRight;
+  SNode*     pFilterConditions;
+  SNodeList* pTargets;
+  SQueryStat inputStat[2];
+
+  SNode*     pPrimKeyCond;
+  SNode*     pColEqCond;
+  SNode*     pTagEqCond;  
+} SHashJoinPhysiNode;
+
+typedef struct SGroupCachePhysiNode {
+  SPhysiNode node;
+  bool       grpColsMayBeNull;
+  bool       grpByUid;
+  bool       globalGrp;
+  bool       batchFetch;
+  SNodeList* pGroupCols;
+} SGroupCachePhysiNode;
+
+typedef struct SStbJoinDynCtrlBasic {
+  bool     batchFetch;
+  int32_t  vgSlot[2];
+  int32_t  uidSlot[2];
+  bool     srcScan[2];
+} SStbJoinDynCtrlBasic;
+
+typedef struct SDynQueryCtrlPhysiNode {
+  SPhysiNode    node;
+  EDynQueryType qType;
+  union {
+    SStbJoinDynCtrlBasic stbJoin;
+  };
+} SDynQueryCtrlPhysiNode;
+
 typedef struct SAggPhysiNode {
   SPhysiNode node;
   SNodeList* pExprs;  // these are expression list of group_by_clause and parameter expression of aggregate function

include/libs/nodes/querynodes.h

@@ -116,6 +116,17 @@ typedef struct SLeftValueNode {
   ENodeType type;
 } SLeftValueNode;
 
+typedef enum EHintOption {
+  HINT_NO_BATCH_SCAN = 1,
+  HINT_BATCH_SCAN,
+} EHintOption;
+
+typedef struct SHintNode {
+  ENodeType   type;
+  EHintOption option;
+  void*       value;
+} SHintNode;
+
 typedef struct SOperatorNode {
   SExprNode     node;  // QUERY_NODE_OPERATOR
   EOperatorType opType;
@@ -169,11 +180,27 @@ typedef struct STempTableNode {
   SNode*     pSubquery;
 } STempTableNode;
 
-typedef enum EJoinType { JOIN_TYPE_INNER = 1 } EJoinType;
+typedef enum EJoinType { 
+  JOIN_TYPE_INNER = 1,
+  JOIN_TYPE_LEFT,
+  JOIN_TYPE_RIGHT,
+} EJoinType;
+
+typedef enum EJoinAlgorithm { 
+  JOIN_ALGO_UNKNOWN = 0,
+  JOIN_ALGO_MERGE,
+  JOIN_ALGO_HASH,
+} EJoinAlgorithm;
+
+typedef enum EDynQueryType {
+  DYN_QTYPE_STB_HASH = 1,
+} EDynQueryType;
 
 typedef struct SJoinTableNode {
   STableNode table;  // QUERY_NODE_JOIN_TABLE
   EJoinType  joinType;
+  bool       hasSubQuery;
+  bool       isLowLevelJoin;
   SNode*     pLeft;
   SNode*     pRight;
   SNode*     pOnCond;
@@ -289,6 +316,7 @@ typedef struct SSelectStmt {
   SLimitNode*   pLimit;
   SLimitNode*   pSlimit;
   STimeWindow   timeRange;
+  SNodeList*    pHint;
   char          stmtName[TSDB_TABLE_NAME_LEN];
   uint8_t       precision;
   int32_t       selectFuncNum;
@@ -470,7 +498,7 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
 int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols);
 
 typedef bool (*FFuncClassifier)(int32_t funcId);
-int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, FFuncClassifier classifier, SNodeList** pFuncs);
+int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
 
 int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes);
 

include/libs/qcom/query.h

@@ -90,11 +90,6 @@ typedef struct SExecResult {
   void*    res;
 } SExecResult;
 
-typedef struct STbVerInfo {
-  char    tbFName[TSDB_TABLE_FNAME_LEN];
-  int32_t sversion;
-  int32_t tversion;
-} STbVerInfo;
 
 #pragma pack(push, 1) 
 typedef struct SCTableMeta {
@@ -212,6 +207,11 @@ typedef struct SQueryNodeStat {
   int32_t tableNum;  // vg table number, unit is TSDB_TABLE_NUM_UNIT
 } SQueryNodeStat;
 
+typedef struct SQueryStat {
+  int64_t inputRowNum;
+  int32_t inputRowSize;
+} SQueryStat;
+
 int32_t initTaskQueue();
 int32_t cleanupTaskQueue();
 

include/libs/scalar/scalar.h

@@ -95,6 +95,8 @@ int32_t qStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
 int32_t qEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t qTbUidFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t qVgIdFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 /* Aggregation functions */
 int32_t countScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);

include/util/taoserror.h

@@ -518,6 +518,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_JOB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x072F)
 #define TSDB_CODE_QRY_QWORKER_QUIT              TAOS_DEF_ERROR_CODE(0, 0x0730)
 #define TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0731)
+#define TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR   TAOS_DEF_ERROR_CODE(0, 0x0732)
 
 // grant
 #define TSDB_CODE_GRANT_EXPIRED                 TAOS_DEF_ERROR_CODE(0, 0x0800)
@@ -714,6 +715,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
 #define TSDB_CODE_PLAN_EXPECTED_TS_EQUAL        TAOS_DEF_ERROR_CODE(0, 0x2701)
 #define TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN   TAOS_DEF_ERROR_CODE(0, 0x2702)
+#define TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND    TAOS_DEF_ERROR_CODE(0, 0x2703)
 
 //function
 #define TSDB_CODE_FUNC_FUNTION_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2800)

source/common/src/tdatablock.c

@@ -146,15 +146,6 @@ int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx,
                            const char* pData) {
   int32_t type = pColumnInfoData->info.type;
   if (IS_VAR_DATA_TYPE(type)) {
-    int32_t dataLen = 0;
-    if (type == TSDB_DATA_TYPE_JSON) {
-      dataLen = getJsonValueLen(pData);
-    } else {
-      dataLen = varDataTLen(pData);
-    }
-
-    SVarColAttr* pAttr = &pColumnInfoData->varmeta;
-
     pColumnInfoData->varmeta.offset[dstRowIdx] = pColumnInfoData->varmeta.offset[srcRowIdx];
     pColumnInfoData->reassigned = true;
   } else {
@@ -247,6 +238,82 @@ int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow,
   return doCopyNItems(pColumnInfoData, currentRow, pData, len, numOfRows, trimValue);
 }
 
+void colDataSetNItemsNull(SColumnInfoData* pColumnInfoData, uint32_t currentRow, uint32_t numOfRows) {
+  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
+    memset(&pColumnInfoData->varmeta.offset[currentRow], -1, sizeof(int32_t) * numOfRows);
+  } else {
+    if (numOfRows < sizeof(char) * 2) {
+      for (int32_t i = 0; i < numOfRows; ++i) {
+        colDataSetNull_f(pColumnInfoData->nullbitmap, currentRow + i);
+      }
+    } else {
+      int32_t i = 0;
+      for (; i < numOfRows; ++i) {
+        if (BitPos(currentRow + i)) {
+          colDataSetNull_f(pColumnInfoData->nullbitmap, currentRow + i);
+        } else {
+          break;
+        }
+      }
+
+      memset(&BMCharPos(pColumnInfoData->nullbitmap, currentRow + i), 0xFF, (numOfRows - i) / sizeof(char));
+      i += (numOfRows - i) / sizeof(char) * sizeof(char);
+      
+      for (; i < numOfRows; ++i) {
+        colDataSetNull_f(pColumnInfoData->nullbitmap, currentRow + i);
+      }
+    }
+  }
+}
+
+int32_t colDataCopyAndReassign(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, uint32_t numOfRows) {
+  int32_t code = colDataSetVal(pColumnInfoData, currentRow, pData, false);
+  if (code) {
+    return code;
+  }
+  
+  if (numOfRows > 1) {
+    int32_t* pOffset = pColumnInfoData->varmeta.offset;
+    memset(&pOffset[currentRow + 1], pOffset[currentRow], sizeof(pOffset[0]) * (numOfRows - 1));
+    pColumnInfoData->reassigned = true;  
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData,
+                            uint32_t numOfRows, bool isNull) {
+  int32_t len = pColumnInfoData->info.bytes;
+  if (isNull) {
+    colDataSetNItemsNull(pColumnInfoData, currentRow, numOfRows);
+    pColumnInfoData->hasNull = true;
+    return 0;
+  }
+
+  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
+    return colDataCopyAndReassign(pColumnInfoData, currentRow, pData, numOfRows);
+  } else {
+    int32_t colBytes = pColumnInfoData->info.bytes;
+    int32_t colOffset = currentRow * colBytes;
+    uint32_t num = 1;
+
+    void* pStart = pColumnInfoData->pData + colOffset;
+    memcpy(pStart, pData, colBytes);
+    colOffset += num * colBytes;
+    
+    while (num < numOfRows) {
+      int32_t maxNum = num << 1;
+      int32_t tnum = maxNum > numOfRows ? (numOfRows - num) : num;
+      
+      memcpy(pColumnInfoData->pData + colOffset, pStart, tnum * colBytes);
+      colOffset += tnum * colBytes;
+      num += tnum;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static void doBitmapMerge(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, const SColumnInfoData* pSource,
                           int32_t numOfRow2) {
   if (numOfRow2 <= 0) return;
@@ -2428,4 +2495,4 @@ void trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList
 
 int32_t blockGetEncodeSize(const SSDataBlock* pBlock) {
   return blockDataGetSerialMetaSize(taosArrayGetSize(pBlock->pDataBlock)) + blockDataGetSize(pBlock);
-}
+}
\ No newline at end of file

source/common/src/tmsg.c

@@ -5563,6 +5563,82 @@ void tFreeSSubQueryMsg(SSubQueryMsg *pReq) {
   taosMemoryFreeClear(pReq->msg);
 }
 
+int32_t tSerializeSOperatorParam(SEncoder* pEncoder, SOperatorParam* pOpParam) {
+  if (tEncodeI32(pEncoder, pOpParam->opType) < 0) return -1;
+  if (tEncodeI32(pEncoder, pOpParam->downstreamIdx) < 0) return -1;
+  switch (pOpParam->opType) {
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: {
+      STableScanOperatorParam* pScan = (STableScanOperatorParam*)pOpParam->value;
+      if (tEncodeI8(pEncoder, pScan->tableSeq) < 0) return -1;
+      int32_t uidNum = taosArrayGetSize(pScan->pUidList);
+      if (tEncodeI32(pEncoder, uidNum) < 0) return -1;
+      for (int32_t m = 0; m < uidNum; ++m) {
+        int64_t* pUid = taosArrayGet(pScan->pUidList, m);
+        if (tEncodeI64(pEncoder, *pUid) < 0) return -1;
+      }
+      break;
+    }
+    default:
+      return TSDB_CODE_INVALID_PARA;
+  }
+  
+  int32_t n = taosArrayGetSize(pOpParam->pChildren);
+  if (tEncodeI32(pEncoder, n) < 0) return -1;
+  for (int32_t i = 0; i < n; ++i) {
+    SOperatorParam* pChild = *(SOperatorParam**)taosArrayGet(pOpParam->pChildren, i);
+    if (tSerializeSOperatorParam(pEncoder, pChild) < 0) return -1;
+  }
+
+  return 0;
+}
+
+int32_t tDeserializeSOperatorParam(SDecoder *pDecoder, SOperatorParam* pOpParam) {
+  if (tDecodeI32(pDecoder, &pOpParam->opType) < 0) return -1;
+  if (tDecodeI32(pDecoder, &pOpParam->downstreamIdx) < 0) return -1;
+  switch (pOpParam->opType) {
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: {
+      STableScanOperatorParam* pScan = taosMemoryMalloc(sizeof(STableScanOperatorParam));
+      if (NULL == pScan) return -1;
+      if (tDecodeI8(pDecoder, (int8_t*)&pScan->tableSeq) < 0) return -1;
+      int32_t uidNum = 0;
+      int64_t uid = 0;
+      if (tDecodeI32(pDecoder, &uidNum) < 0) return -1;
+      if (uidNum > 0) {
+        pScan->pUidList = taosArrayInit(uidNum, sizeof(int64_t));
+        if (NULL == pScan->pUidList) return -1;
+        for (int32_t m = 0; m < uidNum; ++m) {
+          if (tDecodeI64(pDecoder, &uid) < 0) return -1;
+          taosArrayPush(pScan->pUidList, &uid);
+        }
+      } else {
+        pScan->pUidList = NULL;
+      }
+      pOpParam->value = pScan;
+      break;
+    }
+    default:
+      return TSDB_CODE_INVALID_PARA;
+  }
+
+  int32_t childrenNum = 0;
+  if (tDecodeI32(pDecoder, &childrenNum) < 0) return -1;
+  if (childrenNum > 0) {
+    pOpParam->pChildren = taosArrayInit(childrenNum, POINTER_BYTES);
+    if (NULL == pOpParam->pChildren) return -1;
+    for (int32_t i = 0; i < childrenNum; ++i) {
+      SOperatorParam* pChild = taosMemoryCalloc(1, sizeof(SOperatorParam));
+      if (NULL == pChild) return -1;
+      if (tDeserializeSOperatorParam(pDecoder, pChild) < 0) return -1;
+      taosArrayPush(pOpParam->pChildren, &pChild);
+    }
+  } else {
+    pOpParam->pChildren = NULL;
+  }
+
+  return 0;
+}
+
+
 int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) {
   int32_t headLen = sizeof(SMsgHead);
   if (buf != NULL) {
@@ -5578,6 +5654,12 @@ int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) {
   if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1;
   if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->execId) < 0) return -1;
+  if (pReq->pOpParam) {
+    if (tEncodeI32(&encoder, 1) < 0) return -1;
+    if (tSerializeSOperatorParam(&encoder, pReq->pOpParam) < 0) return -1;
+  } else {
+    if (tEncodeI32(&encoder, 0) < 0) return -1;
+  }
 
   tEndEncode(&encoder);
 
@@ -5610,6 +5692,14 @@ int32_t tDeserializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq)
   if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->execId) < 0) return -1;
 
+  int32_t paramNum = 0;
+  if (tDecodeI32(&decoder, &paramNum) < 0) return -1;
+  if (paramNum > 0) {
+    pReq->pOpParam = taosMemoryMalloc(sizeof(*pReq->pOpParam));
+    if (NULL == pReq->pOpParam) return -1;
+    if (tDeserializeSOperatorParam(&decoder, pReq->pOpParam) < 0) return -1;
+  }
+  
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -5754,11 +5844,18 @@ int32_t tSerializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pRsp
   if (tStartEncode(&encoder) < 0) return -1;
 
   if (tEncodeI32(&encoder, pRsp->code) < 0) return -1;
-  if (tEncodeCStr(&encoder, pRsp->tbFName) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->sversion) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->tversion) < 0) return -1;
   if (tEncodeI64(&encoder, pRsp->affectedRows) < 0) return -1;
-
+  int32_t tbNum = taosArrayGetSize(pRsp->tbVerInfo);
+  if (tEncodeI32(&encoder, tbNum) < 0) return -1;
+  if (tbNum > 0) {
+    for (int32_t i = 0; i < tbNum; ++i) {
+      STbVerInfo *pVer = taosArrayGet(pRsp->tbVerInfo, i);
+      if (tEncodeCStr(&encoder, pVer->tbFName) < 0) return -1;
+      if (tEncodeI32(&encoder, pVer->sversion) < 0) return -1;
+      if (tEncodeI32(&encoder, pVer->tversion) < 0) return -1;
+    }
+  }
+  
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -5774,11 +5871,19 @@ int32_t tDeserializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pR
   if (tStartDecode(&decoder) < 0) return -1;
 
   if (tDecodeI32(&decoder, &pRsp->code) < 0) return -1;
-  if (tDecodeCStrTo(&decoder, pRsp->tbFName) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->sversion) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->tversion) < 0) return -1;
   if (tDecodeI64(&decoder, &pRsp->affectedRows) < 0) return -1;
-
+  int32_t tbNum = 0;
+  if (tDecodeI32(&decoder, &tbNum) < 0) return -1;
+  if (tbNum > 0) {
+    pRsp->tbVerInfo = taosArrayInit(tbNum, sizeof(STbVerInfo));
+    if (NULL == pRsp->tbVerInfo) return -1;
+    STbVerInfo tbVer;
+    if (tDecodeCStrTo(&decoder, tbVer.tbFName) < 0) return -1;
+    if (tDecodeI32(&decoder, &tbVer.sversion) < 0) return -1;
+    if (tDecodeI32(&decoder, &tbVer.tversion) < 0) return -1;
+    if (NULL == taosArrayPush(pRsp->tbVerInfo, &tbVer)) return -1;
+  }
+  
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);

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

@@ -312,7 +312,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 _OVER:
   if (code != 0) {
     vnodeClose(pImpl);
-    vnodeDestroy(path, pMgmt->pTfs);
+    vnodeDestroy(0, path, pMgmt->pTfs);
   } else {
     dInfo("vgId:%d, vnode management handle msgType:%s, end to create vnode, vnode is created", req.vgId,
           TMSG_INFO(pMsg->msgType));
@@ -409,7 +409,7 @@ int32_t vmProcessAlterVnodeTypeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   vmCloseVnode(pMgmt, pVnode, false);
 
   int32_t diskPrimary = wrapperCfg.diskPrimary;
-  char path[TSDB_FILENAME_LEN] = {0};
+  char    path[TSDB_FILENAME_LEN] = {0};
   snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, vgId);
 
   dInfo("vgId:%d, start to alter vnode replica at %s", vgId, path);
@@ -507,8 +507,8 @@ int32_t vmProcessAlterHashRangeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   vmCloseVnode(pMgmt, pVnode, true);
 
   int32_t diskPrimary = wrapperCfg.diskPrimary;
-  char srcPath[TSDB_FILENAME_LEN] = {0};
-  char dstPath[TSDB_FILENAME_LEN] = {0};
+  char    srcPath[TSDB_FILENAME_LEN] = {0};
+  char    dstPath[TSDB_FILENAME_LEN] = {0};
   snprintf(srcPath, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, srcVgId);
   snprintf(dstPath, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, dstVgId);
 
@@ -611,7 +611,7 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   vmCloseVnode(pMgmt, pVnode, false);
 
   int32_t diskPrimary = wrapperCfg.diskPrimary;
-  char path[TSDB_FILENAME_LEN] = {0};
+  char    path[TSDB_FILENAME_LEN] = {0};
   snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, vgId);
 
   dInfo("vgId:%d, start to alter vnode replica at %s", vgId, path);

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

@@ -208,7 +208,7 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal)
   if (pVnode->dropped) {
     dInfo("vgId:%d, vnode is destroyed, dropped:%d", pVnode->vgId, pVnode->dropped);
     snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, pVnode->vgId);
-    vnodeDestroy(path, pMgmt->pTfs);
+    vnodeDestroy(pVnode->vgId, path, pMgmt->pTfs);
   }
 
   taosMemoryFree(pVnode->path);

source/dnode/vnode/inc/vnode.h

@@ -33,8 +33,8 @@
 #include "tmsg.h"
 #include "trow.h"
 
-#include "tdb.h"
 #include "storageapi.h"
+#include "tdb.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -57,7 +57,7 @@ int32_t vnodeAlterHashRange(const char *srcPath, const char *dstPath, SAlterVnod
                             int32_t diskPrimary, STfs *pTfs);
 int32_t vnodeRestoreVgroupId(const char *srcPath, const char *dstPath, int32_t srcVgId, int32_t dstVgId,
                              int32_t diskPrimary, STfs *pTfs);
-void    vnodeDestroy(const char *path, STfs *pTfs);
+void    vnodeDestroy(int32_t vgId, const char *path, STfs *pTfs);
 SVnode *vnodeOpen(const char *path, int32_t diskPrimary, STfs *pTfs, SMsgCb msgCb);
 void    vnodePreClose(SVnode *pVnode);
 void    vnodePostClose(SVnode *pVnode);
@@ -66,13 +66,13 @@ void    vnodeClose(SVnode *pVnode);
 int32_t vnodeSyncCommit(SVnode *pVnode);
 int32_t vnodeBegin(SVnode *pVnode);
 
-int32_t   vnodeStart(SVnode *pVnode);
-void      vnodeStop(SVnode *pVnode);
-int64_t   vnodeGetSyncHandle(SVnode *pVnode);
-void      vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot);
-void      vnodeGetInfo(void *pVnode, const char **dbname, int32_t *vgId, int64_t* numOfTables, int64_t* numOfNormalTables);
+int32_t vnodeStart(SVnode *pVnode);
+void    vnodeStop(SVnode *pVnode);
+int64_t vnodeGetSyncHandle(SVnode *pVnode);
+void    vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot);
+void vnodeGetInfo(void *pVnode, const char **dbname, int32_t *vgId, int64_t *numOfTables, int64_t *numOfNormalTables);
 int32_t   vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen);
-int32_t   vnodeGetTableList(void* pVnode, int8_t type, SArray* pList);
+int32_t   vnodeGetTableList(void *pVnode, int8_t type, SArray *pList);
 int32_t   vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list);
 int32_t   vnodeIsCatchUp(SVnode *pVnode);
 ESyncRole vnodeGetRole(SVnode *pVnode);
@@ -80,7 +80,8 @@ ESyncRole vnodeGetRole(SVnode *pVnode);
 int32_t vnodeGetCtbIdList(void *pVnode, int64_t suid, SArray *list);
 int32_t vnodeGetCtbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg), void *arg);
 int32_t vnodeGetStbIdList(SVnode *pVnode, int64_t suid, SArray *list);
-int32_t vnodeGetStbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg, void* arg1), void *arg);
+int32_t vnodeGetStbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg, void *arg1),
+                                  void *arg);
 void   *vnodeGetIdx(void *pVnode);
 void   *vnodeGetIvtIdx(void *pVnode);
 
@@ -105,13 +106,13 @@ void    vnodeApplyWriteMsg(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs
 void    vnodeProposeCommitOnNeed(SVnode *pVnode, bool atExit);
 
 // meta
-void        _metaReaderInit(SMetaReader *pReader, void *pVnode, int32_t flags, SStoreMeta* pAPI);
+void        _metaReaderInit(SMetaReader *pReader, void *pVnode, int32_t flags, SStoreMeta *pAPI);
 void        metaReaderReleaseLock(SMetaReader *pReader);
 void        metaReaderClear(SMetaReader *pReader);
 int32_t     metaReaderGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid);
 int32_t     metaReaderGetTableEntryByUidCache(SMetaReader *pReader, tb_uid_t uid);
 int32_t     metaGetTableTags(void *pVnode, uint64_t suid, SArray *uidList);
-int32_t     metaGetTableTagsByUids(void* pVnode, int64_t suid, SArray *uidList);
+int32_t     metaGetTableTagsByUids(void *pVnode, int64_t suid, SArray *uidList);
 int32_t     metaReadNext(SMetaReader *pReader);
 const void *metaGetTableTagVal(const void *tag, int16_t type, STagVal *tagVal);
 int         metaGetTableNameByUid(void *meta, uint64_t uid, char *tbName);
@@ -120,20 +121,20 @@ int      metaGetTableSzNameByUid(void *meta, uint64_t uid, char *tbName);
 int      metaGetTableUidByName(void *pVnode, char *tbName, uint64_t *uid);
 int      metaGetTableTypeByName(void *meta, char *tbName, ETableType *tbType);
 int      metaGetTableTtlByUid(void *meta, uint64_t uid, int64_t *ttlDays);
-bool     metaIsTableExist(void* pVnode, tb_uid_t uid);
+bool     metaIsTableExist(void *pVnode, tb_uid_t uid);
 int32_t  metaGetCachedTableUidList(void *pVnode, tb_uid_t suid, const uint8_t *key, int32_t keyLen, SArray *pList,
                                    bool *acquired);
 int32_t  metaUidFilterCachePut(void *pVnode, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload,
                                int32_t payloadLen, double selectivityRatio);
 tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name);
 int32_t  metaGetCachedTbGroup(void *pVnode, tb_uid_t suid, const uint8_t *pKey, int32_t keyLen, SArray **pList);
-int32_t  metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload,
+int32_t  metaPutTbGroupToCache(void *pVnode, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload,
                                int32_t payloadLen);
 bool     metaTbInFilterCache(void *pVnode, tb_uid_t suid, int8_t type);
 int32_t  metaPutTbToFilterCache(void *pVnode, tb_uid_t suid, int8_t type);
 int32_t  metaSizeOfTbFilterCache(void *pVnode, int8_t type);
 
-int32_t  metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables);
+int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables);
 
 // tsdb
 typedef struct STsdbReader STsdbReader;
@@ -170,8 +171,8 @@ int64_t      tsdbGetLastTimestamp(SVnode *pVnode, void *pTableList, int32_t numO
 
 //======================================================================================================================
 int32_t      tsdbReaderOpen2(void *pVnode, SQueryTableDataCond *pCond, void *pTableList, int32_t numOfTables,
-                            SSDataBlock *pResBlock, void **ppReader, const char *idstr, bool countOnly,
-                            SHashObj **pIgnoreTables);
+                             SSDataBlock *pResBlock, void **ppReader, const char *idstr, bool countOnly,
+                             SHashObj **pIgnoreTables);
 int32_t      tsdbSetTableList2(STsdbReader *pReader, const void *pTableList, int32_t num);
 void         tsdbReaderSetId2(STsdbReader *pReader, const char *idstr);
 void         tsdbReaderClose2(STsdbReader *pReader);
@@ -228,23 +229,23 @@ STqReader *tqReaderOpen(SVnode *pVnode);
 void       tqReaderClose(STqReader *);
 
 void    tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList);
-int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList, const char* id);
+int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList, const char *id);
 int32_t tqReaderAddTbUidList(STqReader *pReader, const SArray *pTableUidList);
 int32_t tqReaderRemoveTbUidList(STqReader *pReader, const SArray *tbUidList);
 
-bool tqReaderIsQueriedTable(STqReader* pReader, uint64_t uid);
-bool tqCurrentBlockConsumed(const STqReader* pReader);
+bool tqReaderIsQueriedTable(STqReader *pReader, uint64_t uid);
+bool tqCurrentBlockConsumed(const STqReader *pReader);
 
-int32_t tqReaderSeek(STqReader *pReader, int64_t ver, const char *id);
-bool    tqNextBlockInWal(STqReader *pReader, const char *idstr);
-bool    tqNextBlockImpl(STqReader *pReader, const char *idstr);
-SWalReader* tqGetWalReader(STqReader* pReader);
-SSDataBlock* tqGetResultBlock (STqReader* pReader);
+int32_t      tqReaderSeek(STqReader *pReader, int64_t ver, const char *id);
+bool         tqNextBlockInWal(STqReader *pReader, const char *idstr);
+bool         tqNextBlockImpl(STqReader *pReader, const char *idstr);
+SWalReader  *tqGetWalReader(STqReader *pReader);
+SSDataBlock *tqGetResultBlock(STqReader *pReader);
 
 int32_t extractMsgFromWal(SWalReader *pReader, void **pItem, int64_t maxVer, const char *id);
 int32_t tqReaderSetSubmitMsg(STqReader *pReader, void *msgStr, int32_t msgLen, int64_t ver);
 bool    tqNextDataBlockFilterOut(STqReader *pReader, SHashObj *filterOutUids);
-int32_t tqRetrieveDataBlock(STqReader *pReader, SSDataBlock** pRes, const char* idstr);
+int32_t tqRetrieveDataBlock(STqReader *pReader, SSDataBlock **pRes, const char *idstr);
 int32_t tqRetrieveTaosxBlock(STqReader *pReader, SArray *blocks, SArray *schemas, SSubmitTbData **pSubmitTbDataRet);
 
 int32_t vnodeEnqueueStreamMsg(SVnode *pVnode, SRpcMsg *pMsg);

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

@@ -27,6 +27,7 @@ extern int8_t tsS3Enabled;
 int32_t s3Init();
 void    s3CleanUp();
 int32_t s3PutObjectFromFile(const char *file, const char *object);
+void    s3DeleteObjectsByPrefix(const char *prefix);
 void    s3DeleteObjects(const char *object_name[], int nobject);
 bool    s3Exists(const char *object_name);
 bool    s3Get(const char *object_name, const char *path);

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

@@ -44,7 +44,7 @@ int32_t tsdbOpenFile(const char *path, int32_t szPage, int32_t flag, STsdbFD **p
       pFD->pFD = taosOpenFile(path, flag);
 
       if (pFD->pFD == NULL) {
-        code = TAOS_SYSTEM_ERROR(errno);
+        code = TAOS_SYSTEM_ERROR(ENOENT);
         taosMemoryFree(pFD);
         goto _exit;
       }

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

@@ -85,6 +85,25 @@ int32_t s3PutObjectFromFile(const char *file_str, const char *object_str) {
   return code;
 }
 
+void s3DeleteObjectsByPrefix(const char *prefix_str) {
+  cos_pool_t            *p = NULL;
+  cos_request_options_t *options = NULL;
+  int                    is_cname = 0;
+  cos_string_t           bucket;
+  cos_status_t          *s = NULL;
+  cos_string_t           prefix;
+
+  cos_pool_create(&p, NULL);
+  options = cos_request_options_create(p);
+  s3InitRequestOptions(options, is_cname);
+  cos_str_set(&bucket, tsS3BucketName);
+  cos_str_set(&prefix, prefix_str);
+
+  s = cos_delete_objects_by_prefix(options, &bucket, &prefix);
+  log_status(s);
+  cos_pool_destroy(p);
+}
+
 void s3DeleteObjects(const char *object_name[], int nobject) {
   cos_pool_t            *p = NULL;
   int                    is_cname = 0;
@@ -314,6 +333,7 @@ long s3Size(const char *object_name) {
 int32_t s3Init() { return 0; }
 void    s3CleanUp() {}
 int32_t s3PutObjectFromFile(const char *file, const char *object) { return 0; }
+void    s3DeleteObjectsByPrefix(const char *prefix) {}
 void    s3DeleteObjects(const char *object_name[], int nobject) {}
 bool    s3Exists(const char *object_name) { return false; }
 bool    s3Get(const char *object_name, const char *path) { return false; }

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

@@ -14,6 +14,7 @@
  */
 
 #include "vnd.h"
+#include "vndCos.h"
 
 int32_t vnodeGetPrimaryDir(const char *relPath, int32_t diskPrimary, STfs *pTfs, char *buf, size_t bufLen) {
   if (pTfs) {
@@ -100,7 +101,7 @@ int32_t vnodeAlterReplica(const char *path, SAlterVnodeReplicaReq *pReq, int32_t
     vInfo("vgId:%d, replica:%d ep:%s:%u dnode:%d", pReq->vgId, i, pNode->nodeFqdn, pNode->nodePort, pNode->nodeId);
     pCfg->replicaNum++;
   }
-  if(pReq->selfIndex != -1){
+  if (pReq->selfIndex != -1) {
     pCfg->myIndex = pReq->selfIndex;
   }
   for (int i = pCfg->replicaNum; i < pReq->replica + pReq->learnerReplica; ++i) {
@@ -114,12 +115,12 @@ int32_t vnodeAlterReplica(const char *path, SAlterVnodeReplicaReq *pReq, int32_t
     pCfg->totalReplicaNum++;
   }
   pCfg->totalReplicaNum += pReq->replica;
-  if(pReq->learnerSelfIndex != -1){
+  if (pReq->learnerSelfIndex != -1) {
     pCfg->myIndex = pReq->replica + pReq->learnerSelfIndex;
   }
 
-  vInfo("vgId:%d, save config while alter, replicas:%d totalReplicas:%d selfIndex:%d",
-            pReq->vgId, pCfg->replicaNum, pCfg->totalReplicaNum, pCfg->myIndex);
+  vInfo("vgId:%d, save config while alter, replicas:%d totalReplicas:%d selfIndex:%d", pReq->vgId, pCfg->replicaNum,
+        pCfg->totalReplicaNum, pCfg->myIndex);
 
   info.config.syncCfg = *pCfg;
   ret = vnodeSaveInfo(dir, &info);
@@ -293,9 +294,16 @@ int32_t vnodeRestoreVgroupId(const char *srcPath, const char *dstPath, int32_t s
   return dstVgId;
 }
 
-void vnodeDestroy(const char *path, STfs *pTfs) {
+void vnodeDestroy(int32_t vgId, const char *path, STfs *pTfs) {
   vInfo("path:%s is removed while destroy vnode", path);
   tfsRmdir(pTfs, path);
+
+  int32_t nlevel = tfsGetLevel(pTfs);
+  if (vgId > 0 && nlevel > 1 && tsS3Enabled) {
+    char vnode_prefix[TSDB_FILENAME_LEN];
+    snprintf(vnode_prefix, TSDB_FILENAME_LEN, "v%df", vgId);
+    s3DeleteObjectsByPrefix(vnode_prefix);
+  }
 }
 
 static int32_t vnodeCheckDisk(int32_t diskPrimary, STfs *pTfs) {
@@ -498,13 +506,9 @@ void vnodeClose(SVnode *pVnode) {
 // start the sync timer after the queue is ready
 int32_t vnodeStart(SVnode *pVnode) { return vnodeSyncStart(pVnode); }
 
-int32_t vnodeIsCatchUp(SVnode *pVnode){
-  return syncIsCatchUp(pVnode->sync);
-}
+int32_t vnodeIsCatchUp(SVnode *pVnode) { return syncIsCatchUp(pVnode->sync); }
 
-ESyncRole vnodeGetRole(SVnode *pVnode){
-  return syncGetRole(pVnode->sync);
-}
+ESyncRole vnodeGetRole(SVnode *pVnode) { return syncGetRole(pVnode->sync); }
 
 void vnodeStop(SVnode *pVnode) {}
 

source/libs/command/inc/commandInt.h

@@ -67,6 +67,8 @@ extern "C" {
 #define EXPLAIN_EVENT_FORMAT "Event"
 #define EXPLAIN_EVENT_START_FORMAT "Start Cond: "
 #define EXPLAIN_EVENT_END_FORMAT "End Cond: "
+#define EXPLAIN_GROUP_CACHE_FORMAT "Group Cache"
+#define EXPLAIN_DYN_QRY_CTRL_FORMAT "Dynamic Query Control for %s"
 
 #define EXPLAIN_PLANNING_TIME_FORMAT "Planning Time: %.3f ms"
 #define EXPLAIN_EXEC_TIME_FORMAT "Execution Time: %.3f ms"
@@ -96,6 +98,12 @@ extern "C" {
 #define EXPLAIN_OFFSET_FORMAT "offset=%" PRId64
 #define EXPLAIN_SOFFSET_FORMAT "soffset=%" PRId64
 #define EXPLAIN_PARTITIONS_FORMAT "partitions=%d"
+#define EXPLAIN_GLOBAL_GROUP_FORMAT "global_group=%d"
+#define EXPLAIN_GROUP_BY_UID_FORMAT "group_by_uid=%d"
+#define EXPLAIN_BATCH_SCAN_FORMAT "batch_scan=%d"
+#define EXPLAIN_VGROUP_SLOT_FORMAT "vgroup_slot=%d,%d"
+#define EXPLAIN_UID_SLOT_FORMAT "uid_slot=%d,%d"
+#define EXPLAIN_SRC_SCAN_FORMAT "src_scan=%d,%d"
 
 #define COMMAND_RESET_LOG "resetLog"
 #define COMMAND_SCHEDULE_POLICY "schedulePolicy"

source/libs/command/src/explain.c

@@ -24,6 +24,17 @@
 int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pRes);
 int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel);
 
+char *qExplainGetDynQryCtrlType(EDynQueryType type) {
+  switch (type) {
+    case DYN_QTYPE_STB_HASH:
+      return "STable Join";
+    default:
+      break;
+  }
+
+  return "unknown task";
+}
+
 void qExplainFreeResNode(SExplainResNode *resNode) {
   if (NULL == resNode) {
     return;
@@ -575,11 +586,11 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
 
         EXPLAIN_ROW_NEW(level + 1, EXPLAIN_ON_CONDITIONS_FORMAT);
         QRY_ERR_RET(
-            nodesNodeToSQL(pJoinNode->pMergeCondition, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
-        if (pJoinNode->pOnConditions) {
+            nodesNodeToSQL(pJoinNode->pPrimKeyCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+        if (pJoinNode->pOtherOnCond) {
           EXPLAIN_ROW_APPEND(" AND ");
           QRY_ERR_RET(
-              nodesNodeToSQL(pJoinNode->pOnConditions, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+              nodesNodeToSQL(pJoinNode->pOtherOnCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
         }
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));        
@@ -1522,6 +1533,168 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
       }
       break;
     }
+    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:{
+      SHashJoinPhysiNode *pJoinNode = (SHashJoinPhysiNode *)pNode;
+      EXPLAIN_ROW_NEW(level, EXPLAIN_JOIN_FORMAT, EXPLAIN_JOIN_STRING(pJoinNode->joinType));
+      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);
+      if (pResNode->pExecInfo) {
+        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));
+        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      }
+      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pJoinNode->pTargets->length);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->totalRowSize);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pJoinNode->node.inputTsOrder));
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);
+      EXPLAIN_ROW_END();
+      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));
+
+      if (verbose) {
+        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);
+        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,
+                           nodesGetOutputNumFromSlotList(pJoinNode->node.pOutputDataBlockDesc->pSlots));
+        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->outputRowSize);
+        EXPLAIN_ROW_APPEND_LIMIT(pJoinNode->node.pLimit);
+        EXPLAIN_ROW_APPEND_SLIMIT(pJoinNode->node.pSlimit);
+        EXPLAIN_ROW_END();
+        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
+
+        if (pJoinNode->node.pConditions || pJoinNode->pFilterConditions) {
+          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);
+          if (pJoinNode->node.pConditions) {
+            QRY_ERR_RET(nodesNodeToSQL(pJoinNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,
+                                       TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          }
+          if (pJoinNode->pFilterConditions) {
+            if (pJoinNode->node.pConditions) {
+              EXPLAIN_ROW_APPEND(" AND ");
+            }
+            QRY_ERR_RET(nodesNodeToSQL(pJoinNode->pFilterConditions, tbuf + VARSTR_HEADER_SIZE,
+                                       TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          }
+          EXPLAIN_ROW_END();
+          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
+        }
+
+        bool conditionsGot = false;
+        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_ON_CONDITIONS_FORMAT);
+        if (pJoinNode->pPrimKeyCond) {
+          QRY_ERR_RET(
+              nodesNodeToSQL(pJoinNode->pPrimKeyCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          conditionsGot = true;  
+        }
+        if (pJoinNode->pColEqCond) {
+          if (conditionsGot) {
+            EXPLAIN_ROW_APPEND(" AND ");
+          }
+          QRY_ERR_RET(
+              nodesNodeToSQL(pJoinNode->pColEqCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          conditionsGot = true;  
+        }
+        if (pJoinNode->pTagEqCond) {
+          if (conditionsGot) {
+            EXPLAIN_ROW_APPEND(" AND ");
+          }
+          QRY_ERR_RET(
+              nodesNodeToSQL(pJoinNode->pTagEqCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          conditionsGot = true;  
+        }
+        EXPLAIN_ROW_END();
+        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));        
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:{
+      SGroupCachePhysiNode *pGroupCache = (SGroupCachePhysiNode *)pNode;
+      EXPLAIN_ROW_NEW(level, EXPLAIN_GROUP_CACHE_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);
+      if (pResNode->pExecInfo) {
+        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));
+        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      }
+      EXPLAIN_ROW_APPEND(EXPLAIN_GLOBAL_GROUP_FORMAT, pGroupCache->globalGrp);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_GROUP_BY_UID_FORMAT, pGroupCache->grpByUid);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_SCAN_FORMAT, pGroupCache->batchFetch);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pGroupCache->node.pOutputDataBlockDesc->totalRowSize);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pGroupCache->node.inputTsOrder));
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);
+      EXPLAIN_ROW_END();
+      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));
+
+      if (verbose) {
+        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);
+        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,
+                           nodesGetOutputNumFromSlotList(pGroupCache->node.pOutputDataBlockDesc->pSlots));
+        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pGroupCache->node.pOutputDataBlockDesc->outputRowSize);
+        EXPLAIN_ROW_APPEND_LIMIT(pGroupCache->node.pLimit);
+        EXPLAIN_ROW_APPEND_SLIMIT(pGroupCache->node.pSlimit);
+        EXPLAIN_ROW_END();
+        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
+
+        if (pGroupCache->node.pConditions) {
+          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);
+          QRY_ERR_RET(nodesNodeToSQL(pGroupCache->node.pConditions, tbuf + VARSTR_HEADER_SIZE,
+                                     TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          EXPLAIN_ROW_END();
+          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
+        }
+      }
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:{
+      SDynQueryCtrlPhysiNode *pDyn = (SDynQueryCtrlPhysiNode *)pNode;
+      EXPLAIN_ROW_NEW(level, EXPLAIN_DYN_QRY_CTRL_FORMAT, qExplainGetDynQryCtrlType(pDyn->qType));
+      EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);
+      if (pResNode->pExecInfo) {
+        QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));
+        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      }
+      EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_SCAN_FORMAT, pDyn->stbJoin.batchFetch);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_VGROUP_SLOT_FORMAT, pDyn->stbJoin.vgSlot[0], pDyn->stbJoin.vgSlot[1]);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_UID_SLOT_FORMAT, pDyn->stbJoin.uidSlot[0], pDyn->stbJoin.uidSlot[1]);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_SRC_SCAN_FORMAT, pDyn->stbJoin.srcScan[0], pDyn->stbJoin.srcScan[1]);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->totalRowSize);
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pDyn->node.inputTsOrder));
+      EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);
+      EXPLAIN_ROW_END();
+      QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));
+
+      if (verbose) {
+        EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);
+        EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,
+                           nodesGetOutputNumFromSlotList(pDyn->node.pOutputDataBlockDesc->pSlots));
+        EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->outputRowSize);
+        EXPLAIN_ROW_APPEND_LIMIT(pDyn->node.pLimit);
+        EXPLAIN_ROW_APPEND_SLIMIT(pDyn->node.pSlimit);
+        EXPLAIN_ROW_END();
+        QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
+
+        if (pDyn->node.pConditions) {
+          EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);
+          QRY_ERR_RET(nodesNodeToSQL(pDyn->node.pConditions, tbuf + VARSTR_HEADER_SIZE,
+                                     TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
+          EXPLAIN_ROW_END();
+          QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
+        }
+      }
+      break;
+    }
     default:
       qError("not supported physical node type %d", pNode->type);
       return TSDB_CODE_APP_ERROR;

source/libs/executor/inc/dataSinkInt.h

@@ -35,6 +35,7 @@ typedef struct SDataSinkManager {
 
 typedef int32_t (*FPutDataBlock)(struct SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue);
 typedef void (*FEndPut)(struct SDataSinkHandle* pHandle, uint64_t useconds);
+typedef void (*FReset)(struct SDataSinkHandle* pHandle);
 typedef void (*FGetDataLength)(struct SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryEnd);
 typedef int32_t (*FGetDataBlock)(struct SDataSinkHandle* pHandle, SOutputData* pOutput);
 typedef int32_t (*FDestroyDataSinker)(struct SDataSinkHandle* pHandle);
@@ -43,6 +44,7 @@ typedef int32_t (*FGetCacheSize)(struct SDataSinkHandle* pHandle, uint64_t* size
 typedef struct SDataSinkHandle {
   FPutDataBlock      fPut;
   FEndPut            fEndPut;
+  FReset             fReset;
   FGetDataLength     fGetLen;
   FGetDataBlock      fGetData;
   FDestroyDataSinker fDestroy;

source/libs/executor/inc/dynqueryctrl.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_DYNQUERYCTRL_H
+#define TDENGINE_DYNQUERYCTRL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SDynQueryCtrlExecInfo {
+  int64_t prevBlkNum;
+  int64_t prevBlkRows;
+  int64_t postBlkNum;
+  int64_t postBlkRows;
+  int64_t leftCacheNum;
+  int64_t rightCacheNum;
+} SDynQueryCtrlExecInfo;
+
+typedef struct SStbJoinTableList {
+  void    *pNext;
+  int64_t  uidNum;
+  int64_t  readIdx;
+  int32_t *pLeftVg;
+  int64_t *pLeftUid;
+  int32_t *pRightVg;
+  int64_t *pRightUid;
+} SStbJoinTableList;
+
+typedef struct SStbJoinPrevJoinCtx {
+  bool               joinBuild;
+  SSHashObj*         leftHash;
+  SSHashObj*         rightHash;
+  SSHashObj*         leftCache;
+  SSHashObj*         rightCache;
+  SSHashObj*         onceTable;
+  int64_t            tableNum;
+  SStbJoinTableList* pListHead;
+  SStbJoinTableList* pListTail;
+} SStbJoinPrevJoinCtx;
+
+typedef struct SStbJoinPostJoinCtx {
+  bool    isStarted;
+  bool    leftNeedCache;
+  bool    rightNeedCache;
+  int32_t leftVgId;
+  int32_t rightVgId;
+  int64_t leftCurrUid;
+  int64_t rightCurrUid;
+  int64_t rightNextUid;
+} SStbJoinPostJoinCtx;
+
+typedef struct SStbJoinDynCtrlCtx {
+  SStbJoinPrevJoinCtx prev;
+  SStbJoinPostJoinCtx post;
+} SStbJoinDynCtrlCtx;
+
+typedef struct SStbJoinDynCtrlInfo {
+  SDynQueryCtrlExecInfo execInfo;
+  SStbJoinDynCtrlBasic  basic;
+  SStbJoinDynCtrlCtx    ctx;
+  int16_t               outputBlkId;
+} SStbJoinDynCtrlInfo;
+
+typedef struct SDynQueryCtrlOperatorInfo {
+  EDynQueryType         qType;
+  union {
+    SStbJoinDynCtrlInfo stbJoin;
+  };
+} SDynQueryCtrlOperatorInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_DYNQUERYCTRL_H

source/libs/executor/inc/executil.h

@@ -163,7 +163,7 @@ int32_t  getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode
 size_t   getTableTagsBufLen(const SNodeList* pGroups);
 
 SArray* createSortInfo(SNodeList* pNodeList);
-SArray* extractPartitionColInfo(SNodeList* pNodeList);
+SArray* makeColumnArrayFromList(SNodeList* pNodeList);
 int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols,
                             int32_t type, SColMatchInfo* pMatchInfo);
 

source/libs/executor/inc/executorInt.h

@@ -48,6 +48,8 @@ typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int
 typedef struct STsdbReader STsdbReader;
 typedef struct STqReader   STqReader;
 
+typedef enum SOperatorParamType { OP_GET_PARAM = 1, OP_NOTIFY_PARAM } SOperatorParamType;
+
 #define IS_VALID_SESSION_WIN(winInfo)        ((winInfo).sessionWin.win.skey > 0)
 #define SET_SESSION_WIN_INVALID(winInfo)     ((winInfo).sessionWin.win.skey = INT64_MIN)
 #define IS_INVALID_SESSION_WIN_KEY(winKey)   ((winKey).win.skey <= 0)
@@ -105,6 +107,20 @@ typedef struct SExchangeOpStopInfo {
   int64_t refId;
 } SExchangeOpStopInfo;
 
+typedef struct SGcOperatorParam {
+  int64_t sessionId;
+  int32_t downstreamIdx;
+  int32_t vgId;
+  int64_t tbUid;
+  bool    needCache;
+} SGcOperatorParam;
+
+typedef struct SGcNotifyOperatorParam {
+  int32_t downstreamIdx;
+  int32_t vgId;
+  int64_t tbUid;
+} SGcNotifyOperatorParam;
+
 typedef struct SExprSupp {
   SExprInfo*      pExprInfo;
   int32_t         numOfExprs;  // the number of scalar expression in group operator
@@ -115,8 +131,9 @@ typedef struct SExprSupp {
 
 typedef enum {
   EX_SOURCE_DATA_NOT_READY = 0x1,
-  EX_SOURCE_DATA_READY = 0x2,
-  EX_SOURCE_DATA_EXHAUSTED = 0x3,
+  EX_SOURCE_DATA_STARTED,
+  EX_SOURCE_DATA_READY,
+  EX_SOURCE_DATA_EXHAUSTED,
 } EX_SOURCE_STATUS;
 
 #define COL_MATCH_FROM_COL_ID  0x1
@@ -138,11 +155,38 @@ typedef struct SLimitInfo {
   int64_t  numOfOutputRows;
 } SLimitInfo;
 
+typedef struct SSortMergeJoinOperatorParam {
+  bool initDownstream;
+} SSortMergeJoinOperatorParam;
+
+typedef struct SExchangeOperatorBasicParam {
+  int32_t vgId;
+  int32_t srcOpType;
+  bool    tableSeq;
+  SArray* uidList;
+} SExchangeOperatorBasicParam;
+
+typedef struct SExchangeOperatorBatchParam {
+  bool       multiParams;
+  SSHashObj* pBatchs;  // SExchangeOperatorBasicParam
+} SExchangeOperatorBatchParam;
+
+typedef struct SExchangeOperatorParam {
+  bool                        multiParams;
+  SExchangeOperatorBasicParam basic;
+} SExchangeOperatorParam;
+
+typedef struct SExchangeSrcIndex {
+  int32_t srcIdx;
+  int32_t inUseIdx;
+} SExchangeSrcIndex;
+
 typedef struct SExchangeInfo {
-  SArray* pSources;
-  SArray* pSourceDataInfo;
-  tsem_t  ready;
-  void*   pTransporter;
+  SArray*    pSources;
+  SSHashObj* pHashSources;
+  SArray*    pSourceDataInfo;
+  tsem_t     ready;
+  void*      pTransporter;
 
   // SArray<SSDataBlock*>, result block list, used to keep the multi-block that
   // passed by downstream operator
@@ -150,6 +194,7 @@ typedef struct SExchangeInfo {
   SArray*      pRecycledBlocks;  // build a pool for small data block to avoid to repeatly create and then destroy.
   SSDataBlock* pDummyBlock;      // dummy block, not keep data
   bool         seqLoadData;      // sequential load data or not, false by default
+  bool         dynamicOp;
   int32_t      current;
   SLoadRemoteDataInfo loadInfo;
   uint64_t            self;
@@ -610,9 +655,10 @@ typedef struct SStreamFillOperatorInfo {
 #define OPTR_SET_OPENED(_optr) ((_optr)->status |= OP_OPENED)
 
 SSchemaWrapper* extractQueriedColumnSchema(SScanPhysiNode* pScanNode);
-int32_t         initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode, const char* dbName,
-                                           SExecTaskInfo* pTaskInfo);
-void            cleanupQueriedTableScanInfo(SSchemaInfo* pSchemaInfo);
+
+int32_t initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode, const char* dbName,
+                                   SExecTaskInfo* pTaskInfo);
+void    cleanupQueriedTableScanInfo(void* p);
 
 void initBasicInfo(SOptrBasicInfo* pInfo, SSDataBlock* pBlock);
 void cleanupBasicInfo(SOptrBasicInfo* pInfo);
@@ -718,9 +764,17 @@ uint64_t calcGroupId(char* pData, int32_t len);
 void     streamOpReleaseState(struct SOperatorInfo* pOperator);
 void     streamOpReloadState(struct SOperatorInfo* pOperator);
 
-int32_t encodeSTimeWindowAggSupp(void** buf, STimeWindowAggSupp* pTwAggSup);
-void*   decodeSTimeWindowAggSupp(void* buf, STimeWindowAggSupp* pTwAggSup);
-bool    inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo);
+int32_t      encodeSTimeWindowAggSupp(void** buf, STimeWindowAggSupp* pTwAggSup);
+void*        decodeSTimeWindowAggSupp(void* buf, STimeWindowAggSupp* pTwAggSup);
+void         destroyOperatorParamValue(void* pValues);
+int32_t      mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc);
+int32_t      buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, int32_t srcOpType, bool tableSeq);
+void         freeExchangeGetBasicOperatorParam(void* pParam);
+void         freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type);
+void         freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree);
+SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam);
+
+bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo);
 bool inCalSlidingWindow(SInterval* pInterval, STimeWindow* pWin, TSKEY calStart, TSKEY calEnd, EStreamType blockType);
 bool compareVal(const char* v, const SStateKeys* pKey);
 

source/libs/executor/inc/groupcache.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_GROUPCACHE_H
+#define TDENGINE_GROUPCACHE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GROUP_CACHE_DEFAULT_MAX_FILE_SIZE 104857600
+#define GROUP_CACHE_MAX_FILE_FDS 10
+#define GROUP_CACHE_DEFAULT_VGID 0
+
+#pragma pack(push, 1) 
+typedef struct SGcBlkBufBasic {
+  int32_t           fileId;
+  int64_t           blkId;
+  int64_t           offset;
+  int64_t           bufSize;
+} SGcBlkBufBasic;
+#pragma pack(pop)
+
+typedef struct SGroupCacheFileFd {
+  TdThreadMutex mutex;
+  TdFilePtr     fd;
+} SGroupCacheFileFd;
+
+typedef struct SGroupCacheFileInfo {
+  uint32_t          groupNum;
+  bool              deleted;
+  SGroupCacheFileFd fd;
+} SGroupCacheFileInfo;
+
+typedef struct SGcFileCacheCtx {
+  int64_t         fileSize;
+  int32_t         fileId;
+  SHashObj*       pCacheFile;
+  int32_t         baseNameLen;
+  char            baseFilename[256];  
+} SGcFileCacheCtx;
+
+typedef struct SGcDownstreamCtx {
+  int32_t         id;
+  SRWLatch        grpLock;
+  int64_t         fetchSessionId;
+  SArray*         pNewGrpList; // SArray<SGcNewGroupInfo>
+  SSHashObj*      pVgTbHash;   // SHash<SGcVgroupCtx>
+  SHashObj*       pGrpHash;
+  SRWLatch        blkLock;
+  SSDataBlock*    pBaseBlock;
+  SArray*         pFreeBlock;
+  int64_t         lastBlkUid;
+  SHashObj*       pSessions;  
+  SHashObj*       pWaitSessions; 
+  SGcFileCacheCtx fileCtx;
+} SGcDownstreamCtx;
+
+typedef struct SGcVgroupCtx {
+  int32_t         id;
+  SArray*         pTbList;
+  uint64_t        lastBlkUid;
+  SGcFileCacheCtx fileCtx;
+} SGcVgroupCtx;
+
+typedef struct SGcBlkList {
+  SRWLatch         lock;
+  SArray*          pList;
+} SGcBlkList;
+
+typedef struct SGroupCacheData {
+  TdThreadMutex  mutex;
+  SArray*        waitQueue;
+  bool           fetchDone;
+  bool           needCache;
+  SSDataBlock*   pBlock;
+  SGcVgroupCtx*  pVgCtx;
+  int32_t        downstreamIdx;
+  int32_t        vgId;
+  SGcBlkList     blkList;
+  int32_t        fileId;
+  int64_t        startOffset;
+} SGroupCacheData;
+
+typedef struct SGroupColInfo {
+  int32_t  slot;
+  bool     vardata;
+  int32_t  bytes;
+} SGroupColInfo;
+
+typedef struct SGroupColsInfo {
+  int32_t        colNum;
+  bool           withNull;
+  SGroupColInfo* pColsInfo;
+  int32_t        bitMapSize;
+  int32_t        bufSize;
+  char*          pBuf;
+  char*          pData;
+} SGroupColsInfo;
+
+typedef struct SGcNewGroupInfo {
+  int32_t          vgId;
+  int64_t          uid;
+  SGroupCacheData* pGroup;
+  SOperatorParam*  pParam;
+} SGcNewGroupInfo;
+
+typedef struct SGcSessionCtx {
+  int32_t           downstreamIdx;
+  SGcOperatorParam* pParam;
+  SGroupCacheData*  pGroupData;
+  int64_t           lastBlkId;
+  bool              semInit;
+  tsem_t            waitSem;
+  bool              newFetch;
+  int64_t           resRows;
+} SGcSessionCtx;
+
+typedef struct SGcBlkBufInfo {
+  SGcBlkBufBasic    basic;
+  void*             next;
+  void*             pBuf;
+  SGcDownstreamCtx* pCtx;
+  int64_t           groupId;
+} SGcBlkBufInfo;
+
+typedef struct SGcExecInfo {
+  int64_t* pDownstreamBlkNum;
+} SGcExecInfo;
+
+typedef struct SGcCacheFile {
+  uint32_t grpNum;
+  uint32_t grpDone;
+  int64_t  fileSize;
+} SGcCacheFile;
+
+typedef struct SGcBlkCacheInfo {
+  SRWLatch       dirtyLock;
+  SHashObj*      pDirtyBlk;
+  SGcBlkBufInfo* pDirtyHead;
+  SGcBlkBufInfo* pDirtyTail; 
+  SHashObj*      pReadBlk;
+  int64_t        blkCacheSize;
+  int32_t        writeDownstreamId;  
+} SGcBlkCacheInfo;
+
+typedef struct SGroupCacheOperatorInfo {
+  int64_t           maxCacheSize;
+  int64_t           currentBlkId;
+  SGroupColsInfo    groupColsInfo;
+  bool              globalGrp;
+  bool              grpByUid;
+  bool              batchFetch;
+  int32_t           downstreamNum;
+  SGcDownstreamCtx* pDownstreams;
+  SGcBlkCacheInfo   blkCache;
+  SHashObj*         pGrpHash;  
+  SGcExecInfo       execInfo;
+} SGroupCacheOperatorInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_GROUPCACHE_H

source/libs/executor/inc/hashjoin.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_HASHJOIN_H
+#define TDENGINE_HASHJOIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HASH_JOIN_DEFAULT_PAGE_SIZE 10485760
+
+#pragma pack(push, 1) 
+typedef struct SBufRowInfo {
+  void*    next;
+  uint16_t pageId;
+  int32_t  offset;
+} SBufRowInfo;
+#pragma pack(pop)
+
+typedef struct SHJoinCtx {
+  bool         rowRemains;
+  SBufRowInfo* pBuildRow;
+  SSDataBlock* pProbeData;
+  int32_t      probeIdx;
+} SHJoinCtx;
+
+typedef struct SRowLocation {
+  SSDataBlock* pDataBlock;
+  int32_t      pos;
+} SRowLocation;
+
+typedef struct SHJoinColInfo {
+  int32_t  srcSlot;
+  int32_t  dstSlot;
+  bool     keyCol;
+  bool     vardata;
+  int32_t* offset;
+  int32_t  bytes;
+  char*    data;
+  char*    bitMap;
+} SHJoinColInfo;
+
+typedef struct SBufPageInfo {
+  int32_t pageSize;
+  int32_t offset;
+  char*   data;
+} SBufPageInfo;
+
+
+typedef struct SGroupData {
+  SBufRowInfo* rows;
+} SGroupData;
+
+typedef struct SHJoinTableInfo {
+  int32_t        downStreamIdx;
+  SOperatorInfo* downStream;
+  int32_t        blkId;
+  SQueryStat     inputStat;
+  
+  int32_t        keyNum;
+  SHJoinColInfo* keyCols;
+  char*          keyBuf;
+  char*          keyData;
+  
+  int32_t        valNum;
+  SHJoinColInfo* valCols;
+  char*          valData;
+  int32_t        valBitMapSize;
+  int32_t        valBufSize;
+  SArray*        valVarCols;
+  bool           valColExist;
+} SHJoinTableInfo;
+
+typedef struct SHJoinExecInfo {
+  int64_t buildBlkNum;
+  int64_t buildBlkRows;
+  int64_t probeBlkNum;
+  int64_t probeBlkRows;
+  int64_t resRows;
+  int64_t expectRows;
+} SHJoinExecInfo;
+
+
+typedef struct SHJoinOperatorInfo {
+  int32_t          joinType;
+  SHJoinTableInfo  tbs[2];
+  SHJoinTableInfo* pBuild;
+  SHJoinTableInfo* pProbe;
+  SSDataBlock*     pRes;
+  int32_t          pResColNum;
+  int8_t*          pResColMap;
+  SArray*          pRowBufs;
+  SNode*           pCond;
+  SSHashObj*       pKeyHash;
+  bool             keyHashBuilt;
+  SHJoinCtx        ctx;
+  SHJoinExecInfo   execInfo;
+} SHJoinOperatorInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_HASHJOIN_H

source/libs/executor/inc/operator.h

@@ -35,6 +35,8 @@ typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* pOptr);
 typedef void (*__optr_close_fn_t)(void* param);
 typedef int32_t (*__optr_explain_fn_t)(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len);
 typedef int32_t (*__optr_reqBuf_fn_t)(struct SOperatorInfo* pOptr);
+typedef SSDataBlock* (*__optr_get_ext_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param);
+typedef int32_t (*__optr_notify_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param);
 typedef void (*__optr_state_fn_t)(struct SOperatorInfo* pOptr);
 
 typedef struct SOperatorFpSet {
@@ -46,6 +48,8 @@ typedef struct SOperatorFpSet {
   __optr_encode_fn_t  encodeResultRow;
   __optr_decode_fn_t  decodeResultRow;
   __optr_explain_fn_t getExplainFn;
+  __optr_get_ext_fn_t getNextExtFn;
+  __optr_notify_fn_t  notifyFn;
   __optr_state_fn_t   releaseStreamStateFn;
   __optr_state_fn_t   reloadStreamStateFn;
 } SOperatorFpSet;
@@ -61,6 +65,8 @@ typedef struct SOperatorInfo {
   uint16_t               operatorType;
   int16_t                resultDataBlockId;
   bool                   blocking;  // block operator or not
+  bool                   transparent;
+  bool                   dynamicTask;
   uint8_t                status;    // denote if current operator is completed
   char*                  name;      // name, for debug purpose
   void*                  info;      // extension attribution
@@ -68,8 +74,13 @@ typedef struct SOperatorInfo {
   SExecTaskInfo*         pTaskInfo;
   SOperatorCostInfo      cost;
   SResultInfo            resultInfo;
+  SOperatorParam*        pOperatorGetParam;
+  SOperatorParam*        pOperatorNotifyParam;
+  SOperatorParam**       pDownstreamGetParams;
+  SOperatorParam**       pDownstreamNotifyParams;
   struct SOperatorInfo** pDownstream;      // downstram pointer list
   int32_t                numOfDownstream;  // number of downstream. The value is always ONE expect for join operator
+  int32_t                numOfRealDownstream;
   SOperatorFpSet         fpSet;
 } SOperatorInfo;
 
@@ -129,6 +140,8 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode
 
 SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo);
 
+SOperatorInfo* createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream,         SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo);
+
 SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle);
 
 SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle);
@@ -142,10 +155,16 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi
 SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, SExecTaskInfo* pTaskInfo);
 
 SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo);
+
+SOperatorInfo* createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo);
+
+SOperatorInfo* createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream,           SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo);
+
 // clang-format on
 
 SOperatorFpSet createOperatorFpSet(__optr_open_fn_t openFn, __optr_fn_t nextFn, __optr_fn_t cleanup,
-                                   __optr_close_fn_t closeFn, __optr_reqBuf_fn_t reqBufFn, __optr_explain_fn_t explain);
+                                   __optr_close_fn_t closeFn, __optr_reqBuf_fn_t reqBufFn,
+                                   __optr_explain_fn_t explain, __optr_get_ext_fn_t nextExtFn, __optr_notify_fn_t notifyFn);
 void           setOperatorStreamStateFn(SOperatorInfo* pOperator, __optr_state_fn_t relaseFn, __optr_state_fn_t reloadFn);
 int32_t        optrDummyOpenFn(SOperatorInfo* pOperator);
 int32_t        appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t num);
@@ -153,6 +172,11 @@ void           setOperatorCompleted(SOperatorInfo* pOperator);
 void           setOperatorInfo(SOperatorInfo* pOperator, const char* name, int32_t type, bool blocking, int32_t status,
                                void* pInfo, SExecTaskInfo* pTaskInfo);
 int32_t        optrDefaultBufFn(SOperatorInfo* pOperator);
+SSDataBlock*   optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam);
+int32_t        optrDefaultNotifyFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam);
+SSDataBlock*   getNextBlockFromDownstream(struct SOperatorInfo* pOperator, int32_t idx);
+SSDataBlock*   getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, int32_t idx);
+int16_t        getOperatorResultBlockId(struct SOperatorInfo* pOperator, int32_t idx);
 
 SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond,
                               SNode* pTagIndexCond, const char* pUser, const char* dbname);
@@ -162,9 +186,10 @@ SOperatorInfo* extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, con
 int32_t        getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag, bool inheritUsOrder);
 int32_t        stopTableScanOperator(SOperatorInfo* pOperator, const char* pIdStr, SStorageAPI* pAPI);
 int32_t        getOperatorExplainExecInfo(struct SOperatorInfo* operatorInfo, SArray* pExecInfoList);
+void *         getOperatorParam(int32_t opType, SOperatorParam* param, int32_t idx);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_OPERATOR_H
+#endif  // TDENGINE_OPERATOR_H
\ No newline at end of file

source/libs/executor/inc/querytask.h

@@ -39,6 +39,7 @@ typedef struct STaskIdInfo {
   uint64_t templateId;
   char*    str;
   int32_t  vgId;
+  uint64_t taskId;
 } STaskIdInfo;
 
 typedef struct STaskCostInfo {
@@ -81,6 +82,7 @@ struct SExecTaskInfo {
   int32_t               qbufQuota;  // total available buffer (in KB) during execution query
   int64_t               version;    // used for stream to record wal version, why not move to sschemainfo
   SStreamTaskInfo       streamInfo;
+  SArray*               schemaInfos;
   SSchemaInfo           schemaInfo;
   const char*           sql;        // query sql string
   jmp_buf               env;        // jump to this position when error happens.
@@ -92,6 +94,9 @@ struct SExecTaskInfo {
   STaskStopInfo         stopInfo;
   SRWLatch              lock;  // secure the access of STableListInfo
   SStorageAPI           storageAPI;
+  int8_t                dynamicTask;
+  SOperatorParam*       pOpParam;
+  bool                  paramSet;
 };
 
 void           buildTaskId(uint64_t taskId, uint64_t queryId, char* dst);

source/libs/executor/src/aggregateoperator.c

@@ -115,7 +115,7 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN
   setOperatorInfo(pOperator, "TableAggregate", QUERY_NODE_PHYSICAL_PLAN_HASH_AGG,
                   !pAggNode->node.forceCreateNonBlockingOptr, OP_NOT_OPENED, pInfo, pTaskInfo);
   pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, getAggregateResult, NULL, destroyAggOperatorInfo,
-                                         optrDefaultBufFn, NULL);
+                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   if (downstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {
     STableScanInfo* pTableScanInfo = downstream->info;
@@ -187,7 +187,7 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) {
   }
   while (1) {
     bool blockAllocated = false;
-    pBlock = downstream->fpSet.getNextFn(downstream);
+    pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       if (!pAggInfo->hasValidBlock) {
         createDataBlockForEmptyInput(pOperator, &pBlock);

source/libs/executor/src/cachescanoperator.c

@@ -134,7 +134,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
 
   pOperator->fpSet =
-      createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL);
+      createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   pOperator->cost.openCost = 0;
   return pOperator;
@@ -330,7 +330,8 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  SSchemaWrapper* pWrapper = pTaskInfo->schemaInfo.sw;
+  SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos);
+  SSchemaWrapper* pWrapper = pSchemaInfo->sw;
 
   for (int32_t i = 0; i < numOfCols; ++i) {
     SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i);

source/libs/executor/src/dataDispatcher.c

@@ -156,6 +156,13 @@ static void endPut(struct SDataSinkHandle* pHandle, uint64_t useconds) {
   taosThreadMutexUnlock(&pDispatcher->mutex);
 }
 
+static void resetDispatcher(struct SDataSinkHandle* pHandle) {
+  SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
+  taosThreadMutexLock(&pDispatcher->mutex);
+  pDispatcher->queryEnd = false;
+  taosThreadMutexUnlock(&pDispatcher->mutex);
+}
+
 static void getDataLength(SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryEnd) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
   if (taosQueueEmpty(pDispatcher->pDataBlocks)) {
@@ -182,6 +189,7 @@ static void getDataLength(SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryE
          ((SDataCacheEntry*)(pDispatcher->nextOutput.pData))->numOfRows);
 }
 
+
 static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
   if (NULL == pDispatcher->nextOutput.pData) {
@@ -244,6 +252,7 @@ int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSinkNode* pD
   }
   dispatcher->sink.fPut = putDataBlock;
   dispatcher->sink.fEndPut = endPut;
+  dispatcher->sink.fReset = resetDispatcher;
   dispatcher->sink.fGetLen = getDataLength;
   dispatcher->sink.fGetData = getDataBlock;
   dispatcher->sink.fDestroy = destroyDataSinker;

source/libs/executor/src/dataSinkMgt.c

@@ -59,6 +59,13 @@ void dsEndPut(DataSinkHandle handle, uint64_t useconds) {
   return pHandleImpl->fEndPut(pHandleImpl, useconds);
 }
 
+void dsReset(DataSinkHandle handle) {
+  SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle;
+  if (pHandleImpl->fReset) {
+    return pHandleImpl->fReset(pHandleImpl);
+  }
+}
+
 void dsGetDataLength(DataSinkHandle handle, int64_t* pLen, bool* pQueryEnd) {
   SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle;
   pHandleImpl->fGetLen(pHandleImpl, pLen, pQueryEnd);

source/libs/executor/src/eventwindowoperator.c

@@ -123,7 +123,7 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo
   setOperatorInfo(pOperator, "EventWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, true, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
   pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, eventWindowAggregate, NULL, destroyEWindowOperatorInfo,
-                                         optrDefaultBufFn, NULL);
+                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
   if (code != TSDB_CODE_SUCCESS) {
@@ -183,7 +183,7 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) {
 
   SOperatorInfo* downstream = pOperator->pDownstream[0];
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       break;
     }

source/libs/executor/src/exchangeoperator.c

@@ -40,6 +40,9 @@ typedef struct SSourceDataInfo {
   int32_t            code;
   EX_SOURCE_STATUS   status;
   const char*        taskId;
+  SArray*            pSrcUidList;
+  int32_t            srcOpType;
+  bool               tableSeq;
 } SSourceDataInfo;
 
 static void  destroyExchangeOperatorInfo(void* param);
@@ -67,6 +70,8 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
     return;
   }
 
+  SSourceDataInfo* pDataInfo = NULL;
+
   while (1) {
     qDebug("prepare wait for ready, %p, %s", pExchangeInfo, GET_TASKID(pTaskInfo));
     tsem_wait(&pExchangeInfo->ready);
@@ -76,7 +81,7 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
     }
 
     for (int32_t i = 0; i < totalSources; ++i) {
-      SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, i);
+      pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, i);
       if (pDataInfo->status == EX_SOURCE_DATA_EXHAUSTED) {
         continue;
       }
@@ -91,17 +96,26 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
       }
 
       SRetrieveTableRsp*     pRsp = pDataInfo->pRsp;
-      SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, i);
+      SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, pDataInfo->index);
 
       // todo
       SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo;
       if (pRsp->numOfRows == 0) {
-        pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
-        qDebug("%s vgId:%d, taskId:0x%" PRIx64 " execId:%d index:%d completed, rowsOfSource:%" PRIu64
-               ", totalRows:%" PRIu64 ", try next %d/%" PRIzu,
-               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pDataInfo->totalRows,
-               pExchangeInfo->loadInfo.totalRows, i + 1, totalSources);
-        taosMemoryFreeClear(pDataInfo->pRsp);
+        if (NULL != pDataInfo->pSrcUidList) {
+          pDataInfo->status = EX_SOURCE_DATA_NOT_READY;
+          code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, i);
+          if (code != TSDB_CODE_SUCCESS) {
+            taosMemoryFreeClear(pDataInfo->pRsp);
+            goto _error;
+          }
+        } else {
+          pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
+          qDebug("%s vgId:%d, taskId:0x%" PRIx64 " execId:%d index:%d completed, rowsOfSource:%" PRIu64
+                 ", totalRows:%" PRIu64 ", try next %d/%" PRIzu,
+                 GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pDataInfo->totalRows,
+                 pExchangeInfo->loadInfo.totalRows, i + 1, totalSources);
+          taosMemoryFreeClear(pDataInfo->pRsp);
+        }
         break;
       }
 
@@ -131,7 +145,7 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
 
       taosMemoryFreeClear(pDataInfo->pRsp);
 
-      if (pDataInfo->status != EX_SOURCE_DATA_EXHAUSTED) {
+      if (pDataInfo->status != EX_SOURCE_DATA_EXHAUSTED || NULL != pDataInfo->pSrcUidList) {
         pDataInfo->status = EX_SOURCE_DATA_NOT_READY;
         code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, i);
         if (code != TSDB_CODE_SUCCESS) {
@@ -157,11 +171,6 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
   SExchangeInfo* pExchangeInfo = pOperator->info;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
-  pTaskInfo->code = pOperator->fpSet._openFn(pOperator);
-  if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
-    return NULL;
-  }
-
   size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources);
 
   SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo;
@@ -204,6 +213,11 @@ static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) {
   SExchangeInfo* pExchangeInfo = pOperator->info;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
+  pTaskInfo->code = pOperator->fpSet._openFn(pOperator);
+  if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
+    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+  }
+
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
@@ -244,6 +258,10 @@ static int32_t initDataSource(int32_t numOfSources, SExchangeInfo* pInfo, const
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
+  if (pInfo->dynamicOp) {
+    return TSDB_CODE_SUCCESS;
+  }
+  
   for (int32_t i = 0; i < numOfSources; ++i) {
     SSourceDataInfo dataInfo = {0};
     dataInfo.status = EX_SOURCE_DATA_NOT_READY;
@@ -272,9 +290,18 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo*
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
+  if (pExNode->node.dynamicOp) {
+    pInfo->pHashSources = tSimpleHashInit(numOfSources * 2, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));
+    if (NULL == pInfo->pHashSources) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+
   for (int32_t i = 0; i < numOfSources; ++i) {
     SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)nodesListGetNode((SNodeList*)pExNode->pSrcEndPoints, i);
     taosArrayPush(pInfo->pSources, pNode);
+    SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1};
+    tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx));
   }
 
   initLimitInfo(pExNode->node.pLimit, pExNode->node.pSlimit, &pInfo->limitInfo);
@@ -290,6 +317,7 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode
     goto _error;
   }
 
+  pInfo->dynamicOp = pExNode->node.dynamicOp;
   int32_t code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo));
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
@@ -316,7 +344,7 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode
   }
 
   pOperator->fpSet =
-      createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL);
+      createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   return pOperator;
 
 _error:
@@ -354,7 +382,8 @@ void doDestroyExchangeOperatorInfo(void* param) {
   taosArrayDestroyEx(pExInfo->pRecycledBlocks, freeBlock);
 
   blockDataDestroy(pExInfo->pDummyBlock);
-
+  tSimpleHashCleanup(pExInfo->pHashSources);
+  
   tsem_destroy(&pExInfo->ready);
   taosMemoryFreeClear(param);
 }
@@ -402,14 +431,45 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) {
   return code;
 }
 
-int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) {
-  size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources);
+int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, int32_t srcOpType, bool tableSeq) {
+  *ppRes = taosMemoryMalloc(sizeof(SOperatorParam));
+  if (NULL == *ppRes) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  STableScanOperatorParam* pScan = taosMemoryMalloc(sizeof(STableScanOperatorParam));
+  if (NULL == pScan) {
+    taosMemoryFreeClear(*ppRes);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pScan->pUidList = taosArrayDup(pUidList, NULL);
+  if (NULL == pScan->pUidList) {
+    taosMemoryFree(pScan);
+    taosMemoryFreeClear(*ppRes);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pScan->tableSeq = tableSeq;
+  
+  (*ppRes)->opType = srcOpType;
+  (*ppRes)->downstreamIdx = 0;
+  (*ppRes)->value = pScan;
+  (*ppRes)->pChildren = NULL;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 
-  SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, sourceIndex);
+int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) {
   SSourceDataInfo*       pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex);
-  pDataInfo->startTime = taosGetTimestampUs();
+  if (EX_SOURCE_DATA_NOT_READY != pDataInfo->status) {
+    return TSDB_CODE_SUCCESS;
+  }
 
-  ASSERT(pDataInfo->status == EX_SOURCE_DATA_NOT_READY);
+  pDataInfo->status = EX_SOURCE_DATA_STARTED;
+  SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, pDataInfo->index);
+  pDataInfo->startTime = taosGetTimestampUs();
+  size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources);
 
   SFetchRspHandleWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SFetchRspHandleWrapper));
   pWrapper->exchangeId = pExchangeInfo->self;
@@ -429,11 +489,22 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
     req.taskId = pSource->taskId;
     req.queryId = pTaskInfo->id.queryId;
     req.execId = pSource->execId;
-
+    if (pDataInfo->pSrcUidList) {
+      int32_t code = buildTableScanOperatorParam(&req.pOpParam, pDataInfo->pSrcUidList, pDataInfo->srcOpType, pDataInfo->tableSeq);
+      taosArrayDestroy(pDataInfo->pSrcUidList);
+      pDataInfo->pSrcUidList = NULL;
+      if (TSDB_CODE_SUCCESS != code) {
+        pTaskInfo->code = code;
+        taosMemoryFree(pWrapper);
+        return pTaskInfo->code;
+      }
+    }
+    
     int32_t msgSize = tSerializeSResFetchReq(NULL, 0, &req);
     if (msgSize < 0) {
       pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;
       taosMemoryFree(pWrapper);
+      freeOperatorParam(req.pOpParam, OP_GET_PARAM);
       return pTaskInfo->code;
     }
 
@@ -441,6 +512,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
     if (NULL == msg) {
       pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;
       taosMemoryFree(pWrapper);
+      freeOperatorParam(req.pOpParam, OP_GET_PARAM);
       return pTaskInfo->code;
     }
 
@@ -448,9 +520,12 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
       pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;
       taosMemoryFree(pWrapper);
       taosMemoryFree(msg);
+      freeOperatorParam(req.pOpParam, OP_GET_PARAM);
       return pTaskInfo->code;
     }
 
+    freeOperatorParam(req.pOpParam, OP_GET_PARAM);
+
     qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
            GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId,
            pSource->execId, pExchangeInfo, sourceIndex, totalSources);
@@ -560,7 +635,7 @@ int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) {
   SExchangeInfo* pExchangeInfo = pOperator->info;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
-  size_t  totalSources = taosArrayGetSize(pExchangeInfo->pSources);
+  size_t  totalSources = taosArrayGetSize(pExchangeInfo->pSourceDataInfo);
   int64_t startTs = taosGetTimestampUs();
 
   // Asynchronously send all fetch requests to all sources.
@@ -693,14 +768,81 @@ _error:
   return code;
 }
 
+int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasicParam* pBasicParam) {
+  SExchangeInfo* pExchangeInfo = pOperator->info;
+  SExchangeSrcIndex* pIdx = tSimpleHashGet(pExchangeInfo->pHashSources, &pBasicParam->vgId, sizeof(pBasicParam->vgId));
+  if (NULL == pIdx) {
+    qError("No exchange source for vgId: %d", pBasicParam->vgId);
+    return TSDB_CODE_INVALID_PARA;
+  }
+
+  if (pIdx->inUseIdx < 0) {
+    SSourceDataInfo dataInfo = {0};
+    dataInfo.status = EX_SOURCE_DATA_NOT_READY;
+    dataInfo.taskId = GET_TASKID(pOperator->pTaskInfo);
+    dataInfo.index = pIdx->srcIdx;
+    dataInfo.pSrcUidList = taosArrayDup(pBasicParam->uidList, NULL);
+    dataInfo.srcOpType = pBasicParam->srcOpType;
+    dataInfo.tableSeq = pBasicParam->tableSeq;
+    
+    taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo);
+    pIdx->inUseIdx = taosArrayGetSize(pExchangeInfo->pSourceDataInfo) - 1;
+  } else {
+    SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pIdx->inUseIdx);
+    if (pDataInfo->status == EX_SOURCE_DATA_EXHAUSTED) {
+      pDataInfo->status = EX_SOURCE_DATA_NOT_READY;
+    }
+    pDataInfo->pSrcUidList = taosArrayDup(pBasicParam->uidList, NULL);
+    pDataInfo->srcOpType = pBasicParam->srcOpType;
+    pDataInfo->tableSeq = pBasicParam->tableSeq;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t addDynamicExchangeSource(SOperatorInfo* pOperator) {
+  SExchangeInfo* pExchangeInfo = pOperator->info;
+  int32_t code = TSDB_CODE_SUCCESS;
+  SExchangeOperatorBasicParam* pBasicParam = NULL;
+  SExchangeOperatorParam* pParam = (SExchangeOperatorParam*)pOperator->pOperatorGetParam->value;
+  if (pParam->multiParams) {
+    SExchangeOperatorBatchParam* pBatch = (SExchangeOperatorBatchParam*)pOperator->pOperatorGetParam->value;
+    int32_t iter = 0;
+    while (NULL != (pBasicParam = tSimpleHashIterate(pBatch->pBatchs, pBasicParam, &iter))) {
+      code = addSingleExchangeSource(pOperator, pBasicParam);
+      if (code) {
+        return code;
+      }
+    }
+  } else {
+    pBasicParam = &pParam->basic;
+    code = addSingleExchangeSource(pOperator, pBasicParam);
+  }
+
+  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);
+  pOperator->pOperatorGetParam = NULL;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t prepareLoadRemoteData(SOperatorInfo* pOperator) {
-  if (OPTR_IS_OPENED(pOperator)) {
+  SExchangeInfo* pExchangeInfo = pOperator->info;
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((OPTR_IS_OPENED(pOperator) && !pExchangeInfo->dynamicOp) || (pExchangeInfo->dynamicOp && NULL == pOperator->pOperatorGetParam)) {
     return TSDB_CODE_SUCCESS;
   }
 
+  if (pExchangeInfo->dynamicOp) {
+    code = addDynamicExchangeSource(pOperator);
+    if (code) {
+      return code;
+    }
+  }
+
   int64_t st = taosGetTimestampUs();
 
-  SExchangeInfo* pExchangeInfo = pOperator->info;
   if (!pExchangeInfo->seqLoadData) {
     int32_t code = prepareConcurrentlyLoad(pOperator);
     if (code != TSDB_CODE_SUCCESS) {

source/libs/executor/src/executil.c

@@ -926,18 +926,29 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
   return pResBlock;
 }
 
-static void doSetQualifiedUid(SArray* pUidList, const SArray* pUidTagList, bool* pResultList) {
+static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, const SArray* pUidTagList, bool* pResultList, bool addUid) {
   taosArrayClear(pUidList);
 
+  STableKeyInfo info = {.uid = 0, .groupId = 0};
   int32_t numOfTables = taosArrayGetSize(pUidTagList);
   for (int32_t i = 0; i < numOfTables; ++i) {
-    uint64_t uid = ((STUidTagInfo*)taosArrayGet(pUidTagList, i))->uid;
-    qDebug("tagfilter get uid:%" PRId64 ", res:%d", uid, pResultList[i]);
-
     if (pResultList[i]) {
-      taosArrayPush(pUidList, &uid);
+      uint64_t uid = ((STUidTagInfo*)taosArrayGet(pUidTagList, i))->uid;
+      qDebug("tagfilter get uid:%" PRId64 ", res:%d", uid, pResultList[i]);
+
+      info.uid = uid;
+      void* p = taosArrayPush(pListInfo->pTableList, &info);
+      if (p == NULL) {
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+
+      if (addUid) {
+        taosArrayPush(pUidList, &uid);
+      }
     }
   }
+
+  return TSDB_CODE_SUCCESS;
 }
 
 static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) {
@@ -954,7 +965,8 @@ static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) {
 }
 
 static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SNode* pTagCond, void* pVnode,
-                                 SIdxFltStatus status, SStorageAPI* pAPI) {
+                                 SIdxFltStatus status, SStorageAPI* pAPI, bool addUid, bool* listAdded) {
+  *listAdded = false;
   if (pTagCond == NULL) {
     return TSDB_CODE_SUCCESS;
   }
@@ -1043,7 +1055,12 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
     goto end;
   }
 
-  doSetQualifiedUid(pUidList, pUidTagList, (bool*)output.columnData->pData);
+  code = doSetQualifiedUid(pListInfo, pUidList, pUidTagList, (bool*)output.columnData->pData, addUid);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = code;
+    goto end;
+  }
+  *listAdded = true;
 
 end:
   taosHashCleanup(ctx.colHash);
@@ -1061,6 +1078,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
                      STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI) {
   int32_t code = TSDB_CODE_SUCCESS;
   size_t  numOfTables = 0;
+  bool    listAdded = false;
 
   pListInfo->idInfo.suid = pScanNode->suid;
   pListInfo->idInfo.tableType = pScanNode->tableType;
@@ -1073,7 +1091,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
     if (pStorageAPI->metaFn.isTableExisted(pVnode, pScanNode->uid)) {
       taosArrayPush(pUidList, &pScanNode->uid);
     }
-    code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI);
+    code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded);
     if (code != TSDB_CODE_SUCCESS) {
       goto _end;
     }
@@ -1117,7 +1135,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
       }
     }
 
-    code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI);
+    code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, tsTagFilterCache, &listAdded);
     if (code != TSDB_CODE_SUCCESS) {
       goto _end;
     }
@@ -1141,17 +1159,19 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
   }
 
 _end:
-  numOfTables = taosArrayGetSize(pUidList);
-  for (int i = 0; i < numOfTables; i++) {
-    STableKeyInfo info = {.uid = *(uint64_t*)taosArrayGet(pUidList, i), .groupId = 0};
+  if (!listAdded) {
+    numOfTables = taosArrayGetSize(pUidList);
+    for (int i = 0; i < numOfTables; i++) {
+      STableKeyInfo info = {.uid = *(uint64_t*)taosArrayGet(pUidList, i), .groupId = 0};
 
-    void* p = taosArrayPush(pListInfo->pTableList, &info);
-    if (p == NULL) {
-      taosArrayDestroy(pUidList);
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
+      void* p = taosArrayPush(pListInfo->pTableList, &info);
+      if (p == NULL) {
+        taosArrayDestroy(pUidList);
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
 
-    qTrace("tagfilter get uid:%" PRIu64 ", %s", info.uid, idstr);
+      qTrace("tagfilter get uid:%" PRIu64 ", %s", info.uid, idstr);
+    }
   }
 
   taosArrayDestroy(pUidList);
@@ -1254,7 +1274,7 @@ int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode,
   return TSDB_CODE_SUCCESS;
 }
 
-SArray* extractPartitionColInfo(SNodeList* pNodeList) {
+SArray* makeColumnArrayFromList(SNodeList* pNodeList) {
   if (!pNodeList) {
     return NULL;
   }

source/libs/executor/src/executor.c

@@ -471,28 +471,48 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI
 }
 
 int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
-                                    int32_t* tversion) {
+                                    int32_t* tversion, int32_t idx) {
   ASSERT(tinfo != NULL && dbName != NULL && tableName != NULL);
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
 
-  if (pTaskInfo->schemaInfo.sw == NULL) {
-    return TSDB_CODE_SUCCESS;
+  if (taosArrayGetSize(pTaskInfo->schemaInfos) <= idx) {
+    return -1;
   }
 
-  *sversion = pTaskInfo->schemaInfo.sw->version;
-  *tversion = pTaskInfo->schemaInfo.tversion;
-  if (pTaskInfo->schemaInfo.dbname) {
-    strcpy(dbName, pTaskInfo->schemaInfo.dbname);
+  SSchemaInfo* pSchemaInfo = taosArrayGet(pTaskInfo->schemaInfos, idx);
+
+  *sversion = pSchemaInfo->sw->version;
+  *tversion = pSchemaInfo->tversion;
+  if (pSchemaInfo->dbname) {
+    strcpy(dbName, pSchemaInfo->dbname);
   } else {
     dbName[0] = 0;
   }
-  if (pTaskInfo->schemaInfo.tablename) {
-    strcpy(tableName, pTaskInfo->schemaInfo.tablename);
+  if (pSchemaInfo->tablename) {
+    strcpy(tableName, pSchemaInfo->tablename);
   } else {
     tableName[0] = 0;
   }
 
-  return 0;
+  return TSDB_CODE_SUCCESS;
+}
+
+bool qIsDynamicExecTask(qTaskInfo_t tinfo) {
+  return ((SExecTaskInfo*)tinfo)->dynamicTask;
+}
+
+void destroyOperatorParam(SOperatorParam* pParam) {
+  if (NULL == pParam) {
+    return;
+  }
+
+  //TODO
+}
+
+void qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam) {
+  destroyOperatorParam(((SExecTaskInfo*)tinfo)->pOpParam);
+  ((SExecTaskInfo*)tinfo)->pOpParam = pParam;
+  ((SExecTaskInfo*)tinfo)->paramSet = false;
 }
 
 int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, SSubplan* pSubplan,
@@ -503,7 +523,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
   qDebug("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId);
 
   int32_t code = createExecTaskInfo(pSubplan, pTask, readHandle, taskId, vgId, sql, model);
-  if (code != TSDB_CODE_SUCCESS) {
+  if (code != TSDB_CODE_SUCCESS || NULL == *pTask) {
     qError("failed to createExecTaskInfo, code: %s", tstrerror(code));
     goto _error;
   }
@@ -585,12 +605,19 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
 
   int64_t st = taosGetTimestampUs();
 
-  int32_t blockIndex = 0;
+  if (pTaskInfo->pOpParam && !pTaskInfo->paramSet) {
+    pTaskInfo->paramSet = true;
+    pRes = pTaskInfo->pRoot->fpSet.getNextExtFn(pTaskInfo->pRoot, pTaskInfo->pOpParam);
+  } else {
+    pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot);
+  }
+  
   int32_t rowsThreshold = pTaskInfo->pSubplan->rowsThreshold;
   if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) {
     rowsThreshold = 4096;
   }
-  while ((pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot)) != NULL) {
+  int32_t blockIndex = 0;
+  while (pRes != NULL) {
     SSDataBlock* p = NULL;
     if (blockIndex >= taosArrayGetSize(pTaskInfo->pResultBlockList)) {
       SSDataBlock* p1 = createOneDataBlock(pRes, true);
@@ -610,6 +637,8 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
     if (current >= rowsThreshold) {
       break;
     }
+
+    pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot);
   }
   if (pTaskInfo->pSubplan->dynamicRowThreshold) {
     pTaskInfo->pSubplan->rowsThreshold -= current;

source/libs/executor/src/executorInt.c

@@ -1076,6 +1076,142 @@ void streamOpReloadState(SOperatorInfo* pOperator) {
   }
 }
 
+void freeOperatorParamImpl(SOperatorParam* pParam, SOperatorParamType type) {
+  int32_t childrenNum = taosArrayGetSize(pParam->pChildren);
+  for (int32_t i = 0; i < childrenNum; ++i) {
+    SOperatorParam* pChild = taosArrayGetP(pParam->pChildren, i);
+    freeOperatorParam(pChild, type);
+  }
+
+  taosArrayDestroy(pParam->pChildren);
+
+  taosMemoryFree(pParam->value);
+  
+  taosMemoryFree(pParam);
+}
+
+void freeExchangeGetBasicOperatorParam(void* pParam) {
+  SExchangeOperatorBasicParam* pBasic = (SExchangeOperatorBasicParam*)pParam;
+  taosArrayDestroy(pBasic->uidList);
+}
+
+void freeExchangeGetOperatorParam(SOperatorParam* pParam) {
+  SExchangeOperatorParam* pExcParam = (SExchangeOperatorParam*)pParam->value;
+  if (pExcParam->multiParams) {
+    SExchangeOperatorBatchParam* pExcBatch = (SExchangeOperatorBatchParam*)pParam->value;
+    tSimpleHashCleanup(pExcBatch->pBatchs);
+  } else {
+    freeExchangeGetBasicOperatorParam(&pExcParam->basic);
+  }
+
+  freeOperatorParamImpl(pParam, OP_GET_PARAM);
+}
+
+void freeExchangeNotifyOperatorParam(SOperatorParam* pParam) {
+  freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM);
+}
+
+void freeGroupCacheGetOperatorParam(SOperatorParam* pParam) {
+  freeOperatorParamImpl(pParam, OP_GET_PARAM);
+}
+
+void freeGroupCacheNotifyOperatorParam(SOperatorParam* pParam) {
+  freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM);
+}
+
+void freeMergeJoinGetOperatorParam(SOperatorParam* pParam) {
+  freeOperatorParamImpl(pParam, OP_GET_PARAM);
+}
+
+void freeMergeJoinNotifyOperatorParam(SOperatorParam* pParam) {
+  freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM);
+}
+
+void freeTableScanGetOperatorParam(SOperatorParam* pParam) {
+  STableScanOperatorParam* pTableScanParam = (STableScanOperatorParam*)pParam->value;
+  taosArrayDestroy(pTableScanParam->pUidList);
+  freeOperatorParamImpl(pParam, OP_GET_PARAM);
+}
+
+void freeTableScanNotifyOperatorParam(SOperatorParam* pParam) {
+  freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM);
+}
+
+
+void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type) {
+  if (NULL == pParam) {
+    return;
+  }
+  
+  switch (pParam->opType) {
+    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:
+      type == OP_GET_PARAM ? freeExchangeGetOperatorParam(pParam) : freeExchangeNotifyOperatorParam(pParam);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:
+      type == OP_GET_PARAM ? freeGroupCacheGetOperatorParam(pParam) : freeGroupCacheNotifyOperatorParam(pParam);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:
+      type == OP_GET_PARAM ? freeMergeJoinGetOperatorParam(pParam) : freeMergeJoinNotifyOperatorParam(pParam);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
+      type == OP_GET_PARAM ? freeTableScanGetOperatorParam(pParam) : freeTableScanNotifyOperatorParam(pParam);
+      break;
+    default:
+      qError("unsupported op %d param, type %d", pParam->opType, type);
+      break;
+  }
+}
+
+void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree) {
+  SOperatorParam** ppParam = NULL;
+  SOperatorParam*** pppDownstramParam = NULL;
+  switch (type) {
+    case OP_GET_PARAM:
+      ppParam = &pOperator->pOperatorGetParam;
+      pppDownstramParam = &pOperator->pDownstreamGetParams;
+      break;
+    case OP_NOTIFY_PARAM:
+      ppParam = &pOperator->pOperatorNotifyParam;
+      pppDownstramParam = &pOperator->pDownstreamNotifyParams;
+      break;
+    default:
+      return;
+  }
+
+  if (*ppParam) {
+    freeOperatorParam(*ppParam, type);
+    *ppParam = NULL;
+  }
+
+  if (*pppDownstramParam) {
+    for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) {
+      if ((*pppDownstramParam)[i]) {
+        freeOperatorParam((*pppDownstramParam)[i], type);
+        (*pppDownstramParam)[i] = NULL;
+      }
+    }
+    if (allFree) {
+      taosMemoryFreeClear(*pppDownstramParam);
+    }
+  }
+}
+
+
+FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam) {
+  if (pOperator->pDownstreamGetParams && pOperator->pDownstreamGetParams[idx]) {
+    qDebug("DynOp: op %s start to get block from downstream %s", pOperator->name, pOperator->pDownstream[idx]->name);
+    SSDataBlock* pBlock = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], pOperator->pDownstreamGetParams[idx]);
+    if (clearParam) {
+      freeOperatorParam(pOperator->pDownstreamGetParams[idx], OP_GET_PARAM);
+      pOperator->pDownstreamGetParams[idx] = NULL;
+    }
+    return pBlock;
+  }
+  
+  return pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]);
+}
+
+
 bool compareVal(const char* v, const SStateKeys* pKey) {
   if (IS_VAR_DATA_TYPE(pKey->type)) {
     if (varDataLen(v) != varDataLen(pKey->pData)) {

source/libs/executor/src/filloperator.c

@@ -197,7 +197,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
   }
 
   while (1) {
-    SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream);
+    SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       if (pInfo->totalInputRows == 0 &&
           (pInfo->pFillInfo->type != TSDB_FILL_NULL_F && pInfo->pFillInfo->type != TSDB_FILL_SET_VALUE_F)) {
@@ -444,7 +444,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode*
   setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo);
   pOperator->exprSupp.numOfExprs = pInfo->numOfExpr;
   pOperator->fpSet =
-      createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL);
+      createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
   return pOperator;
@@ -1312,7 +1312,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
   while (1) {
     if (pInfo->srcRowIndex >= pInfo->pSrcBlock->info.rows || pInfo->pSrcBlock->info.rows == 0) {
       // If there are delete datablocks, we receive  them first.
-      SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+      SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0);
       if (pBlock == NULL) {
         pOperator->status = OP_RES_TO_RETURN;
         pInfo->pFillInfo->preRowKey = INT64_MIN;
@@ -1570,7 +1570,7 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi
   setOperatorInfo(pOperator, "StreamFillOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
   pOperator->fpSet =
-      createOperatorFpSet(optrDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo, optrDefaultBufFn, NULL);
+      createOperatorFpSet(optrDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState);
 
   code = appendDownstream(pOperator, &downstream, 1);

source/libs/executor/src/groupoperator.c

@@ -383,7 +383,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
   SOperatorInfo* downstream = pOperator->pDownstream[0];
 
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       break;
     }
@@ -480,7 +480,7 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode*
   pInfo->binfo.outputTsOrder = pAggNode->node.outputTsOrder;
 
   pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo,
-                                         optrDefaultBufFn, NULL);
+                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   code = appendDownstream(pOperator, &downstream, 1);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
@@ -754,7 +754,7 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) {
   SOperatorInfo* downstream = pOperator->pDownstream[0];
 
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       break;
     }
@@ -844,7 +844,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition
 
   int32_t    numOfCols = 0;
   SExprInfo* pExprInfo = createExprInfo(pPartNode->pTargets, NULL, &numOfCols);
-  pInfo->pGroupCols = extractPartitionColInfo(pPartNode->pPartitionKeys);
+  pInfo->pGroupCols = makeColumnArrayFromList(pPartNode->pPartitionKeys);
 
   if (pPartNode->pExprs != NULL) {
     int32_t    num = 0;
@@ -906,7 +906,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition
   pOperator->exprSupp.pExprInfo = pExprInfo;
 
   pOperator->fpSet =
-      createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo, optrDefaultBufFn, NULL);
+      createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
   if (code != TSDB_CODE_SUCCESS) {
@@ -1111,7 +1111,7 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) {
   SOperatorInfo* downstream = pOperator->pDownstream[0];
   {
     pInfo->pInputDataBlock = NULL;
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       setOperatorCompleted(pOperator);
       return NULL;
@@ -1248,7 +1248,7 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr
     goto _error;
   }
 
-  pInfo->partitionSup.pGroupCols = extractPartitionColInfo(pPartNode->part.pPartitionKeys);
+  pInfo->partitionSup.pGroupCols = makeColumnArrayFromList(pPartNode->part.pPartitionKeys);
 
   if (pPartNode->part.pExprs != NULL) {
     int32_t    num = 0;
@@ -1328,7 +1328,7 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr
   pOperator->exprSupp.numOfExprs = numOfCols;
   pOperator->exprSupp.pExprInfo = pExprInfo;
   pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamHashPartition, NULL,
-                                         destroyStreamPartitionOperatorInfo, optrDefaultBufFn, NULL);
+                                         destroyStreamPartitionOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState);
 
   initParDownStream(downstream, &pInfo->partitionSup, &pInfo->scalarSup);

source/libs/nodes/CMakeLists.txt

@@ -7,9 +7,9 @@ target_include_directories(
 )
 target_link_libraries(
     nodes
-    PRIVATE os util common qcom
+    PRIVATE os util common qcom function
 )
 
 if(${BUILD_TEST})
     ADD_SUBDIRECTORY(test)
-endif(${BUILD_TEST})
+endif(${BUILD_TEST})
\ No newline at end of file