diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 07e571c67f..73d1ab2473 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -414,8 +414,7 @@ typedef enum ENodeType { 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, - QUERY_NODE_END + QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL } ENodeType; typedef struct { diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h index bcbfd245f8..7fbdbfb211 100644 --- a/include/libs/nodes/nodes.h +++ b/include/libs/nodes/nodes.h @@ -110,7 +110,6 @@ int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId); int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId); void nodesDestroyAllocator(int64_t allocatorId); -int32_t getNodeSize(ENodeType type); SNode* nodesMakeNode(ENodeType type); void nodesDestroyNode(SNode* pNode); void nodesFree(void* p); diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index d6193397f2..f3087dd5d4 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -27,65 +27,380 @@ static int32_t jsonToNode(const SJson* pJson, void* pObj); static int32_t jsonToNodeObject(const SJson* pJson, const char* pName, SNode** pNode); static int32_t makeNodeByJson(const SJson* pJson, SNode** pNode); - -typedef int32_t (*FExecNodeToJson)(const void* pObj, SJson* pJson); -typedef int32_t (*FExecJsonToNode)(const SJson* pJson, void* pObj); -typedef void (*FExecDestoryNode)(SNode* pNode); - -/** - * @brief Node operation to binding function set - */ -typedef struct SBuiltinNodeDefinition { - const char* name; - int32_t nodeSize; - FExecNodeToJson toJsonFunc; - FExecJsonToNode toNodeFunc; - FExecDestoryNode destoryFunc; -} SBuiltinNodeDefinition; - -SBuiltinNodeDefinition funcNodes[QUERY_NODE_END] = {NULL}; - -static TdThreadOnce functionNodeInit = PTHREAD_ONCE_INIT; - - -static void setFunc(const char* name, int32_t type, int32_t nodeSize, FExecNodeToJson toJsonFunc, - FExecJsonToNode toNodeFunc, FExecDestoryNode destoryFunc) { - funcNodes[type].name = name; - funcNodes[type].nodeSize = nodeSize; - funcNodes[type].toJsonFunc = toJsonFunc; - funcNodes[type].toNodeFunc = toNodeFunc; - funcNodes[type].destoryFunc = destoryFunc; -} - -static void doInitNodeFuncArray(); - -bool funcArrayCheck(int32_t type) { - if (type < 0 || QUERY_NODE_END <= type) { - nodesError("funcArrayCheck out of range type = %d", type); - return false; - } - // only init once, do nothing when run funcArrayCheck again - taosThreadOnce(&functionNodeInit, doInitNodeFuncArray); - - if (!funcNodes[type].name) { - nodesError("funcArrayCheck unsupported type = %d", type); - return false; - } - return true; -} - -int32_t getNodeSize(ENodeType type) { - if (!funcArrayCheck(type)) { - return 0; - } - return funcNodes[type].nodeSize; -} - const char* nodesNodeName(ENodeType type) { - if (!funcArrayCheck(type)) { - return NULL; + switch (type) { + case QUERY_NODE_COLUMN: + return "Column"; + case QUERY_NODE_VALUE: + return "Value"; + case QUERY_NODE_OPERATOR: + return "Operator"; + case QUERY_NODE_LOGIC_CONDITION: + return "LogicCondition"; + case QUERY_NODE_FUNCTION: + return "Function"; + case QUERY_NODE_REAL_TABLE: + return "RealTable"; + case QUERY_NODE_TEMP_TABLE: + return "TempTable"; + case QUERY_NODE_JOIN_TABLE: + return "JoinTable"; + case QUERY_NODE_GROUPING_SET: + return "GroupingSet"; + case QUERY_NODE_ORDER_BY_EXPR: + return "OrderByExpr"; + case QUERY_NODE_LIMIT: + return "Limit"; + case QUERY_NODE_STATE_WINDOW: + return "StateWindow"; + case QUERY_NODE_SESSION_WINDOW: + return "SessionWinow"; + case QUERY_NODE_INTERVAL_WINDOW: + return "IntervalWindow"; + case QUERY_NODE_NODE_LIST: + return "NodeList"; + case QUERY_NODE_FILL: + return "Fill"; + case QUERY_NODE_RAW_EXPR: + return "RawExpr"; + case QUERY_NODE_TARGET: + return "Target"; + case QUERY_NODE_DATABLOCK_DESC: + return "DataBlockDesc"; + case QUERY_NODE_SLOT_DESC: + return "SlotDesc"; + case QUERY_NODE_COLUMN_DEF: + return "ColumnDef"; + case QUERY_NODE_DOWNSTREAM_SOURCE: + return "DownstreamSource"; + case QUERY_NODE_DATABASE_OPTIONS: + return "DatabaseOptions"; + case QUERY_NODE_TABLE_OPTIONS: + return "TableOptions"; + case QUERY_NODE_INDEX_OPTIONS: + return "IndexOptions"; + case QUERY_NODE_EXPLAIN_OPTIONS: + return "ExplainOptions"; + case QUERY_NODE_STREAM_OPTIONS: + return "StreamOptions"; + case QUERY_NODE_LEFT_VALUE: + return "LeftValue"; + case QUERY_NODE_WHEN_THEN: + return "WhenThen"; + case QUERY_NODE_CASE_WHEN: + return "CaseWhen"; + case QUERY_NODE_EVENT_WINDOW: + return "EventWindow"; + case QUERY_NODE_SET_OPERATOR: + return "SetOperator"; + case QUERY_NODE_SELECT_STMT: + return "SelectStmt"; + case QUERY_NODE_VNODE_MODIFY_STMT: + return "VnodeModifStmt"; + case QUERY_NODE_CREATE_DATABASE_STMT: + return "CreateDatabaseStmt"; + case QUERY_NODE_DROP_DATABASE_STMT: + return "DropDatabaseStmt"; + case QUERY_NODE_ALTER_DATABASE_STMT: + return "AlterDatabaseStmt"; + case QUERY_NODE_FLUSH_DATABASE_STMT: + return "FlushDatabaseStmt"; + case QUERY_NODE_TRIM_DATABASE_STMT: + return "TrimDatabaseStmt"; + case QUERY_NODE_CREATE_TABLE_STMT: + return "CreateTableStmt"; + case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: + return "CreateSubtableClause"; + case QUERY_NODE_CREATE_MULTI_TABLES_STMT: + return "CreateMultiTableStmt"; + case QUERY_NODE_DROP_TABLE_CLAUSE: + return "DropTableClause"; + case QUERY_NODE_DROP_TABLE_STMT: + return "DropTableStmt"; + case QUERY_NODE_DROP_SUPER_TABLE_STMT: + return "DropSuperTableStmt"; + case QUERY_NODE_ALTER_TABLE_STMT: + return "AlterTableStmt"; + case QUERY_NODE_ALTER_SUPER_TABLE_STMT: + return "AlterSuperTableStmt"; + case QUERY_NODE_CREATE_USER_STMT: + return "CreateUserStmt"; + case QUERY_NODE_ALTER_USER_STMT: + return "AlterUserStmt"; + case QUERY_NODE_DROP_USER_STMT: + return "DropUserStmt"; + case QUERY_NODE_USE_DATABASE_STMT: + return "UseDatabaseStmt"; + case QUERY_NODE_CREATE_DNODE_STMT: + return "CreateDnodeStmt"; + case QUERY_NODE_DROP_DNODE_STMT: + return "DropDnodeStmt"; + case QUERY_NODE_ALTER_DNODE_STMT: + return "AlterDnodeStmt"; + case QUERY_NODE_CREATE_INDEX_STMT: + return "CreateIndexStmt"; + case QUERY_NODE_DROP_INDEX_STMT: + return "DropIndexStmt"; + case QUERY_NODE_CREATE_QNODE_STMT: + return "CreateQnodeStmt"; + case QUERY_NODE_DROP_QNODE_STMT: + return "DropQnodeStmt"; + case QUERY_NODE_CREATE_SNODE_STMT: + return "CreateSnodeStmt"; + case QUERY_NODE_DROP_SNODE_STMT: + return "DropSnodeStmt"; + case QUERY_NODE_CREATE_MNODE_STMT: + return "CreateMnodeStmt"; + case QUERY_NODE_DROP_MNODE_STMT: + return "DropMnodeStmt"; + case QUERY_NODE_CREATE_TOPIC_STMT: + return "CreateTopicStmt"; + case QUERY_NODE_DROP_TOPIC_STMT: + return "DropTopicStmt"; + case QUERY_NODE_DROP_CGROUP_STMT: + return "DropConsumerGroupStmt"; + case QUERY_NODE_ALTER_LOCAL_STMT: + return "AlterLocalStmt"; + case QUERY_NODE_EXPLAIN_STMT: + return "ExplainStmt"; + case QUERY_NODE_DESCRIBE_STMT: + return "DescribeStmt"; + case QUERY_NODE_COMPACT_DATABASE_STMT: + return "CompactDatabaseStmt"; + case QUERY_NODE_CREATE_STREAM_STMT: + return "CreateStreamStmt"; + case QUERY_NODE_DROP_STREAM_STMT: + return "DropStreamStmt"; + case QUERY_NODE_PAUSE_STREAM_STMT: + return "PauseStreamStmt"; + case QUERY_NODE_RESUME_STREAM_STMT: + return "ResumeStreamStmt"; + case QUERY_NODE_BALANCE_VGROUP_STMT: + return "BalanceVgroupStmt"; + case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: + return "BalanceVgroupLeaderStmt"; + case QUERY_NODE_MERGE_VGROUP_STMT: + return "MergeVgroupStmt"; + case QUERY_NODE_SHOW_DB_ALIVE_STMT: + return "ShowDbAliveStmt"; + case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT: + return "ShowClusterAliveStmt"; + case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: + return "RedistributeVgroupStmt"; + case QUERY_NODE_SPLIT_VGROUP_STMT: + return "SplitVgroupStmt"; + case QUERY_NODE_GRANT_STMT: + return "GrantStmt"; + case QUERY_NODE_REVOKE_STMT: + return "RevokeStmt"; + case QUERY_NODE_SHOW_DNODES_STMT: + return "ShowDnodesStmt"; + case QUERY_NODE_SHOW_MNODES_STMT: + return "ShowMnodesStmt"; + case QUERY_NODE_SHOW_MODULES_STMT: + return "ShowModulesStmt"; + case QUERY_NODE_SHOW_QNODES_STMT: + return "ShowQnodesStmt"; + case QUERY_NODE_SHOW_SNODES_STMT: + return "ShowSnodesStmt"; + case QUERY_NODE_SHOW_BNODES_STMT: + return "ShowBnodesStmt"; + case QUERY_NODE_SHOW_CLUSTER_STMT: + return "ShowClusterStmt"; + case QUERY_NODE_SHOW_DATABASES_STMT: + return "ShowDatabaseStmt"; + case QUERY_NODE_SHOW_FUNCTIONS_STMT: + return "ShowFunctionsStmt"; + case QUERY_NODE_SHOW_INDEXES_STMT: + return "ShowIndexesStmt"; + case QUERY_NODE_SHOW_STABLES_STMT: + return "ShowStablesStmt"; + case QUERY_NODE_SHOW_STREAMS_STMT: + return "ShowStreamsStmt"; + case QUERY_NODE_SHOW_TABLES_STMT: + return "ShowTablesStmt"; + case QUERY_NODE_SHOW_TAGS_STMT: + return "ShowTagsStmt"; + case QUERY_NODE_SHOW_USERS_STMT: + return "ShowUsersStmt"; + case QUERY_NODE_SHOW_LICENCES_STMT: + return "ShowGrantsStmt"; + case QUERY_NODE_SHOW_VGROUPS_STMT: + return "ShowVgroupsStmt"; + case QUERY_NODE_SHOW_TOPICS_STMT: + return "ShowTopicsStmt"; + case QUERY_NODE_SHOW_CONSUMERS_STMT: + return "ShowConsumersStmt"; + case QUERY_NODE_SHOW_QUERIES_STMT: + return "ShowQueriesStmt"; + case QUERY_NODE_SHOW_VARIABLES_STMT: + return "ShowVariablesStmt"; + case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: + return "ShowDnodeVariablesStmt"; + case QUERY_NODE_SHOW_TRANSACTIONS_STMT: + return "ShowTransactionsStmt"; + case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT: + return "ShowSubscriptionsStmt"; + case QUERY_NODE_SHOW_VNODES_STMT: + return "ShowVnodeStmt"; + case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT: + return "ShowUserPrivilegesStmt"; + case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: + return "ShowCreateDatabasesStmt"; + case QUERY_NODE_SHOW_CREATE_TABLE_STMT: + return "ShowCreateTablesStmt"; + case QUERY_NODE_SHOW_CREATE_STABLE_STMT: + return "ShowCreateStablesStmt"; + case QUERY_NODE_SHOW_CREATE_VIEW_STMT: + return "ShowCreateViewStmt"; + case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: + return "ShowTableDistributedStmt"; + case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT: + return "ShowLocalVariablesStmt"; + case QUERY_NODE_SHOW_TABLE_TAGS_STMT: + return "ShowTableTagsStmt"; + case QUERY_NODE_DELETE_STMT: + return "DeleteStmt"; + case QUERY_NODE_INSERT_STMT: + return "InsertStmt"; + case QUERY_NODE_RESTORE_DNODE_STMT: + return "RestoreDnodeStmt"; + case QUERY_NODE_RESTORE_QNODE_STMT: + return "RestoreQnodeStmt"; + case QUERY_NODE_RESTORE_MNODE_STMT: + return "RestoreMnodeStmt"; + case QUERY_NODE_RESTORE_VNODE_STMT: + return "RestoreVnodeStmt"; + case QUERY_NODE_CREATE_VIEW_STMT: + return "CreateViewStmt"; + case QUERY_NODE_DROP_VIEW_STMT: + return "DropViewStmt"; + case QUERY_NODE_LOGIC_PLAN_SCAN: + return "LogicScan"; + case QUERY_NODE_LOGIC_PLAN_JOIN: + return "LogicJoin"; + case QUERY_NODE_LOGIC_PLAN_AGG: + return "LogicAgg"; + case QUERY_NODE_LOGIC_PLAN_PROJECT: + return "LogicProject"; + case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: + return "LogicVnodeModify"; + case QUERY_NODE_LOGIC_PLAN_EXCHANGE: + return "LogicExchange"; + case QUERY_NODE_LOGIC_PLAN_MERGE: + return "LogicMerge"; + case QUERY_NODE_LOGIC_PLAN_WINDOW: + return "LogicWindow"; + case QUERY_NODE_LOGIC_PLAN_FILL: + return "LogicFill"; + case QUERY_NODE_LOGIC_PLAN_SORT: + return "LogicSort"; + case QUERY_NODE_LOGIC_PLAN_PARTITION: + return "LogicPartition"; + case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: + return "LogicIndefRowsFunc"; + case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: + return "LogicInterpFunc"; + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: + return "LogicGroupCache"; + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: + return "LogicDynamicQueryCtrl"; + case QUERY_NODE_LOGIC_SUBPLAN: + return "LogicSubplan"; + case QUERY_NODE_LOGIC_PLAN: + return "LogicPlan"; + case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: + return "PhysiTagScan"; + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: + return "PhysiTableScan"; + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN: + return "PhysiTableSeqScan"; + case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: + return "PhysiTableMergeScan"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: + return "PhysiSreamScan"; + case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: + return "PhysiSystemTableScan"; + case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: + return "PhysiBlockDistScan"; + case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: + return "PhysiLastRowScan"; + case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: + return "PhysiTableCountScan"; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: + return "PhysiMergeEventWindow"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: + return "PhysiStreamEventWindow"; + case QUERY_NODE_PHYSICAL_PLAN_PROJECT: + return "PhysiProject"; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: + return "PhysiMergeJoin"; + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: + return "PhysiHashJoin"; + case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: + return "PhysiAgg"; + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: + return "PhysiExchange"; + case QUERY_NODE_PHYSICAL_PLAN_MERGE: + return "PhysiMerge"; + case QUERY_NODE_PHYSICAL_PLAN_SORT: + return "PhysiSort"; + case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: + return "PhysiGroupSort"; + case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: + return "PhysiHashInterval"; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: + return "PhysiMergeAlignedInterval"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: + return "PhysiStreamInterval"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: + return "PhysiStreamFinalInterval"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: + return "PhysiStreamSemiInterval"; + case QUERY_NODE_PHYSICAL_PLAN_FILL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: + return "PhysiFill"; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: + return "PhysiSessionWindow"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: + return "PhysiStreamSessionWindow"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: + return "PhysiStreamSemiSessionWindow"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: + return "PhysiStreamFinalSessionWindow"; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: + return "PhysiStateWindow"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: + return "PhysiStreamStateWindow"; + case QUERY_NODE_PHYSICAL_PLAN_PARTITION: + return "PhysiPartition"; + case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: + return "PhysiStreamPartition"; + case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: + return "PhysiIndefRowsFunc"; + case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: + return "PhysiInterpFunc"; + case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: + return "PhysiDispatch"; + case QUERY_NODE_PHYSICAL_PLAN_INSERT: + return "PhysiInsert"; + case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: + return "PhysiQueryInsert"; + case QUERY_NODE_PHYSICAL_PLAN_DELETE: + return "PhysiDelete"; + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + return "PhysiGroupCache"; + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: + return "PhysiDynamicQueryCtrl"; + case QUERY_NODE_PHYSICAL_SUBPLAN: + return "PhysiSubplan"; + case QUERY_NODE_PHYSICAL_PLAN: + return "PhysiPlan"; + default: + break; } - return funcNodes[type].name; + nodesWarn("nodesNodeName unknown node = %d", type); + return "UnknownNode"; } static int32_t nodeListToJson(SJson* pJson, const char* pName, const SNodeList* pList) { @@ -6488,31 +6803,657 @@ static int32_t jsonToInsertStmt(const SJson* pJson, void* pObj) { return code; } -int32_t specificNodeToJson(const void* pObj, SJson* pJson) { - ENodeType type = nodeType(pObj); - if (!funcArrayCheck(type)) { - return TSDB_CODE_NOT_FOUND; +static int32_t specificNodeToJson(const void* pObj, SJson* pJson) { + switch (nodeType(pObj)) { + case QUERY_NODE_COLUMN: + return columnNodeToJson(pObj, pJson); + case QUERY_NODE_VALUE: + return valueNodeToJson(pObj, pJson); + case QUERY_NODE_OPERATOR: + return operatorNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_CONDITION: + return logicConditionNodeToJson(pObj, pJson); + case QUERY_NODE_FUNCTION: + return functionNodeToJson(pObj, pJson); + case QUERY_NODE_REAL_TABLE: + return realTableNodeToJson(pObj, pJson); + case QUERY_NODE_TEMP_TABLE: + return tempTableNodeToJson(pObj, pJson); + case QUERY_NODE_JOIN_TABLE: + return joinTableNodeToJson(pObj, pJson); + case QUERY_NODE_GROUPING_SET: + return groupingSetNodeToJson(pObj, pJson); + case QUERY_NODE_ORDER_BY_EXPR: + return orderByExprNodeToJson(pObj, pJson); + case QUERY_NODE_LIMIT: + return limitNodeToJson(pObj, pJson); + case QUERY_NODE_STATE_WINDOW: + return stateWindowNodeToJson(pObj, pJson); + case QUERY_NODE_SESSION_WINDOW: + return sessionWindowNodeToJson(pObj, pJson); + case QUERY_NODE_INTERVAL_WINDOW: + return intervalWindowNodeToJson(pObj, pJson); + case QUERY_NODE_NODE_LIST: + return nodeListNodeToJson(pObj, pJson); + case QUERY_NODE_FILL: + return fillNodeToJson(pObj, pJson); + case QUERY_NODE_RAW_EXPR: + break; + case QUERY_NODE_TARGET: + return targetNodeToJson(pObj, pJson); + case QUERY_NODE_DATABLOCK_DESC: + return dataBlockDescNodeToJson(pObj, pJson); + case QUERY_NODE_SLOT_DESC: + return slotDescNodeToJson(pObj, pJson); + case QUERY_NODE_COLUMN_DEF: + return columnDefNodeToJson(pObj, pJson); + case QUERY_NODE_DOWNSTREAM_SOURCE: + return downstreamSourceNodeToJson(pObj, pJson); + case QUERY_NODE_DATABASE_OPTIONS: + return databaseOptionsToJson(pObj, pJson); + case QUERY_NODE_TABLE_OPTIONS: + return tableOptionsToJson(pObj, pJson); + case QUERY_NODE_INDEX_OPTIONS: + return indexOptionsToJson(pObj, pJson); + case QUERY_NODE_EXPLAIN_OPTIONS: + return explainOptionsToJson(pObj, pJson); + case QUERY_NODE_STREAM_OPTIONS: + return streamOptionsToJson(pObj, pJson); + case QUERY_NODE_LEFT_VALUE: + return TSDB_CODE_SUCCESS; // SLeftValueNode has no fields to serialize. + case QUERY_NODE_WHEN_THEN: + return whenThenNodeToJson(pObj, pJson); + case QUERY_NODE_CASE_WHEN: + return caseWhenNodeToJson(pObj, pJson); + case QUERY_NODE_EVENT_WINDOW: + return eventWindowNodeToJson(pObj, pJson); + case QUERY_NODE_SET_OPERATOR: + return setOperatorToJson(pObj, pJson); + case QUERY_NODE_SELECT_STMT: + return selectStmtToJson(pObj, pJson); + case QUERY_NODE_VNODE_MODIFY_STMT: + return vnodeModifyStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_DATABASE_STMT: + return createDatabaseStmtToJson(pObj, pJson); + case QUERY_NODE_ALTER_DATABASE_STMT: + return alterDatabaseStmtToJson(pObj, pJson); + case QUERY_NODE_TRIM_DATABASE_STMT: + return trimDatabaseStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_TABLE_STMT: + return createTableStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: + return createSubTableClauseToJson(pObj, pJson); + case QUERY_NODE_CREATE_MULTI_TABLES_STMT: + return createMultiTablesStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_TABLE_CLAUSE: + return dropTableClauseToJson(pObj, pJson); + case QUERY_NODE_DROP_TABLE_STMT: + return dropTableStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_SUPER_TABLE_STMT: + return dropStableStmtToJson(pObj, pJson); + case QUERY_NODE_ALTER_TABLE_STMT: + return alterTableStmtToJson(pObj, pJson); + case QUERY_NODE_ALTER_SUPER_TABLE_STMT: + return alterStableStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_USER_STMT: + return createUserStmtToJson(pObj, pJson); + case QUERY_NODE_ALTER_USER_STMT: + return alterUserStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_USER_STMT: + return dropUserStmtToJson(pObj, pJson); + case QUERY_NODE_USE_DATABASE_STMT: + return useDatabaseStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_DNODE_STMT: + return createDnodeStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_DNODE_STMT: + return dropDnodeStmtToJson(pObj, pJson); + case QUERY_NODE_ALTER_DNODE_STMT: + return alterDnodeStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_INDEX_STMT: + return createIndexStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_INDEX_STMT: + return dropIndexStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_QNODE_STMT: + return createQnodeStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_QNODE_STMT: + return dropQnodeStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_SNODE_STMT: + return createSnodeStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_SNODE_STMT: + return dropSnodeStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_MNODE_STMT: + return createMnodeStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_MNODE_STMT: + return dropMnodeStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_TOPIC_STMT: + return createTopicStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_TOPIC_STMT: + return dropTopicStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_CGROUP_STMT: + return dropConsumerGroupStmtToJson(pObj, pJson); + case QUERY_NODE_ALTER_LOCAL_STMT: + return alterLocalStmtToJson(pObj, pJson); + case QUERY_NODE_EXPLAIN_STMT: + return explainStmtToJson(pObj, pJson); + case QUERY_NODE_DESCRIBE_STMT: + return describeStmtToJson(pObj, pJson); + case QUERY_NODE_COMPACT_DATABASE_STMT: + return compactDatabaseStmtToJson(pObj, pJson); + case QUERY_NODE_CREATE_STREAM_STMT: + return createStreamStmtToJson(pObj, pJson); + case QUERY_NODE_DROP_STREAM_STMT: + return dropStreamStmtToJson(pObj, pJson); + case QUERY_NODE_BALANCE_VGROUP_STMT: + return TSDB_CODE_SUCCESS; // SBalanceVgroupStmt has no fields to serialize. + case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: + return TSDB_CODE_SUCCESS; // SBalanceVgroupLeaderStmt has no fields to serialize. + case QUERY_NODE_MERGE_VGROUP_STMT: + return mergeVgroupStmtToJson(pObj, pJson); + case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: + return redistributeVgroupStmtToJson(pObj, pJson); + case QUERY_NODE_SPLIT_VGROUP_STMT: + return splitVgroupStmtToJson(pObj, pJson); + case QUERY_NODE_GRANT_STMT: + return grantStmtToJson(pObj, pJson); + case QUERY_NODE_REVOKE_STMT: + return revokeStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_DNODES_STMT: + return showDnodesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_MNODES_STMT: + return showMnodesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_QNODES_STMT: + return showQnodesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_CLUSTER_STMT: + return showClusterStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_DATABASES_STMT: + return showDatabasesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_FUNCTIONS_STMT: + return showFunctionsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_INDEXES_STMT: + return showIndexesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_STABLES_STMT: + return showStablesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_STREAMS_STMT: + return showStreamsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_TABLES_STMT: + return showTablesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_TAGS_STMT: + return showTagsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_USERS_STMT: + return showUsersStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_VGROUPS_STMT: + return showVgroupsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_CONSUMERS_STMT: + return showConsumersStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_VARIABLES_STMT: + return showVariablesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: + return showDnodeVariablesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_TRANSACTIONS_STMT: + return showTransactionsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT: + return showSubscriptionsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_VNODES_STMT: + return showVnodesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT: + return showUserPrivilegesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: + return showCreateDatabaseStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_CREATE_TABLE_STMT: + return showCreateTableStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_CREATE_STABLE_STMT: + return showCreateStableStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_CREATE_VIEW_STMT: + return showCreateViewStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: + return showTableDistributedStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT: + return showLocalVariablesStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_TABLE_TAGS_STMT: + return showTableTagsStmtToJson(pObj, pJson); + case QUERY_NODE_DELETE_STMT: + return deleteStmtToJson(pObj, pJson); + case QUERY_NODE_INSERT_STMT: + return insertStmtToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_SCAN: + return logicScanNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_JOIN: + return logicJoinNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_AGG: + return logicAggNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_PROJECT: + return logicProjectNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: + return logicVnodeModifyNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_EXCHANGE: + return logicExchangeNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_MERGE: + return logicMergeNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_WINDOW: + return logicWindowNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_FILL: + return logicFillNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_SORT: + return logicSortNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_PARTITION: + return logicPartitionNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: + return logicIndefRowsFuncNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: + return logicInterpFuncNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: + return logicGroupCacheNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: + return logicDynQueryCtrlNodeToJson(pObj, pJson); + case QUERY_NODE_LOGIC_SUBPLAN: + return logicSubplanToJson(pObj, pJson); + case QUERY_NODE_LOGIC_PLAN: + return logicPlanToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: + return physiTagScanNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: + return physiScanNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: + return physiLastRowScanNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: + return physiTableScanNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: + return physiSysTableScanNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_PROJECT: + return physiProjectNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: + return physiMergeJoinNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: + return physiHashJoinNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: + return physiAggNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: + return physiExchangeNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_MERGE: + return physiMergeNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_SORT: + case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: + return physiSortNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: + return physiIntervalNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_FILL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: + return physiFillNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: + return physiSessionWindowNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: + return physiStateWindowNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: + return physiEventWindowNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_PARTITION: + return physiPartitionNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: + return physiStreamPartitionNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: + return physiIndefRowsFuncNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: + return physiInterpFuncNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: + return physiDispatchNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_INSERT: + break; + case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: + return physiQueryInsertNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_DELETE: + return physiDeleteNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + return physiGroupCacheNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: + return physiDynQueryCtrlNodeToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_SUBPLAN: + return subplanToJson(pObj, pJson); + case QUERY_NODE_PHYSICAL_PLAN: + return planToJson(pObj, pJson); + default: + break; } - - if (funcNodes[type].toJsonFunc) { - return funcNodes[type].toJsonFunc(pObj, pJson); - } - - nodesWarn("specificNodeToJson unknown node type = %d", type); + nodesWarn("specificNodeToJson unknown node = %s", nodesNodeName(nodeType(pObj))); return TSDB_CODE_SUCCESS; } -int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { - ENodeType type = nodeType(pObj); - if (!funcArrayCheck(type)) { - return TSDB_CODE_NOT_FOUND; +static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { + switch (nodeType(pObj)) { + case QUERY_NODE_COLUMN: + return jsonToColumnNode(pJson, pObj); + case QUERY_NODE_VALUE: + return jsonToValueNode(pJson, pObj); + case QUERY_NODE_OPERATOR: + return jsonToOperatorNode(pJson, pObj); + case QUERY_NODE_LOGIC_CONDITION: + return jsonToLogicConditionNode(pJson, pObj); + case QUERY_NODE_FUNCTION: + return jsonToFunctionNode(pJson, pObj); + case QUERY_NODE_REAL_TABLE: + return jsonToRealTableNode(pJson, pObj); + case QUERY_NODE_TEMP_TABLE: + return jsonToTempTableNode(pJson, pObj); + case QUERY_NODE_JOIN_TABLE: + return jsonToJoinTableNode(pJson, pObj); + case QUERY_NODE_GROUPING_SET: + return jsonToGroupingSetNode(pJson, pObj); + case QUERY_NODE_ORDER_BY_EXPR: + return jsonToOrderByExprNode(pJson, pObj); + case QUERY_NODE_LIMIT: + return jsonToLimitNode(pJson, pObj); + case QUERY_NODE_STATE_WINDOW: + return jsonToStateWindowNode(pJson, pObj); + case QUERY_NODE_SESSION_WINDOW: + return jsonToSessionWindowNode(pJson, pObj); + case QUERY_NODE_INTERVAL_WINDOW: + return jsonToIntervalWindowNode(pJson, pObj); + case QUERY_NODE_NODE_LIST: + return jsonToNodeListNode(pJson, pObj); + case QUERY_NODE_FILL: + return jsonToFillNode(pJson, pObj); + case QUERY_NODE_TARGET: + return jsonToTargetNode(pJson, pObj); + case QUERY_NODE_DATABLOCK_DESC: + return jsonToDataBlockDescNode(pJson, pObj); + case QUERY_NODE_SLOT_DESC: + return jsonToSlotDescNode(pJson, pObj); + case QUERY_NODE_COLUMN_DEF: + return jsonToColumnDefNode(pJson, pObj); + case QUERY_NODE_DOWNSTREAM_SOURCE: + return jsonToDownstreamSourceNode(pJson, pObj); + case QUERY_NODE_DATABASE_OPTIONS: + return jsonToDatabaseOptions(pJson, pObj); + case QUERY_NODE_TABLE_OPTIONS: + return jsonToTableOptions(pJson, pObj); + case QUERY_NODE_INDEX_OPTIONS: + return jsonToIndexOptions(pJson, pObj); + case QUERY_NODE_EXPLAIN_OPTIONS: + return jsonToExplainOptions(pJson, pObj); + case QUERY_NODE_STREAM_OPTIONS: + return jsonToStreamOptions(pJson, pObj); + case QUERY_NODE_LEFT_VALUE: + return TSDB_CODE_SUCCESS; // SLeftValueNode has no fields to deserialize. + case QUERY_NODE_WHEN_THEN: + return jsonToWhenThenNode(pJson, pObj); + case QUERY_NODE_CASE_WHEN: + return jsonToCaseWhenNode(pJson, pObj); + case QUERY_NODE_EVENT_WINDOW: + return jsonToEventWindowNode(pJson, pObj); + case QUERY_NODE_SET_OPERATOR: + return jsonToSetOperator(pJson, pObj); + case QUERY_NODE_SELECT_STMT: + return jsonToSelectStmt(pJson, pObj); + case QUERY_NODE_VNODE_MODIFY_STMT: + return jsonToVnodeModifyStmt(pJson, pObj); + case QUERY_NODE_CREATE_DATABASE_STMT: + return jsonToCreateDatabaseStmt(pJson, pObj); + case QUERY_NODE_ALTER_DATABASE_STMT: + return jsonToAlterDatabaseStmt(pJson, pObj); + case QUERY_NODE_TRIM_DATABASE_STMT: + return jsonToTrimDatabaseStmt(pJson, pObj); + case QUERY_NODE_CREATE_TABLE_STMT: + return jsonToCreateTableStmt(pJson, pObj); + case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: + return jsonToCreateSubTableClause(pJson, pObj); + case QUERY_NODE_CREATE_MULTI_TABLES_STMT: + return jsonToCreateMultiTablesStmt(pJson, pObj); + case QUERY_NODE_DROP_TABLE_CLAUSE: + return jsonToDropTableClause(pJson, pObj); + case QUERY_NODE_DROP_TABLE_STMT: + return jsonToDropTableStmt(pJson, pObj); + case QUERY_NODE_DROP_SUPER_TABLE_STMT: + return jsonToDropStableStmt(pJson, pObj); + case QUERY_NODE_ALTER_TABLE_STMT: + return jsonToAlterTableStmt(pJson, pObj); + case QUERY_NODE_ALTER_SUPER_TABLE_STMT: + return jsonToAlterStableStmt(pJson, pObj); + case QUERY_NODE_CREATE_USER_STMT: + return jsonToCreateUserStmt(pJson, pObj); + case QUERY_NODE_ALTER_USER_STMT: + return jsonToAlterUserStmt(pJson, pObj); + case QUERY_NODE_DROP_USER_STMT: + return jsonToDropUserStmt(pJson, pObj); + case QUERY_NODE_USE_DATABASE_STMT: + return jsonToUseDatabaseStmt(pJson, pObj); + case QUERY_NODE_CREATE_DNODE_STMT: + return jsonToCreateDnodeStmt(pJson, pObj); + case QUERY_NODE_DROP_DNODE_STMT: + return jsonToDropDnodeStmt(pJson, pObj); + case QUERY_NODE_ALTER_DNODE_STMT: + return jsonToAlterDnodeStmt(pJson, pObj); + case QUERY_NODE_CREATE_INDEX_STMT: + return jsonToCreateIndexStmt(pJson, pObj); + case QUERY_NODE_DROP_INDEX_STMT: + return jsonToDropIndexStmt(pJson, pObj); + case QUERY_NODE_CREATE_QNODE_STMT: + return jsonToCreateQnodeStmt(pJson, pObj); + case QUERY_NODE_DROP_QNODE_STMT: + return jsonToDropQnodeStmt(pJson, pObj); + case QUERY_NODE_CREATE_SNODE_STMT: + return jsonToCreateSnodeStmt(pJson, pObj); + case QUERY_NODE_DROP_SNODE_STMT: + return jsonToDropSnodeStmt(pJson, pObj); + case QUERY_NODE_CREATE_MNODE_STMT: + return jsonToCreateMnodeStmt(pJson, pObj); + case QUERY_NODE_DROP_MNODE_STMT: + return jsonToDropMnodeStmt(pJson, pObj); + case QUERY_NODE_CREATE_TOPIC_STMT: + return jsonToCreateTopicStmt(pJson, pObj); + case QUERY_NODE_DROP_TOPIC_STMT: + return jsonToDropTopicStmt(pJson, pObj); + case QUERY_NODE_DROP_CGROUP_STMT: + return jsonToDropConsumerGroupStmt(pJson, pObj); + case QUERY_NODE_ALTER_LOCAL_STMT: + return jsonToAlterLocalStmt(pJson, pObj); + case QUERY_NODE_EXPLAIN_STMT: + return jsonToExplainStmt(pJson, pObj); + case QUERY_NODE_DESCRIBE_STMT: + return jsonToDescribeStmt(pJson, pObj); + case QUERY_NODE_COMPACT_DATABASE_STMT: + return jsonToCompactDatabaseStmt(pJson, pObj); + case QUERY_NODE_CREATE_STREAM_STMT: + return jsonToCreateStreamStmt(pJson, pObj); + case QUERY_NODE_DROP_STREAM_STMT: + return jsonToDropStreamStmt(pJson, pObj); + case QUERY_NODE_BALANCE_VGROUP_STMT: + return TSDB_CODE_SUCCESS; // SBalanceVgroupStmt has no fields to deserialize. + case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: + return TSDB_CODE_SUCCESS; // SBalanceVgroupLeaderStmt has no fields to deserialize. + case QUERY_NODE_MERGE_VGROUP_STMT: + return jsonToMergeVgroupStmt(pJson, pObj); + case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: + return jsonToRedistributeVgroupStmt(pJson, pObj); + case QUERY_NODE_SPLIT_VGROUP_STMT: + return jsonToSplitVgroupStmt(pJson, pObj); + case QUERY_NODE_GRANT_STMT: + return jsonToGrantStmt(pJson, pObj); + case QUERY_NODE_REVOKE_STMT: + return jsonToRevokeStmt(pJson, pObj); + case QUERY_NODE_SHOW_DNODES_STMT: + return jsonToShowDnodesStmt(pJson, pObj); + case QUERY_NODE_SHOW_MNODES_STMT: + return jsonToShowMnodesStmt(pJson, pObj); + case QUERY_NODE_SHOW_QNODES_STMT: + return jsonToShowQnodesStmt(pJson, pObj); + case QUERY_NODE_SHOW_CLUSTER_STMT: + return jsonToShowClusterStmt(pJson, pObj); + case QUERY_NODE_SHOW_DATABASES_STMT: + return jsonToShowDatabasesStmt(pJson, pObj); + case QUERY_NODE_SHOW_FUNCTIONS_STMT: + return jsonToShowFunctionsStmt(pJson, pObj); + case QUERY_NODE_SHOW_INDEXES_STMT: + return jsonToShowIndexesStmt(pJson, pObj); + case QUERY_NODE_SHOW_STABLES_STMT: + return jsonToShowStablesStmt(pJson, pObj); + case QUERY_NODE_SHOW_STREAMS_STMT: + return jsonToShowStreamsStmt(pJson, pObj); + case QUERY_NODE_SHOW_TABLES_STMT: + return jsonToShowTablesStmt(pJson, pObj); + case QUERY_NODE_SHOW_TAGS_STMT: + return jsonToShowTagsStmt(pJson, pObj); + case QUERY_NODE_SHOW_USERS_STMT: + return jsonToShowUsersStmt(pJson, pObj); + case QUERY_NODE_SHOW_VGROUPS_STMT: + return jsonToShowVgroupsStmt(pJson, pObj); + case QUERY_NODE_SHOW_CONSUMERS_STMT: + return jsonToShowConsumersStmt(pJson, pObj); + case QUERY_NODE_SHOW_VARIABLES_STMT: + return jsonToShowVariablesStmt(pJson, pObj); + case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: + return jsonToShowDnodeVariablesStmt(pJson, pObj); + case QUERY_NODE_SHOW_TRANSACTIONS_STMT: + return jsonToShowTransactionsStmt(pJson, pObj); + case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT: + return jsonToShowSubscriptionsStmt(pJson, pObj); + case QUERY_NODE_SHOW_VNODES_STMT: + return jsonToShowVnodesStmt(pJson, pObj); + case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT: + return jsonToShowUserPrivilegesStmt(pJson, pObj); + case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: + return jsonToShowCreateDatabaseStmt(pJson, pObj); + case QUERY_NODE_SHOW_CREATE_TABLE_STMT: + return jsonToShowCreateTableStmt(pJson, pObj); + case QUERY_NODE_SHOW_CREATE_STABLE_STMT: + return jsonToShowCreateStableStmt(pJson, pObj); + case QUERY_NODE_SHOW_CREATE_VIEW_STMT: + return jsonToShowCreateViewStmt(pJson, pObj); + case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: + return jsonToShowTableDistributedStmt(pJson, pObj); + case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT: + return jsonToShowLocalVariablesStmt(pJson, pObj); + case QUERY_NODE_SHOW_TABLE_TAGS_STMT: + return jsonToShowTableTagsStmt(pJson, pObj); + case QUERY_NODE_DELETE_STMT: + return jsonToDeleteStmt(pJson, pObj); + case QUERY_NODE_INSERT_STMT: + return jsonToInsertStmt(pJson, pObj); + case QUERY_NODE_RESTORE_DNODE_STMT: + return jsonToRestoreDnodeStmt(pJson, pObj); + case QUERY_NODE_RESTORE_QNODE_STMT: + return jsonToRestoreQnodeStmt(pJson, pObj); + case QUERY_NODE_RESTORE_MNODE_STMT: + return jsonToRestoreMnodeStmt(pJson, pObj); + case QUERY_NODE_RESTORE_VNODE_STMT: + return jsonToRestoreVnodeStmt(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_SCAN: + return jsonToLogicScanNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_JOIN: + return jsonToLogicJoinNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_AGG: + return jsonToLogicAggNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_PROJECT: + return jsonToLogicProjectNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: + return jsonToLogicVnodeModifyNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_EXCHANGE: + return jsonToLogicExchangeNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_MERGE: + return jsonToLogicMergeNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_WINDOW: + return jsonToLogicWindowNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_FILL: + return jsonToLogicFillNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_SORT: + return jsonToLogicSortNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_PARTITION: + return jsonToLogicPartitionNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: + return jsonToLogicIndefRowsFuncNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: + return jsonToLogicInterpFuncNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: + return jsonToLogicGroupCacheNode(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: + return jsonToLogicDynQueryCtrlNode(pJson, pObj); + case QUERY_NODE_LOGIC_SUBPLAN: + return jsonToLogicSubplan(pJson, pObj); + case QUERY_NODE_LOGIC_PLAN: + return jsonToLogicPlan(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: + return jsonToPhysiTagScanNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: + return jsonToPhysiScanNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: + return jsonToPhysiLastRowScanNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: + return jsonToPhysiTableScanNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: + return jsonToPhysiSysTableScanNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_PROJECT: + return jsonToPhysiProjectNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: + return jsonToPhysiMergeJoinNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: + return jsonToPhysiHashJoinNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: + return jsonToPhysiAggNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: + return jsonToPhysiExchangeNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_MERGE: + return jsonToPhysiMergeNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_SORT: + case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: + return jsonToPhysiSortNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: + return jsonToPhysiIntervalNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_FILL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: + return jsonToPhysiFillNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: + return jsonToPhysiSessionWindowNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: + return jsonToPhysiStateWindowNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: + return jsonToPhysiEventWindowNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_PARTITION: + return jsonToPhysiPartitionNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: + return jsonToPhysiStreamPartitionNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: + return jsonToPhysiIndefRowsFuncNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: + return jsonToPhysiInterpFuncNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: + return jsonToPhysiDispatchNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: + return jsonToPhysiQueryInsertNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_DELETE: + return jsonToPhysiDeleteNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + return jsonToPhysiGroupCacheNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: + return jsonToPhysiDynQueryCtrlNode(pJson, pObj); + case QUERY_NODE_PHYSICAL_SUBPLAN: + return jsonToSubplan(pJson, pObj); + case QUERY_NODE_PHYSICAL_PLAN: + return jsonToPlan(pJson, pObj); + default: + break; } - - if (funcNodes[type].toNodeFunc) { - return funcNodes[type].toNodeFunc(pJson, pObj); - } - - nodesWarn("jsonToSpecificNode unknown node type = %d", type); + nodesWarn("jsonToSpecificNode unknown node = %s", nodesNodeName(nodeType(pObj))); return TSDB_CODE_SUCCESS; } @@ -6670,2180 +7611,3 @@ int32_t nodesStringToList(const char* pStr, SNodeList** pList) { } return TSDB_CODE_SUCCESS; } - -static int32_t emptyNodeToJson(const void* pObj, SJson* pJson) { - return TSDB_CODE_SUCCESS; -} - -static int32_t emptyJsonToNode(const SJson* pJson, void* pObj) { - return TSDB_CODE_SUCCESS; -} - -static void destroyVgDataBlockArray(SArray* pArray) { - size_t size = taosArrayGetSize(pArray); - for (size_t i = 0; i < size; ++i) { - SVgDataBlocks* pVg = taosArrayGetP(pArray, i); - taosMemoryFreeClear(pVg->pData); - taosMemoryFreeClear(pVg); - } - taosArrayDestroy(pArray); -} - -static void destroyLogicNode(SLogicNode* pNode) { - nodesDestroyList(pNode->pTargets); - nodesDestroyNode(pNode->pConditions); - nodesDestroyList(pNode->pChildren); - nodesDestroyNode(pNode->pLimit); - nodesDestroyNode(pNode->pSlimit); - nodesDestroyList(pNode->pHint); -} - -void destroyPhysiNode(SNode* pInput) { - SPhysiNode* pNode = (SPhysiNode*)pInput; - nodesDestroyList(pNode->pChildren); - nodesDestroyNode(pNode->pConditions); - nodesDestroyNode((SNode*)pNode->pOutputDataBlockDesc); - nodesDestroyNode(pNode->pLimit); - nodesDestroyNode(pNode->pSlimit); -} - -void destroyExprNode(SNode* pNode) { - SExprNode* pExpr = (SExprNode*)pNode; - taosArrayDestroy(pExpr->pAssociation); -} - -void destroyDataInSmaIndex(void* pIndex) { - taosMemoryFree(((STableIndexInfo*)pIndex)->expr); -} - -void destoryXNode(SNode* pNode) {} - -void destroyColumnNode(SNode* pNode) { - destroyExprNode(pNode); -} - -void destroyValueNode(SNode* pNode) { - SValueNode* pValue = (SValueNode*)pNode; - destroyExprNode(pNode); - taosMemoryFreeClear(pValue->literal); - if (IS_VAR_DATA_TYPE(pValue->node.resType.type)) { - taosMemoryFreeClear(pValue->datum.p); - } -} - -void destroyOperatorNode(SNode* pNode) { - SOperatorNode* pOp = (SOperatorNode*)pNode; - destroyExprNode(pNode); - nodesDestroyNode(pOp->pLeft); - nodesDestroyNode(pOp->pRight); -} - -void destoryLogicConditionNode(SNode* pNode) { - destroyExprNode(pNode); - nodesDestroyList(((SLogicConditionNode*)pNode)->pParameterList); -} - -void destoryFunctionNode(SNode* pNode) { - destroyExprNode(pNode); - nodesDestroyList(((SFunctionNode*)pNode)->pParameterList); -} - -void destoryRealTableNode(SNode* pNode) { - SRealTableNode* pReal = (SRealTableNode*)pNode; - taosMemoryFreeClear(pReal->pMeta); - taosMemoryFreeClear(pReal->pVgroupList); - taosArrayDestroyEx(pReal->pSmaIndexes, destroyDataInSmaIndex); -} - -void destoryTempTableNode(SNode* pNode) { nodesDestroyNode(((STempTableNode*)pNode)->pSubquery); } - -void destoryJoinTableNode(SNode* pNode) { - SJoinTableNode* pJoin = (SJoinTableNode*)pNode; - nodesDestroyNode(pJoin->pLeft); - nodesDestroyNode(pJoin->pRight); - nodesDestroyNode(pJoin->pOnCond); -} - -void destoryGroupingSetNode(SNode* pNode) { nodesDestroyList(((SGroupingSetNode*)pNode)->pParameterList); } - -void destoryOrderByExprNode(SNode* pNode) { nodesDestroyNode(((SOrderByExprNode*)pNode)->pExpr); } - -void destoryStateWindowNode(SNode* pNode) { - SStateWindowNode* pState = (SStateWindowNode*)pNode; - nodesDestroyNode(pState->pCol); - nodesDestroyNode(pState->pExpr); -} - -void destorySessionWindowNode(SNode* pNode) { - SSessionWindowNode* pSession = (SSessionWindowNode*)pNode; - nodesDestroyNode((SNode*)pSession->pCol); - nodesDestroyNode((SNode*)pSession->pGap); -} - -void destoryIntervalWindowNode(SNode* pNode) { - SIntervalWindowNode* pJoin = (SIntervalWindowNode*)pNode; - nodesDestroyNode(pJoin->pCol); - nodesDestroyNode(pJoin->pInterval); - nodesDestroyNode(pJoin->pOffset); - nodesDestroyNode(pJoin->pSliding); - nodesDestroyNode(pJoin->pFill); -} - -void destoryNodeListNode(SNode* pNode) { nodesDestroyList(((SNodeListNode*)pNode)->pNodeList); } - -void destoryFillNode(SNode* pNode) { - SFillNode* pFill = (SFillNode*)pNode; - nodesDestroyNode(pFill->pValues); - nodesDestroyNode(pFill->pWStartTs); -} - -void destoryRawExprNode(SNode* pNode) { nodesDestroyNode(((SRawExprNode*)pNode)->pNode); } - -void destoryTargetNode(SNode* pNode) { nodesDestroyNode(((STargetNode*)pNode)->pExpr); } - -void destoryDataBlockDescNode(SNode* pNode) { nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots); } - -void destoryDatabaseOptions(SNode* pNode) { - SDatabaseOptions* pOptions = (SDatabaseOptions*)pNode; - nodesDestroyNode((SNode*)pOptions->pDaysPerFile); - nodesDestroyList(pOptions->pKeep); - nodesDestroyList(pOptions->pRetentions); -} - -void destoryTableOptions(SNode* pNode) { - STableOptions* pOptions = (STableOptions*)pNode; - nodesDestroyList(pOptions->pMaxDelay); - nodesDestroyList(pOptions->pWatermark); - nodesDestroyList(pOptions->pRollupFuncs); - nodesDestroyList(pOptions->pSma); - nodesDestroyList(pOptions->pDeleteMark); -} - -void destoryIndexOptions(SNode* pNode) { - SIndexOptions* pOptions = (SIndexOptions*)pNode; - nodesDestroyList(pOptions->pFuncs); - nodesDestroyNode(pOptions->pInterval); - nodesDestroyNode(pOptions->pOffset); - nodesDestroyNode(pOptions->pSliding); - nodesDestroyNode(pOptions->pStreamOptions); -} - -void destoryStreamOptions(SNode* pNode) { - SStreamOptions* pOptions = (SStreamOptions*)pNode; - nodesDestroyNode(pOptions->pDelay); - nodesDestroyNode(pOptions->pWatermark); - nodesDestroyNode(pOptions->pDeleteMark); -} - -void destoryWhenThenNode(SNode* pNode) { - SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode; - nodesDestroyNode(pWhenThen->pWhen); - nodesDestroyNode(pWhenThen->pThen); -} - -void destoryCaseWhenNode(SNode* pNode) { - SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode; - nodesDestroyNode(pCaseWhen->pCase); - nodesDestroyNode(pCaseWhen->pElse); - nodesDestroyList(pCaseWhen->pWhenThenList); -} - -void destoryEventWindowNode(SNode* pNode) { - SEventWindowNode* pEvent = (SEventWindowNode*)pNode; - nodesDestroyNode(pEvent->pCol); - nodesDestroyNode(pEvent->pStartCond); - nodesDestroyNode(pEvent->pEndCond); -} - -void destoryHintNode(SNode* pNode) { - SHintNode* pHint = (SHintNode*)pNode; - taosMemoryFree(pHint->value); -} - -void destoryViewNode(SNode* pNode) { - SViewNode* pView = (SViewNode*)pNode; - taosMemoryFreeClear(pView->pMeta); - taosMemoryFreeClear(pView->pVgroupList); - taosArrayDestroyEx(pView->pSmaIndexes, destroyDataInSmaIndex); -} - -void destorySetOperator(SNode* pNode) { - SSetOperator* pStmt = (SSetOperator*)pNode; - nodesDestroyList(pStmt->pProjectionList); - nodesDestroyNode(pStmt->pLeft); - nodesDestroyNode(pStmt->pRight); - nodesDestroyList(pStmt->pOrderByList); - nodesDestroyNode(pStmt->pLimit); -} - -void destorySelectStmt(SNode* pNode) { - SSelectStmt* pStmt = (SSelectStmt*)pNode; - nodesDestroyList(pStmt->pProjectionList); - nodesDestroyNode(pStmt->pFromTable); - nodesDestroyNode(pStmt->pWhere); - nodesDestroyList(pStmt->pPartitionByList); - nodesDestroyList(pStmt->pTags); - nodesDestroyNode(pStmt->pSubtable); - nodesDestroyNode(pStmt->pWindow); - nodesDestroyList(pStmt->pGroupByList); - nodesDestroyNode(pStmt->pHaving); - nodesDestroyNode(pStmt->pRange); - nodesDestroyNode(pStmt->pEvery); - nodesDestroyNode(pStmt->pFill); - nodesDestroyList(pStmt->pOrderByList); - nodesDestroyNode((SNode*)pStmt->pLimit); - nodesDestroyNode((SNode*)pStmt->pSlimit); - nodesDestroyList(pStmt->pHint); -} - -void destoryVnodeModifyOpStmt(SNode* pNode) { - SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)pNode; - destroyVgDataBlockArray(pStmt->pDataBlocks); - taosMemoryFreeClear(pStmt->pTableMeta); - nodesDestroyNode(pStmt->pTagCond); - taosArrayDestroy(pStmt->pTableTag); - taosHashCleanup(pStmt->pVgroupsHashObj); - taosHashCleanup(pStmt->pSubTableHashObj); - taosHashCleanup(pStmt->pTableNameHashObj); - taosHashCleanup(pStmt->pDbFNameHashObj); - taosHashCleanup(pStmt->pTableCxtHashObj); - if (pStmt->freeHashFunc) { - pStmt->freeHashFunc(pStmt->pTableBlockHashObj); - } - if (pStmt->freeArrayFunc) { - pStmt->freeArrayFunc(pStmt->pVgDataBlocks); - } - tdDestroySVCreateTbReq(pStmt->pCreateTblReq); - taosMemoryFreeClear(pStmt->pCreateTblReq); - if (pStmt->freeStbRowsCxtFunc) { - pStmt->freeStbRowsCxtFunc(pStmt->pStbRowsCxt); - } - taosMemoryFreeClear(pStmt->pStbRowsCxt); - taosCloseFile(&pStmt->fp); -} - -void destoryCreateDatabaseStmt(SNode* pNode) { nodesDestroyNode((SNode*)((SCreateDatabaseStmt*)pNode)->pOptions); } - -void destoryAlterDatabaseStmt(SNode* pNode) { nodesDestroyNode((SNode*)((SAlterDatabaseStmt*)pNode)->pOptions); } - -void destoryCreateTableStmt(SNode* pNode) { - SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode; - nodesDestroyList(pStmt->pCols); - nodesDestroyList(pStmt->pTags); - nodesDestroyNode((SNode*)pStmt->pOptions); -} - -void destoryCreateSubTableClause(SNode* pNode) { - SCreateSubTableClause* pStmt = (SCreateSubTableClause*)pNode; - nodesDestroyList(pStmt->pSpecificTags); - nodesDestroyList(pStmt->pValsOfTags); - nodesDestroyNode((SNode*)pStmt->pOptions); -} - -void destoryCreateMultiTablesStmt(SNode* pNode) { - nodesDestroyList(((SCreateMultiTablesStmt*)pNode)->pSubTables); -} - -void destoryDropTableStmt(SNode* pNode) { - nodesDestroyList(((SDropTableStmt*)pNode)->pTables); -} - -void destoryAlterTableStmt(SNode* pNode) { - SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode; - nodesDestroyNode((SNode*)pStmt->pOptions); - nodesDestroyNode((SNode*)pStmt->pVal); -} - -void destoryCreateUserStmt(SNode* pNode) { - SCreateUserStmt* pStmt = (SCreateUserStmt*)pNode; - taosMemoryFree(pStmt->pIpRanges); - nodesDestroyList(pStmt->pNodeListIpRanges); -} - -void destoryAlterUserStmt(SNode* pNode) { - SAlterUserStmt* pStmt = (SAlterUserStmt*)pNode; - taosMemoryFree(pStmt->pIpRanges); - nodesDestroyList(pStmt->pNodeListIpRanges); -} - -void destoryCreateIndexStmt(SNode* pNode) { - SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode; - nodesDestroyNode((SNode*)pStmt->pOptions); - nodesDestroyList(pStmt->pCols); - if (pStmt->pReq) { - tFreeSMCreateSmaReq(pStmt->pReq); - taosMemoryFreeClear(pStmt->pReq); - } -} - -void destoryCreateTopicStmt(SNode* pNode) { - nodesDestroyNode(((SCreateTopicStmt*)pNode)->pQuery); - nodesDestroyNode(((SCreateTopicStmt*)pNode)->pWhere); -} - -void destoryExplainStmt(SNode* pNode) { - SExplainStmt* pStmt = (SExplainStmt*)pNode; - nodesDestroyNode((SNode*)pStmt->pOptions); - nodesDestroyNode(pStmt->pQuery); -} - -void destoryDescribeStmt(SNode* pNode) { - taosMemoryFree(((SDescribeStmt*)pNode)->pMeta); -} - -void destoryCompactDatabaseStmt(SNode* pNode) { - SCompactDatabaseStmt* pStmt = (SCompactDatabaseStmt*)pNode; - nodesDestroyNode(pStmt->pStart); - nodesDestroyNode(pStmt->pEnd); -} - -void destoryCreateStreamStmt(SNode* pNode) { - SCreateStreamStmt* pStmt = (SCreateStreamStmt*)pNode; - nodesDestroyNode((SNode*)pStmt->pOptions); - nodesDestroyNode(pStmt->pQuery); - nodesDestroyList(pStmt->pTags); - nodesDestroyNode(pStmt->pSubtable); - tFreeSCMCreateStreamReq(pStmt->pReq); - taosMemoryFreeClear(pStmt->pReq); -} - -void destoryRedistributeVgroupStmt(SNode* pNode) { - nodesDestroyList(((SRedistributeVgroupStmt*)pNode)->pDnodes); -} - -void destoryGrantStmt(SNode* pNode) { - nodesDestroyNode(((SGrantStmt*)pNode)->pTagCond); -} - -void destoryRevokeStmt(SNode* pNode) { - nodesDestroyNode(((SRevokeStmt*)pNode)->pTagCond); -} - -void destoryShowStmt(SNode* pNode) { - SShowStmt* pStmt = (SShowStmt*)pNode; - nodesDestroyNode(pStmt->pDbName); - nodesDestroyNode(pStmt->pTbName); -} - -void destoryShowTableTagsStmt(SNode* pNode) { - SShowTableTagsStmt* pStmt = (SShowTableTagsStmt*)pNode; - nodesDestroyNode(pStmt->pDbName); - nodesDestroyNode(pStmt->pTbName); - nodesDestroyList(pStmt->pTags); -} - -void destoryShowDnodeVariablesStmt(SNode* pNode) { - nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pDnodeId); - nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pLikePattern); -} - -void destoryShowCreateDatabaseStmt(SNode* pNode) { - taosMemoryFreeClear(((SShowCreateDatabaseStmt*)pNode)->pCfg); -} - -void destoryShowCreateTableStmt(SNode* pNode) { - STableCfg* pCfg = (STableCfg*)(((SShowCreateTableStmt*)pNode)->pTableCfg); - taosMemoryFreeClear(((SShowCreateTableStmt*)pNode)->pDbCfg); - if (NULL == pCfg) { - return; - } - taosArrayDestroy(pCfg->pFuncs); - taosMemoryFree(pCfg->pComment); - taosMemoryFree(pCfg->pSchemas); - taosMemoryFree(pCfg->pTags); - taosMemoryFree(pCfg); -} - -void destoryDeleteStmt(SNode* pNode) { - SDeleteStmt* pStmt = (SDeleteStmt*)pNode; - nodesDestroyNode(pStmt->pFromTable); - nodesDestroyNode(pStmt->pWhere); - nodesDestroyNode(pStmt->pCountFunc); - nodesDestroyNode(pStmt->pFirstFunc); - nodesDestroyNode(pStmt->pLastFunc); - nodesDestroyNode(pStmt->pTagCond); -} - -void destoryInsertStmt(SNode* pNode) { - SInsertStmt* pStmt = (SInsertStmt*)pNode; - nodesDestroyNode(pStmt->pTable); - nodesDestroyList(pStmt->pCols); - nodesDestroyNode(pStmt->pQuery); -} - -void destoryQueryNode(SNode* pNode) { - SQuery* pQuery = (SQuery*)pNode; - nodesDestroyNode(pQuery->pPrevRoot); - nodesDestroyNode(pQuery->pRoot); - nodesDestroyNode(pQuery->pPostRoot); - taosMemoryFreeClear(pQuery->pResSchema); - if (NULL != pQuery->pCmdMsg) { - taosMemoryFreeClear(pQuery->pCmdMsg->pMsg); - taosMemoryFreeClear(pQuery->pCmdMsg); - } - taosArrayDestroy(pQuery->pDbList); - taosArrayDestroy(pQuery->pTableList); - taosArrayDestroy(pQuery->pTargetTableList); - taosArrayDestroy(pQuery->pPlaceholderValues); - nodesDestroyNode(pQuery->pPrepareRoot); -} - -void destoryCreateViewStmt(SNode* pNode) { - SCreateViewStmt* pStmt = (SCreateViewStmt*)pNode; - taosMemoryFree(pStmt->pQuerySql); - tFreeSCMCreateViewReq(&pStmt->createReq); - nodesDestroyNode(pStmt->pQuery); -} - -void destoryScanLogicNode(SNode* pNode) { - SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pScanCols); - nodesDestroyList(pLogicNode->pScanPseudoCols); - taosMemoryFreeClear(pLogicNode->pVgroupList); - nodesDestroyList(pLogicNode->pDynamicScanFuncs); - nodesDestroyNode(pLogicNode->pTagCond); - nodesDestroyNode(pLogicNode->pTagIndexCond); - taosArrayDestroyEx(pLogicNode->pSmaIndexes, destroyDataInSmaIndex); - nodesDestroyList(pLogicNode->pGroupTags); - nodesDestroyList(pLogicNode->pTags); - nodesDestroyNode(pLogicNode->pSubtable); -} - -void destoryJoinLogicNode(SNode* pNode) { - SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyNode(pLogicNode->pPrimKeyEqCond); - nodesDestroyNode(pLogicNode->pOtherOnCond); - nodesDestroyNode(pLogicNode->pColEqCond); -} - -void destoryAggLogicNode(SNode* pNode) { - SAggLogicNode* pLogicNode = (SAggLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pAggFuncs); - nodesDestroyList(pLogicNode->pGroupKeys); -} - -void destoryProjectLogicNode(SNode* pNode) { - SProjectLogicNode* pLogicNode = (SProjectLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pProjections); -} - -void destoryVnodeModifyLogicNode(SNode* pNode) { - SVnodeModifyLogicNode* pLogicNode = (SVnodeModifyLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - destroyVgDataBlockArray(pLogicNode->pDataBlocks); - // pVgDataBlocks is weak reference - nodesDestroyNode(pLogicNode->pAffectedRows); - nodesDestroyNode(pLogicNode->pStartTs); - nodesDestroyNode(pLogicNode->pEndTs); - taosMemoryFreeClear(pLogicNode->pVgroupList); - nodesDestroyList(pLogicNode->pInsertCols); -} - -void destoryExchangeLogicNode(SNode* pNode) { - destroyLogicNode((SLogicNode*)pNode); -} - -void destoryMergeLogicNode(SNode* pNode) { - SMergeLogicNode* pLogicNode = (SMergeLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pMergeKeys); - nodesDestroyList(pLogicNode->pInputs); -} - -void destoryWindowLogicNode(SNode* pNode) { - SWindowLogicNode* pLogicNode = (SWindowLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pFuncs); - nodesDestroyNode(pLogicNode->pTspk); - nodesDestroyNode(pLogicNode->pTsEnd); - nodesDestroyNode(pLogicNode->pStateExpr); - nodesDestroyNode(pLogicNode->pStartCond); - nodesDestroyNode(pLogicNode->pEndCond); -} - -void destoryFillLogicNode(SNode* pNode) { - SFillLogicNode* pLogicNode = (SFillLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyNode(pLogicNode->pWStartTs); - nodesDestroyNode(pLogicNode->pValues); - nodesDestroyList(pLogicNode->pFillExprs); - nodesDestroyList(pLogicNode->pNotFillExprs); -} - -void destorySortLogicNode(SNode* pNode) { - SSortLogicNode* pLogicNode = (SSortLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pSortKeys); -} - -void destoryPartitionLogicNode(SNode* pNode) { - SPartitionLogicNode* pLogicNode = (SPartitionLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pPartitionKeys); - nodesDestroyList(pLogicNode->pTags); - nodesDestroyNode(pLogicNode->pSubtable); - nodesDestroyList(pLogicNode->pAggFuncs); -} - -void destoryIndefRowsFuncLogicNode(SNode* pNode) { - SIndefRowsFuncLogicNode* pLogicNode = (SIndefRowsFuncLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pFuncs); -} - -void destoryInterpFuncLogicNode(SNode* pNode) { - SInterpFuncLogicNode* pLogicNode = (SInterpFuncLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pFuncs); - nodesDestroyNode(pLogicNode->pFillValues); - nodesDestroyNode(pLogicNode->pTimeSeries); -} - -void destoryGroupCacheLogicNode(SNode* pNode) { - SGroupCacheLogicNode* pLogicNode = (SGroupCacheLogicNode*)pNode; - destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyList(pLogicNode->pGroupCols); -} - -void destoryDynQueryCtrlLogicNode(SNode* pNode) { - destroyLogicNode((SLogicNode*)pNode); -} - -void destoryLogicSubplan(SNode* pNode) { - SLogicSubplan* pSubplan = (SLogicSubplan*)pNode; - nodesDestroyList(pSubplan->pChildren); - nodesDestroyNode((SNode*)pSubplan->pNode); - nodesClearList(pSubplan->pParents); - taosMemoryFreeClear(pSubplan->pVgroupList); -} - -void destoryQueryLogicPlan(SNode* pNode) { - nodesDestroyList(((SQueryLogicPlan*)pNode)->pTopSubplans); -} - -void destroyScanPhysiNode(SNode* pInput) { - SScanPhysiNode* pNode = (SScanPhysiNode*)pInput; - destroyPhysiNode(pInput); - nodesDestroyList(pNode->pScanCols); - nodesDestroyList(pNode->pScanPseudoCols); -} - -void destoryLastRowScanPhysiNode(SNode* pNode) { - SLastRowScanPhysiNode* pPhyNode = (SLastRowScanPhysiNode*)pNode; - destroyScanPhysiNode(pNode); - nodesDestroyList(pPhyNode->pGroupTags); - nodesDestroyList(pPhyNode->pTargets); -} - -void destoryTableScanPhysiNode(SNode* pNode) { - STableScanPhysiNode* pPhyNode = (STableScanPhysiNode*)pNode; - destroyScanPhysiNode(pNode); - nodesDestroyList(pPhyNode->pDynamicScanFuncs); - nodesDestroyList(pPhyNode->pGroupTags); - nodesDestroyList(pPhyNode->pTags); - nodesDestroyNode(pPhyNode->pSubtable); -} - -void destoryProjectPhysiNode(SNode* pNode) { - SProjectPhysiNode* pPhyNode = (SProjectPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pProjections); -} - -void destorySortMergeJoinPhysiNode(SNode* pNode) { - SSortMergeJoinPhysiNode* pPhyNode = (SSortMergeJoinPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyNode(pPhyNode->pPrimKeyCond); - nodesDestroyNode(pPhyNode->pOtherOnCond); - nodesDestroyList(pPhyNode->pTargets); - nodesDestroyNode(pPhyNode->pColEqCond); -} - -void destoryHashJoinPhysiNode(SNode* pNode) { - SHashJoinPhysiNode* pPhyNode = (SHashJoinPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pOnLeft); - nodesDestroyList(pPhyNode->pOnRight); - nodesDestroyNode(pPhyNode->pFilterConditions); - nodesDestroyList(pPhyNode->pTargets); - - nodesDestroyNode(pPhyNode->pPrimKeyCond); - nodesDestroyNode(pPhyNode->pColEqCond); - nodesDestroyNode(pPhyNode->pTagEqCond); -} - -void destoryAggPhysiNode(SNode* pNode) { - SAggPhysiNode* pPhyNode = (SAggPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pExprs); - nodesDestroyList(pPhyNode->pAggFuncs); - nodesDestroyList(pPhyNode->pGroupKeys); -} - -void destoryExchangePhysiNode(SNode* pNode) { - SExchangePhysiNode* pPhyNode = (SExchangePhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pSrcEndPoints); -} - -void destoryMergePhysiNode(SNode* pNode) { - SMergePhysiNode* pPhyNode = (SMergePhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pMergeKeys); - nodesDestroyList(pPhyNode->pTargets); -} - -void destorySortPhysiNode(SNode* pNode) { - SSortPhysiNode* pPhyNode = (SSortPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pExprs); - nodesDestroyList(pPhyNode->pSortKeys); - nodesDestroyList(pPhyNode->pTargets); -} - -void destroyWindowPhysiNode(SNode* pInput) { - SWindowPhysiNode* pNode = (SWindowPhysiNode*)pInput; - destroyPhysiNode(pInput); - nodesDestroyList(pNode->pExprs); - nodesDestroyList(pNode->pFuncs); - nodesDestroyNode(pNode->pTspk); - nodesDestroyNode(pNode->pTsEnd); -} - -void destoryFillPhysiNode(SNode* pNode) { - SFillPhysiNode* pPhyNode = (SFillPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pFillExprs); - nodesDestroyList(pPhyNode->pNotFillExprs); - nodesDestroyNode(pPhyNode->pWStartTs); - nodesDestroyNode(pPhyNode->pValues); -} - -void destoryStateWindowPhysiNode(SNode* pNode) { - SStateWinodwPhysiNode* pPhyNode = (SStateWinodwPhysiNode*)pNode; - destroyWindowPhysiNode(pNode); - nodesDestroyNode(pPhyNode->pStateKey); -} - -void destoryEventWindowPhysiNode(SNode* pNode) { - SEventWinodwPhysiNode* pPhyNode = (SEventWinodwPhysiNode*)pNode; - destroyWindowPhysiNode(pNode); - nodesDestroyNode(pPhyNode->pStartCond); - nodesDestroyNode(pPhyNode->pEndCond); -} - -void destroyPartitionPhysiNode(SNode* pNode) { - SPartitionPhysiNode* pPartitionNode = (SPartitionPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPartitionNode->pExprs); - nodesDestroyList(pPartitionNode->pPartitionKeys); - nodesDestroyList(pPartitionNode->pTargets); -} - -void destoryStreamPartitionPhysiNode(SNode* pNode) { - SStreamPartitionPhysiNode* pPhyNode = (SStreamPartitionPhysiNode*)pNode; - destroyPartitionPhysiNode(pNode); - nodesDestroyList(pPhyNode->pTags); - nodesDestroyNode(pPhyNode->pSubtable); -} - -void destoryIndefRowsFuncPhysiNode(SNode* pNode) { - SIndefRowsFuncPhysiNode* pPhyNode = (SIndefRowsFuncPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pExprs); - nodesDestroyList(pPhyNode->pFuncs); -} - -void destoryInterpFuncPhysiNode(SNode* pNode) { - SInterpFuncPhysiNode* pPhyNode = (SInterpFuncPhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pExprs); - nodesDestroyList(pPhyNode->pFuncs); - nodesDestroyNode(pPhyNode->pFillValues); - nodesDestroyNode(pPhyNode->pTimeSeries); -} - -void destroyDataSinkNode(SNode* pNode) { - SDataSinkNode* pDataNode = (SDataSinkNode*)pNode; - nodesDestroyNode((SNode*)pDataNode->pInputDataBlockDesc); -} - -void destoryDataInserterNode(SNode* pNode) { - SDataInserterNode* pSink = (SDataInserterNode*)pNode; - destroyDataSinkNode(pNode); - taosMemoryFreeClear(pSink->pData); -} - -void destoryQueryInserterNode(SNode* pNode) { - SQueryInserterNode* pSink = (SQueryInserterNode*)pNode; - destroyDataSinkNode(pNode); - nodesDestroyList(pSink->pCols); -} - -void destoryDataDeleterNode(SNode* pNode) { - SDataDeleterNode* pSink = (SDataDeleterNode*)pNode; - destroyDataSinkNode(pNode); - nodesDestroyNode(pSink->pAffectedRows); - nodesDestroyNode(pSink->pStartTs); - nodesDestroyNode(pSink->pEndTs); -} - -void destoryGroupCachePhysiNode(SNode* pNode) { - SGroupCachePhysiNode* pPhyNode = (SGroupCachePhysiNode*)pNode; - destroyPhysiNode(pNode); - nodesDestroyList(pPhyNode->pGroupCols); -} - -void destoryDynQueryCtrlPhysiNode(SNode* pNode) { - destroyPhysiNode(pNode); -} - -void destorySubplanNode(SNode* pNode) { - SSubplan* pSubplan = (SSubplan*)pNode; - nodesClearList(pSubplan->pChildren); - nodesDestroyNode((SNode*)pSubplan->pNode); - nodesDestroyNode((SNode*)pSubplan->pDataSink); - nodesDestroyNode((SNode*)pSubplan->pTagCond); - nodesDestroyNode((SNode*)pSubplan->pTagIndexCond); - nodesClearList(pSubplan->pParents); -} - -void destoryPlanNode(SNode* pNode) { - nodesDestroyList(((SQueryPlan*)pNode)->pSubplans); -} - -void nodesDestroyNode(SNode* pNode) { - if (NULL == pNode) { - return; - } - - int32_t type = nodeType(pNode); - if (!funcArrayCheck(type)) { - return; - } - if (funcNodes[type].destoryFunc) { - funcNodes[type].destoryFunc(pNode); - nodesFree(pNode); - return; - } - nodesWarn("nodesDestroyNode unknown type = %d", type); - nodesFree(pNode); - return; -} - -// clang-format off -static void doInitNodeFuncArray() { - setFunc("Column", - QUERY_NODE_COLUMN, - sizeof(SColumnNode), - columnNodeToJson, - jsonToColumnNode, - destroyColumnNode - ); - setFunc("Value", - QUERY_NODE_VALUE, - sizeof(SValueNode), - valueNodeToJson, - jsonToValueNode, - destroyValueNode - ); - setFunc("Operator", - QUERY_NODE_OPERATOR, - sizeof(SOperatorNode), - operatorNodeToJson, - jsonToOperatorNode, - destroyOperatorNode - ); - setFunc("LogicCondition", - QUERY_NODE_LOGIC_CONDITION, - sizeof(SLogicConditionNode), - logicConditionNodeToJson, - jsonToLogicConditionNode, - destoryLogicConditionNode - ); - setFunc("Function", - QUERY_NODE_FUNCTION, - sizeof(SFunctionNode), - functionNodeToJson, - jsonToFunctionNode, - destoryFunctionNode - ); - setFunc("RealTable", - QUERY_NODE_REAL_TABLE, - sizeof(SRealTableNode), - realTableNodeToJson, - jsonToRealTableNode, - destoryRealTableNode - ); - setFunc("TempTable", - QUERY_NODE_TEMP_TABLE, - sizeof(STempTableNode), - tempTableNodeToJson, - jsonToTempTableNode, - destoryTempTableNode - ); - setFunc("JoinTable", - QUERY_NODE_JOIN_TABLE, - sizeof(SJoinTableNode), - joinTableNodeToJson, - jsonToJoinTableNode, - destoryJoinTableNode - ); - setFunc("GroupingSet", - QUERY_NODE_GROUPING_SET, - sizeof(SGroupingSetNode), - groupingSetNodeToJson, - jsonToGroupingSetNode, - destoryGroupingSetNode - ); - setFunc("OrderByExpr", - QUERY_NODE_ORDER_BY_EXPR, - sizeof(SOrderByExprNode), - orderByExprNodeToJson, - jsonToOrderByExprNode, - destoryOrderByExprNode - ); - setFunc("Limit", - QUERY_NODE_LIMIT, - sizeof(SLimitNode), - limitNodeToJson, - jsonToLimitNode, - destoryXNode - ); - setFunc("StateWindow", - QUERY_NODE_STATE_WINDOW, - sizeof(SStateWindowNode), - stateWindowNodeToJson, - jsonToStateWindowNode, - destoryStateWindowNode - ); - setFunc("SessionWinow", - QUERY_NODE_SESSION_WINDOW, - sizeof(SSessionWindowNode), - sessionWindowNodeToJson, - jsonToSessionWindowNode, - destorySessionWindowNode - ); - setFunc("IntervalWindow", - QUERY_NODE_INTERVAL_WINDOW, - sizeof(SIntervalWindowNode), - intervalWindowNodeToJson, - jsonToIntervalWindowNode, - destoryIntervalWindowNode - ); - setFunc("NodeList", - QUERY_NODE_NODE_LIST, - sizeof(SNodeListNode), - nodeListNodeToJson, - jsonToNodeListNode, - destoryNodeListNode - ); - setFunc("Fill", - QUERY_NODE_FILL, - sizeof(SFillNode), - fillNodeToJson, - jsonToFillNode, - destoryFillNode - ); - setFunc("RawExpr", - QUERY_NODE_RAW_EXPR, - sizeof(SRawExprNode), - emptyNodeToJson, - emptyJsonToNode, - destoryRawExprNode - ); - setFunc("Target", - QUERY_NODE_TARGET, - sizeof(STargetNode), - targetNodeToJson, - jsonToTargetNode, - destoryTargetNode - ); - setFunc("DataBlockDesc", - QUERY_NODE_DATABLOCK_DESC, - sizeof(SDataBlockDescNode), - dataBlockDescNodeToJson, - jsonToDataBlockDescNode, - destoryDataBlockDescNode - ); - setFunc("SlotDesc", - QUERY_NODE_SLOT_DESC, - sizeof(SSlotDescNode), - slotDescNodeToJson, - jsonToSlotDescNode, - destoryXNode - ); - setFunc("ColumnDef", - QUERY_NODE_COLUMN_DEF, - sizeof(SColumnDefNode), - columnDefNodeToJson, - jsonToColumnDefNode, - destoryXNode - ); - setFunc("DownstreamSource", - QUERY_NODE_DOWNSTREAM_SOURCE, - sizeof(SDownstreamSourceNode), - downstreamSourceNodeToJson, - jsonToDownstreamSourceNode, - destoryXNode - ); - setFunc("DatabaseOptions", - QUERY_NODE_DATABASE_OPTIONS, - sizeof(SDatabaseOptions), - databaseOptionsToJson, - jsonToDatabaseOptions, - destoryDatabaseOptions - ); - setFunc("TableOptions", - QUERY_NODE_TABLE_OPTIONS, - sizeof(STableOptions), - tableOptionsToJson, - jsonToTableOptions, - destoryTableOptions - ); - setFunc("IndexOptions", - QUERY_NODE_INDEX_OPTIONS, - sizeof(SIndexOptions), - indexOptionsToJson, - jsonToIndexOptions, - destoryIndexOptions - ); - setFunc("ExplainOptions", - QUERY_NODE_EXPLAIN_OPTIONS, - sizeof(SExplainOptions), - explainOptionsToJson, - jsonToExplainOptions, - destoryXNode - ); - setFunc("StreamOptions", - QUERY_NODE_STREAM_OPTIONS, - sizeof(SStreamOptions), - streamOptionsToJson, - jsonToStreamOptions, - destoryStreamOptions - ); - setFunc("LeftValue", - QUERY_NODE_LEFT_VALUE, - sizeof(SLeftValueNode), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("ColumnRef", - QUERY_NODE_COLUMN_REF, - sizeof(SColumnDefNode), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("WhenThen", - QUERY_NODE_WHEN_THEN, - sizeof(SWhenThenNode), - whenThenNodeToJson, - jsonToWhenThenNode, - destoryWhenThenNode - ); - setFunc("CaseWhen", - QUERY_NODE_CASE_WHEN, - sizeof(SCaseWhenNode), - caseWhenNodeToJson, - jsonToCaseWhenNode, - destoryCaseWhenNode - ); - setFunc("EventWindow", - QUERY_NODE_EVENT_WINDOW, - sizeof(SEventWindowNode), - eventWindowNodeToJson, - jsonToEventWindowNode, - destoryEventWindowNode - ); - setFunc("HintNode", - QUERY_NODE_HINT, - sizeof(SHintNode), - emptyNodeToJson, - emptyJsonToNode, - destoryHintNode - ); - setFunc("ViewNode", - QUERY_NODE_VIEW, - sizeof(SViewNode), - emptyNodeToJson, - emptyJsonToNode, - destoryViewNode - ); - setFunc("SetOperator", - QUERY_NODE_SET_OPERATOR, - sizeof(SSetOperator), - setOperatorToJson, - jsonToSetOperator, - destorySetOperator - ); - setFunc("SelectStmt", - QUERY_NODE_SELECT_STMT, - sizeof(SSelectStmt), - selectStmtToJson, - jsonToSelectStmt, - destorySelectStmt - ); - setFunc("VnodeModifyStmt", - QUERY_NODE_VNODE_MODIFY_STMT, - sizeof(SVnodeModifyOpStmt), - vnodeModifyStmtToJson, - jsonToVnodeModifyStmt, - destoryVnodeModifyOpStmt - ); - setFunc("CreateDatabaseStmt", - QUERY_NODE_CREATE_DATABASE_STMT, - sizeof(SCreateDatabaseStmt), - createDatabaseStmtToJson, - jsonToCreateDatabaseStmt, - destoryCreateDatabaseStmt - ); - setFunc("DropDatabaseStmt", - QUERY_NODE_DROP_DATABASE_STMT, - sizeof(SDropDatabaseStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("AlterDatabaseStmt", - QUERY_NODE_ALTER_DATABASE_STMT, - sizeof(SAlterDatabaseStmt), - alterDatabaseStmtToJson, - jsonToAlterDatabaseStmt, - destoryAlterDatabaseStmt - ); - setFunc("FlushDatabaseStmt", - QUERY_NODE_FLUSH_DATABASE_STMT, - sizeof(SFlushDatabaseStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("TrimDatabaseStmt", - QUERY_NODE_TRIM_DATABASE_STMT, - sizeof(STrimDatabaseStmt), - trimDatabaseStmtToJson, - jsonToTrimDatabaseStmt, - destoryXNode - ); - setFunc("CreateTableStmt", - QUERY_NODE_CREATE_TABLE_STMT, - sizeof(SCreateTableStmt), - createTableStmtToJson, - jsonToCreateTableStmt, - destoryCreateTableStmt - ); - setFunc("CreateSubtableClause", - QUERY_NODE_CREATE_SUBTABLE_CLAUSE, - sizeof(SCreateSubTableClause), - createSubTableClauseToJson, - jsonToCreateSubTableClause, - destoryCreateSubTableClause - ); - setFunc("CreateMultiTableStmt", - QUERY_NODE_CREATE_MULTI_TABLES_STMT, - sizeof(SCreateMultiTablesStmt), - createMultiTablesStmtToJson, - jsonToCreateMultiTablesStmt, - destoryCreateMultiTablesStmt - ); - setFunc("DropTableClause", - QUERY_NODE_DROP_TABLE_CLAUSE, - sizeof(SDropTableClause), - dropTableClauseToJson, - jsonToDropTableClause, - destoryXNode - ); - setFunc("DropTableStmt", - QUERY_NODE_DROP_TABLE_STMT, - sizeof(SDropTableStmt), - dropTableStmtToJson, - jsonToDropTableStmt, - destoryDropTableStmt - ); - setFunc("DropSuperTableStmt", - QUERY_NODE_DROP_SUPER_TABLE_STMT, - sizeof(SDropSuperTableStmt), - dropStableStmtToJson, - jsonToDropStableStmt, - destoryXNode - ); - setFunc("AlterTableStmt", - QUERY_NODE_ALTER_TABLE_STMT, - sizeof(SAlterTableStmt), - alterTableStmtToJson, - jsonToAlterTableStmt, - destoryAlterTableStmt - ); - setFunc("AlterSuperTableStmt", - QUERY_NODE_ALTER_SUPER_TABLE_STMT, - sizeof(SAlterTableStmt), - alterStableStmtToJson, - jsonToAlterStableStmt, - destoryAlterTableStmt - ); - setFunc("CreateUserStmt", - QUERY_NODE_CREATE_USER_STMT, - sizeof(SCreateUserStmt), - createUserStmtToJson, - jsonToCreateUserStmt, - destoryCreateUserStmt - ); - setFunc("AlterUserStmt", - QUERY_NODE_ALTER_USER_STMT, - sizeof(SAlterUserStmt), - alterUserStmtToJson, - jsonToAlterUserStmt, - destoryAlterUserStmt - ); - setFunc("DropUserStmt", - QUERY_NODE_DROP_USER_STMT, - sizeof(SDropUserStmt), - dropUserStmtToJson, - jsonToDropUserStmt, - destoryXNode - ); - setFunc("UseDatabaseStmt", - QUERY_NODE_USE_DATABASE_STMT, - sizeof(SUseDatabaseStmt), - useDatabaseStmtToJson, - jsonToUseDatabaseStmt, - destoryXNode - ); - setFunc("CreateDnodeStmt", - QUERY_NODE_CREATE_DNODE_STMT, - sizeof(SCreateDnodeStmt), - createDnodeStmtToJson, - jsonToCreateDnodeStmt, - destoryXNode - ); - setFunc("DropDnodeStmt", - QUERY_NODE_DROP_DNODE_STMT, - sizeof(SDropDnodeStmt), - dropDnodeStmtToJson, - jsonToDropDnodeStmt, - destoryXNode - ); - setFunc("AlterDnodeStmt", - QUERY_NODE_ALTER_DNODE_STMT, - sizeof(SAlterDnodeStmt), - alterDnodeStmtToJson, - jsonToAlterDnodeStmt, - destoryXNode - ); - setFunc("CreateIndexStmt", - QUERY_NODE_CREATE_INDEX_STMT, - sizeof(SCreateIndexStmt), - createIndexStmtToJson, - jsonToCreateIndexStmt, - destoryCreateIndexStmt - ); - setFunc("DropIndexStmt", - QUERY_NODE_DROP_INDEX_STMT, - sizeof(SDropIndexStmt), - dropIndexStmtToJson, - jsonToDropIndexStmt, - destoryXNode - ); - setFunc("CreateQnodeStmt", - QUERY_NODE_CREATE_QNODE_STMT, - sizeof(SCreateComponentNodeStmt), - createQnodeStmtToJson, - jsonToCreateQnodeStmt, - destoryXNode - ); - setFunc("DropQnodeStmt", - QUERY_NODE_DROP_QNODE_STMT, - sizeof(SDropComponentNodeStmt), - dropQnodeStmtToJson, - jsonToDropQnodeStmt, - destoryXNode - ); - setFunc("CreateBnodeStmt", - QUERY_NODE_CREATE_BNODE_STMT, - sizeof(SCreateComponentNodeStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("DropBnodeStmt", - QUERY_NODE_DROP_BNODE_STMT, - sizeof(SDropComponentNodeStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("CreateSnodeStmt", - QUERY_NODE_CREATE_SNODE_STMT, - sizeof(SCreateComponentNodeStmt), - createSnodeStmtToJson, - jsonToCreateSnodeStmt, - destoryXNode - ); - setFunc("DropSnodeStmt", - QUERY_NODE_DROP_SNODE_STMT, - sizeof(SDropComponentNodeStmt), - dropSnodeStmtToJson, - jsonToDropSnodeStmt, - destoryXNode - ); - setFunc("CreateMnodeStmt", - QUERY_NODE_CREATE_MNODE_STMT, - sizeof(SCreateComponentNodeStmt), - createMnodeStmtToJson, - jsonToCreateMnodeStmt, - destoryXNode - ); - setFunc("DropMnodeStmt", - QUERY_NODE_DROP_MNODE_STMT, - sizeof(SDropComponentNodeStmt), - dropMnodeStmtToJson, - jsonToDropMnodeStmt, - destoryXNode - ); - setFunc("CreateTopicStmt", - QUERY_NODE_CREATE_TOPIC_STMT, - sizeof(SCreateTopicStmt), - createTopicStmtToJson, - jsonToCreateTopicStmt, - destoryCreateTopicStmt - ); - setFunc("DropTopicStmt", - QUERY_NODE_DROP_TOPIC_STMT, - sizeof(SDropTopicStmt), - dropTopicStmtToJson, - jsonToDropTopicStmt, - destoryXNode - ); - setFunc("DropConsumerGroupStmt", - QUERY_NODE_DROP_CGROUP_STMT, - sizeof(SDropCGroupStmt), - dropConsumerGroupStmtToJson, - jsonToDropConsumerGroupStmt, - destoryXNode - ); - setFunc("AlterLocalStmt", - QUERY_NODE_ALTER_LOCAL_STMT, - sizeof(SAlterLocalStmt), - alterLocalStmtToJson, - jsonToAlterLocalStmt, - destoryXNode - ); - setFunc("ExplainStmt", - QUERY_NODE_EXPLAIN_STMT, - sizeof(SExplainStmt), - explainStmtToJson, - jsonToExplainStmt, - destoryExplainStmt - ); - setFunc("DescribeStmt", - QUERY_NODE_DESCRIBE_STMT, - sizeof(SDescribeStmt), - describeStmtToJson, - jsonToDescribeStmt, - destoryDescribeStmt - ); - setFunc("QueryCacheStmt", - QUERY_NODE_RESET_QUERY_CACHE_STMT, - sizeof(SNode), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("CompactDatabaseStmt", - QUERY_NODE_COMPACT_DATABASE_STMT, - sizeof(SCompactDatabaseStmt), - compactDatabaseStmtToJson, - jsonToCompactDatabaseStmt, - destoryCompactDatabaseStmt - ); - setFunc("CreateFunctionStmt", - QUERY_NODE_CREATE_FUNCTION_STMT, - sizeof(SCreateFunctionStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("DropFunctionStmt", - QUERY_NODE_DROP_FUNCTION_STMT, - sizeof(SDropFunctionStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("CreateStreamStmt", - QUERY_NODE_CREATE_STREAM_STMT, - sizeof(SCreateStreamStmt), - createStreamStmtToJson, - jsonToCreateStreamStmt, - destoryCreateStreamStmt - ); - setFunc("DropStreamStmt", - QUERY_NODE_DROP_STREAM_STMT, - sizeof(SDropStreamStmt), - dropStreamStmtToJson, - jsonToDropStreamStmt, - destoryXNode - ); - setFunc("PauseStreamStmt", - QUERY_NODE_PAUSE_STREAM_STMT, - sizeof(SPauseStreamStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("ResumeStreamStmt", - QUERY_NODE_RESUME_STREAM_STMT, - sizeof(SResumeStreamStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("BalanceVgroupStmt", - QUERY_NODE_BALANCE_VGROUP_STMT, - sizeof(SBalanceVgroupStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("BalanceVgroupLeaderStmt", - QUERY_NODE_BALANCE_VGROUP_LEADER_STMT, - sizeof(SBalanceVgroupLeaderStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("MergeVgroupStmt", - QUERY_NODE_MERGE_VGROUP_STMT, - sizeof(SMergeVgroupStmt), - mergeVgroupStmtToJson, - jsonToMergeVgroupStmt, - destoryXNode - ); - setFunc("RedistributeVgroupStmt", - QUERY_NODE_REDISTRIBUTE_VGROUP_STMT, - sizeof(SRedistributeVgroupStmt), - redistributeVgroupStmtToJson, - jsonToRedistributeVgroupStmt, - destoryRedistributeVgroupStmt - ); - setFunc("SplitVgroupStmt", - QUERY_NODE_SPLIT_VGROUP_STMT, - sizeof(SSplitVgroupStmt), - splitVgroupStmtToJson, - jsonToSplitVgroupStmt, - destoryXNode - ); - setFunc("SyncDBStmt", - QUERY_NODE_SYNCDB_STMT, - 0, - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("GrantStmt", - QUERY_NODE_GRANT_STMT, - sizeof(SGrantStmt), - grantStmtToJson, - jsonToGrantStmt, - destoryGrantStmt - ); - setFunc("RevokeStmt", - QUERY_NODE_REVOKE_STMT, - sizeof(SRevokeStmt), - revokeStmtToJson, - jsonToRevokeStmt, - destoryRevokeStmt - ); - setFunc("ShowDnodesStmt", - QUERY_NODE_SHOW_DNODES_STMT, - sizeof(SShowStmt), - showDnodesStmtToJson, - jsonToShowDnodesStmt, - destoryShowStmt - ); - setFunc("ShowMnodesStmt", - QUERY_NODE_SHOW_MNODES_STMT, - sizeof(SShowStmt), - showMnodesStmtToJson, - jsonToShowMnodesStmt, - destoryShowStmt - ); - setFunc("ShowModulesStmt", - QUERY_NODE_SHOW_MODULES_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowQnodesStmt", - QUERY_NODE_SHOW_QNODES_STMT, - sizeof(SShowStmt), - showQnodesStmtToJson, - jsonToShowQnodesStmt, - destoryShowStmt - ); - setFunc("ShowSnodesStmt", - QUERY_NODE_SHOW_SNODES_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowBnodesStmt", - QUERY_NODE_SHOW_BNODES_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowClusterStmt", - QUERY_NODE_SHOW_CLUSTER_STMT, - sizeof(SShowStmt), - showClusterStmtToJson, - jsonToShowClusterStmt, - destoryShowStmt - ); - setFunc("ShowDatabaseStmt", - QUERY_NODE_SHOW_DATABASES_STMT, - sizeof(SShowStmt), - showDatabasesStmtToJson, - jsonToShowDatabasesStmt, - destoryShowStmt - ); - setFunc("ShowFunctionsStmt", - QUERY_NODE_SHOW_FUNCTIONS_STMT, - sizeof(SShowStmt), - showFunctionsStmtToJson, - jsonToShowFunctionsStmt, - destoryShowStmt - ); - setFunc("ShowIndexesStmt", - QUERY_NODE_SHOW_INDEXES_STMT, - sizeof(SShowStmt), - showIndexesStmtToJson, - jsonToShowIndexesStmt, - destoryShowStmt - ); - setFunc("ShowStablesStmt", - QUERY_NODE_SHOW_STABLES_STMT, - sizeof(SShowStmt), - showStablesStmtToJson, - jsonToShowStablesStmt, - destoryShowStmt - ); - setFunc("ShowStreamsStmt", - QUERY_NODE_SHOW_STREAMS_STMT, - sizeof(SShowStmt), - showStreamsStmtToJson, - jsonToShowStreamsStmt, - destoryShowStmt - ); - setFunc("ShowTablesStmt", - QUERY_NODE_SHOW_TABLES_STMT, - sizeof(SShowStmt), - showTablesStmtToJson, - jsonToShowTablesStmt, - destoryShowStmt - ); - setFunc("ShowTagsStmt", - QUERY_NODE_SHOW_TAGS_STMT, - sizeof(SShowStmt), - showTagsStmtToJson, - jsonToShowTagsStmt, - destoryShowStmt - ); - setFunc("ShowUsersStmt", - QUERY_NODE_SHOW_USERS_STMT, - sizeof(SShowStmt), - showUsersStmtToJson, - jsonToShowUsersStmt, - destoryShowStmt - ); - setFunc("ShowLicencesStmt", - QUERY_NODE_SHOW_LICENCES_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowVgroupsStmt", - QUERY_NODE_SHOW_VGROUPS_STMT, - sizeof(SShowStmt), - showVgroupsStmtToJson, - jsonToShowVgroupsStmt, - destoryShowStmt - ); - setFunc("ShowTopicsStmt", - QUERY_NODE_SHOW_TOPICS_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowConsumersStmt", - QUERY_NODE_SHOW_CONSUMERS_STMT, - sizeof(SShowStmt), - showConsumersStmtToJson, - jsonToShowConsumersStmt, - destoryShowStmt - ); - setFunc("ShowQueriesStmt", - QUERY_NODE_SHOW_QUERIES_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowConnectionsStmt", - QUERY_NODE_SHOW_CONNECTIONS_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowAppsStmt", - QUERY_NODE_SHOW_APPS_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowVariablesStmt", - QUERY_NODE_SHOW_VARIABLES_STMT, - sizeof(SShowStmt), - showVariablesStmtToJson, - jsonToShowVariablesStmt, - destoryShowStmt - ); - setFunc("ShowDnodeVariablesStmt", - QUERY_NODE_SHOW_DNODE_VARIABLES_STMT, - sizeof(SShowDnodeVariablesStmt), - showDnodeVariablesStmtToJson, - jsonToShowDnodeVariablesStmt, - destoryShowDnodeVariablesStmt - ); - setFunc("ShowTransactionsStmt", - QUERY_NODE_SHOW_TRANSACTIONS_STMT, - sizeof(SShowStmt), - showTransactionsStmtToJson, - jsonToShowTransactionsStmt, - destoryShowStmt - ); - setFunc("ShowSubscriptionsStmt", - QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT, - sizeof(SShowStmt), - showSubscriptionsStmtToJson, - jsonToShowSubscriptionsStmt, - destoryShowStmt - ); - setFunc("ShowVnodeStmt", - QUERY_NODE_SHOW_VNODES_STMT, - sizeof(SShowStmt), - showVnodesStmtToJson, - jsonToShowVnodesStmt, - destoryShowStmt - ); - setFunc("ShowUserPrivilegesStmt", - QUERY_NODE_SHOW_USER_PRIVILEGES_STMT, - sizeof(SShowStmt), - showUserPrivilegesStmtToJson, - jsonToShowUserPrivilegesStmt, - destoryShowStmt - ); - setFunc("ShowViewsStmt", - QUERY_NODE_SHOW_VIEWS_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowCreateViewStmt", - QUERY_NODE_SHOW_CREATE_VIEW_STMT, - sizeof(SShowCreateViewStmt), - showCreateViewStmtToJson, - jsonToShowCreateViewStmt, - destoryXNode - ); - setFunc("ShowCreateDatabasesStmt", - QUERY_NODE_SHOW_CREATE_DATABASE_STMT, - sizeof(SShowCreateDatabaseStmt), - showCreateDatabaseStmtToJson, - jsonToShowCreateDatabaseStmt, - destoryShowCreateDatabaseStmt - ); - setFunc("ShowCreateTablesStmt", - QUERY_NODE_SHOW_CREATE_TABLE_STMT, - sizeof(SShowCreateTableStmt), - showCreateTableStmtToJson, - jsonToShowCreateTableStmt, - destoryShowCreateTableStmt - ); - setFunc("ShowCreateStablesStmt", - QUERY_NODE_SHOW_CREATE_STABLE_STMT, - sizeof(SShowCreateTableStmt), - showCreateStableStmtToJson, - jsonToShowCreateStableStmt, - destoryShowCreateTableStmt - ); - setFunc("ShowTableDistributedStmt", - QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT, - sizeof(SShowTableDistributedStmt), - showTableDistributedStmtToJson, - jsonToShowTableDistributedStmt, - destoryXNode - ); - setFunc("ShowLocalVariablesStmt", - QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT, - sizeof(SShowStmt), - showLocalVariablesStmtToJson, - jsonToShowLocalVariablesStmt, - destoryShowStmt - ); - setFunc("ShowScoresStmt", - QUERY_NODE_SHOW_SCORES_STMT, - sizeof(SShowStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryShowStmt - ); - setFunc("ShowTableTagsStmt", - QUERY_NODE_SHOW_TABLE_TAGS_STMT, - sizeof(SShowTableTagsStmt), - showTableTagsStmtToJson, - jsonToShowTableTagsStmt, - destoryShowTableTagsStmt - ); - setFunc("KillConnectionStmt", - QUERY_NODE_KILL_CONNECTION_STMT, - sizeof(SKillStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("KillQueryStmt", - QUERY_NODE_KILL_QUERY_STMT, - sizeof(SKillQueryStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("KillTransactionStmt", - QUERY_NODE_KILL_TRANSACTION_STMT, - sizeof(SKillStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("DeleteStmt", - QUERY_NODE_DELETE_STMT, - sizeof(SDeleteStmt), - deleteStmtToJson, - jsonToDeleteStmt, - destoryDeleteStmt - ); - setFunc("InsertStmt", - QUERY_NODE_INSERT_STMT, - sizeof(SInsertStmt), - insertStmtToJson, - jsonToInsertStmt, - destoryInsertStmt - ); - setFunc("QueryNode", - QUERY_NODE_QUERY, - sizeof(SQuery), - emptyNodeToJson, - emptyJsonToNode, - destoryQueryNode - ); - setFunc("ShowDbAliveStmt", - QUERY_NODE_SHOW_DB_ALIVE_STMT, - sizeof(SShowAliveStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("ShowClusterAliveStmt", - QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT, - sizeof(SShowAliveStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("RestoreDnodeStmt", - QUERY_NODE_RESTORE_DNODE_STMT, - sizeof(SRestoreComponentNodeStmt), - emptyNodeToJson, - jsonToRestoreDnodeStmt, - destoryXNode - ); - setFunc("RestoreQnodeStmt", - QUERY_NODE_RESTORE_QNODE_STMT, - sizeof(SRestoreComponentNodeStmt), - emptyNodeToJson, - jsonToRestoreQnodeStmt, - destoryXNode - ); - setFunc("RestoreMnodeStmt", - QUERY_NODE_RESTORE_MNODE_STMT, - sizeof(SRestoreComponentNodeStmt), - emptyNodeToJson, - jsonToRestoreMnodeStmt, - destoryXNode - ); - setFunc("RestoreVnodeStmt", - QUERY_NODE_RESTORE_VNODE_STMT, - sizeof(SRestoreComponentNodeStmt), - emptyNodeToJson, - jsonToRestoreVnodeStmt, - destoryXNode - ); - setFunc("CreateViewStmt", - QUERY_NODE_CREATE_VIEW_STMT, - sizeof(SCreateViewStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryCreateViewStmt - ); - setFunc("DropViewStmt", - QUERY_NODE_DROP_VIEW_STMT, - sizeof(SDropViewStmt), - emptyNodeToJson, - emptyJsonToNode, - destoryXNode - ); - setFunc("LogicScan", - QUERY_NODE_LOGIC_PLAN_SCAN, - sizeof(SScanLogicNode), - logicScanNodeToJson, - jsonToLogicScanNode, - destoryScanLogicNode - ); - setFunc("LogicJoin", - QUERY_NODE_LOGIC_PLAN_JOIN, - sizeof(SJoinLogicNode), - logicJoinNodeToJson, - jsonToLogicJoinNode, - destoryJoinLogicNode - ); - setFunc("LogicAgg", - QUERY_NODE_LOGIC_PLAN_AGG, - sizeof(SAggLogicNode), - logicAggNodeToJson, - jsonToLogicAggNode, - destoryAggLogicNode - ); - setFunc("LogicProject", - QUERY_NODE_LOGIC_PLAN_PROJECT, - sizeof(SProjectLogicNode), - logicProjectNodeToJson, - jsonToLogicProjectNode, - destoryProjectLogicNode - ); - setFunc("LogicVnodeModify", - QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, - sizeof(SVnodeModifyLogicNode), - logicVnodeModifyNodeToJson, - jsonToLogicVnodeModifyNode, - destoryVnodeModifyLogicNode - ); - setFunc("LogicExchange", - QUERY_NODE_LOGIC_PLAN_EXCHANGE, - sizeof(SExchangeLogicNode), - logicExchangeNodeToJson, - jsonToLogicExchangeNode, - destoryExchangeLogicNode - ); - setFunc("LogicMerge", - QUERY_NODE_LOGIC_PLAN_MERGE, - sizeof(SMergeLogicNode), - logicMergeNodeToJson, - jsonToLogicMergeNode, - destoryMergeLogicNode - ); - setFunc("LogicWindow", - QUERY_NODE_LOGIC_PLAN_WINDOW, - sizeof(SWindowLogicNode), - logicWindowNodeToJson, - jsonToLogicWindowNode, - destoryWindowLogicNode - ); - setFunc("LogicFill", - QUERY_NODE_LOGIC_PLAN_FILL, - sizeof(SFillLogicNode), - logicFillNodeToJson, - jsonToLogicFillNode, - destoryFillLogicNode - ); - setFunc("LogicSort", - QUERY_NODE_LOGIC_PLAN_SORT, - sizeof(SSortLogicNode), - logicSortNodeToJson, - jsonToLogicSortNode, - destorySortLogicNode - ); - setFunc("LogicPartition", - QUERY_NODE_LOGIC_PLAN_PARTITION, - sizeof(SPartitionLogicNode), - logicPartitionNodeToJson, - jsonToLogicPartitionNode, - destoryPartitionLogicNode - ); - setFunc("LogicIndefRowsFunc", - QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, - sizeof(SIndefRowsFuncLogicNode), - logicIndefRowsFuncNodeToJson, - jsonToLogicIndefRowsFuncNode, - destoryIndefRowsFuncLogicNode - ); - setFunc("LogicInterpFunc", - QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, - sizeof(SInterpFuncLogicNode), - logicInterpFuncNodeToJson, - jsonToLogicInterpFuncNode, - destoryInterpFuncLogicNode - ); - setFunc("LogicGroupCache", - QUERY_NODE_LOGIC_PLAN_GROUP_CACHE, - sizeof(SGroupCacheLogicNode), - logicGroupCacheNodeToJson, - jsonToLogicGroupCacheNode, - destoryGroupCacheLogicNode - ); - setFunc("LogicDynamicQueryCtrl", - QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL, - sizeof(SDynQueryCtrlLogicNode), - logicDynQueryCtrlNodeToJson, - jsonToLogicDynQueryCtrlNode, - destoryDynQueryCtrlLogicNode - ); - setFunc("LogicSubplan", - QUERY_NODE_LOGIC_SUBPLAN, - sizeof(SLogicSubplan), - logicSubplanToJson, - jsonToLogicSubplan, - destoryLogicSubplan - ); - setFunc("LogicPlan", - QUERY_NODE_LOGIC_PLAN, - sizeof(SQueryLogicPlan), - logicPlanToJson, - jsonToLogicPlan, - destoryQueryLogicPlan - ); - setFunc("PhysiTagScan", - QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, - sizeof(STagScanPhysiNode), - physiTagScanNodeToJson, - jsonToPhysiTagScanNode, - destroyScanPhysiNode - ); - setFunc("PhysiTableScan", - QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, - sizeof(STableScanPhysiNode), - physiTableScanNodeToJson, - jsonToPhysiTableScanNode, - destoryTableScanPhysiNode - ); - setFunc("PhysiTableSeqScan", - QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, - sizeof(STableSeqScanPhysiNode), - emptyNodeToJson, - emptyJsonToNode, - destoryTableScanPhysiNode - ); - setFunc("PhysiTableMergeScan", - QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, - sizeof(STableMergeScanPhysiNode), - physiTableScanNodeToJson, - jsonToPhysiTableScanNode, - destoryTableScanPhysiNode - ); - setFunc("PhysiSreamScan", - QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, - sizeof(SStreamScanPhysiNode), - physiTableScanNodeToJson, - jsonToPhysiTableScanNode, - destoryTableScanPhysiNode - ); - setFunc("PhysiSystemTableScan", - QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, - sizeof(SSystemTableScanPhysiNode), - physiSysTableScanNodeToJson, - jsonToPhysiSysTableScanNode, - destroyScanPhysiNode - ); - setFunc("PhysiBlockDistScan", - QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, - sizeof(SBlockDistScanPhysiNode), - physiScanNodeToJson, - jsonToPhysiScanNode, - destroyScanPhysiNode - ); - setFunc("PhysiLastRowScan", - QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, - sizeof(SLastRowScanPhysiNode), - physiLastRowScanNodeToJson, - jsonToPhysiLastRowScanNode, - destoryLastRowScanPhysiNode - ); - setFunc("PhysiProject", - QUERY_NODE_PHYSICAL_PLAN_PROJECT, - sizeof(SProjectPhysiNode), - physiProjectNodeToJson, - jsonToPhysiProjectNode, - destoryProjectPhysiNode - ); - setFunc("PhysiMergeJoin", - QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN, - sizeof(SSortMergeJoinPhysiNode), - physiMergeJoinNodeToJson, - jsonToPhysiMergeJoinNode, - destorySortMergeJoinPhysiNode - ); - setFunc("PhysiAgg", - QUERY_NODE_PHYSICAL_PLAN_HASH_AGG, - sizeof(SAggPhysiNode), - physiAggNodeToJson, - jsonToPhysiAggNode, - destoryAggPhysiNode - ); - setFunc("PhysiExchange", - QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, - sizeof(SExchangePhysiNode), - physiExchangeNodeToJson, - jsonToPhysiExchangeNode, - destoryExchangePhysiNode - ); - setFunc("PhysiMerge", - QUERY_NODE_PHYSICAL_PLAN_MERGE, - sizeof(SMergePhysiNode), - physiMergeNodeToJson, - jsonToPhysiMergeNode, - destoryMergePhysiNode - ); - setFunc("PhysiSort", - QUERY_NODE_PHYSICAL_PLAN_SORT, - sizeof(SSortPhysiNode), - physiSortNodeToJson, - jsonToPhysiSortNode, - destorySortPhysiNode - ); - setFunc("PhysiGroupSort", - QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, - sizeof(SGroupSortPhysiNode), - physiSortNodeToJson, - jsonToPhysiSortNode, - destorySortPhysiNode - ); - setFunc("PhysiHashInterval", - QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL, - sizeof(SIntervalPhysiNode), - physiIntervalNodeToJson, - jsonToPhysiIntervalNode, - destroyWindowPhysiNode - ); - setFunc("PhysiMergeAlignedInterval", - QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL, - sizeof(SMergeAlignedIntervalPhysiNode), - physiIntervalNodeToJson, - jsonToPhysiIntervalNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStreamInterval", - QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, - sizeof(SStreamIntervalPhysiNode), - physiIntervalNodeToJson, - jsonToPhysiIntervalNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStreamFinalInterval", - QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL, - sizeof(SStreamFinalIntervalPhysiNode), - physiIntervalNodeToJson, - jsonToPhysiIntervalNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStreamSemiInterval", - QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL, - sizeof(SStreamSemiIntervalPhysiNode), - physiIntervalNodeToJson, - jsonToPhysiIntervalNode, - destroyWindowPhysiNode - ); - setFunc("PhysiFill", - QUERY_NODE_PHYSICAL_PLAN_FILL, - sizeof(SFillPhysiNode), - physiFillNodeToJson, - jsonToPhysiFillNode, - destoryFillPhysiNode - ); - setFunc("PhysiStreamFill", - QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, - sizeof(SFillPhysiNode), - physiFillNodeToJson, - jsonToPhysiFillNode, - destoryFillPhysiNode - ); - setFunc("PhysiSessionWindow", - QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION, - sizeof(SSessionWinodwPhysiNode), - physiSessionWindowNodeToJson, - jsonToPhysiSessionWindowNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStreamSessionWindow", - QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION, - sizeof(SStreamSessionWinodwPhysiNode), - physiSessionWindowNodeToJson, - jsonToPhysiSessionWindowNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStreamSemiSessionWindow", - QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION, - sizeof(SStreamSemiSessionWinodwPhysiNode), - physiSessionWindowNodeToJson, - jsonToPhysiSessionWindowNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStreamFinalSessionWindow", - QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION, - sizeof(SStreamFinalSessionWinodwPhysiNode), - physiSessionWindowNodeToJson, - jsonToPhysiSessionWindowNode, - destroyWindowPhysiNode - ); - setFunc("PhysiStateWindow", - QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, - sizeof(SStateWinodwPhysiNode), - physiStateWindowNodeToJson, - jsonToPhysiStateWindowNode, - destoryStateWindowPhysiNode - ); - setFunc("PhysiStreamStateWindow", - QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE, - sizeof(SStreamStateWinodwPhysiNode), - physiStateWindowNodeToJson, - jsonToPhysiStateWindowNode, - destoryStateWindowPhysiNode - ); - setFunc("PhysiPartition", - QUERY_NODE_PHYSICAL_PLAN_PARTITION, - sizeof(SPartitionPhysiNode), - physiPartitionNodeToJson, - jsonToPhysiPartitionNode, - destroyPartitionPhysiNode - ); - setFunc("PhysiStreamPartition", - QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION, - sizeof(SStreamPartitionPhysiNode), - physiStreamPartitionNodeToJson, - jsonToPhysiStreamPartitionNode, - destoryStreamPartitionPhysiNode - ); - setFunc("PhysiIndefRowsFunc", - QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC, - sizeof(SIndefRowsFuncPhysiNode), - physiIndefRowsFuncNodeToJson, - jsonToPhysiIndefRowsFuncNode, - destoryIndefRowsFuncPhysiNode - ); - setFunc("PhysiInterpFunc", - QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, - sizeof(SInterpFuncLogicNode), - physiInterpFuncNodeToJson, - jsonToPhysiInterpFuncNode, - destoryInterpFuncPhysiNode - ); - setFunc("PhysiDispatch", - QUERY_NODE_PHYSICAL_PLAN_DISPATCH, - sizeof(SDataDispatcherNode), - physiDispatchNodeToJson, - jsonToPhysiDispatchNode, - destroyDataSinkNode - ); - setFunc("PhysiInsert", - QUERY_NODE_PHYSICAL_PLAN_INSERT, - sizeof(SDataInserterNode), - emptyNodeToJson, - emptyJsonToNode, - destoryDataInserterNode - ); - setFunc("PhysiQueryInsert", - QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT, - sizeof(SQueryInserterNode), - physiQueryInsertNodeToJson, - jsonToPhysiQueryInsertNode, - destoryQueryInserterNode - ); - setFunc("PhysiDelete", - QUERY_NODE_PHYSICAL_PLAN_DELETE, - sizeof(SDataDeleterNode), - physiDeleteNodeToJson, - jsonToPhysiDeleteNode, - destoryDataDeleterNode - ); - setFunc("PhysiGroupCache", - QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE, - sizeof(SGroupCachePhysiNode), - physiGroupCacheNodeToJson, - jsonToPhysiGroupCacheNode, - destoryGroupCachePhysiNode - ); - setFunc("PhysiDynamicQueryCtrl", - QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL, - sizeof(SDynQueryCtrlPhysiNode), - physiDynQueryCtrlNodeToJson, - jsonToPhysiDynQueryCtrlNode, - destoryDynQueryCtrlPhysiNode - ); - setFunc("PhysiSubplan", - QUERY_NODE_PHYSICAL_SUBPLAN, - sizeof(SSubplan), - subplanToJson, - jsonToSubplan, - destorySubplanNode - ); - setFunc("PhysiPlan", - QUERY_NODE_PHYSICAL_PLAN, - sizeof(SQueryPlan), - planToJson, - jsonToPlan, - destoryPlanNode - ); - setFunc("PhysiTableCountScan", - QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, - sizeof(STableCountScanPhysiNode), - physiLastRowScanNodeToJson, - jsonToPhysiScanNode, - destoryLastRowScanPhysiNode - ); - setFunc("PhysiMergeEventWindow", - QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT, - sizeof(SEventWinodwPhysiNode), - physiEventWindowNodeToJson, - jsonToPhysiEventWindowNode, - destoryEventWindowPhysiNode - ); - setFunc("PhysiStreamEventWindow", - QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT, - sizeof(SStreamEventWinodwPhysiNode), - physiEventWindowNodeToJson, - jsonToPhysiEventWindowNode, - destoryEventWindowPhysiNode - ); - setFunc("PhysiHashJoin", - QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN, - sizeof(SHashJoinPhysiNode), - physiHashJoinNodeToJson, - jsonToPhysiHashJoinNode, - destoryHashJoinPhysiNode - ); -} - -// clang-format on diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 2ea387792b..e730ccf21b 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -237,14 +237,1246 @@ static SNode* makeNode(ENodeType type, int32_t size) { } SNode* nodesMakeNode(ENodeType type) { - int32_t size = getNodeSize(type); - if (size > 0) { - return makeNode(type, size); + switch (type) { + case QUERY_NODE_COLUMN: + return makeNode(type, sizeof(SColumnNode)); + case QUERY_NODE_VALUE: + return makeNode(type, sizeof(SValueNode)); + case QUERY_NODE_OPERATOR: + return makeNode(type, sizeof(SOperatorNode)); + case QUERY_NODE_LOGIC_CONDITION: + return makeNode(type, sizeof(SLogicConditionNode)); + case QUERY_NODE_FUNCTION: + return makeNode(type, sizeof(SFunctionNode)); + case QUERY_NODE_REAL_TABLE: + return makeNode(type, sizeof(SRealTableNode)); + case QUERY_NODE_TEMP_TABLE: + return makeNode(type, sizeof(STempTableNode)); + case QUERY_NODE_JOIN_TABLE: + return makeNode(type, sizeof(SJoinTableNode)); + case QUERY_NODE_GROUPING_SET: + return makeNode(type, sizeof(SGroupingSetNode)); + case QUERY_NODE_ORDER_BY_EXPR: + return makeNode(type, sizeof(SOrderByExprNode)); + case QUERY_NODE_LIMIT: + return makeNode(type, sizeof(SLimitNode)); + case QUERY_NODE_STATE_WINDOW: + return makeNode(type, sizeof(SStateWindowNode)); + case QUERY_NODE_SESSION_WINDOW: + return makeNode(type, sizeof(SSessionWindowNode)); + case QUERY_NODE_INTERVAL_WINDOW: + return makeNode(type, sizeof(SIntervalWindowNode)); + case QUERY_NODE_NODE_LIST: + return makeNode(type, sizeof(SNodeListNode)); + case QUERY_NODE_FILL: + return makeNode(type, sizeof(SFillNode)); + case QUERY_NODE_RAW_EXPR: + return makeNode(type, sizeof(SRawExprNode)); + case QUERY_NODE_TARGET: + return makeNode(type, sizeof(STargetNode)); + case QUERY_NODE_DATABLOCK_DESC: + return makeNode(type, sizeof(SDataBlockDescNode)); + case QUERY_NODE_SLOT_DESC: + return makeNode(type, sizeof(SSlotDescNode)); + case QUERY_NODE_COLUMN_DEF: + return makeNode(type, sizeof(SColumnDefNode)); + case QUERY_NODE_DOWNSTREAM_SOURCE: + return makeNode(type, sizeof(SDownstreamSourceNode)); + case QUERY_NODE_DATABASE_OPTIONS: + return makeNode(type, sizeof(SDatabaseOptions)); + case QUERY_NODE_TABLE_OPTIONS: + return makeNode(type, sizeof(STableOptions)); + case QUERY_NODE_INDEX_OPTIONS: + return makeNode(type, sizeof(SIndexOptions)); + case QUERY_NODE_EXPLAIN_OPTIONS: + return makeNode(type, sizeof(SExplainOptions)); + case QUERY_NODE_STREAM_OPTIONS: + return makeNode(type, sizeof(SStreamOptions)); + case QUERY_NODE_LEFT_VALUE: + return makeNode(type, sizeof(SLeftValueNode)); + case QUERY_NODE_COLUMN_REF: + return makeNode(type, sizeof(SColumnDefNode)); + case QUERY_NODE_WHEN_THEN: + return makeNode(type, sizeof(SWhenThenNode)); + case QUERY_NODE_CASE_WHEN: + return makeNode(type, sizeof(SCaseWhenNode)); + case QUERY_NODE_EVENT_WINDOW: + return makeNode(type, sizeof(SEventWindowNode)); + case QUERY_NODE_HINT: + return makeNode(type, sizeof(SHintNode)); + case QUERY_NODE_VIEW: + return makeNode(type, sizeof(SViewNode)); + case QUERY_NODE_SET_OPERATOR: + return makeNode(type, sizeof(SSetOperator)); + case QUERY_NODE_SELECT_STMT: + return makeNode(type, sizeof(SSelectStmt)); + case QUERY_NODE_VNODE_MODIFY_STMT: + return makeNode(type, sizeof(SVnodeModifyOpStmt)); + case QUERY_NODE_CREATE_DATABASE_STMT: + return makeNode(type, sizeof(SCreateDatabaseStmt)); + case QUERY_NODE_DROP_DATABASE_STMT: + return makeNode(type, sizeof(SDropDatabaseStmt)); + case QUERY_NODE_ALTER_DATABASE_STMT: + return makeNode(type, sizeof(SAlterDatabaseStmt)); + case QUERY_NODE_FLUSH_DATABASE_STMT: + return makeNode(type, sizeof(SFlushDatabaseStmt)); + case QUERY_NODE_TRIM_DATABASE_STMT: + return makeNode(type, sizeof(STrimDatabaseStmt)); + case QUERY_NODE_CREATE_TABLE_STMT: + return makeNode(type, sizeof(SCreateTableStmt)); + case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: + return makeNode(type, sizeof(SCreateSubTableClause)); + case QUERY_NODE_CREATE_MULTI_TABLES_STMT: + return makeNode(type, sizeof(SCreateMultiTablesStmt)); + case QUERY_NODE_DROP_TABLE_CLAUSE: + return makeNode(type, sizeof(SDropTableClause)); + case QUERY_NODE_DROP_TABLE_STMT: + return makeNode(type, sizeof(SDropTableStmt)); + case QUERY_NODE_DROP_SUPER_TABLE_STMT: + return makeNode(type, sizeof(SDropSuperTableStmt)); + case QUERY_NODE_ALTER_TABLE_STMT: + case QUERY_NODE_ALTER_SUPER_TABLE_STMT: + return makeNode(type, sizeof(SAlterTableStmt)); + case QUERY_NODE_CREATE_USER_STMT: + return makeNode(type, sizeof(SCreateUserStmt)); + case QUERY_NODE_ALTER_USER_STMT: + return makeNode(type, sizeof(SAlterUserStmt)); + case QUERY_NODE_DROP_USER_STMT: + return makeNode(type, sizeof(SDropUserStmt)); + case QUERY_NODE_USE_DATABASE_STMT: + return makeNode(type, sizeof(SUseDatabaseStmt)); + case QUERY_NODE_CREATE_DNODE_STMT: + return makeNode(type, sizeof(SCreateDnodeStmt)); + case QUERY_NODE_DROP_DNODE_STMT: + return makeNode(type, sizeof(SDropDnodeStmt)); + case QUERY_NODE_ALTER_DNODE_STMT: + return makeNode(type, sizeof(SAlterDnodeStmt)); + case QUERY_NODE_CREATE_INDEX_STMT: + return makeNode(type, sizeof(SCreateIndexStmt)); + case QUERY_NODE_DROP_INDEX_STMT: + return makeNode(type, sizeof(SDropIndexStmt)); + case QUERY_NODE_CREATE_QNODE_STMT: + case QUERY_NODE_CREATE_BNODE_STMT: + case QUERY_NODE_CREATE_SNODE_STMT: + case QUERY_NODE_CREATE_MNODE_STMT: + return makeNode(type, sizeof(SCreateComponentNodeStmt)); + case QUERY_NODE_DROP_QNODE_STMT: + case QUERY_NODE_DROP_BNODE_STMT: + case QUERY_NODE_DROP_SNODE_STMT: + case QUERY_NODE_DROP_MNODE_STMT: + return makeNode(type, sizeof(SDropComponentNodeStmt)); + case QUERY_NODE_CREATE_TOPIC_STMT: + return makeNode(type, sizeof(SCreateTopicStmt)); + case QUERY_NODE_DROP_TOPIC_STMT: + return makeNode(type, sizeof(SDropTopicStmt)); + case QUERY_NODE_DROP_CGROUP_STMT: + return makeNode(type, sizeof(SDropCGroupStmt)); + case QUERY_NODE_ALTER_LOCAL_STMT: + return makeNode(type, sizeof(SAlterLocalStmt)); + case QUERY_NODE_EXPLAIN_STMT: + return makeNode(type, sizeof(SExplainStmt)); + case QUERY_NODE_DESCRIBE_STMT: + return makeNode(type, sizeof(SDescribeStmt)); + case QUERY_NODE_RESET_QUERY_CACHE_STMT: + return makeNode(type, sizeof(SNode)); + case QUERY_NODE_COMPACT_DATABASE_STMT: + return makeNode(type, sizeof(SCompactDatabaseStmt)); + case QUERY_NODE_CREATE_FUNCTION_STMT: + return makeNode(type, sizeof(SCreateFunctionStmt)); + case QUERY_NODE_DROP_FUNCTION_STMT: + return makeNode(type, sizeof(SDropFunctionStmt)); + case QUERY_NODE_CREATE_STREAM_STMT: + return makeNode(type, sizeof(SCreateStreamStmt)); + case QUERY_NODE_DROP_STREAM_STMT: + return makeNode(type, sizeof(SDropStreamStmt)); + case QUERY_NODE_PAUSE_STREAM_STMT: + return makeNode(type, sizeof(SPauseStreamStmt)); + case QUERY_NODE_RESUME_STREAM_STMT: + return makeNode(type, sizeof(SResumeStreamStmt)); + case QUERY_NODE_BALANCE_VGROUP_STMT: + return makeNode(type, sizeof(SBalanceVgroupStmt)); + case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: + return makeNode(type, sizeof(SBalanceVgroupLeaderStmt)); + case QUERY_NODE_MERGE_VGROUP_STMT: + return makeNode(type, sizeof(SMergeVgroupStmt)); + case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: + return makeNode(type, sizeof(SRedistributeVgroupStmt)); + case QUERY_NODE_SPLIT_VGROUP_STMT: + return makeNode(type, sizeof(SSplitVgroupStmt)); + case QUERY_NODE_SYNCDB_STMT: + break; + case QUERY_NODE_GRANT_STMT: + return makeNode(type, sizeof(SGrantStmt)); + case QUERY_NODE_REVOKE_STMT: + return makeNode(type, sizeof(SRevokeStmt)); + case QUERY_NODE_SHOW_DNODES_STMT: + case QUERY_NODE_SHOW_MNODES_STMT: + case QUERY_NODE_SHOW_MODULES_STMT: + case QUERY_NODE_SHOW_QNODES_STMT: + case QUERY_NODE_SHOW_SNODES_STMT: + case QUERY_NODE_SHOW_BNODES_STMT: + case QUERY_NODE_SHOW_CLUSTER_STMT: + case QUERY_NODE_SHOW_DATABASES_STMT: + case QUERY_NODE_SHOW_FUNCTIONS_STMT: + case QUERY_NODE_SHOW_INDEXES_STMT: + case QUERY_NODE_SHOW_STABLES_STMT: + case QUERY_NODE_SHOW_STREAMS_STMT: + case QUERY_NODE_SHOW_TABLES_STMT: + case QUERY_NODE_SHOW_USERS_STMT: + case QUERY_NODE_SHOW_LICENCES_STMT: + case QUERY_NODE_SHOW_VGROUPS_STMT: + case QUERY_NODE_SHOW_TOPICS_STMT: + case QUERY_NODE_SHOW_CONSUMERS_STMT: + case QUERY_NODE_SHOW_CONNECTIONS_STMT: + case QUERY_NODE_SHOW_QUERIES_STMT: + case QUERY_NODE_SHOW_VNODES_STMT: + case QUERY_NODE_SHOW_APPS_STMT: + case QUERY_NODE_SHOW_SCORES_STMT: + case QUERY_NODE_SHOW_VARIABLES_STMT: + case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT: + case QUERY_NODE_SHOW_TRANSACTIONS_STMT: + case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT: + case QUERY_NODE_SHOW_TAGS_STMT: + case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT: + case QUERY_NODE_SHOW_VIEWS_STMT: + return makeNode(type, sizeof(SShowStmt)); + case QUERY_NODE_SHOW_TABLE_TAGS_STMT: + return makeNode(type, sizeof(SShowTableTagsStmt)); + case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: + return makeNode(type, sizeof(SShowDnodeVariablesStmt)); + case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: + return makeNode(type, sizeof(SShowCreateDatabaseStmt)); + case QUERY_NODE_SHOW_DB_ALIVE_STMT: + case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT: + return makeNode(type, sizeof(SShowAliveStmt)); + case QUERY_NODE_SHOW_CREATE_TABLE_STMT: + case QUERY_NODE_SHOW_CREATE_STABLE_STMT: + return makeNode(type, sizeof(SShowCreateTableStmt)); + case QUERY_NODE_SHOW_CREATE_VIEW_STMT: + return makeNode(type, sizeof(SShowCreateViewStmt)); + case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: + return makeNode(type, sizeof(SShowTableDistributedStmt)); + case QUERY_NODE_KILL_QUERY_STMT: + return makeNode(type, sizeof(SKillQueryStmt)); + case QUERY_NODE_KILL_TRANSACTION_STMT: + case QUERY_NODE_KILL_CONNECTION_STMT: + return makeNode(type, sizeof(SKillStmt)); + case QUERY_NODE_DELETE_STMT: + return makeNode(type, sizeof(SDeleteStmt)); + case QUERY_NODE_INSERT_STMT: + return makeNode(type, sizeof(SInsertStmt)); + case QUERY_NODE_QUERY: + return makeNode(type, sizeof(SQuery)); + case QUERY_NODE_RESTORE_DNODE_STMT: + case QUERY_NODE_RESTORE_QNODE_STMT: + case QUERY_NODE_RESTORE_MNODE_STMT: + case QUERY_NODE_RESTORE_VNODE_STMT: + return makeNode(type, sizeof(SRestoreComponentNodeStmt)); + case QUERY_NODE_CREATE_VIEW_STMT: + return makeNode(type, sizeof(SCreateViewStmt)); + case QUERY_NODE_DROP_VIEW_STMT: + return makeNode(type, sizeof(SDropViewStmt)); + case QUERY_NODE_LOGIC_PLAN_SCAN: + return makeNode(type, sizeof(SScanLogicNode)); + case QUERY_NODE_LOGIC_PLAN_JOIN: + return makeNode(type, sizeof(SJoinLogicNode)); + case QUERY_NODE_LOGIC_PLAN_AGG: + return makeNode(type, sizeof(SAggLogicNode)); + case QUERY_NODE_LOGIC_PLAN_PROJECT: + return makeNode(type, sizeof(SProjectLogicNode)); + case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: + return makeNode(type, sizeof(SVnodeModifyLogicNode)); + case QUERY_NODE_LOGIC_PLAN_EXCHANGE: + return makeNode(type, sizeof(SExchangeLogicNode)); + case QUERY_NODE_LOGIC_PLAN_MERGE: + return makeNode(type, sizeof(SMergeLogicNode)); + case QUERY_NODE_LOGIC_PLAN_WINDOW: + return makeNode(type, sizeof(SWindowLogicNode)); + case QUERY_NODE_LOGIC_PLAN_FILL: + return makeNode(type, sizeof(SFillLogicNode)); + case QUERY_NODE_LOGIC_PLAN_SORT: + return makeNode(type, sizeof(SSortLogicNode)); + case QUERY_NODE_LOGIC_PLAN_PARTITION: + return makeNode(type, sizeof(SPartitionLogicNode)); + case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: + return makeNode(type, sizeof(SIndefRowsFuncLogicNode)); + case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: + return makeNode(type, sizeof(SInterpFuncLogicNode)); + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: + return makeNode(type, sizeof(SGroupCacheLogicNode)); + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: + return makeNode(type, sizeof(SDynQueryCtrlLogicNode)); + case QUERY_NODE_LOGIC_SUBPLAN: + return makeNode(type, sizeof(SLogicSubplan)); + case QUERY_NODE_LOGIC_PLAN: + return makeNode(type, sizeof(SQueryLogicPlan)); + case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: + return makeNode(type, sizeof(STagScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: + return makeNode(type, sizeof(STableScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN: + return makeNode(type, sizeof(STableSeqScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: + return makeNode(type, sizeof(STableMergeScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: + return makeNode(type, sizeof(SStreamScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: + return makeNode(type, sizeof(SSystemTableScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: + return makeNode(type, sizeof(SBlockDistScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: + return makeNode(type, sizeof(SLastRowScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: + return makeNode(type, sizeof(STableCountScanPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_PROJECT: + return makeNode(type, sizeof(SProjectPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: + return makeNode(type, sizeof(SSortMergeJoinPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: + return makeNode(type, sizeof(SHashJoinPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: + return makeNode(type, sizeof(SAggPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: + return makeNode(type, sizeof(SExchangePhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_MERGE: + return makeNode(type, sizeof(SMergePhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_SORT: + return makeNode(type, sizeof(SSortPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: + return makeNode(type, sizeof(SGroupSortPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: + return makeNode(type, sizeof(SIntervalPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: + return makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: + return makeNode(type, sizeof(SStreamIntervalPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: + return makeNode(type, sizeof(SStreamFinalIntervalPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: + return makeNode(type, sizeof(SStreamSemiIntervalPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_FILL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: + return makeNode(type, sizeof(SFillPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: + return makeNode(type, sizeof(SSessionWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: + return makeNode(type, sizeof(SStreamSessionWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: + return makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: + return makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: + return makeNode(type, sizeof(SStateWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: + return makeNode(type, sizeof(SStreamStateWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: + return makeNode(type, sizeof(SEventWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: + return makeNode(type, sizeof(SStreamEventWinodwPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_PARTITION: + return makeNode(type, sizeof(SPartitionPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: + return makeNode(type, sizeof(SStreamPartitionPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: + return makeNode(type, sizeof(SIndefRowsFuncPhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: + return makeNode(type, sizeof(SInterpFuncLogicNode)); + case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: + return makeNode(type, sizeof(SDataDispatcherNode)); + case QUERY_NODE_PHYSICAL_PLAN_INSERT: + return makeNode(type, sizeof(SDataInserterNode)); + case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: + return makeNode(type, sizeof(SQueryInserterNode)); + case QUERY_NODE_PHYSICAL_PLAN_DELETE: + return makeNode(type, sizeof(SDataDeleterNode)); + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + return makeNode(type, sizeof(SGroupCachePhysiNode)); + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: + return makeNode(type, sizeof(SDynQueryCtrlPhysiNode)); + case QUERY_NODE_PHYSICAL_SUBPLAN: + return makeNode(type, sizeof(SSubplan)); + case QUERY_NODE_PHYSICAL_PLAN: + return makeNode(type, sizeof(SQueryPlan)); + default: + break; } - nodesError("nodesMakeNode unsupported type = %d", type); + nodesError("nodesMakeNode unknown node = %s", nodesNodeName(type)); return NULL; } +static void destroyVgDataBlockArray(SArray* pArray) { + size_t size = taosArrayGetSize(pArray); + for (size_t i = 0; i < size; ++i) { + SVgDataBlocks* pVg = taosArrayGetP(pArray, i); + taosMemoryFreeClear(pVg->pData); + taosMemoryFreeClear(pVg); + } + taosArrayDestroy(pArray); +} + +static void destroyLogicNode(SLogicNode* pNode) { + nodesDestroyList(pNode->pTargets); + nodesDestroyNode(pNode->pConditions); + nodesDestroyList(pNode->pChildren); + nodesDestroyNode(pNode->pLimit); + nodesDestroyNode(pNode->pSlimit); + nodesDestroyList(pNode->pHint); +} + +static void destroyPhysiNode(SPhysiNode* pNode) { + nodesDestroyList(pNode->pChildren); + nodesDestroyNode(pNode->pConditions); + nodesDestroyNode((SNode*)pNode->pOutputDataBlockDesc); + nodesDestroyNode(pNode->pLimit); + nodesDestroyNode(pNode->pSlimit); +} + +static void destroyWinodwPhysiNode(SWindowPhysiNode* pNode) { + destroyPhysiNode((SPhysiNode*)pNode); + nodesDestroyList(pNode->pExprs); + nodesDestroyList(pNode->pFuncs); + nodesDestroyNode(pNode->pTspk); + nodesDestroyNode(pNode->pTsEnd); +} + +static void destroyPartitionPhysiNode(SPartitionPhysiNode* pNode) { + destroyPhysiNode((SPhysiNode*)pNode); + nodesDestroyList(pNode->pExprs); + nodesDestroyList(pNode->pPartitionKeys); + nodesDestroyList(pNode->pTargets); +} + +static void destroyScanPhysiNode(SScanPhysiNode* pNode) { + destroyPhysiNode((SPhysiNode*)pNode); + nodesDestroyList(pNode->pScanCols); + nodesDestroyList(pNode->pScanPseudoCols); +} + +static void destroyDataSinkNode(SDataSinkNode* pNode) { nodesDestroyNode((SNode*)pNode->pInputDataBlockDesc); } + +static void destroyExprNode(SExprNode* pExpr) { taosArrayDestroy(pExpr->pAssociation); } + +static void destroyTableCfg(STableCfg* pCfg) { + if (NULL == pCfg) { + return; + } + taosArrayDestroy(pCfg->pFuncs); + taosMemoryFree(pCfg->pComment); + taosMemoryFree(pCfg->pSchemas); + taosMemoryFree(pCfg->pTags); + taosMemoryFree(pCfg); +} + +static void destroySmaIndex(void* pIndex) { taosMemoryFree(((STableIndexInfo*)pIndex)->expr); } + +static void destroyHintValue(EHintOption option, void* value) { + switch (option) { + default: + break; + } + + taosMemoryFree(value); +} + +void nodesDestroyNode(SNode* pNode) { + if (NULL == pNode) { + return; + } + + switch (nodeType(pNode)) { + case QUERY_NODE_COLUMN: + destroyExprNode((SExprNode*)pNode); + break; + case QUERY_NODE_VALUE: { + SValueNode* pValue = (SValueNode*)pNode; + destroyExprNode((SExprNode*)pNode); + taosMemoryFreeClear(pValue->literal); + if (IS_VAR_DATA_TYPE(pValue->node.resType.type)) { + taosMemoryFreeClear(pValue->datum.p); + } + break; + } + case QUERY_NODE_OPERATOR: { + SOperatorNode* pOp = (SOperatorNode*)pNode; + destroyExprNode((SExprNode*)pNode); + nodesDestroyNode(pOp->pLeft); + nodesDestroyNode(pOp->pRight); + break; + } + case QUERY_NODE_LOGIC_CONDITION: + destroyExprNode((SExprNode*)pNode); + nodesDestroyList(((SLogicConditionNode*)pNode)->pParameterList); + break; + case QUERY_NODE_FUNCTION: + destroyExprNode((SExprNode*)pNode); + nodesDestroyList(((SFunctionNode*)pNode)->pParameterList); + break; + case QUERY_NODE_REAL_TABLE: { + SRealTableNode* pReal = (SRealTableNode*)pNode; + taosMemoryFreeClear(pReal->pMeta); + taosMemoryFreeClear(pReal->pVgroupList); + taosArrayDestroyEx(pReal->pSmaIndexes, destroySmaIndex); + break; + } + case QUERY_NODE_TEMP_TABLE: + nodesDestroyNode(((STempTableNode*)pNode)->pSubquery); + break; + case QUERY_NODE_JOIN_TABLE: { + SJoinTableNode* pJoin = (SJoinTableNode*)pNode; + nodesDestroyNode(pJoin->pLeft); + nodesDestroyNode(pJoin->pRight); + nodesDestroyNode(pJoin->pOnCond); + break; + } + case QUERY_NODE_GROUPING_SET: + nodesDestroyList(((SGroupingSetNode*)pNode)->pParameterList); + break; + case QUERY_NODE_ORDER_BY_EXPR: + nodesDestroyNode(((SOrderByExprNode*)pNode)->pExpr); + break; + case QUERY_NODE_LIMIT: // no pointer field + break; + case QUERY_NODE_STATE_WINDOW: { + SStateWindowNode* pState = (SStateWindowNode*)pNode; + nodesDestroyNode(pState->pCol); + nodesDestroyNode(pState->pExpr); + break; + } + case QUERY_NODE_SESSION_WINDOW: { + SSessionWindowNode* pSession = (SSessionWindowNode*)pNode; + nodesDestroyNode((SNode*)pSession->pCol); + nodesDestroyNode((SNode*)pSession->pGap); + break; + } + case QUERY_NODE_INTERVAL_WINDOW: { + SIntervalWindowNode* pJoin = (SIntervalWindowNode*)pNode; + nodesDestroyNode(pJoin->pCol); + nodesDestroyNode(pJoin->pInterval); + nodesDestroyNode(pJoin->pOffset); + nodesDestroyNode(pJoin->pSliding); + nodesDestroyNode(pJoin->pFill); + break; + } + case QUERY_NODE_NODE_LIST: + nodesDestroyList(((SNodeListNode*)pNode)->pNodeList); + break; + case QUERY_NODE_FILL: { + SFillNode* pFill = (SFillNode*)pNode; + nodesDestroyNode(pFill->pValues); + nodesDestroyNode(pFill->pWStartTs); + break; + } + case QUERY_NODE_RAW_EXPR: + nodesDestroyNode(((SRawExprNode*)pNode)->pNode); + break; + case QUERY_NODE_TARGET: + nodesDestroyNode(((STargetNode*)pNode)->pExpr); + break; + case QUERY_NODE_DATABLOCK_DESC: + nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots); + break; + case QUERY_NODE_SLOT_DESC: // no pointer field + case QUERY_NODE_COLUMN_DEF: // no pointer field + case QUERY_NODE_DOWNSTREAM_SOURCE: // no pointer field + break; + case QUERY_NODE_DATABASE_OPTIONS: { + SDatabaseOptions* pOptions = (SDatabaseOptions*)pNode; + nodesDestroyNode((SNode*)pOptions->pDaysPerFile); + nodesDestroyList(pOptions->pKeep); + nodesDestroyList(pOptions->pRetentions); + break; + } + case QUERY_NODE_TABLE_OPTIONS: { + STableOptions* pOptions = (STableOptions*)pNode; + nodesDestroyList(pOptions->pMaxDelay); + nodesDestroyList(pOptions->pWatermark); + nodesDestroyList(pOptions->pRollupFuncs); + nodesDestroyList(pOptions->pSma); + nodesDestroyList(pOptions->pDeleteMark); + break; + } + case QUERY_NODE_INDEX_OPTIONS: { + SIndexOptions* pOptions = (SIndexOptions*)pNode; + nodesDestroyList(pOptions->pFuncs); + nodesDestroyNode(pOptions->pInterval); + nodesDestroyNode(pOptions->pOffset); + nodesDestroyNode(pOptions->pSliding); + nodesDestroyNode(pOptions->pStreamOptions); + break; + } + case QUERY_NODE_EXPLAIN_OPTIONS: // no pointer field + break; + case QUERY_NODE_STREAM_OPTIONS: { + SStreamOptions* pOptions = (SStreamOptions*)pNode; + nodesDestroyNode(pOptions->pDelay); + nodesDestroyNode(pOptions->pWatermark); + nodesDestroyNode(pOptions->pDeleteMark); + break; + } + case QUERY_NODE_LEFT_VALUE: // no pointer field + case QUERY_NODE_COLUMN_REF: // no pointer field + break; + case QUERY_NODE_WHEN_THEN: { + SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode; + nodesDestroyNode(pWhenThen->pWhen); + nodesDestroyNode(pWhenThen->pThen); + break; + } + case QUERY_NODE_CASE_WHEN: { + SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode; + nodesDestroyNode(pCaseWhen->pCase); + nodesDestroyNode(pCaseWhen->pElse); + nodesDestroyList(pCaseWhen->pWhenThenList); + break; + } + case QUERY_NODE_EVENT_WINDOW: { + SEventWindowNode* pEvent = (SEventWindowNode*)pNode; + nodesDestroyNode(pEvent->pCol); + nodesDestroyNode(pEvent->pStartCond); + nodesDestroyNode(pEvent->pEndCond); + break; + } + case QUERY_NODE_HINT: { + SHintNode* pHint = (SHintNode*)pNode; + destroyHintValue(pHint->option, pHint->value); + break; + } + case QUERY_NODE_VIEW: { + SViewNode* pView = (SViewNode*)pNode; + taosMemoryFreeClear(pView->pMeta); + taosMemoryFreeClear(pView->pVgroupList); + taosArrayDestroyEx(pView->pSmaIndexes, destroySmaIndex); + break; + } + case QUERY_NODE_SET_OPERATOR: { + SSetOperator* pStmt = (SSetOperator*)pNode; + nodesDestroyList(pStmt->pProjectionList); + nodesDestroyNode(pStmt->pLeft); + nodesDestroyNode(pStmt->pRight); + nodesDestroyList(pStmt->pOrderByList); + nodesDestroyNode(pStmt->pLimit); + break; + } + case QUERY_NODE_SELECT_STMT: { + SSelectStmt* pStmt = (SSelectStmt*)pNode; + nodesDestroyList(pStmt->pProjectionList); + nodesDestroyNode(pStmt->pFromTable); + nodesDestroyNode(pStmt->pWhere); + nodesDestroyList(pStmt->pPartitionByList); + nodesDestroyList(pStmt->pTags); + nodesDestroyNode(pStmt->pSubtable); + nodesDestroyNode(pStmt->pWindow); + nodesDestroyList(pStmt->pGroupByList); + nodesDestroyNode(pStmt->pHaving); + nodesDestroyNode(pStmt->pRange); + nodesDestroyNode(pStmt->pEvery); + nodesDestroyNode(pStmt->pFill); + nodesDestroyList(pStmt->pOrderByList); + nodesDestroyNode((SNode*)pStmt->pLimit); + nodesDestroyNode((SNode*)pStmt->pSlimit); + nodesDestroyList(pStmt->pHint); + break; + } + case QUERY_NODE_VNODE_MODIFY_STMT: { + SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)pNode; + destroyVgDataBlockArray(pStmt->pDataBlocks); + taosMemoryFreeClear(pStmt->pTableMeta); + nodesDestroyNode(pStmt->pTagCond); + taosArrayDestroy(pStmt->pTableTag); + taosHashCleanup(pStmt->pVgroupsHashObj); + taosHashCleanup(pStmt->pSubTableHashObj); + taosHashCleanup(pStmt->pTableNameHashObj); + taosHashCleanup(pStmt->pDbFNameHashObj); + taosHashCleanup(pStmt->pTableCxtHashObj); + if (pStmt->freeHashFunc) { + pStmt->freeHashFunc(pStmt->pTableBlockHashObj); + } + if (pStmt->freeArrayFunc) { + pStmt->freeArrayFunc(pStmt->pVgDataBlocks); + } + tdDestroySVCreateTbReq(pStmt->pCreateTblReq); + taosMemoryFreeClear(pStmt->pCreateTblReq); + if (pStmt->freeStbRowsCxtFunc) { + pStmt->freeStbRowsCxtFunc(pStmt->pStbRowsCxt); + } + taosMemoryFreeClear(pStmt->pStbRowsCxt); + taosCloseFile(&pStmt->fp); + break; + } + case QUERY_NODE_CREATE_DATABASE_STMT: + nodesDestroyNode((SNode*)((SCreateDatabaseStmt*)pNode)->pOptions); + break; + case QUERY_NODE_DROP_DATABASE_STMT: // no pointer field + break; + case QUERY_NODE_ALTER_DATABASE_STMT: + nodesDestroyNode((SNode*)((SAlterDatabaseStmt*)pNode)->pOptions); + break; + case QUERY_NODE_FLUSH_DATABASE_STMT: // no pointer field + case QUERY_NODE_TRIM_DATABASE_STMT: // no pointer field + break; + case QUERY_NODE_CREATE_TABLE_STMT: { + SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode; + nodesDestroyList(pStmt->pCols); + nodesDestroyList(pStmt->pTags); + nodesDestroyNode((SNode*)pStmt->pOptions); + break; + } + case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: { + SCreateSubTableClause* pStmt = (SCreateSubTableClause*)pNode; + nodesDestroyList(pStmt->pSpecificTags); + nodesDestroyList(pStmt->pValsOfTags); + nodesDestroyNode((SNode*)pStmt->pOptions); + break; + } + case QUERY_NODE_CREATE_MULTI_TABLES_STMT: + nodesDestroyList(((SCreateMultiTablesStmt*)pNode)->pSubTables); + break; + case QUERY_NODE_DROP_TABLE_CLAUSE: // no pointer field + break; + case QUERY_NODE_DROP_TABLE_STMT: + nodesDestroyList(((SDropTableStmt*)pNode)->pTables); + break; + case QUERY_NODE_DROP_SUPER_TABLE_STMT: // no pointer field + break; + case QUERY_NODE_ALTER_TABLE_STMT: + case QUERY_NODE_ALTER_SUPER_TABLE_STMT: { + SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode; + nodesDestroyNode((SNode*)pStmt->pOptions); + nodesDestroyNode((SNode*)pStmt->pVal); + break; + } + case QUERY_NODE_CREATE_USER_STMT: { + SCreateUserStmt* pStmt = (SCreateUserStmt*)pNode; + taosMemoryFree(pStmt->pIpRanges); + nodesDestroyList(pStmt->pNodeListIpRanges); + break; + } + case QUERY_NODE_ALTER_USER_STMT: { + SAlterUserStmt* pStmt = (SAlterUserStmt*)pNode; + taosMemoryFree(pStmt->pIpRanges); + nodesDestroyList(pStmt->pNodeListIpRanges); + } + case QUERY_NODE_DROP_USER_STMT: // no pointer field + case QUERY_NODE_USE_DATABASE_STMT: // no pointer field + case QUERY_NODE_CREATE_DNODE_STMT: // no pointer field + case QUERY_NODE_DROP_DNODE_STMT: // no pointer field + case QUERY_NODE_ALTER_DNODE_STMT: // no pointer field + break; + case QUERY_NODE_CREATE_INDEX_STMT: { + SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode; + nodesDestroyNode((SNode*)pStmt->pOptions); + nodesDestroyList(pStmt->pCols); + if (pStmt->pReq) { + tFreeSMCreateSmaReq(pStmt->pReq); + taosMemoryFreeClear(pStmt->pReq); + } + break; + } + case QUERY_NODE_DROP_INDEX_STMT: // no pointer field + case QUERY_NODE_CREATE_QNODE_STMT: // no pointer field + case QUERY_NODE_DROP_QNODE_STMT: // no pointer field + case QUERY_NODE_CREATE_BNODE_STMT: // no pointer field + case QUERY_NODE_DROP_BNODE_STMT: // no pointer field + case QUERY_NODE_CREATE_SNODE_STMT: // no pointer field + case QUERY_NODE_DROP_SNODE_STMT: // no pointer field + case QUERY_NODE_CREATE_MNODE_STMT: // no pointer field + case QUERY_NODE_DROP_MNODE_STMT: // no pointer field + break; + case QUERY_NODE_CREATE_TOPIC_STMT: + nodesDestroyNode(((SCreateTopicStmt*)pNode)->pQuery); + nodesDestroyNode(((SCreateTopicStmt*)pNode)->pWhere); + break; + case QUERY_NODE_DROP_TOPIC_STMT: // no pointer field + case QUERY_NODE_DROP_CGROUP_STMT: // no pointer field + case QUERY_NODE_ALTER_LOCAL_STMT: // no pointer field + break; + case QUERY_NODE_EXPLAIN_STMT: { + SExplainStmt* pStmt = (SExplainStmt*)pNode; + nodesDestroyNode((SNode*)pStmt->pOptions); + nodesDestroyNode(pStmt->pQuery); + break; + } + case QUERY_NODE_DESCRIBE_STMT: + taosMemoryFree(((SDescribeStmt*)pNode)->pMeta); + break; + case QUERY_NODE_RESET_QUERY_CACHE_STMT: // no pointer field + break; + case QUERY_NODE_COMPACT_DATABASE_STMT: { + SCompactDatabaseStmt* pStmt = (SCompactDatabaseStmt*)pNode; + nodesDestroyNode(pStmt->pStart); + nodesDestroyNode(pStmt->pEnd); + break; + } + case QUERY_NODE_CREATE_FUNCTION_STMT: // no pointer field + case QUERY_NODE_DROP_FUNCTION_STMT: // no pointer field + break; + case QUERY_NODE_CREATE_STREAM_STMT: { + SCreateStreamStmt* pStmt = (SCreateStreamStmt*)pNode; + nodesDestroyNode((SNode*)pStmt->pOptions); + nodesDestroyNode(pStmt->pQuery); + nodesDestroyList(pStmt->pTags); + nodesDestroyNode(pStmt->pSubtable); + tFreeSCMCreateStreamReq(pStmt->pReq); + taosMemoryFreeClear(pStmt->pReq); + break; + } + case QUERY_NODE_DROP_STREAM_STMT: // no pointer field + case QUERY_NODE_PAUSE_STREAM_STMT: // no pointer field + case QUERY_NODE_RESUME_STREAM_STMT: // no pointer field + case QUERY_NODE_BALANCE_VGROUP_STMT: // no pointer field + case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: // no pointer field + case QUERY_NODE_MERGE_VGROUP_STMT: // no pointer field + break; + case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: + nodesDestroyList(((SRedistributeVgroupStmt*)pNode)->pDnodes); + break; + case QUERY_NODE_SPLIT_VGROUP_STMT: // no pointer field + case QUERY_NODE_SYNCDB_STMT: // no pointer field + break; + case QUERY_NODE_GRANT_STMT: + nodesDestroyNode(((SGrantStmt*)pNode)->pTagCond); + break; + case QUERY_NODE_REVOKE_STMT: + nodesDestroyNode(((SRevokeStmt*)pNode)->pTagCond); + break; + case QUERY_NODE_SHOW_DNODES_STMT: + case QUERY_NODE_SHOW_MNODES_STMT: + case QUERY_NODE_SHOW_MODULES_STMT: + case QUERY_NODE_SHOW_QNODES_STMT: + case QUERY_NODE_SHOW_SNODES_STMT: + case QUERY_NODE_SHOW_BNODES_STMT: + case QUERY_NODE_SHOW_CLUSTER_STMT: + case QUERY_NODE_SHOW_DATABASES_STMT: + case QUERY_NODE_SHOW_FUNCTIONS_STMT: + case QUERY_NODE_SHOW_INDEXES_STMT: + case QUERY_NODE_SHOW_STABLES_STMT: + case QUERY_NODE_SHOW_STREAMS_STMT: + case QUERY_NODE_SHOW_TABLES_STMT: + case QUERY_NODE_SHOW_USERS_STMT: + case QUERY_NODE_SHOW_LICENCES_STMT: + case QUERY_NODE_SHOW_VGROUPS_STMT: + case QUERY_NODE_SHOW_TOPICS_STMT: + case QUERY_NODE_SHOW_CONSUMERS_STMT: + case QUERY_NODE_SHOW_CONNECTIONS_STMT: + case QUERY_NODE_SHOW_QUERIES_STMT: + case QUERY_NODE_SHOW_VNODES_STMT: + case QUERY_NODE_SHOW_APPS_STMT: + case QUERY_NODE_SHOW_SCORES_STMT: + case QUERY_NODE_SHOW_VARIABLES_STMT: + case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT: + case QUERY_NODE_SHOW_TRANSACTIONS_STMT: + case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT: + case QUERY_NODE_SHOW_TAGS_STMT: + case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT: + case QUERY_NODE_SHOW_VIEWS_STMT: { + SShowStmt* pStmt = (SShowStmt*)pNode; + nodesDestroyNode(pStmt->pDbName); + nodesDestroyNode(pStmt->pTbName); + break; + } + case QUERY_NODE_SHOW_TABLE_TAGS_STMT: { + SShowTableTagsStmt* pStmt = (SShowTableTagsStmt*)pNode; + nodesDestroyNode(pStmt->pDbName); + nodesDestroyNode(pStmt->pTbName); + nodesDestroyList(pStmt->pTags); + break; + } + case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: + nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pDnodeId); + nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pLikePattern); + break; + case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: + taosMemoryFreeClear(((SShowCreateDatabaseStmt*)pNode)->pCfg); + break; + case QUERY_NODE_SHOW_CREATE_TABLE_STMT: + case QUERY_NODE_SHOW_CREATE_STABLE_STMT: + taosMemoryFreeClear(((SShowCreateTableStmt*)pNode)->pDbCfg); + destroyTableCfg((STableCfg*)(((SShowCreateTableStmt*)pNode)->pTableCfg)); + break; + case QUERY_NODE_SHOW_CREATE_VIEW_STMT: // no pointer field + case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: // no pointer field + case QUERY_NODE_KILL_CONNECTION_STMT: // no pointer field + case QUERY_NODE_KILL_QUERY_STMT: // no pointer field + case QUERY_NODE_KILL_TRANSACTION_STMT: // no pointer field + break; + case QUERY_NODE_DELETE_STMT: { + SDeleteStmt* pStmt = (SDeleteStmt*)pNode; + nodesDestroyNode(pStmt->pFromTable); + nodesDestroyNode(pStmt->pWhere); + nodesDestroyNode(pStmt->pCountFunc); + nodesDestroyNode(pStmt->pFirstFunc); + nodesDestroyNode(pStmt->pLastFunc); + nodesDestroyNode(pStmt->pTagCond); + break; + } + case QUERY_NODE_INSERT_STMT: { + SInsertStmt* pStmt = (SInsertStmt*)pNode; + nodesDestroyNode(pStmt->pTable); + nodesDestroyList(pStmt->pCols); + nodesDestroyNode(pStmt->pQuery); + break; + } + case QUERY_NODE_QUERY: { + SQuery* pQuery = (SQuery*)pNode; + nodesDestroyNode(pQuery->pPrevRoot); + nodesDestroyNode(pQuery->pRoot); + nodesDestroyNode(pQuery->pPostRoot); + taosMemoryFreeClear(pQuery->pResSchema); + if (NULL != pQuery->pCmdMsg) { + taosMemoryFreeClear(pQuery->pCmdMsg->pMsg); + taosMemoryFreeClear(pQuery->pCmdMsg); + } + taosArrayDestroy(pQuery->pDbList); + taosArrayDestroy(pQuery->pTableList); + taosArrayDestroy(pQuery->pTargetTableList); + taosArrayDestroy(pQuery->pPlaceholderValues); + nodesDestroyNode(pQuery->pPrepareRoot); + break; + } + case QUERY_NODE_RESTORE_DNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_QNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_MNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_VNODE_STMT: // no pointer field + break; + case QUERY_NODE_CREATE_VIEW_STMT: { + SCreateViewStmt* pStmt = (SCreateViewStmt*)pNode; + taosMemoryFree(pStmt->pQuerySql); + tFreeSCMCreateViewReq(&pStmt->createReq); + nodesDestroyNode(pStmt->pQuery); + break; + } + case QUERY_NODE_DROP_VIEW_STMT: + break; + case QUERY_NODE_LOGIC_PLAN_SCAN: { + SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pScanCols); + nodesDestroyList(pLogicNode->pScanPseudoCols); + taosMemoryFreeClear(pLogicNode->pVgroupList); + nodesDestroyList(pLogicNode->pDynamicScanFuncs); + nodesDestroyNode(pLogicNode->pTagCond); + nodesDestroyNode(pLogicNode->pTagIndexCond); + taosArrayDestroyEx(pLogicNode->pSmaIndexes, destroySmaIndex); + nodesDestroyList(pLogicNode->pGroupTags); + nodesDestroyList(pLogicNode->pTags); + nodesDestroyNode(pLogicNode->pSubtable); + break; + } + case QUERY_NODE_LOGIC_PLAN_JOIN: { + SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyNode(pLogicNode->pPrimKeyEqCond); + nodesDestroyNode(pLogicNode->pOtherOnCond); + nodesDestroyNode(pLogicNode->pColEqCond); + break; + } + case QUERY_NODE_LOGIC_PLAN_AGG: { + SAggLogicNode* pLogicNode = (SAggLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pAggFuncs); + nodesDestroyList(pLogicNode->pGroupKeys); + break; + } + case QUERY_NODE_LOGIC_PLAN_PROJECT: { + SProjectLogicNode* pLogicNode = (SProjectLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pProjections); + break; + } + case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: { + SVnodeModifyLogicNode* pLogicNode = (SVnodeModifyLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + destroyVgDataBlockArray(pLogicNode->pDataBlocks); + // pVgDataBlocks is weak reference + nodesDestroyNode(pLogicNode->pAffectedRows); + nodesDestroyNode(pLogicNode->pStartTs); + nodesDestroyNode(pLogicNode->pEndTs); + taosMemoryFreeClear(pLogicNode->pVgroupList); + nodesDestroyList(pLogicNode->pInsertCols); + break; + } + case QUERY_NODE_LOGIC_PLAN_EXCHANGE: + destroyLogicNode((SLogicNode*)pNode); + break; + case QUERY_NODE_LOGIC_PLAN_MERGE: { + SMergeLogicNode* pLogicNode = (SMergeLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pMergeKeys); + nodesDestroyList(pLogicNode->pInputs); + break; + } + case QUERY_NODE_LOGIC_PLAN_WINDOW: { + SWindowLogicNode* pLogicNode = (SWindowLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pFuncs); + nodesDestroyNode(pLogicNode->pTspk); + nodesDestroyNode(pLogicNode->pTsEnd); + nodesDestroyNode(pLogicNode->pStateExpr); + nodesDestroyNode(pLogicNode->pStartCond); + nodesDestroyNode(pLogicNode->pEndCond); + break; + } + case QUERY_NODE_LOGIC_PLAN_FILL: { + SFillLogicNode* pLogicNode = (SFillLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyNode(pLogicNode->pWStartTs); + nodesDestroyNode(pLogicNode->pValues); + nodesDestroyList(pLogicNode->pFillExprs); + nodesDestroyList(pLogicNode->pNotFillExprs); + break; + } + case QUERY_NODE_LOGIC_PLAN_SORT: { + SSortLogicNode* pLogicNode = (SSortLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pSortKeys); + break; + } + case QUERY_NODE_LOGIC_PLAN_PARTITION: { + SPartitionLogicNode* pLogicNode = (SPartitionLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pPartitionKeys); + nodesDestroyList(pLogicNode->pTags); + nodesDestroyNode(pLogicNode->pSubtable); + nodesDestroyList(pLogicNode->pAggFuncs); + break; + } + case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: { + SIndefRowsFuncLogicNode* pLogicNode = (SIndefRowsFuncLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pFuncs); + break; + } + case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: { + SInterpFuncLogicNode* pLogicNode = (SInterpFuncLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pFuncs); + nodesDestroyNode(pLogicNode->pFillValues); + nodesDestroyNode(pLogicNode->pTimeSeries); + break; + } + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: { + SGroupCacheLogicNode* pLogicNode = (SGroupCacheLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + nodesDestroyList(pLogicNode->pGroupCols); + break; + } + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: { + SDynQueryCtrlLogicNode* pLogicNode = (SDynQueryCtrlLogicNode*)pNode; + destroyLogicNode((SLogicNode*)pLogicNode); + break; + } + case QUERY_NODE_LOGIC_SUBPLAN: { + SLogicSubplan* pSubplan = (SLogicSubplan*)pNode; + nodesDestroyList(pSubplan->pChildren); + nodesDestroyNode((SNode*)pSubplan->pNode); + nodesClearList(pSubplan->pParents); + taosMemoryFreeClear(pSubplan->pVgroupList); + break; + } + case QUERY_NODE_LOGIC_PLAN: + nodesDestroyList(((SQueryLogicPlan*)pNode)->pTopSubplans); + break; + case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: + destroyScanPhysiNode((SScanPhysiNode*)pNode); + break; + case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: { + SLastRowScanPhysiNode* pPhyNode = (SLastRowScanPhysiNode*)pNode; + destroyScanPhysiNode((SScanPhysiNode*)pNode); + nodesDestroyList(pPhyNode->pGroupTags); + nodesDestroyList(pPhyNode->pTargets); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: { + STableScanPhysiNode* pPhyNode = (STableScanPhysiNode*)pNode; + destroyScanPhysiNode((SScanPhysiNode*)pNode); + nodesDestroyList(pPhyNode->pDynamicScanFuncs); + nodesDestroyList(pPhyNode->pGroupTags); + nodesDestroyList(pPhyNode->pTags); + nodesDestroyNode(pPhyNode->pSubtable); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_PROJECT: { + SProjectPhysiNode* pPhyNode = (SProjectPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pProjections); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: { + SSortMergeJoinPhysiNode* pPhyNode = (SSortMergeJoinPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyNode(pPhyNode->pPrimKeyCond); + nodesDestroyNode(pPhyNode->pOtherOnCond); + nodesDestroyList(pPhyNode->pTargets); + nodesDestroyNode(pPhyNode->pColEqCond); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: { + SHashJoinPhysiNode* pPhyNode = (SHashJoinPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pOnLeft); + nodesDestroyList(pPhyNode->pOnRight); + nodesDestroyNode(pPhyNode->pFilterConditions); + nodesDestroyList(pPhyNode->pTargets); + + nodesDestroyNode(pPhyNode->pPrimKeyCond); + nodesDestroyNode(pPhyNode->pColEqCond); + nodesDestroyNode(pPhyNode->pTagEqCond); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: { + SAggPhysiNode* pPhyNode = (SAggPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pExprs); + nodesDestroyList(pPhyNode->pAggFuncs); + nodesDestroyList(pPhyNode->pGroupKeys); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: { + SExchangePhysiNode* pPhyNode = (SExchangePhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pSrcEndPoints); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_MERGE: { + SMergePhysiNode* pPhyNode = (SMergePhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pMergeKeys); + nodesDestroyList(pPhyNode->pTargets); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_SORT: + case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: { + SSortPhysiNode* pPhyNode = (SSortPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pExprs); + nodesDestroyList(pPhyNode->pSortKeys); + nodesDestroyList(pPhyNode->pTargets); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: + destroyWinodwPhysiNode((SWindowPhysiNode*)pNode); + break; + case QUERY_NODE_PHYSICAL_PLAN_FILL: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: { + SFillPhysiNode* pPhyNode = (SFillPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pFillExprs); + nodesDestroyList(pPhyNode->pNotFillExprs); + nodesDestroyNode(pPhyNode->pWStartTs); + nodesDestroyNode(pPhyNode->pValues); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: + destroyWinodwPhysiNode((SWindowPhysiNode*)pNode); + break; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: { + SStateWinodwPhysiNode* pPhyNode = (SStateWinodwPhysiNode*)pNode; + destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode); + nodesDestroyNode(pPhyNode->pStateKey); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: + case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: { + SEventWinodwPhysiNode* pPhyNode = (SEventWinodwPhysiNode*)pNode; + destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode); + nodesDestroyNode(pPhyNode->pStartCond); + nodesDestroyNode(pPhyNode->pEndCond); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_PARTITION: { + destroyPartitionPhysiNode((SPartitionPhysiNode*)pNode); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: { + SStreamPartitionPhysiNode* pPhyNode = (SStreamPartitionPhysiNode*)pNode; + destroyPartitionPhysiNode((SPartitionPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pTags); + nodesDestroyNode(pPhyNode->pSubtable); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: { + SIndefRowsFuncPhysiNode* pPhyNode = (SIndefRowsFuncPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pExprs); + nodesDestroyList(pPhyNode->pFuncs); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: { + SInterpFuncPhysiNode* pPhyNode = (SInterpFuncPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pExprs); + nodesDestroyList(pPhyNode->pFuncs); + nodesDestroyNode(pPhyNode->pFillValues); + nodesDestroyNode(pPhyNode->pTimeSeries); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: + destroyDataSinkNode((SDataSinkNode*)pNode); + break; + case QUERY_NODE_PHYSICAL_PLAN_INSERT: { + SDataInserterNode* pSink = (SDataInserterNode*)pNode; + destroyDataSinkNode((SDataSinkNode*)pSink); + taosMemoryFreeClear(pSink->pData); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: { + SQueryInserterNode* pSink = (SQueryInserterNode*)pNode; + destroyDataSinkNode((SDataSinkNode*)pSink); + nodesDestroyList(pSink->pCols); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_DELETE: { + SDataDeleterNode* pSink = (SDataDeleterNode*)pNode; + destroyDataSinkNode((SDataSinkNode*)pSink); + nodesDestroyNode(pSink->pAffectedRows); + nodesDestroyNode(pSink->pStartTs); + nodesDestroyNode(pSink->pEndTs); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: { + SGroupCachePhysiNode* pPhyNode = (SGroupCachePhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + nodesDestroyList(pPhyNode->pGroupCols); + break; + } + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: { + SDynQueryCtrlPhysiNode* pPhyNode = (SDynQueryCtrlPhysiNode*)pNode; + destroyPhysiNode((SPhysiNode*)pPhyNode); + break; + } + case QUERY_NODE_PHYSICAL_SUBPLAN: { + SSubplan* pSubplan = (SSubplan*)pNode; + nodesClearList(pSubplan->pChildren); + nodesDestroyNode((SNode*)pSubplan->pNode); + nodesDestroyNode((SNode*)pSubplan->pDataSink); + nodesDestroyNode((SNode*)pSubplan->pTagCond); + nodesDestroyNode((SNode*)pSubplan->pTagIndexCond); + nodesClearList(pSubplan->pParents); + break; + } + case QUERY_NODE_PHYSICAL_PLAN: + nodesDestroyList(((SQueryPlan*)pNode)->pSubplans); + break; + default: + break; + } + nodesFree(pNode); + return; +} SNodeList* nodesMakeList() { SNodeList* p = nodesCalloc(1, sizeof(SNodeList));