diff --git a/include/common/tdatablock.h b/include/common/tdatablock.h index dac723aa58..244894b59b 100644 --- a/include/common/tdatablock.h +++ b/include/common/tdatablock.h @@ -179,6 +179,8 @@ int32_t getJsonValueLen(const char* data); int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull); int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx, const char* pData); int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, uint32_t numOfRows, bool trimValue); +int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, + uint32_t numOfRows, bool isNull); int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity, const SColumnInfoData* pSource, int32_t numOfRow2); int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows, diff --git a/include/common/tmsg.h b/include/common/tmsg.h index d7409da126..ba9db9d88f 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -212,6 +212,215 @@ typedef enum _mgmt_table { #define TD_REQ_FROM_APP 0 #define TD_REQ_FROM_TAOX 1 +typedef enum ENodeType { + // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN, + // VALUE, OPERATOR, FUNCTION and so on. + QUERY_NODE_COLUMN = 1, + QUERY_NODE_VALUE, + QUERY_NODE_OPERATOR, + QUERY_NODE_LOGIC_CONDITION, + QUERY_NODE_FUNCTION, + QUERY_NODE_REAL_TABLE, + QUERY_NODE_TEMP_TABLE, + QUERY_NODE_JOIN_TABLE, + QUERY_NODE_GROUPING_SET, + QUERY_NODE_ORDER_BY_EXPR, + QUERY_NODE_LIMIT, + QUERY_NODE_STATE_WINDOW, + QUERY_NODE_SESSION_WINDOW, + QUERY_NODE_INTERVAL_WINDOW, + QUERY_NODE_NODE_LIST, + QUERY_NODE_FILL, + QUERY_NODE_RAW_EXPR, // Only be used in parser module. + QUERY_NODE_TARGET, + QUERY_NODE_DATABLOCK_DESC, + QUERY_NODE_SLOT_DESC, + QUERY_NODE_COLUMN_DEF, + QUERY_NODE_DOWNSTREAM_SOURCE, + QUERY_NODE_DATABASE_OPTIONS, + QUERY_NODE_TABLE_OPTIONS, + QUERY_NODE_INDEX_OPTIONS, + QUERY_NODE_EXPLAIN_OPTIONS, + QUERY_NODE_STREAM_OPTIONS, + QUERY_NODE_LEFT_VALUE, + QUERY_NODE_COLUMN_REF, + QUERY_NODE_WHEN_THEN, + QUERY_NODE_CASE_WHEN, + QUERY_NODE_EVENT_WINDOW, + QUERY_NODE_HINT, + + // Statement nodes are used in parser and planner module. + QUERY_NODE_SET_OPERATOR = 100, + QUERY_NODE_SELECT_STMT, + QUERY_NODE_VNODE_MODIFY_STMT, + QUERY_NODE_CREATE_DATABASE_STMT, + QUERY_NODE_DROP_DATABASE_STMT, + QUERY_NODE_ALTER_DATABASE_STMT, + QUERY_NODE_FLUSH_DATABASE_STMT, + QUERY_NODE_TRIM_DATABASE_STMT, + QUERY_NODE_CREATE_TABLE_STMT, + QUERY_NODE_CREATE_SUBTABLE_CLAUSE, + QUERY_NODE_CREATE_MULTI_TABLES_STMT, + QUERY_NODE_DROP_TABLE_CLAUSE, + QUERY_NODE_DROP_TABLE_STMT, + QUERY_NODE_DROP_SUPER_TABLE_STMT, + QUERY_NODE_ALTER_TABLE_STMT, + QUERY_NODE_ALTER_SUPER_TABLE_STMT, + QUERY_NODE_CREATE_USER_STMT, + QUERY_NODE_ALTER_USER_STMT, + QUERY_NODE_DROP_USER_STMT, + QUERY_NODE_USE_DATABASE_STMT, + QUERY_NODE_CREATE_DNODE_STMT, + QUERY_NODE_DROP_DNODE_STMT, + QUERY_NODE_ALTER_DNODE_STMT, + QUERY_NODE_CREATE_INDEX_STMT, + QUERY_NODE_DROP_INDEX_STMT, + QUERY_NODE_CREATE_QNODE_STMT, + QUERY_NODE_DROP_QNODE_STMT, + QUERY_NODE_CREATE_BNODE_STMT, + QUERY_NODE_DROP_BNODE_STMT, + QUERY_NODE_CREATE_SNODE_STMT, + QUERY_NODE_DROP_SNODE_STMT, + QUERY_NODE_CREATE_MNODE_STMT, + QUERY_NODE_DROP_MNODE_STMT, + QUERY_NODE_CREATE_TOPIC_STMT, + QUERY_NODE_DROP_TOPIC_STMT, + QUERY_NODE_DROP_CGROUP_STMT, + QUERY_NODE_ALTER_LOCAL_STMT, + QUERY_NODE_EXPLAIN_STMT, + QUERY_NODE_DESCRIBE_STMT, + QUERY_NODE_RESET_QUERY_CACHE_STMT, + QUERY_NODE_COMPACT_DATABASE_STMT, + QUERY_NODE_CREATE_FUNCTION_STMT, + QUERY_NODE_DROP_FUNCTION_STMT, + QUERY_NODE_CREATE_STREAM_STMT, + QUERY_NODE_DROP_STREAM_STMT, + QUERY_NODE_BALANCE_VGROUP_STMT, + QUERY_NODE_MERGE_VGROUP_STMT, + QUERY_NODE_REDISTRIBUTE_VGROUP_STMT, + QUERY_NODE_SPLIT_VGROUP_STMT, + QUERY_NODE_SYNCDB_STMT, + QUERY_NODE_GRANT_STMT, + QUERY_NODE_REVOKE_STMT, + QUERY_NODE_SHOW_DNODES_STMT, + QUERY_NODE_SHOW_MNODES_STMT, + QUERY_NODE_SHOW_MODULES_STMT, + QUERY_NODE_SHOW_QNODES_STMT, + QUERY_NODE_SHOW_SNODES_STMT, + QUERY_NODE_SHOW_BNODES_STMT, + QUERY_NODE_SHOW_CLUSTER_STMT, + QUERY_NODE_SHOW_DATABASES_STMT, + QUERY_NODE_SHOW_FUNCTIONS_STMT, + QUERY_NODE_SHOW_INDEXES_STMT, + QUERY_NODE_SHOW_STABLES_STMT, + QUERY_NODE_SHOW_STREAMS_STMT, + QUERY_NODE_SHOW_TABLES_STMT, + QUERY_NODE_SHOW_TAGS_STMT, + QUERY_NODE_SHOW_USERS_STMT, + QUERY_NODE_SHOW_LICENCES_STMT, + QUERY_NODE_SHOW_VGROUPS_STMT, + QUERY_NODE_SHOW_TOPICS_STMT, + QUERY_NODE_SHOW_CONSUMERS_STMT, + QUERY_NODE_SHOW_CONNECTIONS_STMT, + QUERY_NODE_SHOW_QUERIES_STMT, + QUERY_NODE_SHOW_APPS_STMT, + QUERY_NODE_SHOW_VARIABLES_STMT, + QUERY_NODE_SHOW_DNODE_VARIABLES_STMT, + QUERY_NODE_SHOW_TRANSACTIONS_STMT, + QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT, + QUERY_NODE_SHOW_VNODES_STMT, + QUERY_NODE_SHOW_USER_PRIVILEGES_STMT, + QUERY_NODE_SHOW_CREATE_DATABASE_STMT, + QUERY_NODE_SHOW_CREATE_TABLE_STMT, + QUERY_NODE_SHOW_CREATE_STABLE_STMT, + QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT, + QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT, + QUERY_NODE_SHOW_SCORES_STMT, + QUERY_NODE_SHOW_TABLE_TAGS_STMT, + QUERY_NODE_KILL_CONNECTION_STMT, + QUERY_NODE_KILL_QUERY_STMT, + QUERY_NODE_KILL_TRANSACTION_STMT, + QUERY_NODE_DELETE_STMT, + QUERY_NODE_INSERT_STMT, + QUERY_NODE_QUERY, + QUERY_NODE_SHOW_DB_ALIVE_STMT, + QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT, + QUERY_NODE_BALANCE_VGROUP_LEADER_STMT, + QUERY_NODE_RESTORE_DNODE_STMT, + QUERY_NODE_RESTORE_QNODE_STMT, + QUERY_NODE_RESTORE_MNODE_STMT, + QUERY_NODE_RESTORE_VNODE_STMT, + QUERY_NODE_PAUSE_STREAM_STMT, + QUERY_NODE_RESUME_STREAM_STMT, + + // logic plan node + QUERY_NODE_LOGIC_PLAN_SCAN = 1000, + QUERY_NODE_LOGIC_PLAN_JOIN, + QUERY_NODE_LOGIC_PLAN_AGG, + QUERY_NODE_LOGIC_PLAN_PROJECT, + QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, + QUERY_NODE_LOGIC_PLAN_EXCHANGE, + QUERY_NODE_LOGIC_PLAN_MERGE, + QUERY_NODE_LOGIC_PLAN_WINDOW, + QUERY_NODE_LOGIC_PLAN_FILL, + QUERY_NODE_LOGIC_PLAN_SORT, + QUERY_NODE_LOGIC_PLAN_PARTITION, + QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, + QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, + QUERY_NODE_LOGIC_SUBPLAN, + QUERY_NODE_LOGIC_PLAN, + QUERY_NODE_LOGIC_PLAN_GROUP_CACHE, + QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL, + + // physical plan node + QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN = 1100, + QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, + QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, + QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, + QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, + QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, + QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, + QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, + QUERY_NODE_PHYSICAL_PLAN_PROJECT, + QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN, + QUERY_NODE_PHYSICAL_PLAN_HASH_AGG, + QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, + QUERY_NODE_PHYSICAL_PLAN_MERGE, + QUERY_NODE_PHYSICAL_PLAN_SORT, + QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, + QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL, + QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL, + QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL, + QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, + QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL, + QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL, + QUERY_NODE_PHYSICAL_PLAN_FILL, + QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, + QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION, + QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION, + QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION, + QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION, + QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, + QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE, + QUERY_NODE_PHYSICAL_PLAN_PARTITION, + QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION, + QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC, + QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, + QUERY_NODE_PHYSICAL_PLAN_DISPATCH, + QUERY_NODE_PHYSICAL_PLAN_INSERT, + QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT, + QUERY_NODE_PHYSICAL_PLAN_DELETE, + QUERY_NODE_PHYSICAL_SUBPLAN, + QUERY_NODE_PHYSICAL_PLAN, + QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, + QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT, + QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT, + QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN, + QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE, + QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL +} ENodeType; + + typedef struct { int32_t vgId; char* dbFName; @@ -743,6 +952,10 @@ typedef struct STimeWindow { TSKEY ekey; } STimeWindow; +typedef struct SQueryHint { + bool batchScan; +} SQueryHint; + typedef struct { int32_t tsOffset; // offset value in current msg body, NOTE: ts list is compressed int32_t tsLen; // total length of ts comp block @@ -761,12 +974,18 @@ typedef struct { int64_t offset; } SInterval; -typedef struct { - int32_t code; + +typedef struct STbVerInfo { char tbFName[TSDB_TABLE_FNAME_LEN]; int32_t sversion; int32_t tversion; +} STbVerInfo; + + +typedef struct { + int32_t code; int64_t affectedRows; + SArray* tbVerInfo; // STbVerInfo } SQueryTableRsp; int32_t tSerializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp); @@ -1836,12 +2055,26 @@ typedef struct { int32_t tversion; } SResReadyRsp; + +typedef struct SOperatorParam { + int32_t opType; + int32_t downstreamIdx; + void* value; + SArray* pChildren; //SArray +} SOperatorParam; + +typedef struct STableScanOperatorParam { + bool tableSeq; + SArray* pUidList; +} STableScanOperatorParam; + typedef struct { - SMsgHead header; - uint64_t sId; - uint64_t queryId; - uint64_t taskId; - int32_t execId; + SMsgHead header; + uint64_t sId; + uint64_t queryId; + uint64_t taskId; + int32_t execId; + SOperatorParam* pOpParam; } SResFetchReq; int32_t tSerializeSResFetchReq(void* buf, int32_t bufLen, SResFetchReq* pReq); diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index 0d21e91a08..42b9bc8939 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -276,90 +276,98 @@ #define TK_JOIN 258 #define TK_INNER 259 #define TK_SELECT 260 -#define TK_DISTINCT 261 -#define TK_WHERE 262 -#define TK_PARTITION 263 -#define TK_BY 264 -#define TK_SESSION 265 -#define TK_STATE_WINDOW 266 -#define TK_EVENT_WINDOW 267 -#define TK_SLIDING 268 -#define TK_FILL 269 -#define TK_VALUE 270 -#define TK_VALUE_F 271 -#define TK_NONE 272 -#define TK_PREV 273 -#define TK_NULL_F 274 -#define TK_LINEAR 275 -#define TK_NEXT 276 -#define TK_HAVING 277 -#define TK_RANGE 278 -#define TK_EVERY 279 -#define TK_ORDER 280 -#define TK_SLIMIT 281 -#define TK_SOFFSET 282 -#define TK_LIMIT 283 -#define TK_OFFSET 284 -#define TK_ASC 285 -#define TK_NULLS 286 -#define TK_ABORT 287 -#define TK_AFTER 288 -#define TK_ATTACH 289 -#define TK_BEFORE 290 -#define TK_BEGIN 291 -#define TK_BITAND 292 -#define TK_BITNOT 293 -#define TK_BITOR 294 -#define TK_BLOCKS 295 -#define TK_CHANGE 296 -#define TK_COMMA 297 -#define TK_CONCAT 298 -#define TK_CONFLICT 299 -#define TK_COPY 300 -#define TK_DEFERRED 301 -#define TK_DELIMITERS 302 -#define TK_DETACH 303 -#define TK_DIVIDE 304 -#define TK_DOT 305 -#define TK_EACH 306 -#define TK_FAIL 307 -#define TK_FILE 308 -#define TK_FOR 309 -#define TK_GLOB 310 -#define TK_ID 311 -#define TK_IMMEDIATE 312 -#define TK_IMPORT 313 -#define TK_INITIALLY 314 -#define TK_INSTEAD 315 -#define TK_ISNULL 316 -#define TK_KEY 317 -#define TK_MODULES 318 -#define TK_NK_BITNOT 319 -#define TK_NK_SEMI 320 -#define TK_NOTNULL 321 -#define TK_OF 322 -#define TK_PLUS 323 -#define TK_PRIVILEGE 324 -#define TK_RAISE 325 -#define TK_RESTRICT 326 -#define TK_ROW 327 -#define TK_SEMI 328 -#define TK_STAR 329 -#define TK_STATEMENT 330 -#define TK_STRICT 331 -#define TK_STRING 332 -#define TK_TIMES 333 -#define TK_VALUES 334 -#define TK_VARIABLE 335 -#define TK_VIEW 336 -#define TK_WAL 337 +#define TK_NK_HINT 261 +#define TK_DISTINCT 262 +#define TK_WHERE 263 +#define TK_PARTITION 264 +#define TK_BY 265 +#define TK_SESSION 266 +#define TK_STATE_WINDOW 267 +#define TK_EVENT_WINDOW 268 +#define TK_SLIDING 269 +#define TK_FILL 270 +#define TK_VALUE 271 +#define TK_VALUE_F 272 +#define TK_NONE 273 +#define TK_PREV 274 +#define TK_NULL_F 275 +#define TK_LINEAR 276 +#define TK_NEXT 277 +#define TK_HAVING 278 +#define TK_RANGE 279 +#define TK_EVERY 280 +#define TK_ORDER 281 +#define TK_SLIMIT 282 +#define TK_SOFFSET 283 +#define TK_LIMIT 284 +#define TK_OFFSET 285 +#define TK_ASC 286 +#define TK_NULLS 287 +#define TK_ABORT 288 +#define TK_AFTER 289 +#define TK_ATTACH 290 +#define TK_BEFORE 291 +#define TK_BEGIN 292 +#define TK_BITAND 293 +#define TK_BITNOT 294 +#define TK_BITOR 295 +#define TK_BLOCKS 296 +#define TK_CHANGE 297 +#define TK_COMMA 298 +#define TK_CONCAT 299 +#define TK_CONFLICT 300 +#define TK_COPY 301 +#define TK_DEFERRED 302 +#define TK_DELIMITERS 303 +#define TK_DETACH 304 +#define TK_DIVIDE 305 +#define TK_DOT 306 +#define TK_EACH 307 +#define TK_FAIL 308 +#define TK_FILE 309 +#define TK_FOR 310 +#define TK_GLOB 311 +#define TK_ID 312 +#define TK_IMMEDIATE 313 +#define TK_IMPORT 314 +#define TK_INITIALLY 315 +#define TK_INSTEAD 316 +#define TK_ISNULL 317 +#define TK_KEY 318 +#define TK_MODULES 319 +#define TK_NK_BITNOT 320 +#define TK_NK_SEMI 321 +#define TK_NOTNULL 322 +#define TK_OF 323 +#define TK_PLUS 324 +#define TK_PRIVILEGE 325 +#define TK_RAISE 326 +#define TK_RESTRICT 327 +#define TK_ROW 328 +#define TK_SEMI 329 +#define TK_STAR 330 +#define TK_STATEMENT 331 +#define TK_STRICT 332 +#define TK_STRING 333 +#define TK_TIMES 334 +#define TK_VALUES 335 +#define TK_VARIABLE 336 +#define TK_VIEW 337 +#define TK_WAL 338 + + + + + +#define TK_NK_SPACE 600 +#define TK_NK_COMMENT 601 +#define TK_NK_ILLEGAL 602 +#define TK_NK_HEX 603 // hex number 0x123 +#define TK_NK_OCT 604 // oct number +#define TK_NK_BIN 605 // bin format data 0b111 +#define TK_BATCH_SCAN 606 +#define TK_NO_BATCH_SCAN 607 -#define TK_NK_SPACE 600 -#define TK_NK_COMMENT 601 -#define TK_NK_ILLEGAL 602 -#define TK_NK_HEX 603 // hex number 0x123 -#define TK_NK_OCT 604 // oct number -#define TK_NK_BIN 605 // bin format data 0b111 #define TK_NK_NIL 65535 diff --git a/include/libs/executor/dataSinkMgt.h b/include/libs/executor/dataSinkMgt.h index 0a9037d21c..617ca7c23a 100644 --- a/include/libs/executor/dataSinkMgt.h +++ b/include/libs/executor/dataSinkMgt.h @@ -97,6 +97,8 @@ int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, bool* pC void dsEndPut(DataSinkHandle handle, uint64_t useconds); +void dsReset(DataSinkHandle handle); + /** * Get the length of the data returned by the next call to dsGetDataBlock. * @param handle diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h index e301a37af1..5990ae1c9c 100644 --- a/include/libs/executor/executor.h +++ b/include/libs/executor/executor.h @@ -125,6 +125,10 @@ int32_t qSetSMAInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, */ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableIdList, bool isAdd); +bool qIsDynamicExecTask(qTaskInfo_t tinfo); + +void qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam); + /** * Create the exec task object according to task json * @param readHandle @@ -145,7 +149,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, * @return */ int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion, - int32_t* tversion); + int32_t* tversion, int32_t idx); /** * The main task execution function, including query on both table and multiple tables, diff --git a/include/libs/function/functionMgt.h b/include/libs/function/functionMgt.h index eebb69e6ba..7347cc5a4d 100644 --- a/include/libs/function/functionMgt.h +++ b/include/libs/function/functionMgt.h @@ -122,6 +122,8 @@ typedef enum EFunctionType { FUNCTION_TYPE_IROWTS, FUNCTION_TYPE_ISFILLED, FUNCTION_TYPE_TAGS, + FUNCTION_TYPE_TBUID, + FUNCTION_TYPE_VGID, // internal function FUNCTION_TYPE_SELECT_VALUE = 3750, diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h index 8eeeff4148..6e36ea7514 100644 --- a/include/libs/nodes/nodes.h +++ b/include/libs/nodes/nodes.h @@ -21,6 +21,7 @@ extern "C" { #endif #include "tdef.h" +#include "tmsg.h" #define nodeType(nodeptr) (((const SNode*)(nodeptr))->type) #define setNodeType(nodeptr, nodetype) (((SNode*)(nodeptr))->type = (nodetype)) @@ -78,208 +79,6 @@ extern "C" { (list) = NULL; \ } while (0) -typedef enum ENodeType { - // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN, - // VALUE, OPERATOR, FUNCTION and so on. - QUERY_NODE_COLUMN = 1, - QUERY_NODE_VALUE, - QUERY_NODE_OPERATOR, - QUERY_NODE_LOGIC_CONDITION, - QUERY_NODE_FUNCTION, - QUERY_NODE_REAL_TABLE, - QUERY_NODE_TEMP_TABLE, - QUERY_NODE_JOIN_TABLE, - QUERY_NODE_GROUPING_SET, - QUERY_NODE_ORDER_BY_EXPR, - QUERY_NODE_LIMIT, - QUERY_NODE_STATE_WINDOW, - QUERY_NODE_SESSION_WINDOW, - QUERY_NODE_INTERVAL_WINDOW, - QUERY_NODE_NODE_LIST, - QUERY_NODE_FILL, - QUERY_NODE_RAW_EXPR, // Only be used in parser module. - QUERY_NODE_TARGET, - QUERY_NODE_DATABLOCK_DESC, - QUERY_NODE_SLOT_DESC, - QUERY_NODE_COLUMN_DEF, - QUERY_NODE_DOWNSTREAM_SOURCE, - QUERY_NODE_DATABASE_OPTIONS, - QUERY_NODE_TABLE_OPTIONS, - QUERY_NODE_INDEX_OPTIONS, - QUERY_NODE_EXPLAIN_OPTIONS, - QUERY_NODE_STREAM_OPTIONS, - QUERY_NODE_LEFT_VALUE, - QUERY_NODE_COLUMN_REF, - QUERY_NODE_WHEN_THEN, - QUERY_NODE_CASE_WHEN, - QUERY_NODE_EVENT_WINDOW, - - // Statement nodes are used in parser and planner module. - QUERY_NODE_SET_OPERATOR = 100, - QUERY_NODE_SELECT_STMT, - QUERY_NODE_VNODE_MODIFY_STMT, - QUERY_NODE_CREATE_DATABASE_STMT, - QUERY_NODE_DROP_DATABASE_STMT, - QUERY_NODE_ALTER_DATABASE_STMT, - QUERY_NODE_FLUSH_DATABASE_STMT, - QUERY_NODE_TRIM_DATABASE_STMT, - QUERY_NODE_CREATE_TABLE_STMT, - QUERY_NODE_CREATE_SUBTABLE_CLAUSE, - QUERY_NODE_CREATE_MULTI_TABLES_STMT, - QUERY_NODE_DROP_TABLE_CLAUSE, - QUERY_NODE_DROP_TABLE_STMT, - QUERY_NODE_DROP_SUPER_TABLE_STMT, - QUERY_NODE_ALTER_TABLE_STMT, - QUERY_NODE_ALTER_SUPER_TABLE_STMT, - QUERY_NODE_CREATE_USER_STMT, - QUERY_NODE_ALTER_USER_STMT, - QUERY_NODE_DROP_USER_STMT, - QUERY_NODE_USE_DATABASE_STMT, - QUERY_NODE_CREATE_DNODE_STMT, - QUERY_NODE_DROP_DNODE_STMT, - QUERY_NODE_ALTER_DNODE_STMT, - QUERY_NODE_CREATE_INDEX_STMT, - QUERY_NODE_DROP_INDEX_STMT, - QUERY_NODE_CREATE_QNODE_STMT, - QUERY_NODE_DROP_QNODE_STMT, - QUERY_NODE_CREATE_BNODE_STMT, - QUERY_NODE_DROP_BNODE_STMT, - QUERY_NODE_CREATE_SNODE_STMT, - QUERY_NODE_DROP_SNODE_STMT, - QUERY_NODE_CREATE_MNODE_STMT, - QUERY_NODE_DROP_MNODE_STMT, - QUERY_NODE_CREATE_TOPIC_STMT, - QUERY_NODE_DROP_TOPIC_STMT, - QUERY_NODE_DROP_CGROUP_STMT, - QUERY_NODE_ALTER_LOCAL_STMT, - QUERY_NODE_EXPLAIN_STMT, - QUERY_NODE_DESCRIBE_STMT, - QUERY_NODE_RESET_QUERY_CACHE_STMT, - QUERY_NODE_COMPACT_DATABASE_STMT, - QUERY_NODE_CREATE_FUNCTION_STMT, - QUERY_NODE_DROP_FUNCTION_STMT, - QUERY_NODE_CREATE_STREAM_STMT, - QUERY_NODE_DROP_STREAM_STMT, - QUERY_NODE_BALANCE_VGROUP_STMT, - QUERY_NODE_MERGE_VGROUP_STMT, - QUERY_NODE_REDISTRIBUTE_VGROUP_STMT, - QUERY_NODE_SPLIT_VGROUP_STMT, - QUERY_NODE_SYNCDB_STMT, - QUERY_NODE_GRANT_STMT, - QUERY_NODE_REVOKE_STMT, - QUERY_NODE_SHOW_DNODES_STMT, - QUERY_NODE_SHOW_MNODES_STMT, -// QUERY_NODE_SHOW_MODULES_STMT, - QUERY_NODE_SHOW_QNODES_STMT, - QUERY_NODE_SHOW_SNODES_STMT, - QUERY_NODE_SHOW_BNODES_STMT, - QUERY_NODE_SHOW_CLUSTER_STMT, - QUERY_NODE_SHOW_DATABASES_STMT, - QUERY_NODE_SHOW_FUNCTIONS_STMT, - QUERY_NODE_SHOW_INDEXES_STMT, - QUERY_NODE_SHOW_STABLES_STMT, - QUERY_NODE_SHOW_STREAMS_STMT, - QUERY_NODE_SHOW_TABLES_STMT, - QUERY_NODE_SHOW_TAGS_STMT, - QUERY_NODE_SHOW_USERS_STMT, - QUERY_NODE_SHOW_LICENCES_STMT, - QUERY_NODE_SHOW_VGROUPS_STMT, - QUERY_NODE_SHOW_TOPICS_STMT, - QUERY_NODE_SHOW_CONSUMERS_STMT, - QUERY_NODE_SHOW_CONNECTIONS_STMT, - QUERY_NODE_SHOW_QUERIES_STMT, - QUERY_NODE_SHOW_APPS_STMT, - QUERY_NODE_SHOW_VARIABLES_STMT, - QUERY_NODE_SHOW_DNODE_VARIABLES_STMT, - QUERY_NODE_SHOW_TRANSACTIONS_STMT, - QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT, - QUERY_NODE_SHOW_VNODES_STMT, - QUERY_NODE_SHOW_USER_PRIVILEGES_STMT, - QUERY_NODE_SHOW_CREATE_DATABASE_STMT, - QUERY_NODE_SHOW_CREATE_TABLE_STMT, - QUERY_NODE_SHOW_CREATE_STABLE_STMT, - QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT, - QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT, - QUERY_NODE_SHOW_SCORES_STMT, - QUERY_NODE_SHOW_TABLE_TAGS_STMT, - QUERY_NODE_KILL_CONNECTION_STMT, - QUERY_NODE_KILL_QUERY_STMT, - QUERY_NODE_KILL_TRANSACTION_STMT, - QUERY_NODE_DELETE_STMT, - QUERY_NODE_INSERT_STMT, - QUERY_NODE_QUERY, - QUERY_NODE_SHOW_DB_ALIVE_STMT, - QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT, - QUERY_NODE_BALANCE_VGROUP_LEADER_STMT, - QUERY_NODE_RESTORE_DNODE_STMT, - QUERY_NODE_RESTORE_QNODE_STMT, - QUERY_NODE_RESTORE_MNODE_STMT, - QUERY_NODE_RESTORE_VNODE_STMT, - QUERY_NODE_PAUSE_STREAM_STMT, - QUERY_NODE_RESUME_STREAM_STMT, - - // logic plan node - QUERY_NODE_LOGIC_PLAN_SCAN = 1000, - QUERY_NODE_LOGIC_PLAN_JOIN, - QUERY_NODE_LOGIC_PLAN_AGG, - QUERY_NODE_LOGIC_PLAN_PROJECT, - QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, - QUERY_NODE_LOGIC_PLAN_EXCHANGE, - QUERY_NODE_LOGIC_PLAN_MERGE, - QUERY_NODE_LOGIC_PLAN_WINDOW, - QUERY_NODE_LOGIC_PLAN_FILL, - QUERY_NODE_LOGIC_PLAN_SORT, - QUERY_NODE_LOGIC_PLAN_PARTITION, - QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, - QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, - QUERY_NODE_LOGIC_SUBPLAN, - QUERY_NODE_LOGIC_PLAN, - - // physical plan node - QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN = 1100, - QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, - QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, - QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, - QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, - QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, - QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, - QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, - QUERY_NODE_PHYSICAL_PLAN_PROJECT, - QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN, - QUERY_NODE_PHYSICAL_PLAN_HASH_AGG, - QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, - QUERY_NODE_PHYSICAL_PLAN_MERGE, - QUERY_NODE_PHYSICAL_PLAN_SORT, - QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, - QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL, - QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL, - QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL, - QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, - QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL, - QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL, - QUERY_NODE_PHYSICAL_PLAN_FILL, - QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, - QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION, - QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION, - QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION, - QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION, - QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, - QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE, - QUERY_NODE_PHYSICAL_PLAN_PARTITION, - QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION, - QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC, - QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, - QUERY_NODE_PHYSICAL_PLAN_DISPATCH, - QUERY_NODE_PHYSICAL_PLAN_INSERT, - QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT, - QUERY_NODE_PHYSICAL_PLAN_DELETE, - QUERY_NODE_PHYSICAL_SUBPLAN, - QUERY_NODE_PHYSICAL_PLAN, - QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, - QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT, - QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT -} ENodeType; - /** * The first field of a node of any type is guaranteed to be the ENodeType. * Hence the type of any node can be gotten by casting it to SNode. diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h index b4f0a67fa0..9d2247f479 100644 --- a/include/libs/nodes/plannodes.h +++ b/include/libs/nodes/plannodes.h @@ -42,10 +42,13 @@ typedef enum EGroupAction { typedef struct SLogicNode { ENodeType type; + bool dynamicOp; + bool stmtRoot; SNodeList* pTargets; // SColumnNode SNode* pConditions; SNodeList* pChildren; struct SLogicNode* pParent; + SNodeList* pHint; int32_t optimizedFlag; uint8_t precision; SNode* pLimit; @@ -111,12 +114,17 @@ typedef struct SScanLogicNode { } SScanLogicNode; typedef struct SJoinLogicNode { - SLogicNode node; - EJoinType joinType; - SNode* pMergeCondition; - SNode* pOnConditions; - bool isSingleTableJoin; - SNode* pColEqualOnConditions; + SLogicNode node; + EJoinType joinType; + EJoinAlgorithm joinAlgo; + SNode* pPrimKeyEqCond; + SNode* pColEqCond; + SNode* pTagEqCond; + SNode* pTagOnCond; + SNode* pOtherOnCond; + bool isSingleTableJoin; + bool hasSubQuery; + bool isLowLevelJoin; } SJoinLogicNode; typedef struct SAggLogicNode { @@ -155,6 +163,28 @@ typedef struct SInterpFuncLogicNode { SNode* pTimeSeries; // SColumnNode } SInterpFuncLogicNode; +typedef struct SGroupCacheLogicNode { + SLogicNode node; + bool grpColsMayBeNull; + bool grpByUid; + bool globalGrp; + bool batchFetch; + SNodeList* pGroupCols; +} SGroupCacheLogicNode; + +typedef struct SDynQueryCtrlStbJoin { + bool batchFetch; + SNodeList* pVgList; + SNodeList* pUidList; + bool srcScan[2]; +} SDynQueryCtrlStbJoin; + +typedef struct SDynQueryCtrlLogicNode { + SLogicNode node; + EDynQueryType qType; + SDynQueryCtrlStbJoin stbJoin; +} SDynQueryCtrlLogicNode; + typedef enum EModifyTableType { MODIFY_TABLE_TYPE_INSERT = 1, MODIFY_TABLE_TYPE_DELETE } EModifyTableType; typedef struct SVnodeModifyLogicNode { @@ -313,6 +343,7 @@ typedef struct SDataBlockDescNode { typedef struct SPhysiNode { ENodeType type; + bool dynamicOp; EOrder inputTsOrder; EOrder outputTsOrder; SDataBlockDescNode* pOutputDataBlockDesc; @@ -414,12 +445,50 @@ typedef struct SInterpFuncPhysiNode { typedef struct SSortMergeJoinPhysiNode { SPhysiNode node; EJoinType joinType; - SNode* pMergeCondition; - SNode* pOnConditions; + SNode* pPrimKeyCond; + SNode* pColEqCond; + SNode* pOtherOnCond; SNodeList* pTargets; - SNode* pColEqualOnConditions; } SSortMergeJoinPhysiNode; +typedef struct SHashJoinPhysiNode { + SPhysiNode node; + EJoinType joinType; + SNodeList* pOnLeft; + SNodeList* pOnRight; + SNode* pFilterConditions; + SNodeList* pTargets; + SQueryStat inputStat[2]; + + SNode* pPrimKeyCond; + SNode* pColEqCond; + SNode* pTagEqCond; +} SHashJoinPhysiNode; + +typedef struct SGroupCachePhysiNode { + SPhysiNode node; + bool grpColsMayBeNull; + bool grpByUid; + bool globalGrp; + bool batchFetch; + SNodeList* pGroupCols; +} SGroupCachePhysiNode; + +typedef struct SStbJoinDynCtrlBasic { + bool batchFetch; + int32_t vgSlot[2]; + int32_t uidSlot[2]; + bool srcScan[2]; +} SStbJoinDynCtrlBasic; + +typedef struct SDynQueryCtrlPhysiNode { + SPhysiNode node; + EDynQueryType qType; + union { + SStbJoinDynCtrlBasic stbJoin; + }; +} SDynQueryCtrlPhysiNode; + typedef struct SAggPhysiNode { SPhysiNode node; SNodeList* pExprs; // these are expression list of group_by_clause and parameter expression of aggregate function diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h index dc312a762e..d7d45c57ad 100644 --- a/include/libs/nodes/querynodes.h +++ b/include/libs/nodes/querynodes.h @@ -116,6 +116,17 @@ typedef struct SLeftValueNode { ENodeType type; } SLeftValueNode; +typedef enum EHintOption { + HINT_NO_BATCH_SCAN = 1, + HINT_BATCH_SCAN, +} EHintOption; + +typedef struct SHintNode { + ENodeType type; + EHintOption option; + void* value; +} SHintNode; + typedef struct SOperatorNode { SExprNode node; // QUERY_NODE_OPERATOR EOperatorType opType; @@ -169,11 +180,27 @@ typedef struct STempTableNode { SNode* pSubquery; } STempTableNode; -typedef enum EJoinType { JOIN_TYPE_INNER = 1 } EJoinType; +typedef enum EJoinType { + JOIN_TYPE_INNER = 1, + JOIN_TYPE_LEFT, + JOIN_TYPE_RIGHT, +} EJoinType; + +typedef enum EJoinAlgorithm { + JOIN_ALGO_UNKNOWN = 0, + JOIN_ALGO_MERGE, + JOIN_ALGO_HASH, +} EJoinAlgorithm; + +typedef enum EDynQueryType { + DYN_QTYPE_STB_HASH = 1, +} EDynQueryType; typedef struct SJoinTableNode { STableNode table; // QUERY_NODE_JOIN_TABLE EJoinType joinType; + bool hasSubQuery; + bool isLowLevelJoin; SNode* pLeft; SNode* pRight; SNode* pOnCond; @@ -289,6 +316,7 @@ typedef struct SSelectStmt { SLimitNode* pLimit; SLimitNode* pSlimit; STimeWindow timeRange; + SNodeList* pHint; char stmtName[TSDB_TABLE_NAME_LEN]; uint8_t precision; int32_t selectFuncNum; @@ -470,7 +498,7 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols); typedef bool (*FFuncClassifier)(int32_t funcId); -int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, FFuncClassifier classifier, SNodeList** pFuncs); +int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs); int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes); diff --git a/include/libs/qcom/query.h b/include/libs/qcom/query.h index 6a1091e658..71b8badb13 100644 --- a/include/libs/qcom/query.h +++ b/include/libs/qcom/query.h @@ -90,11 +90,6 @@ typedef struct SExecResult { void* res; } SExecResult; -typedef struct STbVerInfo { - char tbFName[TSDB_TABLE_FNAME_LEN]; - int32_t sversion; - int32_t tversion; -} STbVerInfo; #pragma pack(push, 1) typedef struct SCTableMeta { @@ -212,6 +207,11 @@ typedef struct SQueryNodeStat { int32_t tableNum; // vg table number, unit is TSDB_TABLE_NUM_UNIT } SQueryNodeStat; +typedef struct SQueryStat { + int64_t inputRowNum; + int32_t inputRowSize; +} SQueryStat; + int32_t initTaskQueue(); int32_t cleanupTaskQueue(); diff --git a/include/libs/scalar/scalar.h b/include/libs/scalar/scalar.h index ef8e80b57f..2e6652f860 100644 --- a/include/libs/scalar/scalar.h +++ b/include/libs/scalar/scalar.h @@ -95,6 +95,8 @@ int32_t qStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p int32_t qEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput); int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput); +int32_t qTbUidFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput); +int32_t qVgIdFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput); /* Aggregation functions */ int32_t countScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput); diff --git a/include/util/taoserror.h b/include/util/taoserror.h index a5081f2c7d..629b597d0c 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -518,6 +518,7 @@ int32_t* taosGetErrno(); #define TSDB_CODE_QRY_JOB_NOT_EXIST TAOS_DEF_ERROR_CODE(0, 0x072F) #define TSDB_CODE_QRY_QWORKER_QUIT TAOS_DEF_ERROR_CODE(0, 0x0730) #define TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR TAOS_DEF_ERROR_CODE(0, 0x0731) +#define TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR TAOS_DEF_ERROR_CODE(0, 0x0732) // grant #define TSDB_CODE_GRANT_EXPIRED TAOS_DEF_ERROR_CODE(0, 0x0800) @@ -714,6 +715,7 @@ int32_t* taosGetErrno(); #define TSDB_CODE_PLAN_INTERNAL_ERROR TAOS_DEF_ERROR_CODE(0, 0x2700) #define TSDB_CODE_PLAN_EXPECTED_TS_EQUAL TAOS_DEF_ERROR_CODE(0, 0x2701) #define TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN TAOS_DEF_ERROR_CODE(0, 0x2702) +#define TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND TAOS_DEF_ERROR_CODE(0, 0x2703) //function #define TSDB_CODE_FUNC_FUNTION_ERROR TAOS_DEF_ERROR_CODE(0, 0x2800) diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c index bbbb6c7178..e21e3a06b2 100644 --- a/source/common/src/tdatablock.c +++ b/source/common/src/tdatablock.c @@ -146,15 +146,6 @@ int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, const char* pData) { int32_t type = pColumnInfoData->info.type; if (IS_VAR_DATA_TYPE(type)) { - int32_t dataLen = 0; - if (type == TSDB_DATA_TYPE_JSON) { - dataLen = getJsonValueLen(pData); - } else { - dataLen = varDataTLen(pData); - } - - SVarColAttr* pAttr = &pColumnInfoData->varmeta; - pColumnInfoData->varmeta.offset[dstRowIdx] = pColumnInfoData->varmeta.offset[srcRowIdx]; pColumnInfoData->reassigned = true; } else { @@ -247,6 +238,82 @@ int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, return doCopyNItems(pColumnInfoData, currentRow, pData, len, numOfRows, trimValue); } +void colDataSetNItemsNull(SColumnInfoData* pColumnInfoData, uint32_t currentRow, uint32_t numOfRows) { + if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) { + memset(&pColumnInfoData->varmeta.offset[currentRow], -1, sizeof(int32_t) * numOfRows); + } else { + if (numOfRows < sizeof(char) * 2) { + for (int32_t i = 0; i < numOfRows; ++i) { + colDataSetNull_f(pColumnInfoData->nullbitmap, currentRow + i); + } + } else { + int32_t i = 0; + for (; i < numOfRows; ++i) { + if (BitPos(currentRow + i)) { + colDataSetNull_f(pColumnInfoData->nullbitmap, currentRow + i); + } else { + break; + } + } + + memset(&BMCharPos(pColumnInfoData->nullbitmap, currentRow + i), 0xFF, (numOfRows - i) / sizeof(char)); + i += (numOfRows - i) / sizeof(char) * sizeof(char); + + for (; i < numOfRows; ++i) { + colDataSetNull_f(pColumnInfoData->nullbitmap, currentRow + i); + } + } + } +} + +int32_t colDataCopyAndReassign(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, uint32_t numOfRows) { + int32_t code = colDataSetVal(pColumnInfoData, currentRow, pData, false); + if (code) { + return code; + } + + if (numOfRows > 1) { + int32_t* pOffset = pColumnInfoData->varmeta.offset; + memset(&pOffset[currentRow + 1], pOffset[currentRow], sizeof(pOffset[0]) * (numOfRows - 1)); + pColumnInfoData->reassigned = true; + } + + return TSDB_CODE_SUCCESS; +} + +int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, + uint32_t numOfRows, bool isNull) { + int32_t len = pColumnInfoData->info.bytes; + if (isNull) { + colDataSetNItemsNull(pColumnInfoData, currentRow, numOfRows); + pColumnInfoData->hasNull = true; + return 0; + } + + if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) { + return colDataCopyAndReassign(pColumnInfoData, currentRow, pData, numOfRows); + } else { + int32_t colBytes = pColumnInfoData->info.bytes; + int32_t colOffset = currentRow * colBytes; + uint32_t num = 1; + + void* pStart = pColumnInfoData->pData + colOffset; + memcpy(pStart, pData, colBytes); + colOffset += num * colBytes; + + while (num < numOfRows) { + int32_t maxNum = num << 1; + int32_t tnum = maxNum > numOfRows ? (numOfRows - num) : num; + + memcpy(pColumnInfoData->pData + colOffset, pStart, tnum * colBytes); + colOffset += tnum * colBytes; + num += tnum; + } + } + + return TSDB_CODE_SUCCESS; +} + static void doBitmapMerge(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, const SColumnInfoData* pSource, int32_t numOfRow2) { if (numOfRow2 <= 0) return; @@ -2428,4 +2495,4 @@ void trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList int32_t blockGetEncodeSize(const SSDataBlock* pBlock) { return blockDataGetSerialMetaSize(taosArrayGetSize(pBlock->pDataBlock)) + blockDataGetSize(pBlock); -} \ No newline at end of file +} diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index d6d9e954e8..1bf2fb78a7 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -5563,6 +5563,82 @@ void tFreeSSubQueryMsg(SSubQueryMsg *pReq) { taosMemoryFreeClear(pReq->msg); } +int32_t tSerializeSOperatorParam(SEncoder* pEncoder, SOperatorParam* pOpParam) { + if (tEncodeI32(pEncoder, pOpParam->opType) < 0) return -1; + if (tEncodeI32(pEncoder, pOpParam->downstreamIdx) < 0) return -1; + switch (pOpParam->opType) { + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: { + STableScanOperatorParam* pScan = (STableScanOperatorParam*)pOpParam->value; + if (tEncodeI8(pEncoder, pScan->tableSeq) < 0) return -1; + int32_t uidNum = taosArrayGetSize(pScan->pUidList); + if (tEncodeI32(pEncoder, uidNum) < 0) return -1; + for (int32_t m = 0; m < uidNum; ++m) { + int64_t* pUid = taosArrayGet(pScan->pUidList, m); + if (tEncodeI64(pEncoder, *pUid) < 0) return -1; + } + break; + } + default: + return TSDB_CODE_INVALID_PARA; + } + + int32_t n = taosArrayGetSize(pOpParam->pChildren); + if (tEncodeI32(pEncoder, n) < 0) return -1; + for (int32_t i = 0; i < n; ++i) { + SOperatorParam* pChild = *(SOperatorParam**)taosArrayGet(pOpParam->pChildren, i); + if (tSerializeSOperatorParam(pEncoder, pChild) < 0) return -1; + } + + return 0; +} + +int32_t tDeserializeSOperatorParam(SDecoder *pDecoder, SOperatorParam* pOpParam) { + if (tDecodeI32(pDecoder, &pOpParam->opType) < 0) return -1; + if (tDecodeI32(pDecoder, &pOpParam->downstreamIdx) < 0) return -1; + switch (pOpParam->opType) { + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: { + STableScanOperatorParam* pScan = taosMemoryMalloc(sizeof(STableScanOperatorParam)); + if (NULL == pScan) return -1; + if (tDecodeI8(pDecoder, (int8_t*)&pScan->tableSeq) < 0) return -1; + int32_t uidNum = 0; + int64_t uid = 0; + if (tDecodeI32(pDecoder, &uidNum) < 0) return -1; + if (uidNum > 0) { + pScan->pUidList = taosArrayInit(uidNum, sizeof(int64_t)); + if (NULL == pScan->pUidList) return -1; + for (int32_t m = 0; m < uidNum; ++m) { + if (tDecodeI64(pDecoder, &uid) < 0) return -1; + taosArrayPush(pScan->pUidList, &uid); + } + } else { + pScan->pUidList = NULL; + } + pOpParam->value = pScan; + break; + } + default: + return TSDB_CODE_INVALID_PARA; + } + + int32_t childrenNum = 0; + if (tDecodeI32(pDecoder, &childrenNum) < 0) return -1; + if (childrenNum > 0) { + pOpParam->pChildren = taosArrayInit(childrenNum, POINTER_BYTES); + if (NULL == pOpParam->pChildren) return -1; + for (int32_t i = 0; i < childrenNum; ++i) { + SOperatorParam* pChild = taosMemoryCalloc(1, sizeof(SOperatorParam)); + if (NULL == pChild) return -1; + if (tDeserializeSOperatorParam(pDecoder, pChild) < 0) return -1; + taosArrayPush(pOpParam->pChildren, &pChild); + } + } else { + pOpParam->pChildren = NULL; + } + + return 0; +} + + int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) { int32_t headLen = sizeof(SMsgHead); if (buf != NULL) { @@ -5578,6 +5654,12 @@ int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) { if (tEncodeU64(&encoder, pReq->queryId) < 0) return -1; if (tEncodeU64(&encoder, pReq->taskId) < 0) return -1; if (tEncodeI32(&encoder, pReq->execId) < 0) return -1; + if (pReq->pOpParam) { + if (tEncodeI32(&encoder, 1) < 0) return -1; + if (tSerializeSOperatorParam(&encoder, pReq->pOpParam) < 0) return -1; + } else { + if (tEncodeI32(&encoder, 0) < 0) return -1; + } tEndEncode(&encoder); @@ -5610,6 +5692,14 @@ int32_t tDeserializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) if (tDecodeU64(&decoder, &pReq->taskId) < 0) return -1; if (tDecodeI32(&decoder, &pReq->execId) < 0) return -1; + int32_t paramNum = 0; + if (tDecodeI32(&decoder, ¶mNum) < 0) return -1; + if (paramNum > 0) { + pReq->pOpParam = taosMemoryMalloc(sizeof(*pReq->pOpParam)); + if (NULL == pReq->pOpParam) return -1; + if (tDeserializeSOperatorParam(&decoder, pReq->pOpParam) < 0) return -1; + } + tEndDecode(&decoder); tDecoderClear(&decoder); @@ -5754,11 +5844,18 @@ int32_t tSerializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pRsp if (tStartEncode(&encoder) < 0) return -1; if (tEncodeI32(&encoder, pRsp->code) < 0) return -1; - if (tEncodeCStr(&encoder, pRsp->tbFName) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->sversion) < 0) return -1; - if (tEncodeI32(&encoder, pRsp->tversion) < 0) return -1; if (tEncodeI64(&encoder, pRsp->affectedRows) < 0) return -1; - + int32_t tbNum = taosArrayGetSize(pRsp->tbVerInfo); + if (tEncodeI32(&encoder, tbNum) < 0) return -1; + if (tbNum > 0) { + for (int32_t i = 0; i < tbNum; ++i) { + STbVerInfo *pVer = taosArrayGet(pRsp->tbVerInfo, i); + if (tEncodeCStr(&encoder, pVer->tbFName) < 0) return -1; + if (tEncodeI32(&encoder, pVer->sversion) < 0) return -1; + if (tEncodeI32(&encoder, pVer->tversion) < 0) return -1; + } + } + tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -5774,11 +5871,19 @@ int32_t tDeserializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pR if (tStartDecode(&decoder) < 0) return -1; if (tDecodeI32(&decoder, &pRsp->code) < 0) return -1; - if (tDecodeCStrTo(&decoder, pRsp->tbFName) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->sversion) < 0) return -1; - if (tDecodeI32(&decoder, &pRsp->tversion) < 0) return -1; if (tDecodeI64(&decoder, &pRsp->affectedRows) < 0) return -1; - + int32_t tbNum = 0; + if (tDecodeI32(&decoder, &tbNum) < 0) return -1; + if (tbNum > 0) { + pRsp->tbVerInfo = taosArrayInit(tbNum, sizeof(STbVerInfo)); + if (NULL == pRsp->tbVerInfo) return -1; + STbVerInfo tbVer; + if (tDecodeCStrTo(&decoder, tbVer.tbFName) < 0) return -1; + if (tDecodeI32(&decoder, &tbVer.sversion) < 0) return -1; + if (tDecodeI32(&decoder, &tbVer.tversion) < 0) return -1; + if (NULL == taosArrayPush(pRsp->tbVerInfo, &tbVer)) return -1; + } + tEndDecode(&decoder); tDecoderClear(&decoder); diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c index 9eea7e1149..14704eca2d 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c @@ -312,7 +312,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { _OVER: if (code != 0) { vnodeClose(pImpl); - vnodeDestroy(path, pMgmt->pTfs); + vnodeDestroy(0, path, pMgmt->pTfs); } else { dInfo("vgId:%d, vnode management handle msgType:%s, end to create vnode, vnode is created", req.vgId, TMSG_INFO(pMsg->msgType)); @@ -409,7 +409,7 @@ int32_t vmProcessAlterVnodeTypeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { vmCloseVnode(pMgmt, pVnode, false); int32_t diskPrimary = wrapperCfg.diskPrimary; - char path[TSDB_FILENAME_LEN] = {0}; + char path[TSDB_FILENAME_LEN] = {0}; snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, vgId); dInfo("vgId:%d, start to alter vnode replica at %s", vgId, path); @@ -507,8 +507,8 @@ int32_t vmProcessAlterHashRangeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { vmCloseVnode(pMgmt, pVnode, true); int32_t diskPrimary = wrapperCfg.diskPrimary; - char srcPath[TSDB_FILENAME_LEN] = {0}; - char dstPath[TSDB_FILENAME_LEN] = {0}; + char srcPath[TSDB_FILENAME_LEN] = {0}; + char dstPath[TSDB_FILENAME_LEN] = {0}; snprintf(srcPath, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, srcVgId); snprintf(dstPath, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, dstVgId); @@ -611,7 +611,7 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { vmCloseVnode(pMgmt, pVnode, false); int32_t diskPrimary = wrapperCfg.diskPrimary; - char path[TSDB_FILENAME_LEN] = {0}; + char path[TSDB_FILENAME_LEN] = {0}; snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, vgId); dInfo("vgId:%d, start to alter vnode replica at %s", vgId, path); diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c index 0ff2537e4c..f4ce46411a 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c @@ -208,7 +208,7 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal) if (pVnode->dropped) { dInfo("vgId:%d, vnode is destroyed, dropped:%d", pVnode->vgId, pVnode->dropped); snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, pVnode->vgId); - vnodeDestroy(path, pMgmt->pTfs); + vnodeDestroy(pVnode->vgId, path, pMgmt->pTfs); } taosMemoryFree(pVnode->path); diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h index a7ce18198d..5ae257aef8 100644 --- a/source/dnode/vnode/inc/vnode.h +++ b/source/dnode/vnode/inc/vnode.h @@ -33,8 +33,8 @@ #include "tmsg.h" #include "trow.h" -#include "tdb.h" #include "storageapi.h" +#include "tdb.h" #ifdef __cplusplus extern "C" { @@ -57,7 +57,7 @@ int32_t vnodeAlterHashRange(const char *srcPath, const char *dstPath, SAlterVnod int32_t diskPrimary, STfs *pTfs); int32_t vnodeRestoreVgroupId(const char *srcPath, const char *dstPath, int32_t srcVgId, int32_t dstVgId, int32_t diskPrimary, STfs *pTfs); -void vnodeDestroy(const char *path, STfs *pTfs); +void vnodeDestroy(int32_t vgId, const char *path, STfs *pTfs); SVnode *vnodeOpen(const char *path, int32_t diskPrimary, STfs *pTfs, SMsgCb msgCb); void vnodePreClose(SVnode *pVnode); void vnodePostClose(SVnode *pVnode); @@ -66,13 +66,13 @@ void vnodeClose(SVnode *pVnode); int32_t vnodeSyncCommit(SVnode *pVnode); int32_t vnodeBegin(SVnode *pVnode); -int32_t vnodeStart(SVnode *pVnode); -void vnodeStop(SVnode *pVnode); -int64_t vnodeGetSyncHandle(SVnode *pVnode); -void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot); -void vnodeGetInfo(void *pVnode, const char **dbname, int32_t *vgId, int64_t* numOfTables, int64_t* numOfNormalTables); +int32_t vnodeStart(SVnode *pVnode); +void vnodeStop(SVnode *pVnode); +int64_t vnodeGetSyncHandle(SVnode *pVnode); +void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot); +void vnodeGetInfo(void *pVnode, const char **dbname, int32_t *vgId, int64_t *numOfTables, int64_t *numOfNormalTables); int32_t vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen); -int32_t vnodeGetTableList(void* pVnode, int8_t type, SArray* pList); +int32_t vnodeGetTableList(void *pVnode, int8_t type, SArray *pList); int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list); int32_t vnodeIsCatchUp(SVnode *pVnode); ESyncRole vnodeGetRole(SVnode *pVnode); @@ -80,7 +80,8 @@ ESyncRole vnodeGetRole(SVnode *pVnode); int32_t vnodeGetCtbIdList(void *pVnode, int64_t suid, SArray *list); int32_t vnodeGetCtbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg), void *arg); int32_t vnodeGetStbIdList(SVnode *pVnode, int64_t suid, SArray *list); -int32_t vnodeGetStbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg, void* arg1), void *arg); +int32_t vnodeGetStbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg, void *arg1), + void *arg); void *vnodeGetIdx(void *pVnode); void *vnodeGetIvtIdx(void *pVnode); @@ -105,13 +106,13 @@ void vnodeApplyWriteMsg(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs void vnodeProposeCommitOnNeed(SVnode *pVnode, bool atExit); // meta -void _metaReaderInit(SMetaReader *pReader, void *pVnode, int32_t flags, SStoreMeta* pAPI); +void _metaReaderInit(SMetaReader *pReader, void *pVnode, int32_t flags, SStoreMeta *pAPI); void metaReaderReleaseLock(SMetaReader *pReader); void metaReaderClear(SMetaReader *pReader); int32_t metaReaderGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid); int32_t metaReaderGetTableEntryByUidCache(SMetaReader *pReader, tb_uid_t uid); int32_t metaGetTableTags(void *pVnode, uint64_t suid, SArray *uidList); -int32_t metaGetTableTagsByUids(void* pVnode, int64_t suid, SArray *uidList); +int32_t metaGetTableTagsByUids(void *pVnode, int64_t suid, SArray *uidList); int32_t metaReadNext(SMetaReader *pReader); const void *metaGetTableTagVal(const void *tag, int16_t type, STagVal *tagVal); int metaGetTableNameByUid(void *meta, uint64_t uid, char *tbName); @@ -120,20 +121,20 @@ int metaGetTableSzNameByUid(void *meta, uint64_t uid, char *tbName); int metaGetTableUidByName(void *pVnode, char *tbName, uint64_t *uid); int metaGetTableTypeByName(void *meta, char *tbName, ETableType *tbType); int metaGetTableTtlByUid(void *meta, uint64_t uid, int64_t *ttlDays); -bool metaIsTableExist(void* pVnode, tb_uid_t uid); +bool metaIsTableExist(void *pVnode, tb_uid_t uid); int32_t metaGetCachedTableUidList(void *pVnode, tb_uid_t suid, const uint8_t *key, int32_t keyLen, SArray *pList, bool *acquired); int32_t metaUidFilterCachePut(void *pVnode, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload, int32_t payloadLen, double selectivityRatio); tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name); int32_t metaGetCachedTbGroup(void *pVnode, tb_uid_t suid, const uint8_t *pKey, int32_t keyLen, SArray **pList); -int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload, +int32_t metaPutTbGroupToCache(void *pVnode, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload, int32_t payloadLen); bool metaTbInFilterCache(void *pVnode, tb_uid_t suid, int8_t type); int32_t metaPutTbToFilterCache(void *pVnode, tb_uid_t suid, int8_t type); int32_t metaSizeOfTbFilterCache(void *pVnode, int8_t type); -int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables); +int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables); // tsdb typedef struct STsdbReader STsdbReader; @@ -170,8 +171,8 @@ int64_t tsdbGetLastTimestamp(SVnode *pVnode, void *pTableList, int32_t numO //====================================================================================================================== int32_t tsdbReaderOpen2(void *pVnode, SQueryTableDataCond *pCond, void *pTableList, int32_t numOfTables, - SSDataBlock *pResBlock, void **ppReader, const char *idstr, bool countOnly, - SHashObj **pIgnoreTables); + SSDataBlock *pResBlock, void **ppReader, const char *idstr, bool countOnly, + SHashObj **pIgnoreTables); int32_t tsdbSetTableList2(STsdbReader *pReader, const void *pTableList, int32_t num); void tsdbReaderSetId2(STsdbReader *pReader, const char *idstr); void tsdbReaderClose2(STsdbReader *pReader); @@ -228,23 +229,23 @@ STqReader *tqReaderOpen(SVnode *pVnode); void tqReaderClose(STqReader *); void tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList); -int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList, const char* id); +int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList, const char *id); int32_t tqReaderAddTbUidList(STqReader *pReader, const SArray *pTableUidList); int32_t tqReaderRemoveTbUidList(STqReader *pReader, const SArray *tbUidList); -bool tqReaderIsQueriedTable(STqReader* pReader, uint64_t uid); -bool tqCurrentBlockConsumed(const STqReader* pReader); +bool tqReaderIsQueriedTable(STqReader *pReader, uint64_t uid); +bool tqCurrentBlockConsumed(const STqReader *pReader); -int32_t tqReaderSeek(STqReader *pReader, int64_t ver, const char *id); -bool tqNextBlockInWal(STqReader *pReader, const char *idstr); -bool tqNextBlockImpl(STqReader *pReader, const char *idstr); -SWalReader* tqGetWalReader(STqReader* pReader); -SSDataBlock* tqGetResultBlock (STqReader* pReader); +int32_t tqReaderSeek(STqReader *pReader, int64_t ver, const char *id); +bool tqNextBlockInWal(STqReader *pReader, const char *idstr); +bool tqNextBlockImpl(STqReader *pReader, const char *idstr); +SWalReader *tqGetWalReader(STqReader *pReader); +SSDataBlock *tqGetResultBlock(STqReader *pReader); int32_t extractMsgFromWal(SWalReader *pReader, void **pItem, int64_t maxVer, const char *id); int32_t tqReaderSetSubmitMsg(STqReader *pReader, void *msgStr, int32_t msgLen, int64_t ver); bool tqNextDataBlockFilterOut(STqReader *pReader, SHashObj *filterOutUids); -int32_t tqRetrieveDataBlock(STqReader *pReader, SSDataBlock** pRes, const char* idstr); +int32_t tqRetrieveDataBlock(STqReader *pReader, SSDataBlock **pRes, const char *idstr); int32_t tqRetrieveTaosxBlock(STqReader *pReader, SArray *blocks, SArray *schemas, SSubmitTbData **pSubmitTbDataRet); int32_t vnodeEnqueueStreamMsg(SVnode *pVnode, SRpcMsg *pMsg); diff --git a/source/dnode/vnode/src/inc/vndCos.h b/source/dnode/vnode/src/inc/vndCos.h index cf2c5eb441..51d214518a 100644 --- a/source/dnode/vnode/src/inc/vndCos.h +++ b/source/dnode/vnode/src/inc/vndCos.h @@ -27,6 +27,7 @@ extern int8_t tsS3Enabled; int32_t s3Init(); void s3CleanUp(); int32_t s3PutObjectFromFile(const char *file, const char *object); +void s3DeleteObjectsByPrefix(const char *prefix); void s3DeleteObjects(const char *object_name[], int nobject); bool s3Exists(const char *object_name); bool s3Get(const char *object_name, const char *path); diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index 4d3b53bc5a..0a462c21e3 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -44,7 +44,7 @@ int32_t tsdbOpenFile(const char *path, int32_t szPage, int32_t flag, STsdbFD **p pFD->pFD = taosOpenFile(path, flag); if (pFD->pFD == NULL) { - code = TAOS_SYSTEM_ERROR(errno); + code = TAOS_SYSTEM_ERROR(ENOENT); taosMemoryFree(pFD); goto _exit; } diff --git a/source/dnode/vnode/src/vnd/vnodeCos.c b/source/dnode/vnode/src/vnd/vnodeCos.c index 4c76538eb2..7e95a55077 100644 --- a/source/dnode/vnode/src/vnd/vnodeCos.c +++ b/source/dnode/vnode/src/vnd/vnodeCos.c @@ -85,6 +85,25 @@ int32_t s3PutObjectFromFile(const char *file_str, const char *object_str) { return code; } +void s3DeleteObjectsByPrefix(const char *prefix_str) { + cos_pool_t *p = NULL; + cos_request_options_t *options = NULL; + int is_cname = 0; + cos_string_t bucket; + cos_status_t *s = NULL; + cos_string_t prefix; + + cos_pool_create(&p, NULL); + options = cos_request_options_create(p); + s3InitRequestOptions(options, is_cname); + cos_str_set(&bucket, tsS3BucketName); + cos_str_set(&prefix, prefix_str); + + s = cos_delete_objects_by_prefix(options, &bucket, &prefix); + log_status(s); + cos_pool_destroy(p); +} + void s3DeleteObjects(const char *object_name[], int nobject) { cos_pool_t *p = NULL; int is_cname = 0; @@ -314,6 +333,7 @@ long s3Size(const char *object_name) { int32_t s3Init() { return 0; } void s3CleanUp() {} int32_t s3PutObjectFromFile(const char *file, const char *object) { return 0; } +void s3DeleteObjectsByPrefix(const char *prefix) {} void s3DeleteObjects(const char *object_name[], int nobject) {} bool s3Exists(const char *object_name) { return false; } bool s3Get(const char *object_name, const char *path) { return false; } diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c index 5140f172d9..d444fd314c 100644 --- a/source/dnode/vnode/src/vnd/vnodeOpen.c +++ b/source/dnode/vnode/src/vnd/vnodeOpen.c @@ -14,6 +14,7 @@ */ #include "vnd.h" +#include "vndCos.h" int32_t vnodeGetPrimaryDir(const char *relPath, int32_t diskPrimary, STfs *pTfs, char *buf, size_t bufLen) { if (pTfs) { @@ -100,7 +101,7 @@ int32_t vnodeAlterReplica(const char *path, SAlterVnodeReplicaReq *pReq, int32_t vInfo("vgId:%d, replica:%d ep:%s:%u dnode:%d", pReq->vgId, i, pNode->nodeFqdn, pNode->nodePort, pNode->nodeId); pCfg->replicaNum++; } - if(pReq->selfIndex != -1){ + if (pReq->selfIndex != -1) { pCfg->myIndex = pReq->selfIndex; } for (int i = pCfg->replicaNum; i < pReq->replica + pReq->learnerReplica; ++i) { @@ -114,12 +115,12 @@ int32_t vnodeAlterReplica(const char *path, SAlterVnodeReplicaReq *pReq, int32_t pCfg->totalReplicaNum++; } pCfg->totalReplicaNum += pReq->replica; - if(pReq->learnerSelfIndex != -1){ + if (pReq->learnerSelfIndex != -1) { pCfg->myIndex = pReq->replica + pReq->learnerSelfIndex; } - vInfo("vgId:%d, save config while alter, replicas:%d totalReplicas:%d selfIndex:%d", - pReq->vgId, pCfg->replicaNum, pCfg->totalReplicaNum, pCfg->myIndex); + vInfo("vgId:%d, save config while alter, replicas:%d totalReplicas:%d selfIndex:%d", pReq->vgId, pCfg->replicaNum, + pCfg->totalReplicaNum, pCfg->myIndex); info.config.syncCfg = *pCfg; ret = vnodeSaveInfo(dir, &info); @@ -293,9 +294,16 @@ int32_t vnodeRestoreVgroupId(const char *srcPath, const char *dstPath, int32_t s return dstVgId; } -void vnodeDestroy(const char *path, STfs *pTfs) { +void vnodeDestroy(int32_t vgId, const char *path, STfs *pTfs) { vInfo("path:%s is removed while destroy vnode", path); tfsRmdir(pTfs, path); + + int32_t nlevel = tfsGetLevel(pTfs); + if (vgId > 0 && nlevel > 1 && tsS3Enabled) { + char vnode_prefix[TSDB_FILENAME_LEN]; + snprintf(vnode_prefix, TSDB_FILENAME_LEN, "v%df", vgId); + s3DeleteObjectsByPrefix(vnode_prefix); + } } static int32_t vnodeCheckDisk(int32_t diskPrimary, STfs *pTfs) { @@ -498,13 +506,9 @@ void vnodeClose(SVnode *pVnode) { // start the sync timer after the queue is ready int32_t vnodeStart(SVnode *pVnode) { return vnodeSyncStart(pVnode); } -int32_t vnodeIsCatchUp(SVnode *pVnode){ - return syncIsCatchUp(pVnode->sync); -} +int32_t vnodeIsCatchUp(SVnode *pVnode) { return syncIsCatchUp(pVnode->sync); } -ESyncRole vnodeGetRole(SVnode *pVnode){ - return syncGetRole(pVnode->sync); -} +ESyncRole vnodeGetRole(SVnode *pVnode) { return syncGetRole(pVnode->sync); } void vnodeStop(SVnode *pVnode) {} diff --git a/source/libs/command/inc/commandInt.h b/source/libs/command/inc/commandInt.h index 2a7aeb0060..996891c77a 100644 --- a/source/libs/command/inc/commandInt.h +++ b/source/libs/command/inc/commandInt.h @@ -67,6 +67,8 @@ extern "C" { #define EXPLAIN_EVENT_FORMAT "Event" #define EXPLAIN_EVENT_START_FORMAT "Start Cond: " #define EXPLAIN_EVENT_END_FORMAT "End Cond: " +#define EXPLAIN_GROUP_CACHE_FORMAT "Group Cache" +#define EXPLAIN_DYN_QRY_CTRL_FORMAT "Dynamic Query Control for %s" #define EXPLAIN_PLANNING_TIME_FORMAT "Planning Time: %.3f ms" #define EXPLAIN_EXEC_TIME_FORMAT "Execution Time: %.3f ms" @@ -96,6 +98,12 @@ extern "C" { #define EXPLAIN_OFFSET_FORMAT "offset=%" PRId64 #define EXPLAIN_SOFFSET_FORMAT "soffset=%" PRId64 #define EXPLAIN_PARTITIONS_FORMAT "partitions=%d" +#define EXPLAIN_GLOBAL_GROUP_FORMAT "global_group=%d" +#define EXPLAIN_GROUP_BY_UID_FORMAT "group_by_uid=%d" +#define EXPLAIN_BATCH_SCAN_FORMAT "batch_scan=%d" +#define EXPLAIN_VGROUP_SLOT_FORMAT "vgroup_slot=%d,%d" +#define EXPLAIN_UID_SLOT_FORMAT "uid_slot=%d,%d" +#define EXPLAIN_SRC_SCAN_FORMAT "src_scan=%d,%d" #define COMMAND_RESET_LOG "resetLog" #define COMMAND_SCHEDULE_POLICY "schedulePolicy" diff --git a/source/libs/command/src/explain.c b/source/libs/command/src/explain.c index e167b31ef8..655775e224 100644 --- a/source/libs/command/src/explain.c +++ b/source/libs/command/src/explain.c @@ -24,6 +24,17 @@ int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pRes); int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel); +char *qExplainGetDynQryCtrlType(EDynQueryType type) { + switch (type) { + case DYN_QTYPE_STB_HASH: + return "STable Join"; + default: + break; + } + + return "unknown task"; +} + void qExplainFreeResNode(SExplainResNode *resNode) { if (NULL == resNode) { return; @@ -575,11 +586,11 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i EXPLAIN_ROW_NEW(level + 1, EXPLAIN_ON_CONDITIONS_FORMAT); QRY_ERR_RET( - nodesNodeToSQL(pJoinNode->pMergeCondition, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); - if (pJoinNode->pOnConditions) { + nodesNodeToSQL(pJoinNode->pPrimKeyCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + if (pJoinNode->pOtherOnCond) { EXPLAIN_ROW_APPEND(" AND "); QRY_ERR_RET( - nodesNodeToSQL(pJoinNode->pOnConditions, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + nodesNodeToSQL(pJoinNode->pOtherOnCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); } EXPLAIN_ROW_END(); QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); @@ -1522,6 +1533,168 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i } break; } + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:{ + SHashJoinPhysiNode *pJoinNode = (SHashJoinPhysiNode *)pNode; + EXPLAIN_ROW_NEW(level, EXPLAIN_JOIN_FORMAT, EXPLAIN_JOIN_STRING(pJoinNode->joinType)); + EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT); + if (pResNode->pExecInfo) { + QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + } + EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pJoinNode->pTargets->length); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->totalRowSize); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pJoinNode->node.inputTsOrder)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level)); + + if (verbose) { + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, + nodesGetOutputNumFromSlotList(pJoinNode->node.pOutputDataBlockDesc->pSlots)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pJoinNode->node.pOutputDataBlockDesc->outputRowSize); + EXPLAIN_ROW_APPEND_LIMIT(pJoinNode->node.pLimit); + EXPLAIN_ROW_APPEND_SLIMIT(pJoinNode->node.pSlimit); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + + if (pJoinNode->node.pConditions || pJoinNode->pFilterConditions) { + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT); + if (pJoinNode->node.pConditions) { + QRY_ERR_RET(nodesNodeToSQL(pJoinNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE, + TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + } + if (pJoinNode->pFilterConditions) { + if (pJoinNode->node.pConditions) { + EXPLAIN_ROW_APPEND(" AND "); + } + QRY_ERR_RET(nodesNodeToSQL(pJoinNode->pFilterConditions, tbuf + VARSTR_HEADER_SIZE, + TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + } + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + } + + bool conditionsGot = false; + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_ON_CONDITIONS_FORMAT); + if (pJoinNode->pPrimKeyCond) { + QRY_ERR_RET( + nodesNodeToSQL(pJoinNode->pPrimKeyCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + conditionsGot = true; + } + if (pJoinNode->pColEqCond) { + if (conditionsGot) { + EXPLAIN_ROW_APPEND(" AND "); + } + QRY_ERR_RET( + nodesNodeToSQL(pJoinNode->pColEqCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + conditionsGot = true; + } + if (pJoinNode->pTagEqCond) { + if (conditionsGot) { + EXPLAIN_ROW_APPEND(" AND "); + } + QRY_ERR_RET( + nodesNodeToSQL(pJoinNode->pTagEqCond, tbuf + VARSTR_HEADER_SIZE, TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + conditionsGot = true; + } + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + } + break; + } + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:{ + SGroupCachePhysiNode *pGroupCache = (SGroupCachePhysiNode *)pNode; + EXPLAIN_ROW_NEW(level, EXPLAIN_GROUP_CACHE_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT); + if (pResNode->pExecInfo) { + QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + } + EXPLAIN_ROW_APPEND(EXPLAIN_GLOBAL_GROUP_FORMAT, pGroupCache->globalGrp); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_GROUP_BY_UID_FORMAT, pGroupCache->grpByUid); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_SCAN_FORMAT, pGroupCache->batchFetch); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pGroupCache->node.pOutputDataBlockDesc->totalRowSize); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pGroupCache->node.inputTsOrder)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level)); + + if (verbose) { + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, + nodesGetOutputNumFromSlotList(pGroupCache->node.pOutputDataBlockDesc->pSlots)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pGroupCache->node.pOutputDataBlockDesc->outputRowSize); + EXPLAIN_ROW_APPEND_LIMIT(pGroupCache->node.pLimit); + EXPLAIN_ROW_APPEND_SLIMIT(pGroupCache->node.pSlimit); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + + if (pGroupCache->node.pConditions) { + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT); + QRY_ERR_RET(nodesNodeToSQL(pGroupCache->node.pConditions, tbuf + VARSTR_HEADER_SIZE, + TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + } + } + break; + } + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:{ + SDynQueryCtrlPhysiNode *pDyn = (SDynQueryCtrlPhysiNode *)pNode; + EXPLAIN_ROW_NEW(level, EXPLAIN_DYN_QRY_CTRL_FORMAT, qExplainGetDynQryCtrlType(pDyn->qType)); + EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT); + if (pResNode->pExecInfo) { + QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + } + EXPLAIN_ROW_APPEND(EXPLAIN_BATCH_SCAN_FORMAT, pDyn->stbJoin.batchFetch); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_VGROUP_SLOT_FORMAT, pDyn->stbJoin.vgSlot[0], pDyn->stbJoin.vgSlot[1]); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_UID_SLOT_FORMAT, pDyn->stbJoin.uidSlot[0], pDyn->stbJoin.uidSlot[1]); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_SRC_SCAN_FORMAT, pDyn->stbJoin.srcScan[0], pDyn->stbJoin.srcScan[1]); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->totalRowSize); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_INPUT_ORDER_FORMAT, EXPLAIN_ORDER_STRING(pDyn->node.inputTsOrder)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level)); + + if (verbose) { + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, + nodesGetOutputNumFromSlotList(pDyn->node.pOutputDataBlockDesc->pSlots)); + EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT); + EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pDyn->node.pOutputDataBlockDesc->outputRowSize); + EXPLAIN_ROW_APPEND_LIMIT(pDyn->node.pLimit); + EXPLAIN_ROW_APPEND_SLIMIT(pDyn->node.pSlimit); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + + if (pDyn->node.pConditions) { + EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT); + QRY_ERR_RET(nodesNodeToSQL(pDyn->node.pConditions, tbuf + VARSTR_HEADER_SIZE, + TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen)); + EXPLAIN_ROW_END(); + QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1)); + } + } + break; + } default: qError("not supported physical node type %d", pNode->type); return TSDB_CODE_APP_ERROR; diff --git a/source/libs/executor/inc/dataSinkInt.h b/source/libs/executor/inc/dataSinkInt.h index 9893b4eb76..dcebd2c6fd 100644 --- a/source/libs/executor/inc/dataSinkInt.h +++ b/source/libs/executor/inc/dataSinkInt.h @@ -35,6 +35,7 @@ typedef struct SDataSinkManager { typedef int32_t (*FPutDataBlock)(struct SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue); typedef void (*FEndPut)(struct SDataSinkHandle* pHandle, uint64_t useconds); +typedef void (*FReset)(struct SDataSinkHandle* pHandle); typedef void (*FGetDataLength)(struct SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryEnd); typedef int32_t (*FGetDataBlock)(struct SDataSinkHandle* pHandle, SOutputData* pOutput); typedef int32_t (*FDestroyDataSinker)(struct SDataSinkHandle* pHandle); @@ -43,6 +44,7 @@ typedef int32_t (*FGetCacheSize)(struct SDataSinkHandle* pHandle, uint64_t* size typedef struct SDataSinkHandle { FPutDataBlock fPut; FEndPut fEndPut; + FReset fReset; FGetDataLength fGetLen; FGetDataBlock fGetData; FDestroyDataSinker fDestroy; diff --git a/source/libs/executor/inc/dynqueryctrl.h b/source/libs/executor/inc/dynqueryctrl.h new file mode 100755 index 0000000000..793fbc0e61 --- /dev/null +++ b/source/libs/executor/inc/dynqueryctrl.h @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +#ifndef TDENGINE_DYNQUERYCTRL_H +#define TDENGINE_DYNQUERYCTRL_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct SDynQueryCtrlExecInfo { + int64_t prevBlkNum; + int64_t prevBlkRows; + int64_t postBlkNum; + int64_t postBlkRows; + int64_t leftCacheNum; + int64_t rightCacheNum; +} SDynQueryCtrlExecInfo; + +typedef struct SStbJoinTableList { + void *pNext; + int64_t uidNum; + int64_t readIdx; + int32_t *pLeftVg; + int64_t *pLeftUid; + int32_t *pRightVg; + int64_t *pRightUid; +} SStbJoinTableList; + +typedef struct SStbJoinPrevJoinCtx { + bool joinBuild; + SSHashObj* leftHash; + SSHashObj* rightHash; + SSHashObj* leftCache; + SSHashObj* rightCache; + SSHashObj* onceTable; + int64_t tableNum; + SStbJoinTableList* pListHead; + SStbJoinTableList* pListTail; +} SStbJoinPrevJoinCtx; + +typedef struct SStbJoinPostJoinCtx { + bool isStarted; + bool leftNeedCache; + bool rightNeedCache; + int32_t leftVgId; + int32_t rightVgId; + int64_t leftCurrUid; + int64_t rightCurrUid; + int64_t rightNextUid; +} SStbJoinPostJoinCtx; + +typedef struct SStbJoinDynCtrlCtx { + SStbJoinPrevJoinCtx prev; + SStbJoinPostJoinCtx post; +} SStbJoinDynCtrlCtx; + +typedef struct SStbJoinDynCtrlInfo { + SDynQueryCtrlExecInfo execInfo; + SStbJoinDynCtrlBasic basic; + SStbJoinDynCtrlCtx ctx; + int16_t outputBlkId; +} SStbJoinDynCtrlInfo; + +typedef struct SDynQueryCtrlOperatorInfo { + EDynQueryType qType; + union { + SStbJoinDynCtrlInfo stbJoin; + }; +} SDynQueryCtrlOperatorInfo; + +#ifdef __cplusplus +} +#endif + +#endif // TDENGINE_DYNQUERYCTRL_H diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h index 2622903121..5e2ca462f7 100644 --- a/source/libs/executor/inc/executil.h +++ b/source/libs/executor/inc/executil.h @@ -163,7 +163,7 @@ int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode size_t getTableTagsBufLen(const SNodeList* pGroups); SArray* createSortInfo(SNodeList* pNodeList); -SArray* extractPartitionColInfo(SNodeList* pNodeList); +SArray* makeColumnArrayFromList(SNodeList* pNodeList); int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols, int32_t type, SColMatchInfo* pMatchInfo); diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index 00b47e343f..8726f57977 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -48,6 +48,8 @@ typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int typedef struct STsdbReader STsdbReader; typedef struct STqReader STqReader; +typedef enum SOperatorParamType { OP_GET_PARAM = 1, OP_NOTIFY_PARAM } SOperatorParamType; + #define IS_VALID_SESSION_WIN(winInfo) ((winInfo).sessionWin.win.skey > 0) #define SET_SESSION_WIN_INVALID(winInfo) ((winInfo).sessionWin.win.skey = INT64_MIN) #define IS_INVALID_SESSION_WIN_KEY(winKey) ((winKey).win.skey <= 0) @@ -105,6 +107,20 @@ typedef struct SExchangeOpStopInfo { int64_t refId; } SExchangeOpStopInfo; +typedef struct SGcOperatorParam { + int64_t sessionId; + int32_t downstreamIdx; + int32_t vgId; + int64_t tbUid; + bool needCache; +} SGcOperatorParam; + +typedef struct SGcNotifyOperatorParam { + int32_t downstreamIdx; + int32_t vgId; + int64_t tbUid; +} SGcNotifyOperatorParam; + typedef struct SExprSupp { SExprInfo* pExprInfo; int32_t numOfExprs; // the number of scalar expression in group operator @@ -115,8 +131,9 @@ typedef struct SExprSupp { typedef enum { EX_SOURCE_DATA_NOT_READY = 0x1, - EX_SOURCE_DATA_READY = 0x2, - EX_SOURCE_DATA_EXHAUSTED = 0x3, + EX_SOURCE_DATA_STARTED, + EX_SOURCE_DATA_READY, + EX_SOURCE_DATA_EXHAUSTED, } EX_SOURCE_STATUS; #define COL_MATCH_FROM_COL_ID 0x1 @@ -138,11 +155,38 @@ typedef struct SLimitInfo { int64_t numOfOutputRows; } SLimitInfo; +typedef struct SSortMergeJoinOperatorParam { + bool initDownstream; +} SSortMergeJoinOperatorParam; + +typedef struct SExchangeOperatorBasicParam { + int32_t vgId; + int32_t srcOpType; + bool tableSeq; + SArray* uidList; +} SExchangeOperatorBasicParam; + +typedef struct SExchangeOperatorBatchParam { + bool multiParams; + SSHashObj* pBatchs; // SExchangeOperatorBasicParam +} SExchangeOperatorBatchParam; + +typedef struct SExchangeOperatorParam { + bool multiParams; + SExchangeOperatorBasicParam basic; +} SExchangeOperatorParam; + +typedef struct SExchangeSrcIndex { + int32_t srcIdx; + int32_t inUseIdx; +} SExchangeSrcIndex; + typedef struct SExchangeInfo { - SArray* pSources; - SArray* pSourceDataInfo; - tsem_t ready; - void* pTransporter; + SArray* pSources; + SSHashObj* pHashSources; + SArray* pSourceDataInfo; + tsem_t ready; + void* pTransporter; // SArray, result block list, used to keep the multi-block that // passed by downstream operator @@ -150,6 +194,7 @@ typedef struct SExchangeInfo { SArray* pRecycledBlocks; // build a pool for small data block to avoid to repeatly create and then destroy. SSDataBlock* pDummyBlock; // dummy block, not keep data bool seqLoadData; // sequential load data or not, false by default + bool dynamicOp; int32_t current; SLoadRemoteDataInfo loadInfo; uint64_t self; @@ -610,9 +655,10 @@ typedef struct SStreamFillOperatorInfo { #define OPTR_SET_OPENED(_optr) ((_optr)->status |= OP_OPENED) SSchemaWrapper* extractQueriedColumnSchema(SScanPhysiNode* pScanNode); -int32_t initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode, const char* dbName, - SExecTaskInfo* pTaskInfo); -void cleanupQueriedTableScanInfo(SSchemaInfo* pSchemaInfo); + +int32_t initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode, const char* dbName, + SExecTaskInfo* pTaskInfo); +void cleanupQueriedTableScanInfo(void* p); void initBasicInfo(SOptrBasicInfo* pInfo, SSDataBlock* pBlock); void cleanupBasicInfo(SOptrBasicInfo* pInfo); @@ -718,9 +764,17 @@ uint64_t calcGroupId(char* pData, int32_t len); void streamOpReleaseState(struct SOperatorInfo* pOperator); void streamOpReloadState(struct SOperatorInfo* pOperator); -int32_t encodeSTimeWindowAggSupp(void** buf, STimeWindowAggSupp* pTwAggSup); -void* decodeSTimeWindowAggSupp(void* buf, STimeWindowAggSupp* pTwAggSup); -bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo); +int32_t encodeSTimeWindowAggSupp(void** buf, STimeWindowAggSupp* pTwAggSup); +void* decodeSTimeWindowAggSupp(void* buf, STimeWindowAggSupp* pTwAggSup); +void destroyOperatorParamValue(void* pValues); +int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc); +int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, int32_t srcOpType, bool tableSeq); +void freeExchangeGetBasicOperatorParam(void* pParam); +void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type); +void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree); +SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam); + +bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo); bool inCalSlidingWindow(SInterval* pInterval, STimeWindow* pWin, TSKEY calStart, TSKEY calEnd, EStreamType blockType); bool compareVal(const char* v, const SStateKeys* pKey); diff --git a/source/libs/executor/inc/groupcache.h b/source/libs/executor/inc/groupcache.h new file mode 100755 index 0000000000..ef2730086b --- /dev/null +++ b/source/libs/executor/inc/groupcache.h @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +#ifndef TDENGINE_GROUPCACHE_H +#define TDENGINE_GROUPCACHE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define GROUP_CACHE_DEFAULT_MAX_FILE_SIZE 104857600 +#define GROUP_CACHE_MAX_FILE_FDS 10 +#define GROUP_CACHE_DEFAULT_VGID 0 + +#pragma pack(push, 1) +typedef struct SGcBlkBufBasic { + int32_t fileId; + int64_t blkId; + int64_t offset; + int64_t bufSize; +} SGcBlkBufBasic; +#pragma pack(pop) + +typedef struct SGroupCacheFileFd { + TdThreadMutex mutex; + TdFilePtr fd; +} SGroupCacheFileFd; + +typedef struct SGroupCacheFileInfo { + uint32_t groupNum; + bool deleted; + SGroupCacheFileFd fd; +} SGroupCacheFileInfo; + +typedef struct SGcFileCacheCtx { + int64_t fileSize; + int32_t fileId; + SHashObj* pCacheFile; + int32_t baseNameLen; + char baseFilename[256]; +} SGcFileCacheCtx; + +typedef struct SGcDownstreamCtx { + int32_t id; + SRWLatch grpLock; + int64_t fetchSessionId; + SArray* pNewGrpList; // SArray + SSHashObj* pVgTbHash; // SHash + SHashObj* pGrpHash; + SRWLatch blkLock; + SSDataBlock* pBaseBlock; + SArray* pFreeBlock; + int64_t lastBlkUid; + SHashObj* pSessions; + SHashObj* pWaitSessions; + SGcFileCacheCtx fileCtx; +} SGcDownstreamCtx; + +typedef struct SGcVgroupCtx { + int32_t id; + SArray* pTbList; + uint64_t lastBlkUid; + SGcFileCacheCtx fileCtx; +} SGcVgroupCtx; + +typedef struct SGcBlkList { + SRWLatch lock; + SArray* pList; +} SGcBlkList; + +typedef struct SGroupCacheData { + TdThreadMutex mutex; + SArray* waitQueue; + bool fetchDone; + bool needCache; + SSDataBlock* pBlock; + SGcVgroupCtx* pVgCtx; + int32_t downstreamIdx; + int32_t vgId; + SGcBlkList blkList; + int32_t fileId; + int64_t startOffset; +} SGroupCacheData; + +typedef struct SGroupColInfo { + int32_t slot; + bool vardata; + int32_t bytes; +} SGroupColInfo; + +typedef struct SGroupColsInfo { + int32_t colNum; + bool withNull; + SGroupColInfo* pColsInfo; + int32_t bitMapSize; + int32_t bufSize; + char* pBuf; + char* pData; +} SGroupColsInfo; + +typedef struct SGcNewGroupInfo { + int32_t vgId; + int64_t uid; + SGroupCacheData* pGroup; + SOperatorParam* pParam; +} SGcNewGroupInfo; + +typedef struct SGcSessionCtx { + int32_t downstreamIdx; + SGcOperatorParam* pParam; + SGroupCacheData* pGroupData; + int64_t lastBlkId; + bool semInit; + tsem_t waitSem; + bool newFetch; + int64_t resRows; +} SGcSessionCtx; + +typedef struct SGcBlkBufInfo { + SGcBlkBufBasic basic; + void* next; + void* pBuf; + SGcDownstreamCtx* pCtx; + int64_t groupId; +} SGcBlkBufInfo; + +typedef struct SGcExecInfo { + int64_t* pDownstreamBlkNum; +} SGcExecInfo; + +typedef struct SGcCacheFile { + uint32_t grpNum; + uint32_t grpDone; + int64_t fileSize; +} SGcCacheFile; + +typedef struct SGcBlkCacheInfo { + SRWLatch dirtyLock; + SHashObj* pDirtyBlk; + SGcBlkBufInfo* pDirtyHead; + SGcBlkBufInfo* pDirtyTail; + SHashObj* pReadBlk; + int64_t blkCacheSize; + int32_t writeDownstreamId; +} SGcBlkCacheInfo; + +typedef struct SGroupCacheOperatorInfo { + int64_t maxCacheSize; + int64_t currentBlkId; + SGroupColsInfo groupColsInfo; + bool globalGrp; + bool grpByUid; + bool batchFetch; + int32_t downstreamNum; + SGcDownstreamCtx* pDownstreams; + SGcBlkCacheInfo blkCache; + SHashObj* pGrpHash; + SGcExecInfo execInfo; +} SGroupCacheOperatorInfo; + +#ifdef __cplusplus +} +#endif + +#endif // TDENGINE_GROUPCACHE_H diff --git a/source/libs/executor/inc/hashjoin.h b/source/libs/executor/inc/hashjoin.h new file mode 100755 index 0000000000..6822333d0a --- /dev/null +++ b/source/libs/executor/inc/hashjoin.h @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +#ifndef TDENGINE_HASHJOIN_H +#define TDENGINE_HASHJOIN_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define HASH_JOIN_DEFAULT_PAGE_SIZE 10485760 + +#pragma pack(push, 1) +typedef struct SBufRowInfo { + void* next; + uint16_t pageId; + int32_t offset; +} SBufRowInfo; +#pragma pack(pop) + +typedef struct SHJoinCtx { + bool rowRemains; + SBufRowInfo* pBuildRow; + SSDataBlock* pProbeData; + int32_t probeIdx; +} SHJoinCtx; + +typedef struct SRowLocation { + SSDataBlock* pDataBlock; + int32_t pos; +} SRowLocation; + +typedef struct SHJoinColInfo { + int32_t srcSlot; + int32_t dstSlot; + bool keyCol; + bool vardata; + int32_t* offset; + int32_t bytes; + char* data; + char* bitMap; +} SHJoinColInfo; + +typedef struct SBufPageInfo { + int32_t pageSize; + int32_t offset; + char* data; +} SBufPageInfo; + + +typedef struct SGroupData { + SBufRowInfo* rows; +} SGroupData; + +typedef struct SHJoinTableInfo { + int32_t downStreamIdx; + SOperatorInfo* downStream; + int32_t blkId; + SQueryStat inputStat; + + int32_t keyNum; + SHJoinColInfo* keyCols; + char* keyBuf; + char* keyData; + + int32_t valNum; + SHJoinColInfo* valCols; + char* valData; + int32_t valBitMapSize; + int32_t valBufSize; + SArray* valVarCols; + bool valColExist; +} SHJoinTableInfo; + +typedef struct SHJoinExecInfo { + int64_t buildBlkNum; + int64_t buildBlkRows; + int64_t probeBlkNum; + int64_t probeBlkRows; + int64_t resRows; + int64_t expectRows; +} SHJoinExecInfo; + + +typedef struct SHJoinOperatorInfo { + int32_t joinType; + SHJoinTableInfo tbs[2]; + SHJoinTableInfo* pBuild; + SHJoinTableInfo* pProbe; + SSDataBlock* pRes; + int32_t pResColNum; + int8_t* pResColMap; + SArray* pRowBufs; + SNode* pCond; + SSHashObj* pKeyHash; + bool keyHashBuilt; + SHJoinCtx ctx; + SHJoinExecInfo execInfo; +} SHJoinOperatorInfo; + +#ifdef __cplusplus +} +#endif + +#endif // TDENGINE_HASHJOIN_H diff --git a/source/libs/executor/inc/operator.h b/source/libs/executor/inc/operator.h index 0fcc392a1f..13da9f7238 100644 --- a/source/libs/executor/inc/operator.h +++ b/source/libs/executor/inc/operator.h @@ -35,6 +35,8 @@ typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* pOptr); typedef void (*__optr_close_fn_t)(void* param); typedef int32_t (*__optr_explain_fn_t)(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len); typedef int32_t (*__optr_reqBuf_fn_t)(struct SOperatorInfo* pOptr); +typedef SSDataBlock* (*__optr_get_ext_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param); +typedef int32_t (*__optr_notify_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param); typedef void (*__optr_state_fn_t)(struct SOperatorInfo* pOptr); typedef struct SOperatorFpSet { @@ -46,6 +48,8 @@ typedef struct SOperatorFpSet { __optr_encode_fn_t encodeResultRow; __optr_decode_fn_t decodeResultRow; __optr_explain_fn_t getExplainFn; + __optr_get_ext_fn_t getNextExtFn; + __optr_notify_fn_t notifyFn; __optr_state_fn_t releaseStreamStateFn; __optr_state_fn_t reloadStreamStateFn; } SOperatorFpSet; @@ -61,6 +65,8 @@ typedef struct SOperatorInfo { uint16_t operatorType; int16_t resultDataBlockId; bool blocking; // block operator or not + bool transparent; + bool dynamicTask; uint8_t status; // denote if current operator is completed char* name; // name, for debug purpose void* info; // extension attribution @@ -68,8 +74,13 @@ typedef struct SOperatorInfo { SExecTaskInfo* pTaskInfo; SOperatorCostInfo cost; SResultInfo resultInfo; + SOperatorParam* pOperatorGetParam; + SOperatorParam* pOperatorNotifyParam; + SOperatorParam** pDownstreamGetParams; + SOperatorParam** pDownstreamNotifyParams; struct SOperatorInfo** pDownstream; // downstram pointer list int32_t numOfDownstream; // number of downstream. The value is always ONE expect for join operator + int32_t numOfRealDownstream; SOperatorFpSet fpSet; } SOperatorInfo; @@ -129,6 +140,8 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo); +SOperatorInfo* createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo); + SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle); SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle); @@ -142,10 +155,16 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, SExecTaskInfo* pTaskInfo); SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo); + +SOperatorInfo* createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo); + +SOperatorInfo* createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo); + // clang-format on SOperatorFpSet createOperatorFpSet(__optr_open_fn_t openFn, __optr_fn_t nextFn, __optr_fn_t cleanup, - __optr_close_fn_t closeFn, __optr_reqBuf_fn_t reqBufFn, __optr_explain_fn_t explain); + __optr_close_fn_t closeFn, __optr_reqBuf_fn_t reqBufFn, + __optr_explain_fn_t explain, __optr_get_ext_fn_t nextExtFn, __optr_notify_fn_t notifyFn); void setOperatorStreamStateFn(SOperatorInfo* pOperator, __optr_state_fn_t relaseFn, __optr_state_fn_t reloadFn); int32_t optrDummyOpenFn(SOperatorInfo* pOperator); int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t num); @@ -153,6 +172,11 @@ void setOperatorCompleted(SOperatorInfo* pOperator); void setOperatorInfo(SOperatorInfo* pOperator, const char* name, int32_t type, bool blocking, int32_t status, void* pInfo, SExecTaskInfo* pTaskInfo); int32_t optrDefaultBufFn(SOperatorInfo* pOperator); +SSDataBlock* optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam); +int32_t optrDefaultNotifyFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam); +SSDataBlock* getNextBlockFromDownstream(struct SOperatorInfo* pOperator, int32_t idx); +SSDataBlock* getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, int32_t idx); +int16_t getOperatorResultBlockId(struct SOperatorInfo* pOperator, int32_t idx); SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond, SNode* pTagIndexCond, const char* pUser, const char* dbname); @@ -162,9 +186,10 @@ SOperatorInfo* extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, con int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag, bool inheritUsOrder); int32_t stopTableScanOperator(SOperatorInfo* pOperator, const char* pIdStr, SStorageAPI* pAPI); int32_t getOperatorExplainExecInfo(struct SOperatorInfo* operatorInfo, SArray* pExecInfoList); +void * getOperatorParam(int32_t opType, SOperatorParam* param, int32_t idx); #ifdef __cplusplus } #endif -#endif // TDENGINE_OPERATOR_H \ No newline at end of file +#endif // TDENGINE_OPERATOR_H diff --git a/source/libs/executor/inc/querytask.h b/source/libs/executor/inc/querytask.h index fcd8b28aae..fcafd5a4e3 100644 --- a/source/libs/executor/inc/querytask.h +++ b/source/libs/executor/inc/querytask.h @@ -39,6 +39,7 @@ typedef struct STaskIdInfo { uint64_t templateId; char* str; int32_t vgId; + uint64_t taskId; } STaskIdInfo; typedef struct STaskCostInfo { @@ -81,6 +82,7 @@ struct SExecTaskInfo { int32_t qbufQuota; // total available buffer (in KB) during execution query int64_t version; // used for stream to record wal version, why not move to sschemainfo SStreamTaskInfo streamInfo; + SArray* schemaInfos; SSchemaInfo schemaInfo; const char* sql; // query sql string jmp_buf env; // jump to this position when error happens. @@ -92,6 +94,9 @@ struct SExecTaskInfo { STaskStopInfo stopInfo; SRWLatch lock; // secure the access of STableListInfo SStorageAPI storageAPI; + int8_t dynamicTask; + SOperatorParam* pOpParam; + bool paramSet; }; void buildTaskId(uint64_t taskId, uint64_t queryId, char* dst); diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index 176c4b53be..f6a8c6689f 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -115,7 +115,7 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN setOperatorInfo(pOperator, "TableAggregate", QUERY_NODE_PHYSICAL_PLAN_HASH_AGG, !pAggNode->node.forceCreateNonBlockingOptr, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, getAggregateResult, NULL, destroyAggOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); if (downstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) { STableScanInfo* pTableScanInfo = downstream->info; @@ -187,7 +187,7 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } while (1) { bool blockAllocated = false; - pBlock = downstream->fpSet.getNextFn(downstream); + pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { if (!pAggInfo->hasValidBlock) { createDataBlockForEmptyInput(pOperator, &pBlock); diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index a07a9d5dbd..29d098494b 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -134,7 +134,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); pOperator->cost.openCost = 0; return pOperator; @@ -330,7 +330,8 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask return TSDB_CODE_OUT_OF_MEMORY; } - SSchemaWrapper* pWrapper = pTaskInfo->schemaInfo.sw; + SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos); + SSchemaWrapper* pWrapper = pSchemaInfo->sw; for (int32_t i = 0; i < numOfCols; ++i) { SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i); diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c index d4bbc2cb26..f31658b5c1 100644 --- a/source/libs/executor/src/dataDispatcher.c +++ b/source/libs/executor/src/dataDispatcher.c @@ -156,6 +156,13 @@ static void endPut(struct SDataSinkHandle* pHandle, uint64_t useconds) { taosThreadMutexUnlock(&pDispatcher->mutex); } +static void resetDispatcher(struct SDataSinkHandle* pHandle) { + SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle; + taosThreadMutexLock(&pDispatcher->mutex); + pDispatcher->queryEnd = false; + taosThreadMutexUnlock(&pDispatcher->mutex); +} + static void getDataLength(SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryEnd) { SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle; if (taosQueueEmpty(pDispatcher->pDataBlocks)) { @@ -182,6 +189,7 @@ static void getDataLength(SDataSinkHandle* pHandle, int64_t* pLen, bool* pQueryE ((SDataCacheEntry*)(pDispatcher->nextOutput.pData))->numOfRows); } + static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) { SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle; if (NULL == pDispatcher->nextOutput.pData) { @@ -244,6 +252,7 @@ int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSinkNode* pD } dispatcher->sink.fPut = putDataBlock; dispatcher->sink.fEndPut = endPut; + dispatcher->sink.fReset = resetDispatcher; dispatcher->sink.fGetLen = getDataLength; dispatcher->sink.fGetData = getDataBlock; dispatcher->sink.fDestroy = destroyDataSinker; diff --git a/source/libs/executor/src/dataSinkMgt.c b/source/libs/executor/src/dataSinkMgt.c index 3a972c1c20..38ec3ad393 100644 --- a/source/libs/executor/src/dataSinkMgt.c +++ b/source/libs/executor/src/dataSinkMgt.c @@ -59,6 +59,13 @@ void dsEndPut(DataSinkHandle handle, uint64_t useconds) { return pHandleImpl->fEndPut(pHandleImpl, useconds); } +void dsReset(DataSinkHandle handle) { + SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle; + if (pHandleImpl->fReset) { + return pHandleImpl->fReset(pHandleImpl); + } +} + void dsGetDataLength(DataSinkHandle handle, int64_t* pLen, bool* pQueryEnd) { SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle; pHandleImpl->fGetLen(pHandleImpl, pLen, pQueryEnd); diff --git a/source/libs/executor/src/dynqueryctrloperator.c b/source/libs/executor/src/dynqueryctrloperator.c new file mode 100755 index 0000000000..f2ed4ba618 --- /dev/null +++ b/source/libs/executor/src/dynqueryctrloperator.c @@ -0,0 +1,885 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "executorInt.h" +#include "filter.h" +#include "function.h" +#include "operator.h" +#include "os.h" +#include "querynodes.h" +#include "querytask.h" +#include "tcompare.h" +#include "tdatablock.h" +#include "thash.h" +#include "tmsg.h" +#include "ttypes.h" +#include "dynqueryctrl.h" + +int64_t gSessionId = 0; + +void freeVgTableList(void* ptr) { + taosArrayDestroy(*(SArray**)ptr); +} + +static void destroyStbJoinTableList(SStbJoinTableList* pListHead) { + SStbJoinTableList* pNext = NULL; + + while (pListHead) { + taosMemoryFree(pListHead->pLeftVg); + taosMemoryFree(pListHead->pLeftUid); + taosMemoryFree(pListHead->pRightVg); + taosMemoryFree(pListHead->pRightUid); + pNext = pListHead->pNext; + taosMemoryFree(pListHead); + pListHead = pNext; + } +} + +static void destroyStbJoinDynCtrlInfo(SStbJoinDynCtrlInfo* pStbJoin) { + qError("dynQueryCtrl exec info, prevBlk:%" PRId64 ", prevRows:%" PRId64 ", postBlk:%" PRId64 ", postRows:%" PRId64 ", leftCacheNum:%" PRId64 ", rightCacheNum:%" PRId64, + pStbJoin->execInfo.prevBlkNum, pStbJoin->execInfo.prevBlkRows, pStbJoin->execInfo.postBlkNum, + pStbJoin->execInfo.postBlkRows, pStbJoin->execInfo.leftCacheNum, pStbJoin->execInfo.rightCacheNum); + + if (pStbJoin->basic.batchFetch) { + if (pStbJoin->ctx.prev.leftHash) { + tSimpleHashSetFreeFp(pStbJoin->ctx.prev.leftHash, freeVgTableList); + tSimpleHashCleanup(pStbJoin->ctx.prev.leftHash); + } + if (pStbJoin->ctx.prev.rightHash) { + tSimpleHashSetFreeFp(pStbJoin->ctx.prev.rightHash, freeVgTableList); + tSimpleHashCleanup(pStbJoin->ctx.prev.rightHash); + } + } else { + if (pStbJoin->ctx.prev.leftCache) { + tSimpleHashCleanup(pStbJoin->ctx.prev.leftCache); + } + if (pStbJoin->ctx.prev.rightCache) { + tSimpleHashCleanup(pStbJoin->ctx.prev.rightCache); + } + if (pStbJoin->ctx.prev.onceTable) { + tSimpleHashCleanup(pStbJoin->ctx.prev.onceTable); + } + } + + destroyStbJoinTableList(pStbJoin->ctx.prev.pListHead); +} + +static void destroyDynQueryCtrlOperator(void* param) { + SDynQueryCtrlOperatorInfo* pDyn = (SDynQueryCtrlOperatorInfo*)param; + + switch (pDyn->qType) { + case DYN_QTYPE_STB_HASH: + destroyStbJoinDynCtrlInfo(&pDyn->stbJoin); + break; + default: + qError("unsupported dynamic query ctrl type: %d", pDyn->qType); + break; + } + + taosMemoryFreeClear(param); +} + +static FORCE_INLINE bool tableNeedCache(int64_t uid, SStbJoinPrevJoinCtx* pPrev, SStbJoinPostJoinCtx* pPost, bool rightTable, bool batchFetch) { + if (batchFetch) { + return true; + } + + if (rightTable) { + return pPost->rightCurrUid == pPost->rightNextUid; + } + + uint32_t* num = tSimpleHashGet(pPrev->leftCache, &uid, sizeof(uid)); + + return (NULL == num) ? false : true; +} + +static void updatePostJoinCurrTableInfo(SStbJoinDynCtrlInfo* pStbJoin) { + SStbJoinPrevJoinCtx* pPrev = &pStbJoin->ctx.prev; + SStbJoinPostJoinCtx* pPost = &pStbJoin->ctx.post; + SStbJoinTableList* pNode = pPrev->pListHead; + int32_t* leftVgId = pNode->pLeftVg + pNode->readIdx; + int32_t* rightVgId = pNode->pRightVg + pNode->readIdx; + int64_t* leftUid = pNode->pLeftUid + pNode->readIdx; + int64_t* rightUid = pNode->pRightUid + pNode->readIdx; + int64_t readIdx = pNode->readIdx + 1; + int64_t rightPrevUid = pPost->rightCurrUid; + + pPost->leftCurrUid = *leftUid; + pPost->rightCurrUid = *rightUid; + + pPost->leftVgId = *leftVgId; + pPost->rightVgId = *rightVgId; + + while (true) { + if (readIdx < pNode->uidNum) { + pPost->rightNextUid = *(pNode->pRightUid + readIdx); + break; + } + + pNode = pNode->pNext; + if (NULL == pNode) { + pPost->rightNextUid = 0; + break; + } + + rightUid = pNode->pRightUid; + readIdx = 0; + } + + pPost->leftNeedCache = tableNeedCache(*leftUid, pPrev, pPost, false, pStbJoin->basic.batchFetch); + pPost->rightNeedCache = tableNeedCache(*rightUid, pPrev, pPost, true, pStbJoin->basic.batchFetch); + + if (pPost->rightNeedCache && rightPrevUid != pPost->rightCurrUid) { + tSimpleHashPut(pPrev->rightCache, &pPost->rightCurrUid, sizeof(pPost->rightCurrUid), NULL, 0); + pStbJoin->execInfo.rightCacheNum++; + } +} + + +static int32_t buildGroupCacheOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, int32_t vgId, int64_t tbUid, bool needCache, SOperatorParam* pChild) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (pChild) { + (*ppRes)->pChildren = taosArrayInit(1, POINTER_BYTES); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (NULL == taosArrayPush((*ppRes)->pChildren, &pChild)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } else { + (*ppRes)->pChildren = NULL; + } + + SGcOperatorParam* pGc = taosMemoryMalloc(sizeof(SGcOperatorParam)); + if (NULL == pGc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pGc->sessionId = atomic_add_fetch_64(&gSessionId, 1); + pGc->downstreamIdx = downstreamIdx; + pGc->vgId = vgId; + pGc->tbUid = tbUid; + pGc->needCache = needCache; + + (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE; + (*ppRes)->downstreamIdx = downstreamIdx; + (*ppRes)->value = pGc; + + return TSDB_CODE_SUCCESS; +} + + +static int32_t buildGroupCacheNotifyOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, int32_t vgId, int64_t tbUid) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ppRes)->pChildren = NULL; + + SGcNotifyOperatorParam* pGc = taosMemoryMalloc(sizeof(SGcNotifyOperatorParam)); + if (NULL == pGc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pGc->downstreamIdx = downstreamIdx; + pGc->vgId = vgId; + pGc->tbUid = tbUid; + + (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE; + (*ppRes)->downstreamIdx = downstreamIdx; + (*ppRes)->value = pGc; + + return TSDB_CODE_SUCCESS; +} + + +static int32_t buildExchangeOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, int32_t* pVgId, int64_t* pUid) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ppRes)->pChildren = NULL; + + SExchangeOperatorParam* pExc = taosMemoryMalloc(sizeof(SExchangeOperatorParam)); + if (NULL == pExc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pExc->multiParams = false; + pExc->basic.vgId = *pVgId; + pExc->basic.tableSeq = true; + pExc->basic.srcOpType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN; + pExc->basic.uidList = taosArrayInit(1, sizeof(int64_t)); + if (NULL == pExc->basic.uidList) { + taosMemoryFree(pExc); + return TSDB_CODE_OUT_OF_MEMORY; + } + taosArrayPush(pExc->basic.uidList, pUid); + + (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_EXCHANGE; + (*ppRes)->downstreamIdx = downstreamIdx; + (*ppRes)->value = pExc; + + return TSDB_CODE_SUCCESS; +} + + +static int32_t buildBatchExchangeOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, SSHashObj* pVg) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ppRes)->pChildren = NULL; + + SExchangeOperatorBatchParam* pExc = taosMemoryMalloc(sizeof(SExchangeOperatorBatchParam)); + if (NULL == pExc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pExc->multiParams = true; + pExc->pBatchs = tSimpleHashInit(tSimpleHashGetSize(pVg), taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); + if (NULL == pExc->pBatchs) { + taosMemoryFree(pExc); + return TSDB_CODE_OUT_OF_MEMORY; + } + tSimpleHashSetFreeFp(pExc->pBatchs, freeExchangeGetBasicOperatorParam); + + SExchangeOperatorBasicParam basic; + basic.srcOpType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN; + + int32_t iter = 0; + void* p = NULL; + while (NULL != (p = tSimpleHashIterate(pVg, p, &iter))) { + int32_t* pVgId = tSimpleHashGetKey(p, NULL); + SArray* pUidList = *(SArray**)p; + basic.vgId = *pVgId; + basic.uidList = pUidList; + basic.tableSeq = false; + + tSimpleHashPut(pExc->pBatchs, pVgId, sizeof(*pVgId), &basic, sizeof(basic)); + + qTrace("build downstreamIdx %d batch scan, vgId:%d, uidNum:%" PRId64, downstreamIdx, *pVgId, (int64_t)taosArrayGetSize(pUidList)); + *(SArray**)p = NULL; + } + + (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_EXCHANGE; + (*ppRes)->downstreamIdx = downstreamIdx; + (*ppRes)->value = pExc; + + return TSDB_CODE_SUCCESS; +} + + +static int32_t buildMergeJoinOperatorParam(SOperatorParam** ppRes, bool initParam, SOperatorParam* pChild0, SOperatorParam* pChild1) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ppRes)->pChildren = taosArrayInit(2, POINTER_BYTES); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (NULL == taosArrayPush((*ppRes)->pChildren, &pChild0)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (NULL == taosArrayPush((*ppRes)->pChildren, &pChild1)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + SSortMergeJoinOperatorParam* pJoin = taosMemoryMalloc(sizeof(SSortMergeJoinOperatorParam)); + if (NULL == pJoin) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pJoin->initDownstream = initParam; + + (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN; + (*ppRes)->value = pJoin; + + return TSDB_CODE_SUCCESS; +} + + +static int32_t buildMergeJoinNotifyOperatorParam(SOperatorParam** ppRes, SOperatorParam* pChild0, SOperatorParam* pChild1) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ppRes)->pChildren = taosArrayInit(2, POINTER_BYTES); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (pChild0 && NULL == taosArrayPush((*ppRes)->pChildren, &pChild0)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (pChild1 && NULL == taosArrayPush((*ppRes)->pChildren, &pChild1)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN; + (*ppRes)->value = NULL; + + return TSDB_CODE_SUCCESS; +} + + + +static int32_t buildBatchTableScanOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, SSHashObj* pVg) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t vgNum = tSimpleHashGetSize(pVg); + if (vgNum <= 0 || vgNum > 1) { + qError("Invalid vgroup num %d to build table scan operator param", vgNum); + return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; + } + + int32_t iter = 0; + void* p = NULL; + while (NULL != (p = tSimpleHashIterate(pVg, p, &iter))) { + int32_t* pVgId = tSimpleHashGetKey(p, NULL); + SArray* pUidList = *(SArray**)p; + + code = buildTableScanOperatorParam(ppRes, pUidList, QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false); + if (code) { + return code; + } + taosArrayDestroy(pUidList); + *(SArray**)p = NULL; + } + + return TSDB_CODE_SUCCESS; +} + + +static int32_t buildSingleTableScanOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, int32_t* pVgId, int64_t* pUid) { + SArray* pUidList = taosArrayInit(1, sizeof(int64_t)); + if (NULL == pUidList) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosArrayPush(pUidList, pUid); + + int32_t code = buildTableScanOperatorParam(ppRes, pUidList, QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, true); + taosArrayDestroy(pUidList); + if (code) { + return code; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t buildSeqStbJoinOperatorParam(SDynQueryCtrlOperatorInfo* pInfo, SStbJoinPrevJoinCtx* pPrev, SStbJoinPostJoinCtx* pPost, SOperatorParam** ppParam) { + int64_t rowIdx = pPrev->pListHead->readIdx; + SOperatorParam* pSrcParam0 = NULL; + SOperatorParam* pSrcParam1 = NULL; + SOperatorParam* pGcParam0 = NULL; + SOperatorParam* pGcParam1 = NULL; + int32_t* leftVg = pPrev->pListHead->pLeftVg + rowIdx; + int64_t* leftUid = pPrev->pListHead->pLeftUid + rowIdx; + int32_t* rightVg = pPrev->pListHead->pRightVg + rowIdx; + int64_t* rightUid = pPrev->pListHead->pRightUid + rowIdx; + int32_t code = TSDB_CODE_SUCCESS; + + qError("start %" PRId64 ":%" PRId64 "th stbJoin, left:%d,%" PRIu64 " - right:%d,%" PRIu64, + rowIdx, pPrev->tableNum, *leftVg, *leftUid, *rightVg, *rightUid); + + updatePostJoinCurrTableInfo(&pInfo->stbJoin); + + if (pInfo->stbJoin.basic.batchFetch) { + if (pPrev->leftHash) { + code = pInfo->stbJoin.basic.srcScan[0] ? buildBatchTableScanOperatorParam(&pSrcParam0, 0, pPrev->leftHash) : buildBatchExchangeOperatorParam(&pSrcParam0, 0, pPrev->leftHash); + if (TSDB_CODE_SUCCESS == code) { + code = pInfo->stbJoin.basic.srcScan[1] ? buildBatchTableScanOperatorParam(&pSrcParam1, 1, pPrev->rightHash) : buildBatchExchangeOperatorParam(&pSrcParam1, 1, pPrev->rightHash); + } + if (TSDB_CODE_SUCCESS == code) { + tSimpleHashCleanup(pPrev->leftHash); + tSimpleHashCleanup(pPrev->rightHash); + pPrev->leftHash = NULL; + pPrev->rightHash = NULL; + } + } + } else { + code = pInfo->stbJoin.basic.srcScan[0] ? buildSingleTableScanOperatorParam(&pSrcParam0, 0, leftVg, leftUid) : buildExchangeOperatorParam(&pSrcParam0, 0, leftVg, leftUid); + if (TSDB_CODE_SUCCESS == code) { + code = pInfo->stbJoin.basic.srcScan[1] ? buildSingleTableScanOperatorParam(&pSrcParam1, 1, rightVg, rightUid) : buildExchangeOperatorParam(&pSrcParam1, 1, rightVg, rightUid); + } + } + + if (TSDB_CODE_SUCCESS == code) { + code = buildGroupCacheOperatorParam(&pGcParam0, 0, *leftVg, *leftUid, pPost->leftNeedCache, pSrcParam0); + } + if (TSDB_CODE_SUCCESS == code) { + code = buildGroupCacheOperatorParam(&pGcParam1, 1, *rightVg, *rightUid, pPost->rightNeedCache, pSrcParam1); + } + if (TSDB_CODE_SUCCESS == code) { + code = buildMergeJoinOperatorParam(ppParam, pSrcParam0 ? true : false, pGcParam0, pGcParam1); + } + return code; +} + + +static void seqJoinLaunchNewRetrieveImpl(SOperatorInfo* pOperator, SSDataBlock** ppRes) { + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; + SStbJoinPrevJoinCtx* pPrev = &pStbJoin->ctx.prev; + SStbJoinPostJoinCtx* pPost = &pStbJoin->ctx.post; + SOperatorParam* pParam = NULL; + int32_t code = buildSeqStbJoinOperatorParam(pInfo, pPrev, pPost, &pParam); + if (TSDB_CODE_SUCCESS != code) { + pOperator->pTaskInfo->code = code; + T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); + } + + qError("dynamic post task begin"); + *ppRes = pOperator->pDownstream[1]->fpSet.getNextExtFn(pOperator->pDownstream[1], pParam); + if (*ppRes) { + pPost->isStarted = true; + pStbJoin->execInfo.postBlkNum++; + pStbJoin->execInfo.postBlkRows += (*ppRes)->info.rows; + qError("join res block retrieved"); + } else { + qError("Empty join res block retrieved"); + } +} + + +static int32_t notifySeqJoinTableCacheEnd(SOperatorInfo* pOperator, SStbJoinPostJoinCtx* pPost, bool leftTable) { + SOperatorParam* pGcParam = NULL; + SOperatorParam* pMergeJoinParam = NULL; + int32_t downstreamId = leftTable ? 0 : 1; + int32_t vgId = leftTable ? pPost->leftVgId : pPost->rightVgId; + int64_t uid = leftTable ? pPost->leftCurrUid : pPost->rightCurrUid; + + qError("notify table %" PRIu64 " in vgId %d downstreamId %d cache end", uid, vgId, downstreamId); + + int32_t code = buildGroupCacheNotifyOperatorParam(&pGcParam, downstreamId, vgId, uid); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = buildMergeJoinNotifyOperatorParam(&pMergeJoinParam, pGcParam, NULL); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + + return optrDefaultNotifyFn(pOperator->pDownstream[1], pMergeJoinParam); +} + +static void handleSeqJoinCurrRetrieveEnd(SOperatorInfo* pOperator, SStbJoinDynCtrlInfo* pStbJoin) { + SStbJoinPostJoinCtx* pPost = &pStbJoin->ctx.post; + + pPost->isStarted = false; + + if (pStbJoin->basic.batchFetch) { + return; + } + + if (pPost->leftNeedCache) { + uint32_t* num = tSimpleHashGet(pStbJoin->ctx.prev.leftCache, &pPost->leftCurrUid, sizeof(pPost->leftCurrUid)); + if (--(*num) <= 0) { + tSimpleHashRemove(pStbJoin->ctx.prev.leftCache, &pPost->leftCurrUid, sizeof(pPost->leftCurrUid)); + notifySeqJoinTableCacheEnd(pOperator, pPost, true); + } + } + + if (!pPost->rightNeedCache) { + void* v = tSimpleHashGet(pStbJoin->ctx.prev.rightCache, &pPost->rightCurrUid, sizeof(pPost->rightCurrUid)); + if (NULL != v) { + tSimpleHashRemove(pStbJoin->ctx.prev.rightCache, &pPost->rightCurrUid, sizeof(pPost->rightCurrUid)); + notifySeqJoinTableCacheEnd(pOperator, pPost, false); + } + } +} + + +static FORCE_INLINE void seqJoinContinueCurrRetrieve(SOperatorInfo* pOperator, SSDataBlock** ppRes) { + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinPostJoinCtx* pPost = &pInfo->stbJoin.ctx.post; + SStbJoinPrevJoinCtx* pPrev = &pInfo->stbJoin.ctx.prev; + + if (!pPost->isStarted) { + return; + } + + qDebug("%s dynQueryCtrl continue to retrieve block from post op", GET_TASKID(pOperator->pTaskInfo)); + + *ppRes = getNextBlockFromDownstream(pOperator, 1); + if (NULL == *ppRes) { + handleSeqJoinCurrRetrieveEnd(pOperator, &pInfo->stbJoin); + pPrev->pListHead->readIdx++; + } else { + pInfo->stbJoin.execInfo.postBlkNum++; + pInfo->stbJoin.execInfo.postBlkRows += (*ppRes)->info.rows; + return; + } +} + +static FORCE_INLINE int32_t addToJoinVgroupHash(SSHashObj* pHash, void* pKey, int32_t keySize, void* pVal, int32_t valSize) { + SArray** ppArray = tSimpleHashGet(pHash, pKey, keySize); + if (NULL == ppArray) { + SArray* pArray = taosArrayInit(10, valSize); + if (NULL == pArray) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (NULL == taosArrayPush(pArray, pVal)) { + taosArrayDestroy(pArray); + return TSDB_CODE_OUT_OF_MEMORY; + } + if (tSimpleHashPut(pHash, pKey, keySize, &pArray, POINTER_BYTES)) { + taosArrayDestroy(pArray); + return TSDB_CODE_OUT_OF_MEMORY; + } + return TSDB_CODE_SUCCESS; + } + + if (NULL == taosArrayPush(*ppArray, pVal)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE int32_t addToJoinTableHash(SSHashObj* pHash, SSHashObj* pOnceHash, void* pKey, int32_t keySize) { + uint32_t* pNum = tSimpleHashGet(pHash, pKey, keySize); + if (NULL == pNum) { + uint32_t n = 1; + if (tSimpleHashPut(pHash, pKey, keySize, &n, sizeof(n))) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (tSimpleHashPut(pOnceHash, pKey, keySize, NULL, 0)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + return TSDB_CODE_SUCCESS; + } + + switch (*pNum) { + case 0: + break; + case UINT32_MAX: + *pNum = 0; + break; + default: + if (1 == (*pNum)) { + tSimpleHashRemove(pOnceHash, pKey, keySize); + } + (*pNum)++; + break; + } + + return TSDB_CODE_SUCCESS; +} + + +static void freeStbJoinTableList(SStbJoinTableList* pList) { + if (NULL == pList) { + return; + } + taosMemoryFree(pList->pLeftVg); + taosMemoryFree(pList->pLeftUid); + taosMemoryFree(pList->pRightVg); + taosMemoryFree(pList->pRightUid); + taosMemoryFree(pList); +} + +static int32_t appendStbJoinTableList(SStbJoinPrevJoinCtx* pCtx, int64_t rows, int32_t* pLeftVg, int64_t* pLeftUid, int32_t* pRightVg, int64_t* pRightUid) { + SStbJoinTableList* pNew = taosMemoryMalloc(sizeof(SStbJoinTableList)); + if (NULL == pNew) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pNew->pLeftVg = taosMemoryMalloc(rows * sizeof(*pLeftVg)); + pNew->pLeftUid = taosMemoryMalloc(rows * sizeof(*pLeftUid)); + pNew->pRightVg = taosMemoryMalloc(rows * sizeof(*pRightVg)); + pNew->pRightUid = taosMemoryMalloc(rows * sizeof(*pRightUid)); + if (NULL == pNew->pLeftVg || NULL == pNew->pLeftUid || NULL == pNew->pRightVg || NULL == pNew->pRightUid) { + freeStbJoinTableList(pNew); + return TSDB_CODE_OUT_OF_MEMORY; + } + + memcpy(pNew->pLeftVg, pLeftVg, rows * sizeof(*pLeftVg)); + memcpy(pNew->pLeftUid, pLeftUid, rows * sizeof(*pLeftUid)); + memcpy(pNew->pRightVg, pRightVg, rows * sizeof(*pRightVg)); + memcpy(pNew->pRightUid, pRightUid, rows * sizeof(*pRightUid)); + + pNew->readIdx = 0; + pNew->uidNum = rows; + pNew->pNext = NULL; + + if (pCtx->pListTail) { + pCtx->pListTail->pNext = pNew; + pCtx->pListTail = pNew; + } else { + pCtx->pListHead = pNew; + pCtx->pListTail= pNew; + } + + return TSDB_CODE_SUCCESS; +} + +static void doBuildStbJoinTableHash(SOperatorInfo* pOperator, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; + SColumnInfoData* pVg0 = taosArrayGet(pBlock->pDataBlock, pStbJoin->basic.vgSlot[0]); + SColumnInfoData* pVg1 = taosArrayGet(pBlock->pDataBlock, pStbJoin->basic.vgSlot[1]); + SColumnInfoData* pUid0 = taosArrayGet(pBlock->pDataBlock, pStbJoin->basic.uidSlot[0]); + SColumnInfoData* pUid1 = taosArrayGet(pBlock->pDataBlock, pStbJoin->basic.uidSlot[1]); + + if (pStbJoin->basic.batchFetch) { + for (int32_t i = 0; i < pBlock->info.rows; ++i) { + int32_t* leftVg = (int32_t*)(pVg0->pData + pVg0->info.bytes * i); + int64_t* leftUid = (int64_t*)(pUid0->pData + pUid0->info.bytes * i); + int32_t* rightVg = (int32_t*)(pVg1->pData + pVg1->info.bytes * i); + int64_t* rightUid = (int64_t*)(pUid1->pData + pUid1->info.bytes * i); + + code = addToJoinVgroupHash(pStbJoin->ctx.prev.leftHash, leftVg, sizeof(*leftVg), leftUid, sizeof(*leftUid)); + if (TSDB_CODE_SUCCESS != code) { + break; + } + code = addToJoinVgroupHash(pStbJoin->ctx.prev.rightHash, rightVg, sizeof(*rightVg), rightUid, sizeof(*rightUid)); + if (TSDB_CODE_SUCCESS != code) { + break; + } + } + } else { + for (int32_t i = 0; i < pBlock->info.rows; ++i) { + int64_t* leftUid = (int64_t*)(pUid0->pData + pUid0->info.bytes * i); + + code = addToJoinTableHash(pStbJoin->ctx.prev.leftCache, pStbJoin->ctx.prev.onceTable, leftUid, sizeof(*leftUid)); + if (TSDB_CODE_SUCCESS != code) { + break; + } + } + } + + if (TSDB_CODE_SUCCESS == code) { + code = appendStbJoinTableList(&pStbJoin->ctx.prev, pBlock->info.rows, (int32_t*)pVg0->pData, (int64_t*)pUid0->pData, (int32_t*)pVg1->pData, (int64_t*)pUid1->pData); + if (TSDB_CODE_SUCCESS == code) { + pStbJoin->ctx.prev.tableNum += pBlock->info.rows; + } + } + + if (TSDB_CODE_SUCCESS != code) { + pOperator->pTaskInfo->code = code; + T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); + } +} + + +static void postProcessStbJoinTableHash(SOperatorInfo* pOperator) { + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; + + if (pStbJoin->basic.batchFetch) { + return; + } + + if (tSimpleHashGetSize(pStbJoin->ctx.prev.leftCache) == tSimpleHashGetSize(pStbJoin->ctx.prev.onceTable)) { + tSimpleHashClear(pStbJoin->ctx.prev.leftCache); + return; + } + + uint64_t* pUid = NULL; + int32_t iter = 0; + while (NULL != (pUid = tSimpleHashIterate(pStbJoin->ctx.prev.onceTable, pUid, &iter))) { + tSimpleHashRemove(pStbJoin->ctx.prev.leftCache, pUid, sizeof(*pUid)); + } + + pStbJoin->execInfo.leftCacheNum = tSimpleHashGetSize(pStbJoin->ctx.prev.leftCache); + qError("more than 1 ref build table num %" PRId64, (int64_t)tSimpleHashGetSize(pStbJoin->ctx.prev.leftCache)); + + // debug only + iter = 0; + uint32_t* num = NULL; + while (NULL != (num = tSimpleHashIterate(pStbJoin->ctx.prev.leftCache, num, &iter))) { + ASSERT(*num > 1); + } +} + +static void buildStbJoinTableList(SOperatorInfo* pOperator) { + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; + + while (true) { + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); + if (NULL == pBlock) { + break; + } + + pStbJoin->execInfo.prevBlkNum++; + pStbJoin->execInfo.prevBlkRows += pBlock->info.rows; + + doBuildStbJoinTableHash(pOperator, pBlock); + } + + postProcessStbJoinTableHash(pOperator); + + pStbJoin->ctx.prev.joinBuild = true; +} + +static void seqJoinLaunchNewRetrieve(SOperatorInfo* pOperator, SSDataBlock** ppRes) { + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; + SStbJoinPrevJoinCtx* pPrev = &pStbJoin->ctx.prev; + SStbJoinTableList* pNode = pPrev->pListHead; + + while (pNode) { + if (pNode->readIdx >= pNode->uidNum) { + pPrev->pListHead = pNode->pNext; + freeStbJoinTableList(pNode); + pNode = pPrev->pListHead; + continue; + } + + seqJoinLaunchNewRetrieveImpl(pOperator, ppRes); + if (*ppRes) { + return; + } + + handleSeqJoinCurrRetrieveEnd(pOperator, pStbJoin); + pPrev->pListHead->readIdx++; + } + + *ppRes = NULL; + setOperatorCompleted(pOperator); + + return; +} + +static FORCE_INLINE SSDataBlock* seqStableJoinComposeRes(SStbJoinDynCtrlInfo* pStbJoin, SSDataBlock* pBlock) { + pBlock->info.id.blockId = pStbJoin->outputBlkId; + return pBlock; +} + + +SSDataBlock* seqStableJoin(SOperatorInfo* pOperator) { + SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; + SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; + SSDataBlock* pRes = NULL; + + if (pOperator->status == OP_EXEC_DONE) { + return pRes; + } + + int64_t st = 0; + if (pOperator->cost.openCost == 0) { + st = taosGetTimestampUs(); + } + + if (!pStbJoin->ctx.prev.joinBuild) { + buildStbJoinTableList(pOperator); + if (pStbJoin->execInfo.prevBlkRows <= 0) { + setOperatorCompleted(pOperator); + goto _return; + } + } + + seqJoinContinueCurrRetrieve(pOperator, &pRes); + if (pRes) { + goto _return; + } + + seqJoinLaunchNewRetrieve(pOperator, &pRes); + +_return: + + if (pOperator->cost.openCost == 0) { + pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; + } + + return pRes ? seqStableJoinComposeRes(pStbJoin, pRes) : NULL; +} + +int32_t initSeqStbJoinTableHash(SStbJoinPrevJoinCtx* pPrev, bool batchFetch) { + if (batchFetch) { + pPrev->leftHash = tSimpleHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); + if (NULL == pPrev->leftHash) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pPrev->rightHash = tSimpleHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); + if (NULL == pPrev->rightHash) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } else { + pPrev->leftCache = tSimpleHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT)); + if (NULL == pPrev->leftCache) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pPrev->rightCache = tSimpleHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT)); + if (NULL == pPrev->rightCache) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pPrev->onceTable = tSimpleHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT)); + if (NULL == pPrev->onceTable) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + return TSDB_CODE_SUCCESS; +} + + +SOperatorInfo* createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo) { + SDynQueryCtrlOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SDynQueryCtrlOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + __optr_fn_t nextFp = NULL; + + int32_t code = TSDB_CODE_SUCCESS; + if (pOperator == NULL || pInfo == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + + pTaskInfo->dynamicTask = pPhyciNode->node.dynamicOp; + + code = appendDownstream(pOperator, pDownstream, numOfDownstream); + if (TSDB_CODE_SUCCESS != code) { + goto _error; + } + + pInfo->qType = pPhyciNode->qType; + switch (pInfo->qType) { + case DYN_QTYPE_STB_HASH: + memcpy(&pInfo->stbJoin.basic, &pPhyciNode->stbJoin, sizeof(pPhyciNode->stbJoin)); + pInfo->stbJoin.outputBlkId = pPhyciNode->node.pOutputDataBlockDesc->dataBlockId; + code = initSeqStbJoinTableHash(&pInfo->stbJoin.ctx.prev, pInfo->stbJoin.basic.batchFetch); + if (TSDB_CODE_SUCCESS != code) { + goto _error; + } + nextFp = seqStableJoin; + break; + default: + qError("unsupported dynamic query ctrl type: %d", pInfo->qType); + code = TSDB_CODE_INVALID_PARA; + goto _error; + } + + setOperatorInfo(pOperator, "DynQueryCtrlOperator", QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL, false, OP_NOT_OPENED, pInfo, pTaskInfo); + + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, nextFp, NULL, destroyDynQueryCtrlOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + + return pOperator; + +_error: + if (pInfo != NULL) { + destroyDynQueryCtrlOperator(pInfo); + } + + taosMemoryFree(pOperator); + pTaskInfo->code = code; + return NULL; +} + + diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index 5c335c116f..d61034c26e 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -123,7 +123,7 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo setOperatorInfo(pOperator, "EventWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, true, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, eventWindowAggregate, NULL, destroyEWindowOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -183,7 +183,7 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { break; } diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index 4fbe6785a3..ef8bf9674a 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -40,6 +40,9 @@ typedef struct SSourceDataInfo { int32_t code; EX_SOURCE_STATUS status; const char* taskId; + SArray* pSrcUidList; + int32_t srcOpType; + bool tableSeq; } SSourceDataInfo; static void destroyExchangeOperatorInfo(void* param); @@ -67,6 +70,8 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn return; } + SSourceDataInfo* pDataInfo = NULL; + while (1) { qDebug("prepare wait for ready, %p, %s", pExchangeInfo, GET_TASKID(pTaskInfo)); tsem_wait(&pExchangeInfo->ready); @@ -76,7 +81,7 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn } for (int32_t i = 0; i < totalSources; ++i) { - SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, i); + pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, i); if (pDataInfo->status == EX_SOURCE_DATA_EXHAUSTED) { continue; } @@ -91,17 +96,26 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn } SRetrieveTableRsp* pRsp = pDataInfo->pRsp; - SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, i); + SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, pDataInfo->index); // todo SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo; if (pRsp->numOfRows == 0) { - pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED; - qDebug("%s vgId:%d, taskId:0x%" PRIx64 " execId:%d index:%d completed, rowsOfSource:%" PRIu64 - ", totalRows:%" PRIu64 ", try next %d/%" PRIzu, - GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pDataInfo->totalRows, - pExchangeInfo->loadInfo.totalRows, i + 1, totalSources); - taosMemoryFreeClear(pDataInfo->pRsp); + if (NULL != pDataInfo->pSrcUidList) { + pDataInfo->status = EX_SOURCE_DATA_NOT_READY; + code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, i); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFreeClear(pDataInfo->pRsp); + goto _error; + } + } else { + pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED; + qDebug("%s vgId:%d, taskId:0x%" PRIx64 " execId:%d index:%d completed, rowsOfSource:%" PRIu64 + ", totalRows:%" PRIu64 ", try next %d/%" PRIzu, + GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pDataInfo->totalRows, + pExchangeInfo->loadInfo.totalRows, i + 1, totalSources); + taosMemoryFreeClear(pDataInfo->pRsp); + } break; } @@ -131,7 +145,7 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn taosMemoryFreeClear(pDataInfo->pRsp); - if (pDataInfo->status != EX_SOURCE_DATA_EXHAUSTED) { + if (pDataInfo->status != EX_SOURCE_DATA_EXHAUSTED || NULL != pDataInfo->pSrcUidList) { pDataInfo->status = EX_SOURCE_DATA_NOT_READY; code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, i); if (code != TSDB_CODE_SUCCESS) { @@ -157,11 +171,6 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - pTaskInfo->code = pOperator->fpSet._openFn(pOperator); - if (pTaskInfo->code != TSDB_CODE_SUCCESS) { - return NULL; - } - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo; @@ -204,6 +213,11 @@ static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) { SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + pTaskInfo->code = pOperator->fpSet._openFn(pOperator); + if (pTaskInfo->code != TSDB_CODE_SUCCESS) { + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } + if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -244,6 +258,10 @@ static int32_t initDataSource(int32_t numOfSources, SExchangeInfo* pInfo, const return TSDB_CODE_OUT_OF_MEMORY; } + if (pInfo->dynamicOp) { + return TSDB_CODE_SUCCESS; + } + for (int32_t i = 0; i < numOfSources; ++i) { SSourceDataInfo dataInfo = {0}; dataInfo.status = EX_SOURCE_DATA_NOT_READY; @@ -272,9 +290,18 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* return TSDB_CODE_OUT_OF_MEMORY; } + if (pExNode->node.dynamicOp) { + pInfo->pHashSources = tSimpleHashInit(numOfSources * 2, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); + if (NULL == pInfo->pHashSources) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + for (int32_t i = 0; i < numOfSources; ++i) { SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)nodesListGetNode((SNodeList*)pExNode->pSrcEndPoints, i); taosArrayPush(pInfo->pSources, pNode); + SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1}; + tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx)); } initLimitInfo(pExNode->node.pLimit, pExNode->node.pSlimit, &pInfo->limitInfo); @@ -290,6 +317,7 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode goto _error; } + pInfo->dynamicOp = pExNode->node.dynamicOp; int32_t code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo)); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -316,7 +344,7 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode } pOperator->fpSet = - createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _error: @@ -354,7 +382,8 @@ void doDestroyExchangeOperatorInfo(void* param) { taosArrayDestroyEx(pExInfo->pRecycledBlocks, freeBlock); blockDataDestroy(pExInfo->pDummyBlock); - + tSimpleHashCleanup(pExInfo->pHashSources); + tsem_destroy(&pExInfo->ready); taosMemoryFreeClear(param); } @@ -402,14 +431,45 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) { return code; } +int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, int32_t srcOpType, bool tableSeq) { + *ppRes = taosMemoryMalloc(sizeof(SOperatorParam)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + STableScanOperatorParam* pScan = taosMemoryMalloc(sizeof(STableScanOperatorParam)); + if (NULL == pScan) { + taosMemoryFreeClear(*ppRes); + return TSDB_CODE_OUT_OF_MEMORY; + } + + pScan->pUidList = taosArrayDup(pUidList, NULL); + if (NULL == pScan->pUidList) { + taosMemoryFree(pScan); + taosMemoryFreeClear(*ppRes); + return TSDB_CODE_OUT_OF_MEMORY; + } + pScan->tableSeq = tableSeq; + + (*ppRes)->opType = srcOpType; + (*ppRes)->downstreamIdx = 0; + (*ppRes)->value = pScan; + (*ppRes)->pChildren = NULL; + + return TSDB_CODE_SUCCESS; +} + + int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) { - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); - - SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, sourceIndex); SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex); - pDataInfo->startTime = taosGetTimestampUs(); + if (EX_SOURCE_DATA_NOT_READY != pDataInfo->status) { + return TSDB_CODE_SUCCESS; + } - ASSERT(pDataInfo->status == EX_SOURCE_DATA_NOT_READY); + pDataInfo->status = EX_SOURCE_DATA_STARTED; + SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, pDataInfo->index); + pDataInfo->startTime = taosGetTimestampUs(); + size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); SFetchRspHandleWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SFetchRspHandleWrapper)); pWrapper->exchangeId = pExchangeInfo->self; @@ -429,11 +489,22 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas req.taskId = pSource->taskId; req.queryId = pTaskInfo->id.queryId; req.execId = pSource->execId; - + if (pDataInfo->pSrcUidList) { + int32_t code = buildTableScanOperatorParam(&req.pOpParam, pDataInfo->pSrcUidList, pDataInfo->srcOpType, pDataInfo->tableSeq); + taosArrayDestroy(pDataInfo->pSrcUidList); + pDataInfo->pSrcUidList = NULL; + if (TSDB_CODE_SUCCESS != code) { + pTaskInfo->code = code; + taosMemoryFree(pWrapper); + return pTaskInfo->code; + } + } + int32_t msgSize = tSerializeSResFetchReq(NULL, 0, &req); if (msgSize < 0) { pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(pWrapper); + freeOperatorParam(req.pOpParam, OP_GET_PARAM); return pTaskInfo->code; } @@ -441,6 +512,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas if (NULL == msg) { pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(pWrapper); + freeOperatorParam(req.pOpParam, OP_GET_PARAM); return pTaskInfo->code; } @@ -448,9 +520,12 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(pWrapper); taosMemoryFree(msg); + freeOperatorParam(req.pOpParam, OP_GET_PARAM); return pTaskInfo->code; } + freeOperatorParam(req.pOpParam, OP_GET_PARAM); + qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu, GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId, pSource->execId, pExchangeInfo, sourceIndex, totalSources); @@ -560,7 +635,7 @@ int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) { SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); + size_t totalSources = taosArrayGetSize(pExchangeInfo->pSourceDataInfo); int64_t startTs = taosGetTimestampUs(); // Asynchronously send all fetch requests to all sources. @@ -693,14 +768,81 @@ _error: return code; } +int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasicParam* pBasicParam) { + SExchangeInfo* pExchangeInfo = pOperator->info; + SExchangeSrcIndex* pIdx = tSimpleHashGet(pExchangeInfo->pHashSources, &pBasicParam->vgId, sizeof(pBasicParam->vgId)); + if (NULL == pIdx) { + qError("No exchange source for vgId: %d", pBasicParam->vgId); + return TSDB_CODE_INVALID_PARA; + } + + if (pIdx->inUseIdx < 0) { + SSourceDataInfo dataInfo = {0}; + dataInfo.status = EX_SOURCE_DATA_NOT_READY; + dataInfo.taskId = GET_TASKID(pOperator->pTaskInfo); + dataInfo.index = pIdx->srcIdx; + dataInfo.pSrcUidList = taosArrayDup(pBasicParam->uidList, NULL); + dataInfo.srcOpType = pBasicParam->srcOpType; + dataInfo.tableSeq = pBasicParam->tableSeq; + + taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo); + pIdx->inUseIdx = taosArrayGetSize(pExchangeInfo->pSourceDataInfo) - 1; + } else { + SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pIdx->inUseIdx); + if (pDataInfo->status == EX_SOURCE_DATA_EXHAUSTED) { + pDataInfo->status = EX_SOURCE_DATA_NOT_READY; + } + pDataInfo->pSrcUidList = taosArrayDup(pBasicParam->uidList, NULL); + pDataInfo->srcOpType = pBasicParam->srcOpType; + pDataInfo->tableSeq = pBasicParam->tableSeq; + } + + return TSDB_CODE_SUCCESS; +} + + +int32_t addDynamicExchangeSource(SOperatorInfo* pOperator) { + SExchangeInfo* pExchangeInfo = pOperator->info; + int32_t code = TSDB_CODE_SUCCESS; + SExchangeOperatorBasicParam* pBasicParam = NULL; + SExchangeOperatorParam* pParam = (SExchangeOperatorParam*)pOperator->pOperatorGetParam->value; + if (pParam->multiParams) { + SExchangeOperatorBatchParam* pBatch = (SExchangeOperatorBatchParam*)pOperator->pOperatorGetParam->value; + int32_t iter = 0; + while (NULL != (pBasicParam = tSimpleHashIterate(pBatch->pBatchs, pBasicParam, &iter))) { + code = addSingleExchangeSource(pOperator, pBasicParam); + if (code) { + return code; + } + } + } else { + pBasicParam = &pParam->basic; + code = addSingleExchangeSource(pOperator, pBasicParam); + } + + freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM); + pOperator->pOperatorGetParam = NULL; + + return TSDB_CODE_SUCCESS; +} + + int32_t prepareLoadRemoteData(SOperatorInfo* pOperator) { - if (OPTR_IS_OPENED(pOperator)) { + SExchangeInfo* pExchangeInfo = pOperator->info; + int32_t code = TSDB_CODE_SUCCESS; + if ((OPTR_IS_OPENED(pOperator) && !pExchangeInfo->dynamicOp) || (pExchangeInfo->dynamicOp && NULL == pOperator->pOperatorGetParam)) { return TSDB_CODE_SUCCESS; } + if (pExchangeInfo->dynamicOp) { + code = addDynamicExchangeSource(pOperator); + if (code) { + return code; + } + } + int64_t st = taosGetTimestampUs(); - SExchangeInfo* pExchangeInfo = pOperator->info; if (!pExchangeInfo->seqLoadData) { int32_t code = prepareConcurrentlyLoad(pOperator); if (code != TSDB_CODE_SUCCESS) { diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index c4f03c5779..52631cd0db 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -926,18 +926,29 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S return pResBlock; } -static void doSetQualifiedUid(SArray* pUidList, const SArray* pUidTagList, bool* pResultList) { +static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, const SArray* pUidTagList, bool* pResultList, bool addUid) { taosArrayClear(pUidList); + STableKeyInfo info = {.uid = 0, .groupId = 0}; int32_t numOfTables = taosArrayGetSize(pUidTagList); for (int32_t i = 0; i < numOfTables; ++i) { - uint64_t uid = ((STUidTagInfo*)taosArrayGet(pUidTagList, i))->uid; - qDebug("tagfilter get uid:%" PRId64 ", res:%d", uid, pResultList[i]); - if (pResultList[i]) { - taosArrayPush(pUidList, &uid); + uint64_t uid = ((STUidTagInfo*)taosArrayGet(pUidTagList, i))->uid; + qDebug("tagfilter get uid:%" PRId64 ", res:%d", uid, pResultList[i]); + + info.uid = uid; + void* p = taosArrayPush(pListInfo->pTableList, &info); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (addUid) { + taosArrayPush(pUidList, &uid); + } } } + + return TSDB_CODE_SUCCESS; } static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) { @@ -954,7 +965,8 @@ static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) { } static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SNode* pTagCond, void* pVnode, - SIdxFltStatus status, SStorageAPI* pAPI) { + SIdxFltStatus status, SStorageAPI* pAPI, bool addUid, bool* listAdded) { + *listAdded = false; if (pTagCond == NULL) { return TSDB_CODE_SUCCESS; } @@ -1043,7 +1055,12 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN goto end; } - doSetQualifiedUid(pUidList, pUidTagList, (bool*)output.columnData->pData); + code = doSetQualifiedUid(pListInfo, pUidList, pUidTagList, (bool*)output.columnData->pData, addUid); + if (code != TSDB_CODE_SUCCESS) { + terrno = code; + goto end; + } + *listAdded = true; end: taosHashCleanup(ctx.colHash); @@ -1061,6 +1078,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI) { int32_t code = TSDB_CODE_SUCCESS; size_t numOfTables = 0; + bool listAdded = false; pListInfo->idInfo.suid = pScanNode->suid; pListInfo->idInfo.tableType = pScanNode->tableType; @@ -1073,7 +1091,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S if (pStorageAPI->metaFn.isTableExisted(pVnode, pScanNode->uid)) { taosArrayPush(pUidList, &pScanNode->uid); } - code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI); + code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded); if (code != TSDB_CODE_SUCCESS) { goto _end; } @@ -1117,7 +1135,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S } } - code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI); + code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, tsTagFilterCache, &listAdded); if (code != TSDB_CODE_SUCCESS) { goto _end; } @@ -1141,17 +1159,19 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S } _end: - numOfTables = taosArrayGetSize(pUidList); - for (int i = 0; i < numOfTables; i++) { - STableKeyInfo info = {.uid = *(uint64_t*)taosArrayGet(pUidList, i), .groupId = 0}; + if (!listAdded) { + numOfTables = taosArrayGetSize(pUidList); + for (int i = 0; i < numOfTables; i++) { + STableKeyInfo info = {.uid = *(uint64_t*)taosArrayGet(pUidList, i), .groupId = 0}; - void* p = taosArrayPush(pListInfo->pTableList, &info); - if (p == NULL) { - taosArrayDestroy(pUidList); - return TSDB_CODE_OUT_OF_MEMORY; + void* p = taosArrayPush(pListInfo->pTableList, &info); + if (p == NULL) { + taosArrayDestroy(pUidList); + return TSDB_CODE_OUT_OF_MEMORY; + } + + qTrace("tagfilter get uid:%" PRIu64 ", %s", info.uid, idstr); } - - qTrace("tagfilter get uid:%" PRIu64 ", %s", info.uid, idstr); } taosArrayDestroy(pUidList); @@ -1254,7 +1274,7 @@ int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, return TSDB_CODE_SUCCESS; } -SArray* extractPartitionColInfo(SNodeList* pNodeList) { +SArray* makeColumnArrayFromList(SNodeList* pNodeList) { if (!pNodeList) { return NULL; } diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 83f82080b4..4d8b69a1d8 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -471,28 +471,48 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI } int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion, - int32_t* tversion) { + int32_t* tversion, int32_t idx) { ASSERT(tinfo != NULL && dbName != NULL && tableName != NULL); SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; - if (pTaskInfo->schemaInfo.sw == NULL) { - return TSDB_CODE_SUCCESS; + if (taosArrayGetSize(pTaskInfo->schemaInfos) <= idx) { + return -1; } - *sversion = pTaskInfo->schemaInfo.sw->version; - *tversion = pTaskInfo->schemaInfo.tversion; - if (pTaskInfo->schemaInfo.dbname) { - strcpy(dbName, pTaskInfo->schemaInfo.dbname); + SSchemaInfo* pSchemaInfo = taosArrayGet(pTaskInfo->schemaInfos, idx); + + *sversion = pSchemaInfo->sw->version; + *tversion = pSchemaInfo->tversion; + if (pSchemaInfo->dbname) { + strcpy(dbName, pSchemaInfo->dbname); } else { dbName[0] = 0; } - if (pTaskInfo->schemaInfo.tablename) { - strcpy(tableName, pTaskInfo->schemaInfo.tablename); + if (pSchemaInfo->tablename) { + strcpy(tableName, pSchemaInfo->tablename); } else { tableName[0] = 0; } - return 0; + return TSDB_CODE_SUCCESS; +} + +bool qIsDynamicExecTask(qTaskInfo_t tinfo) { + return ((SExecTaskInfo*)tinfo)->dynamicTask; +} + +void destroyOperatorParam(SOperatorParam* pParam) { + if (NULL == pParam) { + return; + } + + //TODO +} + +void qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam) { + destroyOperatorParam(((SExecTaskInfo*)tinfo)->pOpParam); + ((SExecTaskInfo*)tinfo)->pOpParam = pParam; + ((SExecTaskInfo*)tinfo)->paramSet = false; } int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, SSubplan* pSubplan, @@ -503,7 +523,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, qDebug("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId); int32_t code = createExecTaskInfo(pSubplan, pTask, readHandle, taskId, vgId, sql, model); - if (code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_SUCCESS || NULL == *pTask) { qError("failed to createExecTaskInfo, code: %s", tstrerror(code)); goto _error; } @@ -585,12 +605,19 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo int64_t st = taosGetTimestampUs(); - int32_t blockIndex = 0; + if (pTaskInfo->pOpParam && !pTaskInfo->paramSet) { + pTaskInfo->paramSet = true; + pRes = pTaskInfo->pRoot->fpSet.getNextExtFn(pTaskInfo->pRoot, pTaskInfo->pOpParam); + } else { + pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot); + } + int32_t rowsThreshold = pTaskInfo->pSubplan->rowsThreshold; if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) { rowsThreshold = 4096; } - while ((pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot)) != NULL) { + int32_t blockIndex = 0; + while (pRes != NULL) { SSDataBlock* p = NULL; if (blockIndex >= taosArrayGetSize(pTaskInfo->pResultBlockList)) { SSDataBlock* p1 = createOneDataBlock(pRes, true); @@ -610,6 +637,8 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo if (current >= rowsThreshold) { break; } + + pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot); } if (pTaskInfo->pSubplan->dynamicRowThreshold) { pTaskInfo->pSubplan->rowsThreshold -= current; diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index 88d11df166..3a60a7bf83 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -1076,6 +1076,142 @@ void streamOpReloadState(SOperatorInfo* pOperator) { } } +void freeOperatorParamImpl(SOperatorParam* pParam, SOperatorParamType type) { + int32_t childrenNum = taosArrayGetSize(pParam->pChildren); + for (int32_t i = 0; i < childrenNum; ++i) { + SOperatorParam* pChild = taosArrayGetP(pParam->pChildren, i); + freeOperatorParam(pChild, type); + } + + taosArrayDestroy(pParam->pChildren); + + taosMemoryFree(pParam->value); + + taosMemoryFree(pParam); +} + +void freeExchangeGetBasicOperatorParam(void* pParam) { + SExchangeOperatorBasicParam* pBasic = (SExchangeOperatorBasicParam*)pParam; + taosArrayDestroy(pBasic->uidList); +} + +void freeExchangeGetOperatorParam(SOperatorParam* pParam) { + SExchangeOperatorParam* pExcParam = (SExchangeOperatorParam*)pParam->value; + if (pExcParam->multiParams) { + SExchangeOperatorBatchParam* pExcBatch = (SExchangeOperatorBatchParam*)pParam->value; + tSimpleHashCleanup(pExcBatch->pBatchs); + } else { + freeExchangeGetBasicOperatorParam(&pExcParam->basic); + } + + freeOperatorParamImpl(pParam, OP_GET_PARAM); +} + +void freeExchangeNotifyOperatorParam(SOperatorParam* pParam) { + freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); +} + +void freeGroupCacheGetOperatorParam(SOperatorParam* pParam) { + freeOperatorParamImpl(pParam, OP_GET_PARAM); +} + +void freeGroupCacheNotifyOperatorParam(SOperatorParam* pParam) { + freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); +} + +void freeMergeJoinGetOperatorParam(SOperatorParam* pParam) { + freeOperatorParamImpl(pParam, OP_GET_PARAM); +} + +void freeMergeJoinNotifyOperatorParam(SOperatorParam* pParam) { + freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); +} + +void freeTableScanGetOperatorParam(SOperatorParam* pParam) { + STableScanOperatorParam* pTableScanParam = (STableScanOperatorParam*)pParam->value; + taosArrayDestroy(pTableScanParam->pUidList); + freeOperatorParamImpl(pParam, OP_GET_PARAM); +} + +void freeTableScanNotifyOperatorParam(SOperatorParam* pParam) { + freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); +} + + +void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type) { + if (NULL == pParam) { + return; + } + + switch (pParam->opType) { + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: + type == OP_GET_PARAM ? freeExchangeGetOperatorParam(pParam) : freeExchangeNotifyOperatorParam(pParam); + break; + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + type == OP_GET_PARAM ? freeGroupCacheGetOperatorParam(pParam) : freeGroupCacheNotifyOperatorParam(pParam); + break; + case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: + type == OP_GET_PARAM ? freeMergeJoinGetOperatorParam(pParam) : freeMergeJoinNotifyOperatorParam(pParam); + break; + case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: + type == OP_GET_PARAM ? freeTableScanGetOperatorParam(pParam) : freeTableScanNotifyOperatorParam(pParam); + break; + default: + qError("unsupported op %d param, type %d", pParam->opType, type); + break; + } +} + +void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree) { + SOperatorParam** ppParam = NULL; + SOperatorParam*** pppDownstramParam = NULL; + switch (type) { + case OP_GET_PARAM: + ppParam = &pOperator->pOperatorGetParam; + pppDownstramParam = &pOperator->pDownstreamGetParams; + break; + case OP_NOTIFY_PARAM: + ppParam = &pOperator->pOperatorNotifyParam; + pppDownstramParam = &pOperator->pDownstreamNotifyParams; + break; + default: + return; + } + + if (*ppParam) { + freeOperatorParam(*ppParam, type); + *ppParam = NULL; + } + + if (*pppDownstramParam) { + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + if ((*pppDownstramParam)[i]) { + freeOperatorParam((*pppDownstramParam)[i], type); + (*pppDownstramParam)[i] = NULL; + } + } + if (allFree) { + taosMemoryFreeClear(*pppDownstramParam); + } + } +} + + +FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam) { + if (pOperator->pDownstreamGetParams && pOperator->pDownstreamGetParams[idx]) { + qDebug("DynOp: op %s start to get block from downstream %s", pOperator->name, pOperator->pDownstream[idx]->name); + SSDataBlock* pBlock = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], pOperator->pDownstreamGetParams[idx]); + if (clearParam) { + freeOperatorParam(pOperator->pDownstreamGetParams[idx], OP_GET_PARAM); + pOperator->pDownstreamGetParams[idx] = NULL; + } + return pBlock; + } + + return pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]); +} + + bool compareVal(const char* v, const SStateKeys* pKey) { if (IS_VAR_DATA_TYPE(pKey->type)) { if (varDataLen(v) != varDataLen(pKey->pData)) { diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index bf321b75b1..4cf3b3239d 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -197,7 +197,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } while (1) { - SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { if (pInfo->totalInputRows == 0 && (pInfo->pFillInfo->type != TSDB_FILL_NULL_F && pInfo->pFillInfo->type != TSDB_FILL_SET_VALUE_F)) { @@ -444,7 +444,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->exprSupp.numOfExprs = pInfo->numOfExpr; pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); return pOperator; @@ -1312,7 +1312,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) { while (1) { if (pInfo->srcRowIndex >= pInfo->pSrcBlock->info.rows || pInfo->pSrcBlock->info.rows == 0) { // If there are delete datablocks, we receive them first. - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { pOperator->status = OP_RES_TO_RETURN; pInfo->pFillInfo->preRowKey = INT64_MIN; @@ -1570,7 +1570,7 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi setOperatorInfo(pOperator, "StreamFillOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState); code = appendDownstream(pOperator, &downstream, 1); diff --git a/source/libs/executor/src/groupcacheoperator.c b/source/libs/executor/src/groupcacheoperator.c new file mode 100755 index 0000000000..ff771ccc8c --- /dev/null +++ b/source/libs/executor/src/groupcacheoperator.c @@ -0,0 +1,1395 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "executorInt.h" +#include "filter.h" +#include "function.h" +#include "operator.h" +#include "os.h" +#include "querynodes.h" +#include "querytask.h" +#include "tcompare.h" +#include "tdatablock.h" +#include "thash.h" +#include "tmsg.h" +#include "ttypes.h" +#include "groupcache.h" + + +static void removeGroupCacheFile(SGroupCacheFileInfo* pFileInfo) { + if (pFileInfo->fd.fd) { + taosCloseFile(&pFileInfo->fd.fd); + pFileInfo->fd.fd = NULL; + taosThreadMutexDestroy(&pFileInfo->fd.mutex); + } + pFileInfo->deleted = true; +} + + +static int32_t initGroupColsInfo(SGroupColsInfo* pCols, bool grpColsMayBeNull, SNodeList* pList) { + pCols->colNum = LIST_LENGTH(pList); + pCols->withNull = grpColsMayBeNull; + pCols->pColsInfo = taosMemoryMalloc(pCols->colNum * sizeof(SGroupColInfo)); + if (NULL == pCols->pColsInfo) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + int32_t i = 0; + SNode* pNode = NULL; + FOREACH(pNode, pList) { + SColumnNode* pColNode = (SColumnNode*)pNode; + pCols->pColsInfo[i].slot = pColNode->slotId; + pCols->pColsInfo[i].vardata = IS_VAR_DATA_TYPE(pColNode->node.resType.type); + pCols->pColsInfo[i].bytes = pColNode->node.resType.bytes; + pCols->bufSize += pColNode->node.resType.bytes; + ++i; + } + + if (pCols->withNull) { + pCols->bitMapSize = pCols->colNum / sizeof(int8_t) + ((pCols->colNum % sizeof(int8_t)) ? 1 : 0); + pCols->bufSize += pCols->bitMapSize; + } + + if (pCols->colNum > 1) { + pCols->pBuf = taosMemoryMalloc(pCols->bufSize); + if (NULL == pCols->pBuf) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + return TSDB_CODE_SUCCESS; +} + +static void logGroupCacheExecInfo(SGroupCacheOperatorInfo* pGrpCacheOperator) { + char* buf = taosMemoryMalloc(pGrpCacheOperator->downstreamNum * 32 + 100); + if (NULL == buf) { + return; + } + int32_t offset = sprintf(buf, "groupCache exec info, downstreamBlkNum:"); + for (int32_t i = 0; i < pGrpCacheOperator->downstreamNum; ++i) { + offset += sprintf(buf + offset, " %" PRId64 , pGrpCacheOperator->execInfo.pDownstreamBlkNum[i]); + } + qDebug("%s", buf); + taosMemoryFree(buf); +} + +static void freeSGcSessionCtx(void* p) { + SGcSessionCtx* pSession = p; + if (pSession->semInit) { + tsem_destroy(&pSession->waitSem); + } +} + +static void freeSGroupCacheFileInfo(void* p) { + SGroupCacheFileInfo* pFileInfo = p; + if (pFileInfo->deleted) { + return; + } + + removeGroupCacheFile(pFileInfo); +} + +static void freeSGcFileCacheCtx(SGcFileCacheCtx* pFileCtx) { + taosHashCleanup(pFileCtx->pCacheFile); +} + +static void freeSGcVgroupCtx(void* p) { + SGcVgroupCtx* pVgCtx = p; + taosArrayDestroy(pVgCtx->pTbList); + freeSGcFileCacheCtx(&pVgCtx->fileCtx); +} + +static void freeGcBlockInList(void* p) { + SSDataBlock** ppBlock = p; + if (*ppBlock) { + taosArrayDestroy((*ppBlock)->pDataBlock); + taosMemoryFree(*ppBlock); + } +} + +static void freeSGcDownstreamCtx(SGcDownstreamCtx* pCtx) { + taosArrayDestroy(pCtx->pNewGrpList); + taosHashCleanup(pCtx->pGrpHash); + tSimpleHashCleanup(pCtx->pVgTbHash); + + taosArrayDestroyEx(pCtx->pFreeBlock, freeGcBlockInList); + taosHashCleanup(pCtx->pSessions); + taosHashCleanup(pCtx->pWaitSessions); + freeSGcFileCacheCtx(&pCtx->fileCtx); +} + +static void destroyGroupCacheDownstreamCtx(SGroupCacheOperatorInfo* pGrpCacheOperator) { + if (NULL == pGrpCacheOperator->pDownstreams) { + return; + } + + for (int32_t i = 0; i < pGrpCacheOperator->downstreamNum; ++i) { + SGcDownstreamCtx* pCtx = &pGrpCacheOperator->pDownstreams[i]; + freeSGcDownstreamCtx(pCtx); + } + + taosMemoryFree(pGrpCacheOperator->pDownstreams); +} + + +void blockDataDeepCleanup(SSDataBlock* pDataBlock) { + size_t numOfCols = taosArrayGetSize(pDataBlock->pDataBlock); + for (int32_t i = 0; i < numOfCols; ++i) { + SColumnInfoData* p = taosArrayGet(pDataBlock->pDataBlock, i); + taosMemoryFreeClear(p->pData); + if (IS_VAR_DATA_TYPE(p->info.type)) { + taosMemoryFreeClear(p->varmeta.offset); + p->varmeta.length = 0; + p->varmeta.allocLen = 0; + } else { + taosMemoryFreeClear(p->nullbitmap); + } + } + pDataBlock->info.capacity = 0; + pDataBlock->info.rows = 0; +} + + + +static void destroySGcBlkCacheInfo(SGcBlkCacheInfo* pBlkCache) { + taosHashCleanup(pBlkCache->pDirtyBlk); + + void* p = NULL; + while (NULL != (p = taosHashIterate(pBlkCache->pReadBlk, p))) { + blockDataDeepCleanup(*(SSDataBlock**)p); + freeGcBlockInList(p); + } + + taosHashCleanup(pBlkCache->pReadBlk); +} + +static void destroyGroupCacheOperator(void* param) { + SGroupCacheOperatorInfo* pGrpCacheOperator = (SGroupCacheOperatorInfo*)param; + + logGroupCacheExecInfo(pGrpCacheOperator); + + taosMemoryFree(pGrpCacheOperator->groupColsInfo.pColsInfo); + taosMemoryFree(pGrpCacheOperator->groupColsInfo.pBuf); + + destroyGroupCacheDownstreamCtx(pGrpCacheOperator); + destroySGcBlkCacheInfo(&pGrpCacheOperator->blkCache); + taosHashCleanup(pGrpCacheOperator->pGrpHash); + + taosMemoryFree(pGrpCacheOperator->execInfo.pDownstreamBlkNum); + + taosMemoryFreeClear(param); +} + +static FORCE_INLINE int32_t initOpenCacheFile(SGroupCacheFileFd* pFileFd, char* filename) { + TdFilePtr newFd = taosOpenFile(filename, TD_FILE_CREATE|TD_FILE_READ|TD_FILE_WRITE|TD_FILE_AUTO_DEL); + //TdFilePtr newFd = taosOpenFile(filename, TD_FILE_CREATE|TD_FILE_READ|TD_FILE_WRITE); + if (NULL == newFd) { + return TAOS_SYSTEM_ERROR(errno); + } + pFileFd->fd = newFd; + taosThreadMutexInit(&pFileFd->mutex, NULL); + + qTrace("file path %s created", filename); + + return TSDB_CODE_SUCCESS; +} + +static int32_t acquireFdFromFileCtx(SGcFileCacheCtx* pFileCtx, int32_t fileId, SGroupCacheFileFd** ppFd, bool* pDeleted) { + int32_t code = TSDB_CODE_SUCCESS; + if (NULL == pFileCtx->pCacheFile) { + pFileCtx->pCacheFile = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_ENTRY_LOCK); + if (NULL == pFileCtx->pCacheFile) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosHashSetFreeFp(pFileCtx->pCacheFile, freeSGroupCacheFileInfo); + } + + SGroupCacheFileInfo* pTmp = taosHashGet(pFileCtx->pCacheFile, &fileId, sizeof(fileId)); + if (NULL == pTmp) { + sprintf(&pFileCtx->baseFilename[pFileCtx->baseNameLen], "_%d", fileId); + + SGroupCacheFileInfo newFile = {0}; + taosHashPut(pFileCtx->pCacheFile, &fileId, sizeof(fileId), &newFile, sizeof(newFile)); + pTmp = taosHashGet(pFileCtx->pCacheFile, &fileId, sizeof(fileId)); + } + + if (pTmp->deleted) { + *pDeleted = true; + return TSDB_CODE_SUCCESS; + } + + if (NULL == pTmp->fd.fd) { + code = initOpenCacheFile(&pTmp->fd, pFileCtx->baseFilename); + if (code) { + return code; + } + } + + taosThreadMutexLock(&pTmp->fd.mutex); + *ppFd = &pTmp->fd; + + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE void releaseFdToFileCtx(SGroupCacheFileFd* pFd) { + taosThreadMutexUnlock(&pFd->mutex); +} + +static int32_t saveBlocksToDisk(SGroupCacheOperatorInfo* pGCache, SGcDownstreamCtx* pCtx, SGcBlkBufInfo* pHead) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheFileFd *pFd = NULL; + SGcFileCacheCtx* pFileCtx = NULL; + SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash; + int64_t lastGroupId = 0; + SGroupCacheData* pGroup = NULL; + + while (NULL != pHead) { + if (pGCache->batchFetch) { + pFileCtx = &pHead->pCtx->fileCtx; + } else { + if (pHead->groupId != lastGroupId) { + if (NULL != pGroup) { + taosHashRelease(pGrpHash, pGroup); + } + pGroup = taosHashAcquire(pGrpHash, &pHead->groupId, sizeof(pHead->groupId)); + lastGroupId = pHead->groupId; + } + + if (NULL == pGroup) { + qTrace("group %" PRIu64 " in downstream %d may already be deleted, skip write", pHead->groupId, pHead->pCtx->id); + + int64_t blkId = pHead->basic.blkId; + pHead = pHead->next; + taosHashRemove(pGCache->blkCache.pDirtyBlk, &blkId, sizeof(blkId)); + continue; + } + + pFileCtx = &pGroup->pVgCtx->fileCtx; + } + + bool deleted = false; + code = acquireFdFromFileCtx(pFileCtx, pHead->basic.fileId, &pFd, &deleted); + if (code) { + goto _return; + } + + if (deleted) { + qTrace("FileId:%d-%d-%d already be deleted, skip write", + pCtx->id, pGroup->vgId, pHead->basic.fileId); + + int64_t blkId = pHead->basic.blkId; + pHead = pHead->next; + + taosHashRemove(pGCache->blkCache.pDirtyBlk, &blkId, sizeof(blkId)); + continue; + } + + int32_t ret = taosLSeekFile(pFd->fd, pHead->basic.offset, SEEK_SET); + if (ret == -1) { + releaseFdToFileCtx(pFd); + code = TAOS_SYSTEM_ERROR(errno); + goto _return; + } + + ret = (int32_t)taosWriteFile(pFd->fd, pHead->pBuf, pHead->basic.bufSize); + if (ret != pHead->basic.bufSize) { + releaseFdToFileCtx(pFd); + code = TAOS_SYSTEM_ERROR(errno); + goto _return; + } + + releaseFdToFileCtx(pFd); + + qTrace("FileId:%d-%d-%d blk %" PRIu64 " in group %" PRIu64 " size %" PRIu64 " written to offset %" PRIu64, + pCtx->id, pGroup ? pGroup->vgId : GROUP_CACHE_DEFAULT_VGID, pHead->basic.fileId, pHead->basic.blkId, pHead->groupId, pHead->basic.bufSize, pHead->basic.offset); + + int64_t blkId = pHead->basic.blkId; + pHead = pHead->next; + + taosHashRemove(pGCache->blkCache.pDirtyBlk, &blkId, sizeof(blkId)); + } + +_return: + + if (NULL != pGroup) { + taosHashRelease(pGrpHash, pGroup); + } + + atomic_val_compare_exchange_32(&pGCache->blkCache.writeDownstreamId, pCtx->id, -1); + + return code; +} + +static int32_t addBlkToDirtyBufList(SGroupCacheOperatorInfo* pGCache, SGcDownstreamCtx* pCtx, SGcBlkCacheInfo* pCache, SGcBlkBufInfo* pBufInfo) { + if (0 != taosHashPut(pCache->pDirtyBlk, &pBufInfo->basic.blkId, sizeof(pBufInfo->basic.blkId), pBufInfo, sizeof(*pBufInfo))) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pBufInfo = taosHashGet(pCache->pDirtyBlk, &pBufInfo->basic.blkId, sizeof(pBufInfo->basic.blkId)); + + int32_t code = TSDB_CODE_SUCCESS; + SGcBlkBufInfo* pWriteHead = NULL; + + taosWLockLatch(&pCache->dirtyLock); + pCache->blkCacheSize += pBufInfo->basic.bufSize; + qError("group cache total dirty block num:%d size:%" PRId64 , taosHashGetSize(pCache->pDirtyBlk), pCache->blkCacheSize); + + if (NULL == pCache->pDirtyHead) { + pCache->pDirtyHead = pBufInfo; + } else { + pCache->pDirtyTail->next = pBufInfo; + } + pCache->pDirtyTail = pBufInfo; + + if (pGCache->maxCacheSize >= 0 && pCache->blkCacheSize > pGCache->maxCacheSize) { + if (-1 == atomic_val_compare_exchange_32(&pCache->writeDownstreamId, -1, pCtx->id)) { + pWriteHead = pCache->pDirtyHead; + SGcBlkBufInfo* pTmp = pCache->pDirtyHead; + while (NULL != pTmp) { + pCache->blkCacheSize -= pTmp->basic.bufSize; + if (pCache->blkCacheSize <= pGCache->maxCacheSize) { + pCache->pDirtyHead = pTmp->next; + pTmp->next = NULL; + break; + } + pTmp = pTmp->next; + } + } + } + taosWUnLockLatch(&pCache->dirtyLock); + + if (NULL != pWriteHead) { + code = saveBlocksToDisk(pGCache, pCtx, pWriteHead); + } + + return code; +} + +static FORCE_INLINE void chkRemoveVgroupCurrFile(SGcFileCacheCtx* pFileCtx, int32_t downstreamIdx, int32_t vgId) { + SGroupCacheFileInfo* pFileInfo = taosHashGet(pFileCtx->pCacheFile, &pFileCtx->fileId, sizeof(pFileCtx->fileId)); + if (0 == pFileInfo->groupNum) { + removeGroupCacheFile(pFileInfo); + +#if 0 + /* debug only */ + sprintf(&pFileCtx->baseFilename[pFileCtx->baseNameLen], "_%d", pFileCtx->fileId); + taosRemoveFile(pFileCtx->baseFilename); + /* debug only */ +#endif + + qTrace("FileId:%d-%d-%d removed", downstreamIdx, vgId, pFileCtx->fileId); + //taosHashRemove(pFileCtx->pCacheFile, &pGroup->fileId, sizeof(pGroup->fileId)); + } +} + +static FORCE_INLINE void groupCacheSwitchNewFile(SGcFileCacheCtx* pFileCtx, int32_t downstreamIdx, int32_t vgId, bool removeCheck) { + if (pFileCtx->fileSize < GROUP_CACHE_DEFAULT_MAX_FILE_SIZE) { + return; + } + + if (removeCheck) { + chkRemoveVgroupCurrFile(pFileCtx, downstreamIdx, vgId); + } + + pFileCtx->fileId++; + pFileCtx->fileSize = 0; +} + + +static int32_t addBlkToBufCache(struct SOperatorInfo* pOperator, SSDataBlock* pBlock, SGcDownstreamCtx* pCtx, SGroupCacheData* pGroup, SGcBlkBufInfo* pBufInfo) { + SGroupCacheOperatorInfo* pGCache = pOperator->info; + int64_t bufSize = blockDataGetSize(pBlock) + sizeof(int32_t) + taosArrayGetSize(pBlock->pDataBlock) * sizeof(int32_t); + pBufInfo->pBuf = taosMemoryMalloc(bufSize); + if (NULL == pBufInfo->pBuf) { + qError("group cache add block to cache failed, size:%" PRId64, bufSize); + return TSDB_CODE_OUT_OF_MEMORY; + } + blockDataToBuf(pBufInfo->pBuf, pBlock); + + SGcFileCacheCtx* pFileCtx = pGCache->batchFetch ? &pCtx->fileCtx : &pGroup->pVgCtx->fileCtx; + + pBufInfo->next = NULL; + pBufInfo->basic.blkId = atomic_add_fetch_64(&pGCache->currentBlkId, 1); + pBufInfo->basic.fileId = pGCache->batchFetch ? pFileCtx->fileId : pGroup->fileId; + pBufInfo->basic.bufSize = bufSize; + pBufInfo->basic.offset = atomic_fetch_add_64(&pFileCtx->fileSize, bufSize); + pBufInfo->pCtx = pCtx; + pBufInfo->groupId = pBlock->info.id.groupId; + + if (pGCache->batchFetch) { + groupCacheSwitchNewFile(pFileCtx, pCtx->id, pGroup->vgId, false); + } + + int32_t code = addBlkToDirtyBufList(pGCache, pCtx, &pGCache->blkCache, pBufInfo); + + return code; +} + +void blockDataDeepClear(SSDataBlock* pDataBlock) { + size_t numOfCols = taosArrayGetSize(pDataBlock->pDataBlock); + for (int32_t i = 0; i < numOfCols; ++i) { + SColumnInfoData* p = taosArrayGet(pDataBlock->pDataBlock, i); + p->pData = NULL; + if (IS_VAR_DATA_TYPE(p->info.type)) { + p->varmeta.offset = NULL; + p->varmeta.length = 0; + p->varmeta.allocLen = 0; + } else { + p->nullbitmap = NULL; + } + } + pDataBlock->info.capacity = 0; + pDataBlock->info.rows = 0; +} + +static int32_t buildGroupCacheBaseBlock(SSDataBlock** ppDst, SSDataBlock* pSrc) { + *ppDst = taosMemoryMalloc(sizeof(*pSrc)); + if (NULL == *ppDst) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ppDst)->pBlockAgg = NULL; + (*ppDst)->pDataBlock = taosArrayDup(pSrc->pDataBlock, NULL); + if (NULL == (*ppDst)->pDataBlock) { + taosMemoryFree(*ppDst); + return TSDB_CODE_OUT_OF_MEMORY; + } + memcpy(&(*ppDst)->info, &pSrc->info, sizeof(pSrc->info)); + blockDataDeepClear(*ppDst); + return TSDB_CODE_SUCCESS; +} + +static int32_t acquireBaseBlockFromList(SGcDownstreamCtx* pCtx, SSDataBlock** ppRes) { + taosWLockLatch(&pCtx->blkLock); + if (taosArrayGetSize(pCtx->pFreeBlock) <= 0) { + taosWUnLockLatch(&pCtx->blkLock); + return buildGroupCacheBaseBlock(ppRes, pCtx->pBaseBlock); + } + *ppRes = *(SSDataBlock**)taosArrayPop(pCtx->pFreeBlock); + taosWUnLockLatch(&pCtx->blkLock); + + return TSDB_CODE_SUCCESS; +} + +static void releaseBaseBlockToList(SGcDownstreamCtx* pCtx, SSDataBlock* pBlock) { + blockDataDeepCleanup(pBlock); + taosWLockLatch(&pCtx->blkLock); + taosArrayPush(pCtx->pFreeBlock, &pBlock); + taosWUnLockLatch(&pCtx->blkLock); +} + + +static int32_t buildGroupCacheResultBlock(SGroupCacheOperatorInfo* pGCache, int32_t downstreamIdx, void* pBuf, SSDataBlock** ppRes) { + int32_t code = acquireBaseBlockFromList(&pGCache->pDownstreams[downstreamIdx], ppRes); + if (code) { + return code; + } + //TODO OPTIMIZE PERF + return blockDataFromBuf(*ppRes, pBuf); +} + +static int32_t readBlockFromDisk(SGroupCacheOperatorInfo* pGCache, SGroupCacheData* pGrp, SGcBlkBufBasic* pBasic, void** ppBuf) { + SGroupCacheFileFd *pFileFd = NULL; + SGcFileCacheCtx* pFileCtx = pGCache->batchFetch ? &pGCache->pDownstreams[pGrp->downstreamIdx].fileCtx : &pGrp->pVgCtx->fileCtx; + bool deleted = false; + int32_t code = acquireFdFromFileCtx(pFileCtx, pBasic->fileId, &pFileFd, &deleted); + if (code) { + return code; + } + if (deleted) { + qError("FileId:%d-%d-%d already be deleted, skip read", pGrp->downstreamIdx, pGrp->vgId, pBasic->fileId); + return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; + } + + int32_t ret = taosLSeekFile(pFileFd->fd, pBasic->offset, SEEK_SET); + if (ret == -1) { + code = TAOS_SYSTEM_ERROR(errno); + goto _return; + } + + *ppBuf = taosMemoryMalloc(pBasic->bufSize); + if (NULL == *ppBuf) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _return; + } + + ret = (int32_t)taosReadFile(pFileFd->fd, *ppBuf, pBasic->bufSize); + if (ret != pBasic->bufSize) { + taosMemoryFreeClear(*ppBuf); + code = TAOS_SYSTEM_ERROR(errno); + goto _return; + } + + qTrace("FileId:%d-%d-%d blk %" PRIu64 " size %" PRIu64 " read from offset %" PRIu64, + pGrp->downstreamIdx, pGrp->vgId, pBasic->fileId, pBasic->blkId, pBasic->bufSize, pBasic->offset); + +_return: + + releaseFdToFileCtx(pFileFd); + return code; +} + +static int32_t retrieveBlkFromBufCache(SGroupCacheOperatorInfo* pGCache, SGroupCacheData* pGrp, int64_t sessionId, SGcBlkBufBasic* pBasic, SSDataBlock** ppRes) { + int32_t code = TSDB_CODE_SUCCESS; + SGcBlkCacheInfo* pCache = &pGCache->blkCache; + void* pBuf = NULL; + + SGcBlkBufInfo* pBufInfo = taosHashAcquire(pCache->pDirtyBlk, &pBasic->blkId, sizeof(pBasic->blkId)); + if (NULL == pBufInfo) { + code = readBlockFromDisk(pGCache, pGrp, pBasic, &pBuf); + if (code) { + return code; + } + } else { + pBuf = pBufInfo->pBuf; + } + + code = buildGroupCacheResultBlock(pGCache, pGrp->downstreamIdx, pBuf, ppRes); + taosHashRelease(pCache->pDirtyBlk, pBufInfo); + if (NULL == pBufInfo) { + taosMemoryFree(pBuf); + } + + if (code) { + return code; + } + + taosHashPut(pCache->pReadBlk, &sessionId, sizeof(sessionId), ppRes, POINTER_BYTES); + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE void initGcVgroupCtx(SOperatorInfo* pOperator, SGcVgroupCtx* pVgCtx, int32_t downstreamId, int32_t vgId, SArray* pTbList) { + pVgCtx->pTbList = pTbList; + pVgCtx->id = vgId; + snprintf(pVgCtx->fileCtx.baseFilename, sizeof(pVgCtx->fileCtx.baseFilename) - 1, "%s/gc_%d_%" PRIx64 "_%" PRIu64 "_%d_%d", + tsTempDir, getpid(), pOperator->pTaskInfo->id.queryId, pOperator->pTaskInfo->id.taskId, downstreamId, vgId); + pVgCtx->fileCtx.baseFilename[sizeof(pVgCtx->fileCtx.baseFilename) - 1] = 0; + + pVgCtx->fileCtx.baseNameLen = strlen(pVgCtx->fileCtx.baseFilename); +} + +static int32_t addNewGroupToVgHash(SOperatorInfo* pOperator, SSHashObj* pHash, SGcNewGroupInfo* pNew) { + SGcVgroupCtx* pVgCtx = pNew->pGroup->pVgCtx; + if (NULL == pVgCtx) { + SArray* pList = taosArrayInit(10, sizeof(*pNew)); + if (NULL == pList) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosArrayPush(pList, pNew); + SGcVgroupCtx vgCtx = {0}; + initGcVgroupCtx(pOperator, &vgCtx, pNew->pGroup->downstreamIdx, pNew->vgId, pList); + tSimpleHashPut(pHash, &pNew->vgId, sizeof(pNew->vgId), &vgCtx, sizeof(vgCtx)); + pNew->pGroup->pVgCtx = tSimpleHashGet(pHash, &pNew->vgId, sizeof(pNew->vgId)); + return TSDB_CODE_SUCCESS; + } + + taosArrayPush(pVgCtx->pTbList, pNew); + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE int32_t appendNewGroupToDownstream(struct SOperatorInfo* pOperator, int32_t downstreamIdx, SOperatorParam** ppParam) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[downstreamIdx]; + SOperatorParam* pDst = NULL; + + taosWLockLatch(&pCtx->grpLock); + int32_t num = taosArrayGetSize(pCtx->pNewGrpList); + if (num <= 0) { + goto _return; + } + + for (int32_t i = 0; i < num; ++i) { + SGcNewGroupInfo* pNew = taosArrayGet(pCtx->pNewGrpList, i); + if (!pGCache->batchFetch) { + code = addNewGroupToVgHash(pOperator, pCtx->pVgTbHash, pNew); + if (code) { + goto _return; + } + } + + if (NULL == pDst) { + pDst = pNew->pParam; + } else if (pNew->pParam) { + code = mergeOperatorParams(pDst, pNew->pParam); + if (code) { + goto _return; + } + } + } + + taosArrayClear(pCtx->pNewGrpList); + +_return: + + taosWUnLockLatch(&pCtx->grpLock); + *ppParam = pDst; + + return code; +} + +static FORCE_INLINE int32_t getBlkFromDownstreamOperator(struct SOperatorInfo* pOperator, int32_t downstreamIdx, SSDataBlock** ppRes) { + int32_t code = TSDB_CODE_SUCCESS; + SOperatorParam* pDownstreamParam = NULL; + SSDataBlock* pBlock = NULL; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + code = appendNewGroupToDownstream(pOperator, downstreamIdx, &pDownstreamParam); + if (code) { + return code; + } + + if (pDownstreamParam) { + pBlock = pOperator->pDownstream[downstreamIdx]->fpSet.getNextExtFn(pOperator->pDownstream[downstreamIdx], pDownstreamParam); + } else { + pBlock = pOperator->pDownstream[downstreamIdx]->fpSet.getNextFn(pOperator->pDownstream[downstreamIdx]); + } + + if (pBlock) { + qError("%s blk retrieved from group %" PRIu64, GET_TASKID(pOperator->pTaskInfo), pBlock->info.id.groupId); + + pGCache->execInfo.pDownstreamBlkNum[downstreamIdx]++; + if (NULL == pGCache->pDownstreams[downstreamIdx].pBaseBlock) { + code = buildGroupCacheBaseBlock(&pGCache->pDownstreams[downstreamIdx].pBaseBlock, pBlock); + if (code) { + return code; + } + taosArrayPush(pGCache->pDownstreams[downstreamIdx].pFreeBlock, &pGCache->pDownstreams[downstreamIdx].pBaseBlock); + } + } + + *ppRes = pBlock; + + return code; +} + +static void notifyWaitingSessions(SArray* pWaitQueue) { + if (NULL == pWaitQueue || taosArrayGetSize(pWaitQueue) <= 0) { + return; + } + + int32_t n = taosArrayGetSize(pWaitQueue); + for (int32_t i = 0; i < n; ++i) { + SGcSessionCtx* pSession = taosArrayGetP(pWaitQueue, i); + tsem_post(&pSession->waitSem); + } +} + +static FORCE_INLINE void handleGroupFetchDone(SGroupCacheData* pGroup) { + pGroup->pBlock = NULL; + atomic_store_8((int8_t*)&pGroup->fetchDone, true); + + taosThreadMutexLock(&pGroup->mutex); + notifyWaitingSessions(pGroup->waitQueue); + taosArrayClear(pGroup->waitQueue); + taosThreadMutexUnlock(&pGroup->mutex); +} + +static int32_t addFileRefTableNum(SGcFileCacheCtx* pFileCtx, int32_t fileId, int32_t downstreamId, int32_t vgId) { + if (NULL == pFileCtx->pCacheFile) { + pFileCtx->pCacheFile = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_ENTRY_LOCK); + if (NULL == pFileCtx->pCacheFile) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosHashSetFreeFp(pFileCtx->pCacheFile, freeSGroupCacheFileInfo); + } + + SGroupCacheFileInfo* pTmp = taosHashGet(pFileCtx->pCacheFile, &fileId, sizeof(fileId)); + if (NULL == pTmp) { + sprintf(&pFileCtx->baseFilename[pFileCtx->baseNameLen], "_%u", fileId); + + SGroupCacheFileInfo newFile = {0}; + newFile.groupNum = 1; + taosHashPut(pFileCtx->pCacheFile, &fileId, sizeof(fileId), &newFile, sizeof(newFile)); + pTmp = taosHashGet(pFileCtx->pCacheFile, &fileId, sizeof(fileId)); + } else { + pTmp->groupNum++; + } + + qTrace("FileId:%d-%d-%d add groupNum to %u", downstreamId, vgId, fileId, pTmp->groupNum); + + return TSDB_CODE_SUCCESS; +} + +static int32_t handleVgroupTableFetchDone(SGcDownstreamCtx* pCtx, SGroupCacheData* pGroup, uint64_t uid) { + if (pCtx->lastBlkUid == uid || pGroup->pVgCtx->lastBlkUid == uid) { + return TSDB_CODE_SUCCESS; + } + + pCtx->lastBlkUid = uid; + pGroup->pVgCtx->lastBlkUid = uid; + + int32_t i = 0; + while (true) { + SGcNewGroupInfo* pNew = taosArrayGet(pGroup->pVgCtx->pTbList, i++); + if (NULL == pNew || pNew->uid == uid) { + break; + } + handleGroupFetchDone(pNew->pGroup); + } + + groupCacheSwitchNewFile(&pGroup->pVgCtx->fileCtx, pGroup->downstreamIdx, pGroup->vgId, true); + + pGroup->fileId = pGroup->pVgCtx->fileCtx.fileId; + pGroup->startOffset = pGroup->pVgCtx->fileCtx.fileSize; + + qTrace("FileId:%d-%d-%d add groupNum for group %" PRIu64, pGroup->downstreamIdx, pGroup->vgId, pGroup->pVgCtx->fileCtx.fileId, uid); + + if (pGroup->needCache) { + return addFileRefTableNum(&pGroup->pVgCtx->fileCtx, pGroup->pVgCtx->fileCtx.fileId, pGroup->downstreamIdx, pGroup->vgId); + } + + return TSDB_CODE_SUCCESS; +} + + +static FORCE_INLINE void initNewGroupData(SGcDownstreamCtx* pCtx, SGroupCacheData* pGroup, int32_t downstreamIdx, int32_t vgId, bool batchFetch, bool needCache) { + taosThreadMutexInit(&pGroup->mutex, NULL); + pGroup->downstreamIdx = downstreamIdx; + pGroup->vgId = vgId; + pGroup->fileId = -1; + pGroup->blkList.pList = taosArrayInit(10, sizeof(SGcBlkBufBasic)); + pGroup->startOffset = -1; + pGroup->needCache = needCache; + pGroup->pVgCtx = tSimpleHashGet(pCtx->pVgTbHash, &pGroup->vgId, sizeof(pGroup->vgId)); +} + +static int32_t addNewGroupData(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SGroupCacheData** ppGrp, int32_t vgId, int64_t uid) { + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pParam->downstreamIdx]; + SGcOperatorParam* pGcParam = pParam->value; + SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash; + SGroupCacheData grpData = {0}; + + while (true) { + if (0 != taosHashPut(pGrpHash, &uid, sizeof(uid), &grpData, sizeof(grpData))) { + if (terrno == TSDB_CODE_DUP_KEY) { + *ppGrp = taosHashGet(pGrpHash, &uid, sizeof(uid)); + if (*ppGrp) { + break; + } + } else { + return terrno; + } + } + + break; + } + + *ppGrp = taosHashGet(pGrpHash, &uid, sizeof(uid)); + initNewGroupData(pCtx, *ppGrp, pParam->downstreamIdx, vgId, pGCache->batchFetch, pGcParam->needCache); + + qError("new group %" PRIu64 " initialized, downstreamIdx:%d, vgId:%d, needCache:%d", uid, pParam->downstreamIdx, vgId, pGcParam->needCache); + + if (pParam->pChildren) { + SGcNewGroupInfo newGroup; + newGroup.pGroup = *ppGrp; + newGroup.vgId = vgId; + newGroup.uid = uid; + newGroup.pParam = taosArrayGetP(pParam->pChildren, 0); + + taosWLockLatch(&pCtx->grpLock); + if (NULL == taosArrayPush(pCtx->pNewGrpList, &newGroup)) { + taosWUnLockLatch(&pCtx->grpLock); + return TSDB_CODE_OUT_OF_MEMORY; + } + taosWUnLockLatch(&pCtx->grpLock); + + taosArrayDestroy(pParam->pChildren); + pParam->pChildren = NULL; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t addBlkToGroupCache(bool batchFetch, SGroupCacheData* pGroup, SGcBlkBufInfo* pNewBlk, int64_t* pIdx) { + taosWLockLatch(&pGroup->blkList.lock); + taosArrayPush(pGroup->blkList.pList, &pNewBlk->basic); + *pIdx = taosArrayGetSize(pGroup->blkList.pList) - 1; + taosWUnLockLatch(&pGroup->blkList.lock); + + qError("block added to group cache, total block num:%" PRId64, *pIdx + 1); + + return TSDB_CODE_SUCCESS; +} + +static int32_t handleGroupCacheRetrievedBlk(struct SOperatorInfo* pOperator, SSDataBlock* pBlock, SGcSessionCtx* pSession, bool* continueFetch) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pSession->downstreamIdx]; + SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash; + int64_t newBlkIdx = 0; + + SGroupCacheData* pGroup = taosHashGet(pGrpHash, &pBlock->info.id.groupId, sizeof(pBlock->info.id.groupId)); + if (NULL == pGroup) { + if (pGCache->batchFetch) { + SGcOperatorParam fakeGcParam = {0}; + SOperatorParam fakeParam = {0}; + fakeGcParam.needCache = true; + fakeParam.downstreamIdx = pSession->downstreamIdx; + fakeParam.value = &fakeGcParam; + code = addNewGroupData(pOperator, &fakeParam, &pGroup, GROUP_CACHE_DEFAULT_VGID, pBlock->info.id.groupId); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } else { + qError("group %" PRIu64 " not found in group hash", pBlock->info.id.groupId); + return TSDB_CODE_INVALID_PARA; + } + } + + if (!pGCache->batchFetch) { + code = handleVgroupTableFetchDone(pCtx, pGroup, pBlock->info.id.groupId); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + + if (pGroup->needCache) { + qError("add block to group cache"); + + SGcBlkBufInfo newBlkBuf; + code = addBlkToBufCache(pOperator, pBlock, pCtx, pGroup, &newBlkBuf); + if (code) { + return code; + } + + code = addBlkToGroupCache(pGCache->batchFetch, pGroup, &newBlkBuf, &newBlkIdx); + if (code) { + return code; + } + } else { + qError("no need to add block to group cache"); + + pGroup->pBlock = pBlock; + } + + notifyWaitingSessions(pGroup->waitQueue); + if (pGroup == pSession->pGroupData) { + if (pGroup->needCache) { + pSession->lastBlkId = newBlkIdx; + } + + *continueFetch = false; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t handleDownstreamFetchDone(struct SOperatorInfo* pOperator, SGcSessionCtx* pSession) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pSession->downstreamIdx]; + if (pGCache->batchFetch) { + SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash; + SGroupCacheData* pGroup = NULL; + while (NULL != (pGroup = taosHashIterate(pGrpHash, pGroup))) { + handleGroupFetchDone(pGroup); + } + } else { + int32_t uidNum = 0; + SGcVgroupCtx* pVgCtx = NULL; + int32_t iter = 0; + while (NULL != (pVgCtx = tSimpleHashIterate(pCtx->pVgTbHash, pVgCtx, &iter))) { + uidNum = taosArrayGetSize(pVgCtx->pTbList); + for (int32_t i = 0; i < uidNum; ++i) { + SGcNewGroupInfo* pNew = taosArrayGet(pVgCtx->pTbList, i); + handleGroupFetchDone(pNew->pGroup); + } + taosArrayClear(pVgCtx->pTbList); + } + } + + taosHashClear(pCtx->pWaitSessions); + + return TSDB_CODE_SUCCESS; +} + +static int32_t getCacheBlkFromDownstreamOperator(struct SOperatorInfo* pOperator, SGcDownstreamCtx* pCtx, int64_t sessionId, SGcSessionCtx* pSession, SSDataBlock** ppRes) { + bool continueFetch = true; + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + + while (continueFetch && TSDB_CODE_SUCCESS == code) { + int32_t code = getBlkFromDownstreamOperator(pOperator, pSession->downstreamIdx, ppRes); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + + if (NULL == *ppRes) { + code = handleDownstreamFetchDone(pOperator, pSession); + break; + } else { + code = handleGroupCacheRetrievedBlk(pOperator, *ppRes, pSession, &continueFetch); + } + } + + if (!continueFetch) { + SGcSessionCtx** ppWaitCtx = taosHashIterate(pCtx->pWaitSessions, NULL); + if (ppWaitCtx) { + taosHashCancelIterate(pCtx->pWaitSessions, ppWaitCtx); + int64_t* pSessionId = taosHashGetKey(ppWaitCtx, NULL); + if (sessionId != atomic_val_compare_exchange_64(&pCtx->fetchSessionId, sessionId, *pSessionId)) { + qError("wrong fetch sessionId: %" PRIu64 " expected: %" PRIu64 , pCtx->fetchSessionId, sessionId); + return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; + } + SGcSessionCtx* pWaitCtx = *ppWaitCtx; + pWaitCtx->newFetch = true; + taosHashRemove(pCtx->pWaitSessions, pSessionId, sizeof(*pSessionId)); + tsem_post(&pWaitCtx->waitSem); + + return code; + } + } + + if (sessionId != atomic_val_compare_exchange_64(&pCtx->fetchSessionId, sessionId, -1)) { + qError("wrong fetch sessionId: %" PRIu64 " expected: %" PRIu64 , pCtx->fetchSessionId, sessionId); + return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; + } + + return code; +} + +static int32_t getBlkFromSessionCacheImpl(struct SOperatorInfo* pOperator, int64_t sessionId, SGcSessionCtx* pSession, SSDataBlock** ppRes, bool* got) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + *got = true; + + if (pSession->pGroupData->needCache) { + SGcBlkList* pBlkList = &pSession->pGroupData->blkList; + taosRLockLatch(&pBlkList->lock); + int64_t blkNum = taosArrayGetSize(pBlkList->pList); + if (pSession->lastBlkId < 0) { + if (blkNum > 0) { + SGcBlkBufBasic* pBasic = taosArrayGet(pBlkList->pList, 0); + taosRUnLockLatch(&pBlkList->lock); + code = retrieveBlkFromBufCache(pGCache, pSession->pGroupData, sessionId, pBasic, ppRes); + pSession->lastBlkId = 0; + return code; + } + } else if ((pSession->lastBlkId + 1) < blkNum) { + SGcBlkBufBasic* pBasic = taosArrayGet(pBlkList->pList, pSession->lastBlkId + 1); + taosRUnLockLatch(&pBlkList->lock); + code = retrieveBlkFromBufCache(pGCache, pSession->pGroupData, sessionId, pBasic, ppRes); + pSession->lastBlkId++; + return code; + } + taosRUnLockLatch(&pBlkList->lock); + } else if (pSession->pGroupData->pBlock) { + *ppRes = pSession->pGroupData->pBlock; + pSession->pGroupData->pBlock = NULL; + } + + if (atomic_load_8((int8_t*)&pSession->pGroupData->fetchDone)) { + *ppRes = NULL; + return code; + } + + *got = false; + return code; +} + + +static int32_t groupCacheSessionWait(struct SOperatorInfo* pOperator, SGcDownstreamCtx* pCtx, int64_t sessionId, SGcSessionCtx* pSession, SSDataBlock** ppRes) { + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGroupCacheData* pGroup = pSession->pGroupData; + int32_t code = TSDB_CODE_SUCCESS; + if (NULL == pGroup->waitQueue) { + pGroup->waitQueue = taosArrayInit(1, POINTER_BYTES); + if (NULL == pGroup->waitQueue) { + taosThreadMutexUnlock(&pSession->pGroupData->mutex); + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + taosArrayPush(pGroup->waitQueue, &pSession); + + if (!pSession->semInit) { + tsem_init(&pSession->waitSem, 0, 0); + pSession->semInit = true; + } + + taosThreadMutexUnlock(&pSession->pGroupData->mutex); + + taosHashPut(pCtx->pWaitSessions, &sessionId, sizeof(sessionId), &pSession, POINTER_BYTES); + + tsem_wait(&pSession->waitSem); + + if (pSession->newFetch) { + pSession->newFetch = false; + return getCacheBlkFromDownstreamOperator(pOperator, pCtx, sessionId, pSession, ppRes); + } + + taosHashRemove(pCtx->pWaitSessions, &sessionId, sizeof(sessionId)); + + bool got = false; + return getBlkFromSessionCacheImpl(pOperator, sessionId, pSession, ppRes, &got); +} + + +static int32_t getBlkFromSessionCache(struct SOperatorInfo* pOperator, int64_t sessionId, SGcSessionCtx* pSession, SSDataBlock** ppRes) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + bool locked = false; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pSession->downstreamIdx]; + + while (true) { + bool got = false; + code = getBlkFromSessionCacheImpl(pOperator, sessionId, pSession, ppRes, &got); + if (TSDB_CODE_SUCCESS != code || got) { + goto _return; + } + + if ((atomic_load_64(&pCtx->fetchSessionId) == sessionId) + || (-1 == atomic_val_compare_exchange_64(&pCtx->fetchSessionId, -1, sessionId))) { + if (locked) { + taosThreadMutexUnlock(&pSession->pGroupData->mutex); + locked = false; + } + + code = getCacheBlkFromDownstreamOperator(pOperator, pCtx, sessionId, pSession, ppRes); + goto _return; + } + + if (locked) { + code = groupCacheSessionWait(pOperator, pCtx, sessionId, pSession, ppRes); + locked = false; + if (TSDB_CODE_SUCCESS != code) { + goto _return; + } + + break; + } + + taosThreadMutexLock(&pSession->pGroupData->mutex); + locked = true; + }; + + +_return: + + if (locked) { + taosThreadMutexUnlock(&pSession->pGroupData->mutex); + } + + return code; +} + +void freeGcBlkBufInfo(void* ptr) { + SGcBlkBufInfo* pBlk = (SGcBlkBufInfo*)ptr; + taosMemoryFree(pBlk->pBuf); +} + +static int32_t initGroupCacheBlockCache(SGroupCacheOperatorInfo* pInfo) { + SGcBlkCacheInfo* pCache = &pInfo->blkCache; + pCache->pDirtyBlk = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + if (NULL == pCache->pDirtyBlk) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosHashSetFreeFp(pCache->pDirtyBlk, freeGcBlkBufInfo); + pCache->pReadBlk = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + if (NULL == pCache->pReadBlk) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pCache->writeDownstreamId = -1; + + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE void initGroupCacheSessionCtx(SGcSessionCtx* pSession, SGcOperatorParam* pGcParam, SGroupCacheData* pGroup) { + pSession->pParam = pGcParam; + pSession->downstreamIdx = pGcParam->downstreamIdx; + pSession->pGroupData = pGroup; + pSession->lastBlkId = -1; +} + +static int32_t initGroupCacheSession(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SGcSessionCtx** ppSession) { + int32_t code = TSDB_CODE_SUCCESS; + SGcSessionCtx ctx = {0}; + SGcOperatorParam* pGcParam = pParam->value; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pParam->downstreamIdx]; + SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash; + + SGroupCacheData* pGroup = taosHashGet(pGrpHash, &pGcParam->tbUid, sizeof(pGcParam->tbUid)); + if (NULL == pGroup) { + code = addNewGroupData(pOperator, pParam, &pGroup, pGCache->batchFetch ? GROUP_CACHE_DEFAULT_VGID : pGcParam->vgId, pGcParam->tbUid); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + + initGroupCacheSessionCtx(&ctx, pGcParam, pGroup); + + code = taosHashPut(pCtx->pSessions, &pGcParam->sessionId, sizeof(pGcParam->sessionId), &ctx, sizeof(ctx)); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + + *ppSession = taosHashGet(pCtx->pSessions, &pGcParam->sessionId, sizeof(pGcParam->sessionId)); + + return TSDB_CODE_SUCCESS; +} + +static int32_t getBlkFromGroupCache(struct SOperatorInfo* pOperator, SSDataBlock** ppRes, SOperatorParam* pParam) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcOperatorParam* pGcParam = pParam->value; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pParam->downstreamIdx]; + SGcSessionCtx* pSession = taosHashGet(pCtx->pSessions, &pGcParam->sessionId, sizeof(pGcParam->sessionId)); + if (NULL == pSession) { + int32_t code = initGroupCacheSession(pOperator, pParam, &pSession); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } else if (pSession->pGroupData->needCache) { + SSDataBlock** ppBlock = taosHashGet(pGCache->blkCache.pReadBlk, &pGcParam->sessionId, sizeof(pGcParam->sessionId)); + if (ppBlock) { + releaseBaseBlockToList(pCtx, *ppBlock); + taosHashRemove(pGCache->blkCache.pReadBlk, &pGcParam->sessionId, sizeof(pGcParam->sessionId)); + } + } + + code = getBlkFromSessionCache(pOperator, pGcParam->sessionId, pSession, ppRes); + if (NULL == *ppRes) { + qError("session %" PRId64 " in downstream %d total got %" PRId64 " rows", pGcParam->sessionId, pCtx->id, pSession->resRows); + taosHashRemove(pCtx->pSessions, &pGcParam->sessionId, sizeof(pGcParam->sessionId)); + } else { + pSession->resRows += (*ppRes)->info.rows; + qError("session %" PRId64 " in downstream %d got %" PRId64 " rows in one block", pGcParam->sessionId, pCtx->id, (*ppRes)->info.rows); + } + + return code; +} + +static int32_t initGroupCacheExecInfo(SOperatorInfo* pOperator) { + SGroupCacheOperatorInfo* pInfo = pOperator->info; + pInfo->execInfo.pDownstreamBlkNum = taosMemoryCalloc(pOperator->numOfDownstream, sizeof(int64_t)); + if (NULL == pInfo->execInfo.pDownstreamBlkNum) { + return TSDB_CODE_OUT_OF_MEMORY; + } + return TSDB_CODE_SUCCESS; +} + +static void freeRemoveGroupCacheData(void* p) { + SGroupCacheData* pGroup = p; + if (pGroup->vgId > 0 && pGroup->needCache) { + SGcFileCacheCtx* pFileCtx = &pGroup->pVgCtx->fileCtx; + if (pGroup->fileId >= 0) { + SGroupCacheFileInfo* pFileInfo = taosHashGet(pFileCtx->pCacheFile, &pGroup->fileId, sizeof(pGroup->fileId)); + uint32_t remainNum = atomic_sub_fetch_32(&pFileInfo->groupNum, 1); + + qTrace("FileId:%d-%d-%d sub group num to %u", pGroup->downstreamIdx, pGroup->vgId, pFileCtx->fileId, remainNum); + + if (0 == remainNum && pGroup->fileId != pFileCtx->fileId) { + removeGroupCacheFile(pFileInfo); + +#if 0 + /* debug only */ + sprintf(&pFileCtx->baseFilename[pFileCtx->baseNameLen], "_%d", pGroup->fileId); + taosRemoveFile(pFileCtx->baseFilename); + /* debug only */ +#endif + + qTrace("FileId:%d-%d-%d removed", pGroup->downstreamIdx, pGroup->vgId, pFileCtx->fileId); + //taosHashRemove(pFileCtx->pCacheFile, &pGroup->fileId, sizeof(pGroup->fileId)); + } + } + } + + taosArrayDestroy(pGroup->waitQueue); + taosArrayDestroy(pGroup->blkList.pList); + taosThreadMutexDestroy(&pGroup->mutex); + + qTrace("group removed"); +} + + + +static int32_t initGroupCacheDownstreamCtx(SOperatorInfo* pOperator) { + SGroupCacheOperatorInfo* pInfo = pOperator->info; + pInfo->pDownstreams = taosMemoryCalloc(pOperator->numOfDownstream, sizeof(*pInfo->pDownstreams)); + if (NULL == pInfo->pDownstreams) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pInfo->downstreamNum = pOperator->numOfDownstream; + + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + SGcDownstreamCtx* pCtx = &pInfo->pDownstreams[i]; + pCtx->id = i; + pCtx->fetchSessionId = -1; + pCtx->lastBlkUid = 0; + pCtx->pVgTbHash = tSimpleHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); + if (NULL == pCtx->pVgTbHash) { + return TSDB_CODE_OUT_OF_MEMORY; + } + tSimpleHashSetFreeFp(pCtx->pVgTbHash, freeSGcVgroupCtx); + + if (pInfo->batchFetch) { + int32_t defaultVg = 0; + SGcVgroupCtx vgCtx = {0}; + initGcVgroupCtx(pOperator, &vgCtx, pCtx->id, defaultVg, NULL); + tSimpleHashPut(pCtx->pVgTbHash, &defaultVg, sizeof(defaultVg), &vgCtx, sizeof(vgCtx)); + } + + pCtx->pNewGrpList = taosArrayInit(10, sizeof(SGcNewGroupInfo)); + if (NULL == pCtx->pNewGrpList) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (!pInfo->globalGrp) { + pCtx->pGrpHash = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); + if (pCtx->pGrpHash == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosHashSetFreeFp(pCtx->pGrpHash, freeRemoveGroupCacheData); + } + + pCtx->pSessions = taosHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + if (pCtx->pSessions == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + taosHashSetFreeFp(pCtx->pSessions, freeSGcSessionCtx); + + pCtx->pFreeBlock = taosArrayInit(10, POINTER_BYTES); + if (NULL == pCtx->pFreeBlock) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pCtx->pWaitSessions = taosHashInit(20, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + if (pCtx->pWaitSessions == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + snprintf(pCtx->fileCtx.baseFilename, sizeof(pCtx->fileCtx.baseFilename) - 1, "%s/gc_%d_%" PRIx64 "_%" PRIu64 "_%d", + tsTempDir, getpid(), pOperator->pTaskInfo->id.queryId, pOperator->pTaskInfo->id.taskId, pCtx->id); + pCtx->fileCtx.baseFilename[sizeof(pCtx->fileCtx.baseFilename) - 1] = 0; + pCtx->fileCtx.baseNameLen = strlen(pCtx->fileCtx.baseFilename); + } + + return TSDB_CODE_SUCCESS; +} + +static SSDataBlock* groupCacheGetNext(struct SOperatorInfo* pOperator, SOperatorParam* pParam) { + SSDataBlock* pBlock = NULL; + int64_t st = 0; + + if (pOperator->cost.openCost == 0) { + st = taosGetTimestampUs(); + } + + int32_t code = getBlkFromGroupCache(pOperator, &pBlock, pParam); + if (TSDB_CODE_SUCCESS != code) { + pOperator->pTaskInfo->code = code; + T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); + } + + if (pOperator->cost.openCost == 0) { + pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; + } + + return pBlock; +} + +static int32_t groupCacheTableCacheEnd(SOperatorInfo* pOperator, SOperatorParam* pParam) { + SGcNotifyOperatorParam* pGcParam = pParam->value; + SGroupCacheOperatorInfo* pGCache = pOperator->info; + SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pGcParam->downstreamIdx]; + SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash; + + qTrace("try to remove group %" PRIu64, pGcParam->tbUid); + if (taosHashRemove(pGrpHash, &pGcParam->tbUid, sizeof(pGcParam->tbUid))) { + qError("failed to remove group %" PRIu64 " in vgId %d downstreamIdx %d", pGcParam->tbUid, pGcParam->vgId, pGcParam->downstreamIdx); + return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; + } + + return TSDB_CODE_SUCCESS; +} + +SOperatorInfo* createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo) { + SGroupCacheOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupCacheOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + + int32_t code = TSDB_CODE_SUCCESS; + if (pOperator == NULL || pInfo == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + + pOperator->transparent = true; + + setOperatorInfo(pOperator, "GroupCacheOperator", QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE, false, OP_NOT_OPENED, pInfo, pTaskInfo); + + pInfo->maxCacheSize = 0; + pInfo->grpByUid = pPhyciNode->grpByUid; + pInfo->globalGrp = pPhyciNode->globalGrp; + pInfo->batchFetch = pPhyciNode->batchFetch; + + if (!pInfo->grpByUid) { + qError("only group cache by uid is supported now"); + code = TSDB_CODE_INVALID_PARA; + goto _error; + } + + if (pPhyciNode->pGroupCols) { + code = initGroupColsInfo(&pInfo->groupColsInfo, pPhyciNode->grpColsMayBeNull, pPhyciNode->pGroupCols); + if (code) { + goto _error; + } + } + + code = initGroupCacheBlockCache(pInfo); + if (code) { + goto _error; + } + + if (pInfo->globalGrp) { + pInfo->pGrpHash = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); + if (pInfo->pGrpHash == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + taosHashSetFreeFp(pInfo->pGrpHash, freeRemoveGroupCacheData); + } + + code = appendDownstream(pOperator, pDownstream, numOfDownstream); + if (TSDB_CODE_SUCCESS != code) { + goto _error; + } + + code = initGroupCacheDownstreamCtx(pOperator); + if (TSDB_CODE_SUCCESS != code) { + goto _error; + } + + code = initGroupCacheExecInfo(pOperator); + if (TSDB_CODE_SUCCESS != code) { + goto _error; + } + + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, NULL, NULL, destroyGroupCacheOperator, optrDefaultBufFn, NULL, groupCacheGetNext, groupCacheTableCacheEnd); + + qTrace("new group cache operator, maxCacheSize:%" PRId64 ", globalGrp:%d, batchFetch:%d", pInfo->maxCacheSize, pInfo->globalGrp, pInfo->batchFetch); + + return pOperator; + +_error: + if (pInfo != NULL) { + destroyGroupCacheOperator(pInfo); + } + + taosMemoryFree(pOperator); + pTaskInfo->code = code; + return NULL; +} + + diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 0a14d6ea09..bc078621ce 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -383,7 +383,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { break; } @@ -480,7 +480,7 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pInfo->binfo.outputTsOrder = pAggNode->node.outputTsOrder; pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -754,7 +754,7 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { break; } @@ -844,7 +844,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pPartNode->pTargets, NULL, &numOfCols); - pInfo->pGroupCols = extractPartitionColInfo(pPartNode->pPartitionKeys); + pInfo->pGroupCols = makeColumnArrayFromList(pPartNode->pPartitionKeys); if (pPartNode->pExprs != NULL) { int32_t num = 0; @@ -906,7 +906,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition pOperator->exprSupp.pExprInfo = pExprInfo; pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -1111,7 +1111,7 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; { pInfo->pInputDataBlock = NULL; - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { setOperatorCompleted(pOperator); return NULL; @@ -1248,7 +1248,7 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr goto _error; } - pInfo->partitionSup.pGroupCols = extractPartitionColInfo(pPartNode->part.pPartitionKeys); + pInfo->partitionSup.pGroupCols = makeColumnArrayFromList(pPartNode->part.pPartitionKeys); if (pPartNode->part.pExprs != NULL) { int32_t num = 0; @@ -1328,7 +1328,7 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr pOperator->exprSupp.numOfExprs = numOfCols; pOperator->exprSupp.pExprInfo = pExprInfo; pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamHashPartition, NULL, - destroyStreamPartitionOperatorInfo, optrDefaultBufFn, NULL); + destroyStreamPartitionOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState); initParDownStream(downstream, &pInfo->partitionSup, &pInfo->scalarSup); diff --git a/source/libs/executor/src/hashjoinoperator.c b/source/libs/executor/src/hashjoinoperator.c new file mode 100755 index 0000000000..d57f9f9f90 --- /dev/null +++ b/source/libs/executor/src/hashjoinoperator.c @@ -0,0 +1,917 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "executorInt.h" +#include "filter.h" +#include "function.h" +#include "operator.h" +#include "os.h" +#include "querynodes.h" +#include "querytask.h" +#include "tcompare.h" +#include "tdatablock.h" +#include "thash.h" +#include "tmsg.h" +#include "ttypes.h" +#include "hashjoin.h" + + +static int64_t getSingleKeyRowsNum(SBufRowInfo* pRow) { + int64_t rows = 0; + while (pRow) { + rows++; + pRow = pRow->next; + } + return rows; +} + +static int64_t getRowsNumOfKeyHash(SSHashObj* pHash) { + SGroupData* pGroup = NULL; + int32_t iter = 0; + int64_t rowsNum = 0; + + while (NULL != (pGroup = tSimpleHashIterate(pHash, pGroup, &iter))) { + int32_t* pKey = tSimpleHashGetKey(pGroup, NULL); + int64_t rows = getSingleKeyRowsNum(pGroup->rows); + qTrace("build_key:%d, rows:%" PRId64, *pKey, rows); + rowsNum += rows; + } + + return rowsNum; +} + +static int32_t initHJoinKeyColsInfo(SHJoinTableInfo* pTable, SNodeList* pList) { + pTable->keyNum = LIST_LENGTH(pList); + + pTable->keyCols = taosMemoryMalloc(pTable->keyNum * sizeof(SHJoinColInfo)); + if (NULL == pTable->keyCols) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + int64_t bufSize = 0; + int32_t i = 0; + SNode* pNode = NULL; + FOREACH(pNode, pList) { + SColumnNode* pColNode = (SColumnNode*)pNode; + pTable->keyCols[i].srcSlot = pColNode->slotId; + pTable->keyCols[i].vardata = IS_VAR_DATA_TYPE(pColNode->node.resType.type); + pTable->keyCols[i].bytes = pColNode->node.resType.bytes; + bufSize += pColNode->node.resType.bytes; + ++i; + } + + if (pTable->keyNum > 1) { + pTable->keyBuf = taosMemoryMalloc(bufSize); + if (NULL == pTable->keyBuf) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + return TSDB_CODE_SUCCESS; +} + +static void getHJoinValColNum(SNodeList* pList, int32_t blkId, int32_t* colNum) { + *colNum = 0; + + SNode* pNode = NULL; + FOREACH(pNode, pList) { + STargetNode* pTarget = (STargetNode*)pNode; + SColumnNode* pCol = (SColumnNode*)pTarget->pExpr; + if (pCol->dataBlockId == blkId) { + (*colNum)++; + } + } +} + +static bool valColInKeyCols(int16_t slotId, int32_t keyNum, SHJoinColInfo* pKeys, int32_t* pKeyIdx) { + for (int32_t i = 0; i < keyNum; ++i) { + if (pKeys[i].srcSlot == slotId) { + *pKeyIdx = i; + return true; + } + } + + return false; +} + +static int32_t initJoinValColsInfo(SHJoinTableInfo* pTable, SNodeList* pList) { + getHJoinValColNum(pList, pTable->blkId, &pTable->valNum); + if (pTable->valNum == 0) { + return TSDB_CODE_SUCCESS; + } + + pTable->valCols = taosMemoryMalloc(pTable->valNum * sizeof(SHJoinColInfo)); + if (NULL == pTable->valCols) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + int32_t i = 0; + int32_t colNum = 0; + SNode* pNode = NULL; + FOREACH(pNode, pList) { + STargetNode* pTarget = (STargetNode*)pNode; + SColumnNode* pColNode = (SColumnNode*)pTarget->pExpr; + if (pColNode->dataBlockId == pTable->blkId) { + if (valColInKeyCols(pColNode->slotId, pTable->keyNum, pTable->keyCols, &pTable->valCols[i].srcSlot)) { + pTable->valCols[i].keyCol = true; + } else { + pTable->valCols[i].keyCol = false; + pTable->valCols[i].srcSlot = pColNode->slotId; + pTable->valColExist = true; + colNum++; + } + pTable->valCols[i].dstSlot = pTarget->slotId; + pTable->valCols[i].vardata = IS_VAR_DATA_TYPE(pColNode->node.resType.type); + if (pTable->valCols[i].vardata) { + if (NULL == pTable->valVarCols) { + pTable->valVarCols = taosArrayInit(pTable->valNum, sizeof(int32_t)); + if (NULL == pTable->valVarCols) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + taosArrayPush(pTable->valVarCols, &i); + } + pTable->valCols[i].bytes = pColNode->node.resType.bytes; + if (!pTable->valCols[i].keyCol && !pTable->valCols[i].vardata) { + pTable->valBufSize += pColNode->node.resType.bytes; + } + i++; + } + } + + pTable->valBitMapSize = BitmapLen(colNum); + pTable->valBufSize += pTable->valBitMapSize; + + return TSDB_CODE_SUCCESS; +} + + +static int32_t initHJoinTableInfo(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinNode, SOperatorInfo** pDownstream, int32_t idx, SQueryStat* pStat) { + SNodeList* pKeyList = NULL; + SHJoinTableInfo* pTable = &pJoin->tbs[idx]; + pTable->downStream = pDownstream[idx]; + pTable->blkId = pDownstream[idx]->resultDataBlockId; + if (0 == idx) { + pKeyList = pJoinNode->pOnLeft; + } else { + pKeyList = pJoinNode->pOnRight; + } + + int32_t code = initHJoinKeyColsInfo(pTable, pKeyList); + if (code) { + return code; + } + code = initJoinValColsInfo(pTable, pJoinNode->pTargets); + if (code) { + return code; + } + + memcpy(&pTable->inputStat, pStat, sizeof(*pStat)); + + return TSDB_CODE_SUCCESS; +} + +static void setHJoinBuildAndProbeTable(SHJoinOperatorInfo* pInfo, SHashJoinPhysiNode* pJoinNode) { + int32_t buildIdx = 0; + int32_t probeIdx = 1; + + pInfo->joinType = pJoinNode->joinType; + + switch (pInfo->joinType) { + case JOIN_TYPE_INNER: + if (pInfo->tbs[0].inputStat.inputRowNum <= pInfo->tbs[1].inputStat.inputRowNum) { + buildIdx = 0; + probeIdx = 1; + } else { + buildIdx = 1; + probeIdx = 0; + } + break; + case JOIN_TYPE_LEFT: + buildIdx = 1; + probeIdx = 0; + break; + case JOIN_TYPE_RIGHT: + buildIdx = 0; + probeIdx = 1; + break; + default: + break; + } + + pInfo->pBuild = &pInfo->tbs[buildIdx]; + pInfo->pProbe = &pInfo->tbs[probeIdx]; + + pInfo->pBuild->downStreamIdx = buildIdx; + pInfo->pProbe->downStreamIdx = probeIdx; +} + +static int32_t buildHJoinResColMap(SHJoinOperatorInfo* pInfo, SHashJoinPhysiNode* pJoinNode) { + pInfo->pResColNum = pJoinNode->pTargets->length; + pInfo->pResColMap = taosMemoryCalloc(pJoinNode->pTargets->length, sizeof(int8_t)); + if (NULL == pInfo->pResColMap) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + SNode* pNode = NULL; + int32_t i = 0; + FOREACH(pNode, pJoinNode->pTargets) { + STargetNode* pTarget = (STargetNode*)pNode; + SColumnNode* pCol = (SColumnNode*)pTarget->pExpr; + if (pCol->dataBlockId == pInfo->pBuild->blkId) { + pInfo->pResColMap[i] = 1; + } + + i++; + } + + return TSDB_CODE_SUCCESS; +} + + +static FORCE_INLINE int32_t addPageToHJoinBuf(SArray* pRowBufs) { + SBufPageInfo page; + page.pageSize = HASH_JOIN_DEFAULT_PAGE_SIZE; + page.offset = 0; + page.data = taosMemoryMalloc(page.pageSize); + if (NULL == page.data) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + taosArrayPush(pRowBufs, &page); + return TSDB_CODE_SUCCESS; +} + +static int32_t initHJoinBufPages(SHJoinOperatorInfo* pInfo) { + pInfo->pRowBufs = taosArrayInit(32, sizeof(SBufPageInfo)); + if (NULL == pInfo->pRowBufs) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + return addPageToHJoinBuf(pInfo->pRowBufs); +} + +static void freeHJoinTableInfo(SHJoinTableInfo* pTable) { + taosMemoryFreeClear(pTable->keyCols); + taosMemoryFreeClear(pTable->keyBuf); + taosMemoryFreeClear(pTable->valCols); + taosArrayDestroy(pTable->valVarCols); +} + +static void freeHJoinBufPage(void* param) { + SBufPageInfo* pInfo = (SBufPageInfo*)param; + taosMemoryFree(pInfo->data); +} + +static void destroyHJoinKeyHash(SSHashObj** ppHash) { + if (NULL == ppHash || NULL == (*ppHash)) { + return; + } + + void* pIte = NULL; + int32_t iter = 0; + while ((pIte = tSimpleHashIterate(*ppHash, pIte, &iter)) != NULL) { + SGroupData* pGroup = pIte; + SBufRowInfo* pRow = pGroup->rows; + SBufRowInfo* pNext = NULL; + while (pRow) { + pNext = pRow->next; + taosMemoryFree(pRow); + pRow = pNext; + } + } + + tSimpleHashCleanup(*ppHash); + *ppHash = NULL; +} + +static void destroyHashJoinOperator(void* param) { + SHJoinOperatorInfo* pJoinOperator = (SHJoinOperatorInfo*)param; + qError("hashJoin exec info, buildBlk:%" PRId64 ", buildRows:%" PRId64 ", probeBlk:%" PRId64 ", probeRows:%" PRId64 ", resRows:%" PRId64, + pJoinOperator->execInfo.buildBlkNum, pJoinOperator->execInfo.buildBlkRows, pJoinOperator->execInfo.probeBlkNum, + pJoinOperator->execInfo.probeBlkRows, pJoinOperator->execInfo.resRows); + + destroyHJoinKeyHash(&pJoinOperator->pKeyHash); + + freeHJoinTableInfo(&pJoinOperator->tbs[0]); + freeHJoinTableInfo(&pJoinOperator->tbs[1]); + pJoinOperator->pRes = blockDataDestroy(pJoinOperator->pRes); + taosMemoryFreeClear(pJoinOperator->pResColMap); + taosArrayDestroyEx(pJoinOperator->pRowBufs, freeHJoinBufPage); + nodesDestroyNode(pJoinOperator->pCond); + + taosMemoryFreeClear(param); +} + +static FORCE_INLINE char* retrieveColDataFromRowBufs(SArray* pRowBufs, SBufRowInfo* pRow) { + SBufPageInfo *pPage = taosArrayGet(pRowBufs, pRow->pageId); + return pPage->data + pRow->offset; +} + +static FORCE_INLINE int32_t copyHJoinResRowsToBlock(SHJoinOperatorInfo* pJoin, int32_t rowNum, SBufRowInfo* pStart, SSDataBlock* pRes) { + SHJoinTableInfo* pBuild = pJoin->pBuild; + SHJoinTableInfo* pProbe = pJoin->pProbe; + int32_t buildIdx = 0, buildValIdx = 0; + int32_t probeIdx = 0; + SBufRowInfo* pRow = pStart; + int32_t code = 0; + + for (int32_t r = 0; r < rowNum; ++r) { + char* pData = retrieveColDataFromRowBufs(pJoin->pRowBufs, pRow); + char* pValData = pData + pBuild->valBitMapSize; + char* pKeyData = pProbe->keyData; + buildIdx = buildValIdx = probeIdx = 0; + for (int32_t i = 0; i < pJoin->pResColNum; ++i) { + if (pJoin->pResColMap[i]) { + SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pBuild->valCols[buildIdx].dstSlot); + if (pBuild->valCols[buildIdx].keyCol) { + code = colDataSetVal(pDst, pRes->info.rows + r, pKeyData, false); + if (code) { + return code; + } + pKeyData += pBuild->valCols[buildIdx].vardata ? varDataTLen(pKeyData) : pBuild->valCols[buildIdx].bytes; + } else { + if (colDataIsNull_f(pData, buildValIdx)) { + code = colDataSetVal(pDst, pRes->info.rows + r, NULL, true); + if (code) { + return code; + } + } else { + code = colDataSetVal(pDst, pRes->info.rows + r, pValData, false); + if (code) { + return code; + } + pValData += pBuild->valCols[buildIdx].vardata ? varDataTLen(pValData) : pBuild->valCols[buildIdx].bytes; + } + buildValIdx++; + } + buildIdx++; + } else if (0 == r) { + SColumnInfoData* pSrc = taosArrayGet(pJoin->ctx.pProbeData->pDataBlock, pProbe->valCols[probeIdx].srcSlot); + SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pProbe->valCols[probeIdx].dstSlot); + + code = colDataCopyNItems(pDst, pRes->info.rows, colDataGetData(pSrc, pJoin->ctx.probeIdx), rowNum, colDataIsNull_s(pSrc, pJoin->ctx.probeIdx)); + if (code) { + return code; + } + probeIdx++; + } + } + pRow = pRow->next; + } + + return TSDB_CODE_SUCCESS; +} + + +static FORCE_INLINE void appendHJoinResToBlock(struct SOperatorInfo* pOperator, SSDataBlock* pRes, bool* allFetched) { + SHJoinOperatorInfo* pJoin = pOperator->info; + SHJoinCtx* pCtx = &pJoin->ctx; + SBufRowInfo* pStart = pCtx->pBuildRow; + int32_t rowNum = 0; + int32_t resNum = pRes->info.rows; + + while (pCtx->pBuildRow && (resNum < pRes->info.capacity)) { + rowNum++; + resNum++; + pCtx->pBuildRow = pCtx->pBuildRow->next; + } + + pJoin->execInfo.resRows += rowNum; + + int32_t code = copyHJoinResRowsToBlock(pJoin, rowNum, pStart, pRes); + if (code) { + pOperator->pTaskInfo->code = code; + T_LONG_JMP(pOperator->pTaskInfo->env, code); + } + + pRes->info.rows = resNum; + *allFetched = pCtx->pBuildRow ? false : true; +} + + +static FORCE_INLINE void copyKeyColsDataToBuf(SHJoinTableInfo* pTable, int32_t rowIdx, size_t *pBufLen) { + char *pData = NULL; + size_t bufLen = 0; + + if (1 == pTable->keyNum) { + if (pTable->keyCols[0].vardata) { + pData = pTable->keyCols[0].data + pTable->keyCols[0].offset[rowIdx]; + bufLen = varDataTLen(pData); + } else { + pData = pTable->keyCols[0].data + pTable->keyCols[0].bytes * rowIdx; + bufLen = pTable->keyCols[0].bytes; + } + pTable->keyData = pData; + } else { + for (int32_t i = 0; i < pTable->keyNum; ++i) { + if (pTable->keyCols[i].vardata) { + pData = pTable->keyCols[i].data + pTable->keyCols[i].offset[rowIdx]; + memcpy(pTable->keyBuf + bufLen, pData, varDataTLen(pData)); + bufLen += varDataTLen(pData); + } else { + pData = pTable->keyCols[i].data + pTable->keyCols[i].bytes * rowIdx; + memcpy(pTable->keyBuf + bufLen, pData, pTable->keyCols[i].bytes); + bufLen += pTable->keyCols[i].bytes; + } + } + pTable->keyData = pTable->keyBuf; + } + + if (pBufLen) { + *pBufLen = bufLen; + } +} + + +static void doHashJoinImpl(struct SOperatorInfo* pOperator) { + SHJoinOperatorInfo* pJoin = pOperator->info; + SHJoinTableInfo* pProbe = pJoin->pProbe; + SHJoinCtx* pCtx = &pJoin->ctx; + SSDataBlock* pRes = pJoin->pRes; + size_t bufLen = 0; + bool allFetched = false; + + if (pJoin->ctx.pBuildRow) { + appendHJoinResToBlock(pOperator, pRes, &allFetched); + if (pRes->info.rows >= pRes->info.capacity) { + if (allFetched) { + ++pCtx->probeIdx; + } + + return; + } else { + ++pCtx->probeIdx; + } + } + + for (; pCtx->probeIdx < pCtx->pProbeData->info.rows; ++pCtx->probeIdx) { + copyKeyColsDataToBuf(pProbe, pCtx->probeIdx, &bufLen); + SGroupData* pGroup = tSimpleHashGet(pJoin->pKeyHash, pProbe->keyData, bufLen); +/* + size_t keySize = 0; + int32_t* pKey = tSimpleHashGetKey(pGroup, &keySize); + ASSERT(keySize == bufLen && 0 == memcmp(pKey, pProbe->keyData, bufLen)); + int64_t rows = getSingleKeyRowsNum(pGroup->rows); + pJoin->execInfo.expectRows += rows; + qTrace("hash_key:%d, rows:%" PRId64, *pKey, rows); +*/ + if (pGroup) { + pCtx->pBuildRow = pGroup->rows; + appendHJoinResToBlock(pOperator, pRes, &allFetched); + if (pRes->info.rows >= pRes->info.capacity) { + if (allFetched) { + ++pCtx->probeIdx; + } + + return; + } + } else { + qTrace("no key matched"); + } + } + + pCtx->rowRemains = false; +} + +static int32_t setKeyColsData(SSDataBlock* pBlock, SHJoinTableInfo* pTable) { + for (int32_t i = 0; i < pTable->keyNum; ++i) { + SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, pTable->keyCols[i].srcSlot); + if (pTable->keyCols[i].vardata != IS_VAR_DATA_TYPE(pCol->info.type)) { + qError("column type mismatch, idx:%d, slotId:%d, type:%d, vardata:%d", i, pTable->keyCols[i].srcSlot, pCol->info.type, pTable->keyCols[i].vardata); + return TSDB_CODE_INVALID_PARA; + } + if (pTable->keyCols[i].bytes != pCol->info.bytes) { + qError("column bytes mismatch, idx:%d, slotId:%d, bytes:%d, %d", i, pTable->keyCols[i].srcSlot, pCol->info.bytes, pTable->keyCols[i].bytes); + return TSDB_CODE_INVALID_PARA; + } + pTable->keyCols[i].data = pCol->pData; + if (pTable->keyCols[i].vardata) { + pTable->keyCols[i].offset = pCol->varmeta.offset; + } + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t setValColsData(SSDataBlock* pBlock, SHJoinTableInfo* pTable) { + if (!pTable->valColExist) { + return TSDB_CODE_SUCCESS; + } + for (int32_t i = 0; i < pTable->valNum; ++i) { + if (pTable->valCols[i].keyCol) { + continue; + } + SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, pTable->valCols[i].srcSlot); + if (pTable->valCols[i].vardata != IS_VAR_DATA_TYPE(pCol->info.type)) { + qError("column type mismatch, idx:%d, slotId:%d, type:%d, vardata:%d", i, pTable->valCols[i].srcSlot, pCol->info.type, pTable->valCols[i].vardata); + return TSDB_CODE_INVALID_PARA; + } + if (pTable->valCols[i].bytes != pCol->info.bytes) { + qError("column bytes mismatch, idx:%d, slotId:%d, bytes:%d, %d", i, pTable->valCols[i].srcSlot, pCol->info.bytes, pTable->valCols[i].bytes); + return TSDB_CODE_INVALID_PARA; + } + if (!pTable->valCols[i].vardata) { + pTable->valCols[i].bitMap = pCol->nullbitmap; + } + pTable->valCols[i].data = pCol->pData; + if (pTable->valCols[i].vardata) { + pTable->valCols[i].offset = pCol->varmeta.offset; + } + } + + return TSDB_CODE_SUCCESS; +} + + + +static FORCE_INLINE void copyValColsDataToBuf(SHJoinTableInfo* pTable, int32_t rowIdx) { + if (!pTable->valColExist) { + return; + } + + char *pData = NULL; + size_t bufLen = pTable->valBitMapSize; + memset(pTable->valData, 0, pTable->valBitMapSize); + for (int32_t i = 0, m = 0; i < pTable->valNum; ++i) { + if (pTable->valCols[i].keyCol) { + continue; + } + if (pTable->valCols[i].vardata) { + if (-1 == pTable->valCols[i].offset[rowIdx]) { + colDataSetNull_f(pTable->valData, m); + } else { + pData = pTable->valCols[i].data + pTable->valCols[i].offset[rowIdx]; + memcpy(pTable->valData + bufLen, pData, varDataTLen(pData)); + bufLen += varDataTLen(pData); + } + } else { + if (colDataIsNull_f(pTable->valCols[i].bitMap, rowIdx)) { + colDataSetNull_f(pTable->valData, m); + } else { + pData = pTable->valCols[i].data + pTable->valCols[i].bytes * rowIdx; + memcpy(pTable->valData + bufLen, pData, pTable->valCols[i].bytes); + bufLen += pTable->valCols[i].bytes; + } + } + m++; + } +} + + +static FORCE_INLINE int32_t getValBufFromPages(SArray* pPages, int32_t bufSize, char** pBuf, SBufRowInfo* pRow) { + if (0 == bufSize) { + pRow->pageId = -1; + return TSDB_CODE_SUCCESS; + } + + if (bufSize > HASH_JOIN_DEFAULT_PAGE_SIZE) { + qError("invalid join value buf size:%d", bufSize); + return TSDB_CODE_INVALID_PARA; + } + + do { + SBufPageInfo* page = taosArrayGetLast(pPages); + if ((page->pageSize - page->offset) >= bufSize) { + *pBuf = page->data + page->offset; + pRow->pageId = taosArrayGetSize(pPages) - 1; + pRow->offset = page->offset; + page->offset += bufSize; + return TSDB_CODE_SUCCESS; + } + + int32_t code = addPageToHJoinBuf(pPages); + if (code) { + return code; + } + } while (true); +} + +static FORCE_INLINE int32_t getHJoinValBufSize(SHJoinTableInfo* pTable, int32_t rowIdx) { + if (NULL == pTable->valVarCols) { + return pTable->valBufSize; + } + + int32_t* varColIdx = NULL; + int32_t bufLen = pTable->valBufSize; + int32_t varColNum = taosArrayGetSize(pTable->valVarCols); + for (int32_t i = 0; i < varColNum; ++i) { + varColIdx = taosArrayGet(pTable->valVarCols, i); + char* pData = pTable->valCols[*varColIdx].data + pTable->valCols[*varColIdx].offset[rowIdx]; + bufLen += varDataTLen(pData); + } + + return bufLen; +} + + +static int32_t addRowToHashImpl(SHJoinOperatorInfo* pJoin, SGroupData* pGroup, SHJoinTableInfo* pTable, size_t keyLen, int32_t rowIdx) { + SGroupData group = {0}; + SBufRowInfo* pRow = NULL; + + if (NULL == pGroup) { + group.rows = taosMemoryMalloc(sizeof(SBufRowInfo)); + if (NULL == group.rows) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pRow = group.rows; + } else { + pRow = taosMemoryMalloc(sizeof(SBufRowInfo)); + if (NULL == pRow) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + int32_t code = getValBufFromPages(pJoin->pRowBufs, getHJoinValBufSize(pTable, rowIdx), &pTable->valData, pRow); + if (code) { + return code; + } + + if (NULL == pGroup) { + pRow->next = NULL; + if (tSimpleHashPut(pJoin->pKeyHash, pTable->keyData, keyLen, &group, sizeof(group))) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } else { + pRow->next = pGroup->rows; + pGroup->rows = pRow; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t addRowToHash(SHJoinOperatorInfo* pJoin, SSDataBlock* pBlock, size_t keyLen, int32_t rowIdx) { + SHJoinTableInfo* pBuild = pJoin->pBuild; + int32_t code = setValColsData(pBlock, pBuild); + if (code) { + return code; + } + + SGroupData* pGroup = tSimpleHashGet(pJoin->pKeyHash, pBuild->keyData, keyLen); + code = addRowToHashImpl(pJoin, pGroup, pBuild, keyLen, rowIdx); + if (code) { + return code; + } + + copyValColsDataToBuf(pBuild, rowIdx); + + return TSDB_CODE_SUCCESS; +} + +static int32_t addBlockRowsToHash(SSDataBlock* pBlock, SHJoinOperatorInfo* pJoin) { + SHJoinTableInfo* pBuild = pJoin->pBuild; + int32_t code = setKeyColsData(pBlock, pBuild); + if (code) { + return code; + } + + size_t bufLen = 0; + for (int32_t i = 0; i < pBlock->info.rows; ++i) { + copyKeyColsDataToBuf(pBuild, i, &bufLen); + code = addRowToHash(pJoin, pBlock, bufLen, i); + if (code) { + return code; + } + } + + return code; +} + +static int32_t buildHJoinKeyHash(struct SOperatorInfo* pOperator) { + SHJoinOperatorInfo* pJoin = pOperator->info; + SSDataBlock* pBlock = NULL; + int32_t code = TSDB_CODE_SUCCESS; + + while (true) { + pBlock = getNextBlockFromDownstream(pOperator, pJoin->pBuild->downStreamIdx); + if (NULL == pBlock) { + break; + } + + pJoin->execInfo.buildBlkNum++; + pJoin->execInfo.buildBlkRows += pBlock->info.rows; + + code = addBlockRowsToHash(pBlock, pJoin); + if (code) { + return code; + } + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t launchBlockHashJoin(struct SOperatorInfo* pOperator, SSDataBlock* pBlock) { + SHJoinOperatorInfo* pJoin = pOperator->info; + SHJoinTableInfo* pProbe = pJoin->pProbe; + int32_t code = setKeyColsData(pBlock, pProbe); + if (code) { + return code; + } + code = setValColsData(pBlock, pProbe); + if (code) { + return code; + } + + pJoin->ctx.probeIdx = 0; + pJoin->ctx.pBuildRow = NULL; + pJoin->ctx.pProbeData = pBlock; + pJoin->ctx.rowRemains = true; + + doHashJoinImpl(pOperator); + + return TSDB_CODE_SUCCESS; +} + +static void setHJoinDone(struct SOperatorInfo* pOperator) { + setOperatorCompleted(pOperator); + + SHJoinOperatorInfo* pInfo = pOperator->info; + destroyHJoinKeyHash(&pInfo->pKeyHash); + + qError("hash Join done"); +} + +static SSDataBlock* doHashJoin(struct SOperatorInfo* pOperator) { + SHJoinOperatorInfo* pJoin = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + int32_t code = TSDB_CODE_SUCCESS; + SSDataBlock* pRes = pJoin->pRes; + pRes->info.rows = 0; + int64_t st = 0; + + if (pOperator->cost.openCost == 0) { + st = taosGetTimestampUs(); + } + + if (pOperator->status == OP_EXEC_DONE) { + goto _return; + } + + if (!pJoin->keyHashBuilt) { + pJoin->keyHashBuilt = true; + + code = buildHJoinKeyHash(pOperator); + if (code) { + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + + if (tSimpleHashGetSize(pJoin->pKeyHash) <= 0) { + setHJoinDone(pOperator); + goto _return; + } + + //qTrace("build table rows:%" PRId64, getRowsNumOfKeyHash(pJoin->pKeyHash)); + } + + if (pJoin->ctx.rowRemains) { + doHashJoinImpl(pOperator); + + if (pRes->info.rows >= pRes->info.capacity && pOperator->exprSupp.pFilterInfo != NULL) { + doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + } + if (pRes->info.rows > 0) { + return pRes; + } + } + + while (true) { + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, pJoin->pProbe->downStreamIdx); + if (NULL == pBlock) { + setHJoinDone(pOperator); + break; + } + + pJoin->execInfo.probeBlkNum++; + pJoin->execInfo.probeBlkRows += pBlock->info.rows; + + code = launchBlockHashJoin(pOperator, pBlock); + if (code) { + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + + if (pRes->info.rows < pOperator->resultInfo.threshold) { + continue; + } + + if (pOperator->exprSupp.pFilterInfo != NULL) { + doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + } + if (pRes->info.rows > 0) { + break; + } + } + +_return: + + if (pOperator->cost.openCost == 0) { + pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; + } + + return (pRes->info.rows > 0) ? pRes : NULL; +} + +SOperatorInfo* createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo) { + SHJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SHJoinOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + + int32_t code = TSDB_CODE_SUCCESS; + if (pOperator == NULL || pInfo == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + + int32_t numOfCols = 0; + pInfo->pRes = createDataBlockFromDescNode(pJoinNode->node.pOutputDataBlockDesc); + initResultSizeInfo(&pOperator->resultInfo, 4096); + blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + + setOperatorInfo(pOperator, "HashJoinOperator", QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN, false, OP_NOT_OPENED, pInfo, pTaskInfo); + + initHJoinTableInfo(pInfo, pJoinNode, pDownstream, 0, &pJoinNode->inputStat[0]); + initHJoinTableInfo(pInfo, pJoinNode, pDownstream, 1, &pJoinNode->inputStat[1]); + + setHJoinBuildAndProbeTable(pInfo, pJoinNode); + code = buildHJoinResColMap(pInfo, pJoinNode); + if (code) { + goto _error; + } + + code = initHJoinBufPages(pInfo); + if (code) { + goto _error; + } + + size_t hashCap = pInfo->pBuild->inputStat.inputRowNum > 0 ? (pInfo->pBuild->inputStat.inputRowNum * 1.5) : 1024; + pInfo->pKeyHash = tSimpleHashInit(hashCap, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY)); + if (pInfo->pKeyHash == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + + if (pJoinNode->pFilterConditions != NULL && pJoinNode->node.pConditions != NULL) { + pInfo->pCond = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + if (pInfo->pCond == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + + SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(pInfo->pCond); + pLogicCond->pParameterList = nodesMakeList(); + if (pLogicCond->pParameterList == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + + nodesListMakeAppend(&pLogicCond->pParameterList, nodesCloneNode(pJoinNode->pFilterConditions)); + nodesListMakeAppend(&pLogicCond->pParameterList, nodesCloneNode(pJoinNode->node.pConditions)); + pLogicCond->condType = LOGIC_COND_TYPE_AND; + } else if (pJoinNode->pFilterConditions != NULL) { + pInfo->pCond = nodesCloneNode(pJoinNode->pFilterConditions); + } else if (pJoinNode->node.pConditions != NULL) { + pInfo->pCond = nodesCloneNode(pJoinNode->node.pConditions); + } else { + pInfo->pCond = NULL; + } + + code = filterInitFromNode(pInfo->pCond, &pOperator->exprSupp.pFilterInfo, 0); + if (code != TSDB_CODE_SUCCESS) { + goto _error; + } + + code = appendDownstream(pOperator, pDownstream, numOfDownstream); + if (code != TSDB_CODE_SUCCESS) { + goto _error; + } + + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doHashJoin, NULL, destroyHashJoinOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + + qError("create hash Join operator done"); + + return pOperator; + +_error: + if (pInfo != NULL) { + destroyHashJoinOperator(pInfo); + } + + taosMemoryFree(pOperator); + pTaskInfo->code = code; + return NULL; +} + + diff --git a/source/libs/executor/src/joinoperator.c b/source/libs/executor/src/mergejoinoperator.c similarity index 76% rename from source/libs/executor/src/joinoperator.c rename to source/libs/executor/src/mergejoinoperator.c index f334ae02f6..1b286f9bdd 100644 --- a/source/libs/executor/src/joinoperator.c +++ b/source/libs/executor/src/mergejoinoperator.c @@ -26,7 +26,7 @@ #include "tmsg.h" #include "ttypes.h" -typedef struct SJoinRowCtx { +typedef struct SMJoinRowCtx { bool rowRemains; int64_t ts; SArray* leftRowLocations; @@ -37,12 +37,15 @@ typedef struct SJoinRowCtx { bool rightUseBuildTable; SArray* rightRowLocations; -} SJoinRowCtx; +} SMJoinRowCtx; -typedef struct SJoinOperatorInfo { +typedef struct SMJoinOperatorInfo { SSDataBlock* pRes; int32_t joinType; int32_t inputOrder; + bool downstreamInitDone[2]; + bool downstreamFetchDone[2]; + int16_t downstreamResBlkId[2]; SSDataBlock* pLeft; int32_t leftPos; @@ -63,24 +66,24 @@ typedef struct SJoinOperatorInfo { int32_t rightEqOnCondKeyLen; SSHashObj* rightBuildTable; - SJoinRowCtx rowCtx; -} SJoinOperatorInfo; + SMJoinRowCtx rowCtx; + + int64_t resRows; +} SMJoinOperatorInfo; static void setJoinColumnInfo(SColumnInfo* pColumn, const SColumnNode* pColumnNode); static SSDataBlock* doMergeJoin(struct SOperatorInfo* pOperator); static void destroyMergeJoinOperator(void* param); -static void extractTimeCondition(SJoinOperatorInfo* pInfo, SOperatorInfo** pDownstream, int32_t num, - SSortMergeJoinPhysiNode* pJoinNode, const char* idStr); +static void extractTimeCondition(SMJoinOperatorInfo* pInfo, SSortMergeJoinPhysiNode* pJoinNode, const char* idStr); -static void extractTimeCondition(SJoinOperatorInfo* pInfo, SOperatorInfo** pDownstream, int32_t num, - SSortMergeJoinPhysiNode* pJoinNode, const char* idStr) { - SNode* pMergeCondition = pJoinNode->pMergeCondition; - if (nodeType(pMergeCondition) != QUERY_NODE_OPERATOR) { +static void extractTimeCondition(SMJoinOperatorInfo* pInfo, SSortMergeJoinPhysiNode* pJoinNode, const char* idStr) { + SNode* pPrimKeyCond = pJoinNode->pPrimKeyCond; + if (nodeType(pPrimKeyCond) != QUERY_NODE_OPERATOR) { qError("not support this in join operator, %s", idStr); return; // do not handle this } - SOperatorNode* pNode = (SOperatorNode*)pMergeCondition; + SOperatorNode* pNode = (SOperatorNode*)pPrimKeyCond; SColumnNode* col1 = (SColumnNode*)pNode->pLeft; SColumnNode* col2 = (SColumnNode*)pNode->pRight; SColumnNode* leftTsCol = NULL; @@ -89,13 +92,13 @@ static void extractTimeCondition(SJoinOperatorInfo* pInfo, SOperatorInfo** pDown leftTsCol = col1; rightTsCol = col2; } else { - if (col1->dataBlockId == pDownstream[0]->resultDataBlockId) { - ASSERT(col2->dataBlockId == pDownstream[1]->resultDataBlockId); + if (col1->dataBlockId == pInfo->downstreamResBlkId[0]) { + ASSERT(col2->dataBlockId == pInfo->downstreamResBlkId[1]); leftTsCol = col1; rightTsCol = col2; } else { - ASSERT(col1->dataBlockId == pDownstream[1]->resultDataBlockId); - ASSERT(col2->dataBlockId == pDownstream[0]->resultDataBlockId); + ASSERT(col1->dataBlockId == pInfo->downstreamResBlkId[1]); + ASSERT(col2->dataBlockId == pInfo->downstreamResBlkId[0]); leftTsCol = col2; rightTsCol = col1; } @@ -104,11 +107,11 @@ static void extractTimeCondition(SJoinOperatorInfo* pInfo, SOperatorInfo** pDown setJoinColumnInfo(&pInfo->rightCol, rightTsCol); } -static void extractEqualOnCondColsFromOper(SJoinOperatorInfo* pInfo, SOperatorInfo** pDownstreams, SOperatorNode* pOperNode, +static void extractEqualOnCondColsFromOper(SMJoinOperatorInfo* pInfo, SOperatorNode* pOperNode, SColumn* pLeft, SColumn* pRight) { SColumnNode* pLeftNode = (SColumnNode*)pOperNode->pLeft; SColumnNode* pRightNode = (SColumnNode*)pOperNode->pRight; - if (pLeftNode->dataBlockId == pRightNode->dataBlockId || pLeftNode->dataBlockId == pDownstreams[0]->resultDataBlockId) { + if (pLeftNode->dataBlockId == pRightNode->dataBlockId || pLeftNode->dataBlockId == pInfo->downstreamResBlkId[0]) { *pLeft = extractColumnFromColumnNode((SColumnNode*)pOperNode->pLeft); *pRight = extractColumnFromColumnNode((SColumnNode*)pOperNode->pRight); } else { @@ -117,7 +120,7 @@ static void extractEqualOnCondColsFromOper(SJoinOperatorInfo* pInfo, SOperatorIn } } -static void extractEqualOnCondCols(SJoinOperatorInfo* pInfo, SOperatorInfo** pDownStream, SNode* pEqualOnCondNode, +static void extractEqualOnCondCols(SMJoinOperatorInfo* pInfo, SNode* pEqualOnCondNode, SArray* leftTagEqCols, SArray* rightTagEqCols) { SColumn left = {0}; SColumn right = {0}; @@ -125,7 +128,7 @@ static void extractEqualOnCondCols(SJoinOperatorInfo* pInfo, SOperatorInfo** pDo SNode* pNode = NULL; FOREACH(pNode, ((SLogicConditionNode*)pEqualOnCondNode)->pParameterList) { SOperatorNode* pOperNode = (SOperatorNode*)pNode; - extractEqualOnCondColsFromOper(pInfo, pDownStream, pOperNode, &left, &right); + extractEqualOnCondColsFromOper(pInfo, pOperNode, &left, &right); taosArrayPush(leftTagEqCols, &left); taosArrayPush(rightTagEqCols, &right); } @@ -134,7 +137,7 @@ static void extractEqualOnCondCols(SJoinOperatorInfo* pInfo, SOperatorInfo** pDo if (nodeType(pEqualOnCondNode) == QUERY_NODE_OPERATOR) { SOperatorNode* pOperNode = (SOperatorNode*)pEqualOnCondNode; - extractEqualOnCondColsFromOper(pInfo, pDownStream, pOperNode, &left, &right); + extractEqualOnCondColsFromOper(pInfo, pOperNode, &left, &right); taosArrayPush(leftTagEqCols, &left); taosArrayPush(rightTagEqCols, &right); } @@ -201,17 +204,44 @@ static int32_t fillKeyBufFromTagCols(SArray* pCols, SSDataBlock* pBlock, int32_t return (int32_t)(pStart - (char*)pKey); } +SOperatorInfo** buildMergeJoinDownstreams(SMJoinOperatorInfo* pInfo, SOperatorInfo** pDownstream) { + SOperatorInfo** p = taosMemoryMalloc(2 * POINTER_BYTES); + if (p) { + p[0] = pDownstream[0]; + p[1] = pDownstream[0]; + pInfo->downstreamResBlkId[0] = getOperatorResultBlockId(p[0], 0); + pInfo->downstreamResBlkId[1] = getOperatorResultBlockId(p[1], 1); + } + + return p; +} + + SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo) { - SJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SJoinOperatorInfo)); + SMJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SMJoinOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - + bool newDownstreams = false; + int32_t code = TSDB_CODE_SUCCESS; if (pOperator == NULL || pInfo == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } + if (1 == numOfDownstream) { + newDownstreams = true; + pDownstream = buildMergeJoinDownstreams(pInfo, pDownstream); + if (NULL == pDownstream) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _error; + } + numOfDownstream = 2; + } else { + pInfo->downstreamResBlkId[0] = getOperatorResultBlockId(pDownstream[0], 0); + pInfo->downstreamResBlkId[1] = getOperatorResultBlockId(pDownstream[1], 1); + } + int32_t numOfCols = 0; pInfo->pRes = createDataBlockFromDescNode(pJoinNode->node.pOutputDataBlockDesc); @@ -223,9 +253,9 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t pOperator->exprSupp.pExprInfo = pExprInfo; pOperator->exprSupp.numOfExprs = numOfCols; - extractTimeCondition(pInfo, pDownstream, numOfDownstream, pJoinNode, GET_TASKID(pTaskInfo)); + extractTimeCondition(pInfo, pJoinNode, GET_TASKID(pTaskInfo)); - if (pJoinNode->pOnConditions != NULL && pJoinNode->node.pConditions != NULL) { + if (pJoinNode->pOtherOnCond != NULL && pJoinNode->node.pConditions != NULL) { pInfo->pCondAfterMerge = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); if (pInfo->pCondAfterMerge == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; @@ -239,11 +269,13 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t goto _error; } - nodesListMakeAppend(&pLogicCond->pParameterList, nodesCloneNode(pJoinNode->pOnConditions)); + nodesListMakeAppend(&pLogicCond->pParameterList, nodesCloneNode(pJoinNode->pOtherOnCond)); nodesListMakeAppend(&pLogicCond->pParameterList, nodesCloneNode(pJoinNode->node.pConditions)); pLogicCond->condType = LOGIC_COND_TYPE_AND; - } else if (pJoinNode->pOnConditions != NULL) { - pInfo->pCondAfterMerge = nodesCloneNode(pJoinNode->pOnConditions); + } else if (pJoinNode->pOtherOnCond != NULL) { + pInfo->pCondAfterMerge = nodesCloneNode(pJoinNode->pOtherOnCond); + } else if (pJoinNode->pColEqCond != NULL) { + pInfo->pCondAfterMerge = nodesCloneNode(pJoinNode->pColEqCond); } else if (pJoinNode->node.pConditions != NULL) { pInfo->pCondAfterMerge = nodesCloneNode(pJoinNode->node.pConditions); } else { @@ -262,21 +294,27 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t pInfo->inputOrder = TSDB_ORDER_DESC; } - pInfo->pColEqualOnConditions = pJoinNode->pColEqualOnConditions; + pInfo->pColEqualOnConditions = pJoinNode->pColEqCond; if (pInfo->pColEqualOnConditions != NULL) { pInfo->leftEqOnCondCols = taosArrayInit(4, sizeof(SColumn)); pInfo->rightEqOnCondCols = taosArrayInit(4, sizeof(SColumn)); - extractEqualOnCondCols(pInfo, pDownstream, pInfo->pColEqualOnConditions, pInfo->leftEqOnCondCols, pInfo->rightEqOnCondCols); + extractEqualOnCondCols(pInfo, pInfo->pColEqualOnConditions, pInfo->leftEqOnCondCols, pInfo->rightEqOnCondCols); initTagColskeyBuf(&pInfo->leftEqOnCondKeyLen, &pInfo->leftEqOnCondKeyBuf, pInfo->leftEqOnCondCols); initTagColskeyBuf(&pInfo->rightEqOnCondKeyLen, &pInfo->rightEqOnCondKeyBuf, pInfo->rightEqOnCondCols); _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); pInfo->rightBuildTable = tSimpleHashInit(256, hashFn); } - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doMergeJoin, NULL, destroyMergeJoinOperator, optrDefaultBufFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doMergeJoin, NULL, destroyMergeJoinOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + code = appendDownstream(pOperator, pDownstream, numOfDownstream); if (code != TSDB_CODE_SUCCESS) { goto _error; } + if (newDownstreams) { + taosMemoryFree(pDownstream); + } + + pOperator->numOfRealDownstream = newDownstreams ? 1 : 2; return pOperator; @@ -284,6 +322,9 @@ _error: if (pInfo != NULL) { destroyMergeJoinOperator(pInfo); } + if (newDownstreams) { + taosMemoryFree(pDownstream); + } taosMemoryFree(pOperator); pTaskInfo->code = code; @@ -311,7 +352,7 @@ static void mergeJoinDestoryBuildTable(SSHashObj* pBuildTable) { } void destroyMergeJoinOperator(void* param) { - SJoinOperatorInfo* pJoinOperator = (SJoinOperatorInfo*)param; + SMJoinOperatorInfo* pJoinOperator = (SMJoinOperatorInfo*)param; if (pJoinOperator->pColEqualOnConditions != NULL) { mergeJoinDestoryBuildTable(pJoinOperator->rightBuildTable); taosMemoryFreeClear(pJoinOperator->rightEqOnCondKeyBuf); @@ -334,7 +375,7 @@ void destroyMergeJoinOperator(void* param) { static void mergeJoinJoinLeftRight(struct SOperatorInfo* pOperator, SSDataBlock* pRes, int32_t currRow, SSDataBlock* pLeftBlock, int32_t leftPos, SSDataBlock* pRightBlock, int32_t rightPos) { - SJoinOperatorInfo* pJoinInfo = pOperator->info; + SMJoinOperatorInfo* pJoinInfo = pOperator->info; for (int32_t i = 0; i < pOperator->exprSupp.numOfExprs; ++i) { SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, i); @@ -411,13 +452,14 @@ static int32_t mergeJoinGetDownStreamRowsEqualTimeStamp(SOperatorInfo* pOperator SArray* createdBlocks) { ASSERT(whichChild == 0 || whichChild == 1); - SJoinOperatorInfo* pJoinInfo = pOperator->info; + SMJoinOperatorInfo* pJoinInfo = pOperator->info; int32_t endPos = -1; SSDataBlock* dataBlock = startDataBlock; mergeJoinGetBlockRowsEqualTs(dataBlock, tsSlotId, startPos, timestamp, &endPos, rowLocations, createdBlocks); while (endPos == dataBlock->info.rows) { SOperatorInfo* ds = pOperator->pDownstream[whichChild]; - dataBlock = ds->fpSet.getNextFn(ds); + dataBlock = getNextBlockFromDownstreamRemain(pOperator, whichChild); + qError("merge join %s got block for same ts, rows:%" PRId64, whichChild == 0 ? "left" : "right", dataBlock ? dataBlock->info.rows : 0); if (whichChild == 0) { pJoinInfo->leftPos = 0; pJoinInfo->pLeft = dataBlock; @@ -427,7 +469,7 @@ static int32_t mergeJoinGetDownStreamRowsEqualTimeStamp(SOperatorInfo* pOperator } if (dataBlock == NULL) { - setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED); + pJoinInfo->downstreamFetchDone[whichChild] = true; endPos = -1; break; } @@ -444,7 +486,7 @@ static int32_t mergeJoinGetDownStreamRowsEqualTimeStamp(SOperatorInfo* pOperator return 0; } -static int32_t mergeJoinFillBuildTable(SJoinOperatorInfo* pInfo, SArray* rightRowLocations) { +static int32_t mergeJoinFillBuildTable(SMJoinOperatorInfo* pInfo, SArray* rightRowLocations) { for (int32_t i = 0; i < taosArrayGetSize(rightRowLocations); ++i) { SRowLocation* rightRow = taosArrayGet(rightRowLocations, i); int32_t keyLen = fillKeyBufFromTagCols(pInfo->rightEqOnCondCols, rightRow->pDataBlock, rightRow->pos, pInfo->rightEqOnCondKeyBuf); @@ -465,7 +507,7 @@ static int32_t mergeJoinLeftRowsRightRows(SOperatorInfo* pOperator, SSDataBlock* int32_t rightRowIdx, bool useBuildTableTSRange, SArray* rightRowLocations, bool* pReachThreshold) { *pReachThreshold = false; uint32_t limitRowNum = pOperator->resultInfo.threshold; - SJoinOperatorInfo* pJoinInfo = pOperator->info; + SMJoinOperatorInfo* pJoinInfo = pOperator->info; size_t leftNumJoin = taosArrayGetSize(leftRowLocations); int32_t i,j; @@ -508,7 +550,7 @@ static int32_t mergeJoinLeftRowsRightRows(SOperatorInfo* pOperator, SSDataBlock* return TSDB_CODE_SUCCESS; } -static void mergeJoinDestroyTSRangeCtx(SJoinOperatorInfo* pJoinInfo, SArray* leftRowLocations, SArray* leftCreatedBlocks, +static void mergeJoinDestroyTSRangeCtx(SMJoinOperatorInfo* pJoinInfo, SArray* leftRowLocations, SArray* leftCreatedBlocks, SArray* rightCreatedBlocks, bool rightUseBuildTable, SArray* rightRowLocations) { for (int i = 0; i < taosArrayGetSize(rightCreatedBlocks); ++i) { SSDataBlock* pBlock = taosArrayGetP(rightCreatedBlocks, i); @@ -546,7 +588,7 @@ static void mergeJoinDestroyTSRangeCtx(SJoinOperatorInfo* pJoinInfo, SArray* lef static int32_t mergeJoinJoinDownstreamTsRanges(SOperatorInfo* pOperator, int64_t timestamp, SSDataBlock* pRes, int32_t* nRows) { int32_t code = TSDB_CODE_SUCCESS; - SJoinOperatorInfo* pJoinInfo = pOperator->info; + SMJoinOperatorInfo* pJoinInfo = pOperator->info; SArray* leftRowLocations = NULL; SArray* rightRowLocations = NULL; SArray* leftCreatedBlocks = NULL; @@ -613,30 +655,63 @@ static int32_t mergeJoinJoinDownstreamTsRanges(SOperatorInfo* pOperator, int64_t return TSDB_CODE_SUCCESS; } +static void setMergeJoinDone(SOperatorInfo* pOperator) { + setOperatorCompleted(pOperator); + if (pOperator->pDownstreamGetParams) { + freeOperatorParam(pOperator->pDownstreamGetParams[0], OP_GET_PARAM); + freeOperatorParam(pOperator->pDownstreamGetParams[1], OP_GET_PARAM); + pOperator->pDownstreamGetParams[0] = NULL; + pOperator->pDownstreamGetParams[1] = NULL; + } +} + static bool mergeJoinGetNextTimestamp(SOperatorInfo* pOperator, int64_t* pLeftTs, int64_t* pRightTs) { - SJoinOperatorInfo* pJoinInfo = pOperator->info; - + SMJoinOperatorInfo* pJoinInfo = pOperator->info; + bool leftEmpty = false; + if (pJoinInfo->pLeft == NULL || pJoinInfo->leftPos >= pJoinInfo->pLeft->info.rows) { - SOperatorInfo* ds1 = pOperator->pDownstream[0]; - pJoinInfo->pLeft = ds1->fpSet.getNextFn(ds1); + if (!pJoinInfo->downstreamFetchDone[0]) { + pJoinInfo->pLeft = getNextBlockFromDownstreamRemain(pOperator, 0); + pJoinInfo->downstreamInitDone[0] = true; - pJoinInfo->leftPos = 0; + pJoinInfo->leftPos = 0; + qError("merge join left got block, rows:%" PRId64, pJoinInfo->pLeft ? pJoinInfo->pLeft->info.rows : 0); + } else { + pJoinInfo->pLeft = NULL; + } + if (pJoinInfo->pLeft == NULL) { - setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED); - return false; + if (pOperator->pOperatorGetParam && ((SSortMergeJoinOperatorParam*)pOperator->pOperatorGetParam->value)->initDownstream && !pJoinInfo->downstreamInitDone[1]) { + leftEmpty = true; + } else { + setMergeJoinDone(pOperator); + return false; + } } } if (pJoinInfo->pRight == NULL || pJoinInfo->rightPos >= pJoinInfo->pRight->info.rows) { - SOperatorInfo* ds2 = pOperator->pDownstream[1]; - pJoinInfo->pRight = ds2->fpSet.getNextFn(ds2); + if (!pJoinInfo->downstreamFetchDone[1]) { + pJoinInfo->pRight = getNextBlockFromDownstreamRemain(pOperator, 1); + pJoinInfo->downstreamInitDone[1] = true; - pJoinInfo->rightPos = 0; + pJoinInfo->rightPos = 0; + qError("merge join right got block, rows:%" PRId64, pJoinInfo->pRight ? pJoinInfo->pRight->info.rows : 0); + } else { + pJoinInfo->pRight = NULL; + } + if (pJoinInfo->pRight == NULL) { - setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED); + setMergeJoinDone(pOperator); return false; + } else { + if (leftEmpty) { + setMergeJoinDone(pOperator); + return false; + } } } + // only the timestamp match support for ordinary table SColumnInfoData* pLeftCol = taosArrayGet(pJoinInfo->pLeft->pDataBlock, pJoinInfo->leftCol.slotId); char* pLeftVal = colDataGetData(pLeftCol, pJoinInfo->leftPos); @@ -650,7 +725,7 @@ static bool mergeJoinGetNextTimestamp(SOperatorInfo* pOperator, int64_t* pLeftTs } static void doMergeJoinImpl(struct SOperatorInfo* pOperator, SSDataBlock* pRes) { - SJoinOperatorInfo* pJoinInfo = pOperator->info; + SMJoinOperatorInfo* pJoinInfo = pOperator->info; int32_t nrows = pRes->info.rows; @@ -694,8 +769,40 @@ static void doMergeJoinImpl(struct SOperatorInfo* pOperator, SSDataBlock* pRes) } } +void resetMergeJoinOperator(struct SOperatorInfo* pOperator) { + SMJoinOperatorInfo* pJoinInfo = pOperator->info; + if (pJoinInfo->rowCtx.rowRemains) { + mergeJoinDestroyTSRangeCtx(pJoinInfo, pJoinInfo->rowCtx.leftRowLocations, pJoinInfo->rowCtx.leftCreatedBlocks, pJoinInfo->rowCtx.rightCreatedBlocks, + pJoinInfo->rowCtx.rightUseBuildTable, pJoinInfo->rowCtx.rightRowLocations); + } + pJoinInfo->pLeft = NULL; + pJoinInfo->leftPos = 0; + pJoinInfo->pRight = NULL; + pJoinInfo->rightPos = 0; + pJoinInfo->downstreamFetchDone[0] = false; + pJoinInfo->downstreamFetchDone[1] = false; + pJoinInfo->downstreamInitDone[0] = false; + pJoinInfo->downstreamInitDone[1] = false; + pJoinInfo->resRows = 0; + pOperator->status = OP_OPENED; +} + SSDataBlock* doMergeJoin(struct SOperatorInfo* pOperator) { - SJoinOperatorInfo* pJoinInfo = pOperator->info; + SMJoinOperatorInfo* pJoinInfo = pOperator->info; + if (pOperator->status == OP_EXEC_DONE) { + if (NULL == pOperator->pDownstreamGetParams || NULL == pOperator->pDownstreamGetParams[0] || NULL == pOperator->pDownstreamGetParams[1]) { + qError("total merge join res rows:%" PRId64, pJoinInfo->resRows); + return NULL; + } else { + resetMergeJoinOperator(pOperator); + qError("start new merge join"); + } + } + + int64_t st = 0; + if (pOperator->cost.openCost == 0) { + st = taosGetTimestampUs(); + } SSDataBlock* pRes = pJoinInfo->pRes; blockDataCleanup(pRes); @@ -713,6 +820,24 @@ SSDataBlock* doMergeJoin(struct SOperatorInfo* pOperator) { if (pRes->info.rows >= pOperator->resultInfo.threshold) { break; } + if (pOperator->status == OP_EXEC_DONE) { + break; + } + } + + if (pOperator->cost.openCost == 0) { + pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; + } + + if (pRes->info.rows > 0) { + pJoinInfo->resRows += pRes->info.rows; + qError("merge join returns res rows:%" PRId64, pRes->info.rows); + return pRes; + } else { + qError("total merge join res rows:%" PRId64, pJoinInfo->resRows); + return NULL; } - return (pRes->info.rows > 0) ? pRes : NULL; } + + + diff --git a/source/libs/executor/src/operator.c b/source/libs/executor/src/operator.c index 88710680d9..6f9aac7595 100644 --- a/source/libs/executor/src/operator.c +++ b/source/libs/executor/src/operator.c @@ -30,7 +30,7 @@ SOperatorFpSet createOperatorFpSet(__optr_open_fn_t openFn, __optr_fn_t nextFn, __optr_fn_t cleanup, __optr_close_fn_t closeFn, __optr_reqBuf_fn_t reqBufFn, - __optr_explain_fn_t explain) { + __optr_explain_fn_t explain, __optr_get_ext_fn_t nextExtFn, __optr_notify_fn_t notifyFn) { SOperatorFpSet fpSet = { ._openFn = openFn, .getNextFn = nextFn, @@ -38,6 +38,8 @@ SOperatorFpSet createOperatorFpSet(__optr_open_fn_t openFn, __optr_fn_t nextFn, .closeFn = closeFn, .reqBufFn = reqBufFn, .getExplainFn = explain, + .getNextExtFn = nextExtFn, + .notifyFn = notifyFn, .releaseStreamStateFn = NULL, .reloadStreamStateFn = NULL, }; @@ -64,6 +66,7 @@ int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t memcpy(p->pDownstream, pDownstream, num * POINTER_BYTES); p->numOfDownstream = num; + p->numOfRealDownstream = num; return TSDB_CODE_SUCCESS; } @@ -279,7 +282,6 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR SOperatorInfo* pOperator = NULL; if (QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == type) { STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pPhyNode; - // NOTE: this is an patch to fix the physical plan // TODO remove it later if (pTableScanNode->scan.node.pLimit != NULL) { @@ -287,21 +289,27 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR } STableListInfo* pTableListInfo = tableListCreate(); - int32_t code = - createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort, pHandle, - pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); + + int32_t code = initQueriedTableSchemaInfo(pHandle, &pTableScanNode->scan, dbname, pTaskInfo); if (code) { pTaskInfo->code = code; tableListDestroy(pTableListInfo); - qError("failed to createScanTableListInfo, code:%s, %s", tstrerror(code), idstr); return NULL; } - code = initQueriedTableSchemaInfo(pHandle, &pTableScanNode->scan, dbname, pTaskInfo); - if (code) { - pTaskInfo->code = code; - tableListDestroy(pTableListInfo); - return NULL; + if (pTableScanNode->scan.node.dynamicOp) { + pTaskInfo->dynamicTask = true; + pTableListInfo->idInfo.suid = pTableScanNode->scan.suid; + pTableListInfo->idInfo.tableType = pTableScanNode->scan.tableType; + } else { + code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort, pHandle, + pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); + if (code) { + pTaskInfo->code = code; + tableListDestroy(pTableListInfo); + qError("failed to createScanTableListInfo, code:%s, %s", tstrerror(code), idstr); + return NULL; + } } pOperator = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo); @@ -361,7 +369,7 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR } } - pTaskInfo->schemaInfo.qsw = extractQueriedColumnSchema(&pTableScanNode->scan); + //pTaskInfo->schemaInfo.qsw = extractQueriedColumnSchema(&pTableScanNode->scan); pOperator = createStreamScanOperatorInfo(pHandle, pTableScanNode, pTagCond, pTableListInfo, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN == type) { SSystemTableScanPhysiNode* pSysScanPhyNode = (SSystemTableScanPhysiNode*)pPhyNode; @@ -429,6 +437,7 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR pOperator = createProjectOperatorInfo(NULL, (SProjectPhysiNode*)pPhyNode, pTaskInfo); } else { terrno = TSDB_CODE_INVALID_PARA; + pTaskInfo->code = terrno; return NULL; } @@ -442,6 +451,8 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR size_t size = LIST_LENGTH(pPhyNode->pChildren); SOperatorInfo** ops = taosMemoryCalloc(size, POINTER_BYTES); if (ops == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + pTaskInfo->code = terrno; return NULL; } @@ -510,6 +521,8 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR pOptr = createStreamStateAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN == type) { pOptr = createMergeJoinOperatorInfo(ops, size, (SSortMergeJoinPhysiNode*)pPhyNode, pTaskInfo); + } else if (QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN == type) { + pOptr = createHashJoinOperatorInfo(ops, size, (SHashJoinPhysiNode*)pPhyNode, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_FILL == type) { pOptr = createFillOperatorInfo(ops[0], (SFillPhysiNode*)pPhyNode, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL == type) { @@ -520,8 +533,13 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR pOptr = createTimeSliceOperatorInfo(ops[0], pPhyNode, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT == type) { pOptr = createEventwindowOperatorInfo(ops[0], pPhyNode, pTaskInfo); + } else if (QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE == type) { + pOptr = createGroupCacheOperatorInfo(ops, size, (SGroupCachePhysiNode*)pPhyNode, pTaskInfo); + } else if (QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL == type) { + pOptr = createDynQueryCtrlOperatorInfo(ops, size, (SDynQueryCtrlPhysiNode*)pPhyNode, pTaskInfo); } else { terrno = TSDB_CODE_INVALID_PARA; + pTaskInfo->code = terrno; taosMemoryFree(ops); return NULL; } @@ -534,17 +552,21 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR return pOptr; } + void destroyOperator(SOperatorInfo* pOperator) { if (pOperator == NULL) { return; } + freeResetOperatorParams(pOperator, OP_GET_PARAM, true); + freeResetOperatorParams(pOperator, OP_NOTIFY_PARAM, true); + if (pOperator->fpSet.closeFn != NULL) { pOperator->fpSet.closeFn(pOperator->info); } if (pOperator->pDownstream != NULL) { - for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + for (int32_t i = 0; i < pOperator->numOfRealDownstream; ++i) { destroyOperator(pOperator->pDownstream[i]); } @@ -586,3 +608,170 @@ int32_t getOperatorExplainExecInfo(SOperatorInfo* operatorInfo, SArray* pExecInf return TSDB_CODE_SUCCESS; } + +int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc) { + if (pDst->opType != pSrc->opType) { + qError("different optype %d:%d for merge operator params", pDst->opType, pSrc->opType); + return TSDB_CODE_INVALID_PARA; + } + + switch (pDst->opType) { + case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: { + SExchangeOperatorParam* pDExc = pDst->value; + SExchangeOperatorParam* pSExc = pSrc->value; + if (!pDExc->multiParams) { + if (pSExc->basic.vgId != pDExc->basic.vgId) { + SExchangeOperatorBatchParam* pBatch = taosMemoryMalloc(sizeof(SExchangeOperatorBatchParam)); + if (NULL == pBatch) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pBatch->multiParams = true; + pBatch->pBatchs = tSimpleHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); + if (NULL == pBatch->pBatchs) { + taosMemoryFree(pBatch); + return TSDB_CODE_OUT_OF_MEMORY; + } + tSimpleHashSetFreeFp(pBatch->pBatchs, freeExchangeGetBasicOperatorParam); + + tSimpleHashPut(pBatch->pBatchs, &pDExc->basic.vgId, sizeof(pDExc->basic.vgId), &pDExc->basic, sizeof(pDExc->basic)); + tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic)); + + taosMemoryFree(pDst->value); + pDst->value = pBatch; + } else { + taosArrayAddAll(pDExc->basic.uidList, pSExc->basic.uidList); + } + } else { + SExchangeOperatorBatchParam* pBatch = pDst->value; + SExchangeOperatorBasicParam* pBasic = tSimpleHashGet(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId)); + if (pBasic) { + taosArrayAddAll(pBasic->uidList, pSExc->basic.uidList); + } else { + tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic)); + } + } + break; + } + default: + qError("invalid optype %d for merge operator params", pDst->opType); + return TSDB_CODE_INVALID_PARA; + } + + return TSDB_CODE_SUCCESS; +} + + +int32_t setOperatorParams(struct SOperatorInfo* pOperator, SOperatorParam* pInput, SOperatorParamType type) { + SOperatorParam** ppParam = NULL; + SOperatorParam*** pppDownstramParam = NULL; + switch (type) { + case OP_GET_PARAM: + ppParam = &pOperator->pOperatorGetParam; + pppDownstramParam = &pOperator->pDownstreamGetParams; + break; + case OP_NOTIFY_PARAM: + ppParam = &pOperator->pOperatorNotifyParam; + pppDownstramParam = &pOperator->pDownstreamNotifyParams; + break; + default: + return TSDB_CODE_INVALID_PARA; + } + + freeResetOperatorParams(pOperator, type, false); + + if (NULL == pInput) { + return TSDB_CODE_SUCCESS; + } + + *ppParam = (pInput->opType == pOperator->operatorType) ? pInput : NULL; + + if (NULL == *pppDownstramParam) { + *pppDownstramParam = taosMemoryCalloc(pOperator->numOfDownstream, POINTER_BYTES); + if (NULL == *pppDownstramParam) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + if (NULL == *ppParam) { + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + (*pppDownstramParam)[i] = pInput; + } + return TSDB_CODE_SUCCESS; + } + + memset(*pppDownstramParam, 0, pOperator->numOfDownstream * POINTER_BYTES); + + int32_t childrenNum = taosArrayGetSize((*ppParam)->pChildren); + if (childrenNum <= 0) { + return TSDB_CODE_SUCCESS; + } + + for (int32_t i = 0; i < childrenNum; ++i) { + SOperatorParam* pChild = *(SOperatorParam**)taosArrayGet((*ppParam)->pChildren, i); + if ((*pppDownstramParam)[pChild->downstreamIdx]) { + int32_t code = mergeOperatorParams((*pppDownstramParam)[pChild->downstreamIdx], pChild); + if (code) { + return code; + } + } else { + (*pppDownstramParam)[pChild->downstreamIdx] = pChild; + } + } + + taosArrayDestroy((*ppParam)->pChildren); + (*ppParam)->pChildren = NULL; + + return TSDB_CODE_SUCCESS; +} + + +SSDataBlock* getNextBlockFromDownstream(struct SOperatorInfo* pOperator, int32_t idx) { + return getNextBlockFromDownstreamImpl(pOperator, idx, true); +} + +SSDataBlock* getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, int32_t idx) { + return getNextBlockFromDownstreamImpl(pOperator, idx, false); +} + + +SSDataBlock* optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam) { + int32_t code = setOperatorParams(pOperator, pParam, OP_GET_PARAM); + if (TSDB_CODE_SUCCESS != code) { + pOperator->pTaskInfo->code = code; + T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); + } + return pOperator->fpSet.getNextFn(pOperator); +} + +int32_t optrDefaultNotifyFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam) { + int32_t code = setOperatorParams(pOperator, pParam, OP_NOTIFY_PARAM); + if (TSDB_CODE_SUCCESS == code && pOperator->fpSet.notifyFn && pOperator->pOperatorNotifyParam) { + code = pOperator->fpSet.notifyFn(pOperator, pOperator->pOperatorNotifyParam); + } + if (TSDB_CODE_SUCCESS == code) { + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + if (pOperator->pDownstreamNotifyParams[i]) { + code = optrDefaultNotifyFn(pOperator->pDownstream[i], pOperator->pDownstreamNotifyParams[i]); + if (TSDB_CODE_SUCCESS != code) { + break; + } + pOperator->pDownstreamNotifyParams[i] = NULL; + } + } + } + if (TSDB_CODE_SUCCESS != code) { + pOperator->pTaskInfo->code = code; + T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); + } + + return code; +} + +int16_t getOperatorResultBlockId(struct SOperatorInfo* pOperator, int32_t idx) { + if (pOperator->transparent) { + return getOperatorResultBlockId(pOperator->pDownstream[idx], 0); + } + return pOperator->resultDataBlockId; +} + + diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c index 8e31bc042f..00b246afad 100644 --- a/source/libs/executor/src/projectoperator.c +++ b/source/libs/executor/src/projectoperator.c @@ -149,7 +149,7 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys setOperatorInfo(pOperator, "ProjectOperator", QUERY_NODE_PHYSICAL_PLAN_PROJECT, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doProjectOperation, NULL, destroyProjectOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamOperatorReleaseState, streamOperatorReloadState); code = appendDownstream(pOperator, &downstream, 1); @@ -280,7 +280,7 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { blockDataCleanup(pRes); // The downstream exec may change the value of the newgroup, so use a local variable instead. - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { qDebug("set op close, exec %d, status %d rows %" PRId64 , pTaskInfo->execModel, pOperator->status, pFinalRes->info.rows); setOperatorCompleted(pOperator); @@ -440,7 +440,7 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy setOperatorInfo(pOperator, "IndefinitOperator", QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doApplyIndefinitFunction, NULL, destroyIndefinitOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -525,7 +525,7 @@ SSDataBlock* doApplyIndefinitFunction(SOperatorInfo* pOperator) { if (pInfo->pRes->info.rows < pOperator->resultInfo.threshold) { while (1) { // The downstream exec may change the value of the newgroup, so use a local variable instead. - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { setOperatorCompleted(pOperator); break; diff --git a/source/libs/executor/src/querytask.c b/source/libs/executor/src/querytask.c index 980ef1a61a..9eb1c8d653 100644 --- a/source/libs/executor/src/querytask.c +++ b/source/libs/executor/src/querytask.c @@ -54,8 +54,11 @@ SExecTaskInfo* doCreateTask(uint64_t queryId, uint64_t taskId, int32_t vgId, EOP pTaskInfo->id.vgId = vgId; pTaskInfo->id.queryId = queryId; + pTaskInfo->id.taskId = taskId; pTaskInfo->id.str = taosMemoryMalloc(64); buildTaskId(taskId, queryId, pTaskInfo->id.str); + pTaskInfo->schemaInfos = taosArrayInit(1, sizeof(SSchemaInfo)); + return pTaskInfo; } @@ -106,7 +109,9 @@ int32_t createExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SReadHand } } -void cleanupQueriedTableScanInfo(SSchemaInfo* pSchemaInfo) { +void cleanupQueriedTableScanInfo(void* p) { + SSchemaInfo* pSchemaInfo = p; + taosMemoryFreeClear(pSchemaInfo->dbname); taosMemoryFreeClear(pSchemaInfo->tablename); tDeleteSchemaWrapper(pSchemaInfo->sw); @@ -132,14 +137,14 @@ int32_t initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNo return terrno; } - SSchemaInfo* pSchemaInfo = &pTaskInfo->schemaInfo; + SSchemaInfo schemaInfo = {0}; - pSchemaInfo->tablename = taosStrdup(mr.me.name); - pSchemaInfo->dbname = taosStrdup(dbName); + schemaInfo.tablename = taosStrdup(mr.me.name); + schemaInfo.dbname = taosStrdup(dbName); if (mr.me.type == TSDB_SUPER_TABLE) { - pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow); - pSchemaInfo->tversion = mr.me.stbEntry.schemaTag.version; + schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow); + schemaInfo.tversion = mr.me.stbEntry.schemaTag.version; } else if (mr.me.type == TSDB_CHILD_TABLE) { tDecoderClear(&mr.coder); @@ -147,18 +152,23 @@ int32_t initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNo code = pAPI->metaReaderFn.getEntryGetUidCache(&mr, suid); if (code != TSDB_CODE_SUCCESS) { pAPI->metaReaderFn.clearReader(&mr); + taosMemoryFree(schemaInfo.tablename); + taosMemoryFree(schemaInfo.dbname); return terrno; } - pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow); - pSchemaInfo->tversion = mr.me.stbEntry.schemaTag.version; + schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow); + schemaInfo.tversion = mr.me.stbEntry.schemaTag.version; } else { - pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.ntbEntry.schemaRow); + schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.ntbEntry.schemaRow); } pAPI->metaReaderFn.clearReader(&mr); - pSchemaInfo->qsw = extractQueriedColumnSchema(pScanNode); + schemaInfo.qsw = extractQueriedColumnSchema(pScanNode); + + taosArrayPush(pTaskInfo->schemaInfos, &schemaInfo); + return TSDB_CODE_SUCCESS; } @@ -211,7 +221,7 @@ void doDestroyTask(SExecTaskInfo* pTaskInfo) { destroyOperator(pTaskInfo->pRoot); pTaskInfo->pRoot = NULL; - cleanupQueriedTableScanInfo(&pTaskInfo->schemaInfo); + taosArrayDestroyEx(pTaskInfo->schemaInfos, cleanupQueriedTableScanInfo); cleanupStreamInfo(&pTaskInfo->streamInfo); if (!pTaskInfo->localFetch.localExec) { diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 741e8ff43a..3d2eef66ea 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -783,11 +783,167 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { return NULL; } +static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) { + STableScanInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + int32_t code = 0; + STableListInfo* pListInfo = pInfo->base.pTableListInfo; + STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value; + int32_t num = taosArrayGetSize(pParam->pUidList); + if (num <= 0) { + qError("empty table scan uid list"); + return TSDB_CODE_INVALID_PARA; + } + + qError("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d", + pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList), pOperator->status); + + if (pParam->tableSeq) { + pListInfo->oneTableForEachGroup = true; + if (taosArrayGetSize(pListInfo->pTableList) > 0) { + taosHashClear(pListInfo->map); + taosArrayClear(pListInfo->pTableList); + pOperator->status = OP_EXEC_DONE; + } + } else { + pListInfo->oneTableForEachGroup = false; + pListInfo->numOfOuputGroups = 1; + } + + STableKeyInfo info = {.groupId = 0}; + int32_t tableIdx = 0; + for (int32_t i = 0; i < num; ++i) { + uint64_t* pUid = taosArrayGet(pParam->pUidList, i); + + if (taosHashPut(pListInfo->map, pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) { + if (TSDB_CODE_DUP_KEY == terrno) { + continue; + } + return TSDB_CODE_OUT_OF_MEMORY; + } + + info.uid = *pUid; + void* p = taosArrayPush(pListInfo->pTableList, &info); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + tableIdx++; + qError("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo)); + } + + return code; +} + +static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) { + STableScanInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; + + if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { + setOperatorCompleted(pOperator); + if (pOperator->dynamicTask) { + taosArrayClear(pInfo->base.pTableListInfo->pTableList); + taosHashClear(pInfo->base.pTableListInfo->map); + } + return NULL; + } + + // reset value for the next group data output + pOperator->status = OP_OPENED; + resetLimitInfoForNextGroup(&pInfo->base.limitInfo); + + int32_t num = 0; + STableKeyInfo* pList = NULL; + tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, &pList, &num); + + pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, pList, num); + pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond); + pInfo->scanTimes = 0; + + SSDataBlock* result = doGroupedTableScan(pOperator); + if (result != NULL) { + if (pOperator->dynamicTask) { + result->info.id.groupId = result->info.id.uid; + } + return result; + } + + return NULL; +} + +static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { + STableScanInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; + + if (pInfo->currentGroupId == -1) { + if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { + setOperatorCompleted(pOperator); + return NULL; + } + + int32_t num = 0; + STableKeyInfo* pList = NULL; + tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, &pList, &num); + ASSERT(pInfo->base.dataReader == NULL); + + int32_t code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, + (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), pInfo->countOnly, &pInfo->pIgnoreTables); + if (code != TSDB_CODE_SUCCESS) { + T_LONG_JMP(pTaskInfo->env, code); + } + + if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) { + pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity; + } + } + + SSDataBlock* result = doGroupedTableScan(pOperator); + if (result != NULL) { + if (pOperator->dynamicTask) { + result->info.id.groupId = result->info.id.uid; + } + return result; + } + + while (true) { + result = startNextGroupScan(pOperator); + if (result || pOperator->status == OP_EXEC_DONE) { + return result; + } + } + + return result; +} + static SSDataBlock* doTableScan(SOperatorInfo* pOperator) { STableScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; + if (pOperator->pOperatorGetParam) { + pOperator->dynamicTask = true; + int32_t code = createTableListInfoFromParam(pOperator); + freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM); + pOperator->pOperatorGetParam = NULL; + if (code != TSDB_CODE_SUCCESS) { + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + if (pOperator->status == OP_EXEC_DONE) { + pInfo->currentGroupId = -1; + pOperator->status = OP_OPENED; + SSDataBlock* result = NULL; + while (true) { + result = startNextGroupScan(pOperator); + if (result || pOperator->status == OP_EXEC_DONE) { + return result; + } + } + } + } + // scan table one by one sequentially if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) { int32_t numOfTables = 0; // tableListGetSize(pTaskInfo->pTableListInfo); @@ -822,56 +978,7 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator) { pInfo->scanTimes = 0; } } else { // scan table group by group sequentially - if (pInfo->currentGroupId == -1) { - if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { - setOperatorCompleted(pOperator); - return NULL; - } - - int32_t num = 0; - STableKeyInfo* pList = NULL; - tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, &pList, &num); - ASSERT(pInfo->base.dataReader == NULL); - - int32_t code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, - (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), pInfo->countOnly, &pInfo->pIgnoreTables); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } - - if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) { - pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity; - } - } - - SSDataBlock* result = doGroupedTableScan(pOperator); - if (result != NULL) { - return result; - } - - while (1) { - if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { - setOperatorCompleted(pOperator); - return NULL; - } - - // reset value for the next group data output - pOperator->status = OP_OPENED; - resetLimitInfoForNextGroup(&pInfo->base.limitInfo); - - int32_t num = 0; - STableKeyInfo* pList = NULL; - tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, &pList, &num); - - pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, pList, num); - pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond); - pInfo->scanTimes = 0; - - result = doGroupedTableScan(pOperator); - if (result != NULL) { - return result; - } - } + return groupSeqTableScan(pOperator); } } @@ -980,7 +1087,7 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, taosLRUCacheSetStrictCapacity(pInfo->base.metaCache.pTableMetaEntryCache, false); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScan, NULL, destroyTableScanOperatorInfo, - optrDefaultBufFn, getTableScannerExecInfo); + optrDefaultBufFn, getTableScannerExecInfo, optrDefaultGetNextExtFn, NULL); // for non-blocking operator, the open cost is always 0 pOperator->cost.openCost = 0; @@ -1005,7 +1112,7 @@ SOperatorInfo* createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* setOperatorInfo(pOperator, "TableSeqScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImpl, NULL, NULL, optrDefaultBufFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImpl, NULL, NULL, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; } @@ -2357,7 +2464,7 @@ SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pT setOperatorInfo(pOperator, "RawScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(NULL, doRawScan, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL); + pOperator->fpSet = createOperatorFpSet(NULL, doRawScan, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _end: @@ -2635,7 +2742,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys __optr_fn_t nextFn = (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) ? doStreamScan : doQueueScan; pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, nextFn, NULL, destroyStreamScanOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, nextFn, NULL, destroyStreamScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamScanReleaseState, streamScanReloadState); return pOperator; @@ -2673,9 +2780,13 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId); // refactor later - if (fmIsScanPseudoColumnFunc(pExprInfo[j].pExpr->_function.functionId)) { + if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) { STR_TO_VARSTR(str, (*mr).me.name); colDataSetVal(pDst, (count), str, false); + } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) { + colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false); + } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) { + colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false); } else { // it is a tag value STagVal val = {0}; val.cid = pExprInfo[j].base.pParam[0].pCol->colId; @@ -2802,12 +2913,18 @@ static void tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aF } -static void tagScanFillOneCellWithTag(const STUidTagInfo* pUidTagInfo, SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex, const SStorageAPI* pAPI, void* pVnode) { - if (fmIsScanPseudoColumnFunc(pExprInfo->pExpr->_function.functionId)) { // tbname - char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - STR_TO_VARSTR(str, "ctbidx"); +static void tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo, SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex, const SStorageAPI* pAPI, void* pVnode) { + if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) { + if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) { // tbname + char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; + STR_TO_VARSTR(str, "ctbidx"); - colDataSetVal(pColInfo, rowIndex, str, false); + colDataSetVal(pColInfo, rowIndex, str, false); + } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) { + colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false); + } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) { + colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false); + } } else { STagVal tagVal = {0}; tagVal.cid = pExprInfo->base.pParam[0].pCol->colId; @@ -2844,7 +2961,7 @@ static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRe STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx); for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) { SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId); - tagScanFillOneCellWithTag(pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); + tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); } } } else { @@ -2853,7 +2970,7 @@ static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRe STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i); for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) { SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId); - tagScanFillOneCellWithTag(pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); + tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); } } } @@ -3056,7 +3173,7 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi } __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry; pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; @@ -3462,7 +3579,7 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN pOperator->exprSupp.numOfExprs = numOfCols; pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableMergeScan, NULL, destroyTableMergeScanOperatorInfo, - optrDefaultBufFn, getTableMergeScanExplainExecInfo); + optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn, NULL); pOperator->cost.openCost = 0; return pOperator; @@ -3612,7 +3729,7 @@ SOperatorInfo* createTableCountScanOperatorInfo(SReadHandle* readHandle, STableC setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScan, NULL, destoryTableCountScanOperator, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _error: diff --git a/source/libs/executor/src/sortoperator.c b/source/libs/executor/src/sortoperator.c index 459474d06e..9bd0991435 100644 --- a/source/libs/executor/src/sortoperator.c +++ b/source/libs/executor/src/sortoperator.c @@ -91,7 +91,7 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* // TODO dynamic set the available sort buffer pOperator->fpSet = - createOperatorFpSet(doOpenSortOperator, doSort, NULL, destroySortOperatorInfo, optrDefaultBufFn, getExplainExecInfo); + createOperatorFpSet(doOpenSortOperator, doSort, NULL, destroySortOperatorInfo, optrDefaultBufFn, getExplainExecInfo, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -461,7 +461,7 @@ SSDataBlock* doGroupSort(SOperatorInfo* pOperator) { if (!pInfo->hasGroupId) { pInfo->hasGroupId = true; - pInfo->prefetchedSortInput = pOperator->pDownstream[0]->fpSet.getNextFn(pOperator->pDownstream[0]); + pInfo->prefetchedSortInput = getNextBlockFromDownstream(pOperator, 0); if (pInfo->prefetchedSortInput == NULL) { setOperatorCompleted(pOperator); return NULL; @@ -556,7 +556,7 @@ SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSort pInfo->pSortInfo = createSortInfo(pSortPhyNode->pSortKeys); setOperatorInfo(pOperator, "GroupSortOperator", QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doGroupSort, NULL, destroyGroupSortOperatorInfo, - optrDefaultBufFn, getGroupSortExplainExecInfo); + optrDefaultBufFn, getGroupSortExplainExecInfo, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -845,7 +845,7 @@ SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size setOperatorInfo(pOperator, "MultiwayMergeOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(openMultiwayMergeOperator, doMultiwayMerge, NULL, - destroyMultiwayMergeOperatorInfo, optrDefaultBufFn, getMultiwayMergeExplainExecInfo); + destroyMultiwayMergeOperatorInfo, optrDefaultBufFn, getMultiwayMergeExplainExecInfo, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, downStreams, numStreams); if (code != TSDB_CODE_SUCCESS) { diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 4757aa872f..816f460d15 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1494,7 +1494,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, pOperator->info = pInfo; pOperator->fpSet = createOperatorFpSet(NULL, doStreamFinalIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState); if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) { initIntervalDownStream(downstream, pPhyNode->type, pInfo); @@ -2624,7 +2624,7 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh setOperatorInfo(pOperator, getStreamOpName(pOperator->operatorType), QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION, true, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionAgg, NULL, destroyStreamSessionAggOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamSessionReleaseState, streamSessionReloadState); if (downstream) { @@ -2762,7 +2762,7 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream if (pPhyNode->type != QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION) { pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionSemiAgg, NULL, - destroyStreamSessionAggOperatorInfo, optrDefaultBufFn, NULL); + destroyStreamSessionAggOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); } setOperatorInfo(pOperator, getStreamOpName(pOperator->operatorType), pPhyNode->type, false, OP_NOT_OPENED, pInfo, pTaskInfo); @@ -3425,7 +3425,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys setOperatorInfo(pOperator, "StreamStateAggOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE, true, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamStateAgg, NULL, destroyStreamStateOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamStateReleaseState, streamStateReloadState); initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup); code = appendDownstream(pOperator, &downstream, 1); @@ -3669,7 +3669,7 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys setOperatorInfo(pOperator, "StreamIntervalOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, true, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamIntervalAgg, NULL, - destroyStreamFinalIntervalOperatorInfo, optrDefaultBufFn, NULL); + destroyStreamFinalIntervalOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState); pInfo->stateStore = pTaskInfo->storageAPI.stateStore; diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index 9048dd43d7..333bb4768f 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -933,7 +933,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, } else { int32_t bufSize = IS_VAR_DATA_TYPE(tagType) ? (tagLen + VARSTR_HEADER_SIZE) : (3 + DBL_MANT_DIG - DBL_MIN_EXP + VARSTR_HEADER_SIZE); - tagVarChar = taosMemoryMalloc(bufSize); + tagVarChar = taosMemoryCalloc(1, bufSize + 1); int32_t len = -1; convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len); varDataSetLen(tagVarChar, len); @@ -1788,7 +1788,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan pInfo, pTaskInfo); pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doSysTableScan, NULL, destroySysScanOperator, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, doSysTableScan, NULL, destroySysScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _error: @@ -2325,7 +2325,7 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi setOperatorInfo(pOperator, "DataBlockDistScanOperator", QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doBlockInfoScan, NULL, destroyBlockDistScanOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _error: diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index c9824ff2d6..abaebb1543 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -900,7 +900,7 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { } while (1) { - SSDataBlock* pBlock = pSliceInfo->pRemainRes ? pSliceInfo->pRemainRes : downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = pSliceInfo->pRemainRes ? pSliceInfo->pRemainRes : getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { setOperatorCompleted(pOperator); break; @@ -1011,7 +1011,7 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode setOperatorInfo(pOperator, "TimeSliceOperator", QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, optrDefaultBufFn, NULL); + createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index ef0c206e7b..5d804812ab 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -859,7 +859,7 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { int64_t st = taosGetTimestampUs(); while (1) { - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { break; } @@ -983,7 +983,7 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { break; } @@ -1292,7 +1292,7 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(doOpenIntervalAgg, doBuildIntervalResult, NULL, destroyIntervalOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -1415,7 +1415,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { - SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream); + SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { break; } @@ -1516,7 +1516,7 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi setOperatorInfo(pOperator, "StateWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, true, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(openStateWindowAggOptr, doStateWindowAgg, NULL, destroyStateWindowOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -1592,7 +1592,7 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW setOperatorInfo(pOperator, "SessionWindowAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION, true, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doSessionWindowAgg, NULL, destroySWindowOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); pOperator->pTaskInfo = pTaskInfo; code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -1725,7 +1725,7 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { while (1) { SSDataBlock* pBlock = NULL; if (pMiaInfo->prefetchedBlock == NULL) { - pBlock = downstream->fpSet.getNextFn(downstream); + pBlock = getNextBlockFromDownstream(pOperator, 0); } else { pBlock = pMiaInfo->prefetchedBlock; pMiaInfo->prefetchedBlock = NULL; @@ -1876,7 +1876,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, false, OP_NOT_OPENED, miaInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, mergeAlignedIntervalAgg, NULL, destroyMAIOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { @@ -2057,7 +2057,7 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { while (1) { SSDataBlock* pBlock = NULL; if (miaInfo->prefetchedBlock == NULL) { - pBlock = downstream->fpSet.getNextFn(downstream); + pBlock = getNextBlockFromDownstream(pOperator, 0); } else { pBlock = miaInfo->prefetchedBlock; miaInfo->groupId = pBlock->info.id.groupId; @@ -2163,7 +2163,7 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge setOperatorInfo(pOperator, "TimeMergeIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL, false, OP_NOT_OPENED, pMergeIntervalInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doMergeIntervalAgg, NULL, destroyMergeIntervalOperatorInfo, - optrDefaultBufFn, NULL); + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 9a301b7f1c..188a1fcd4d 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -681,6 +681,21 @@ static int32_t translateTbnameColumn(SFunctionNode* pFunc, char* pErrBuf, int32_ return TSDB_CODE_SUCCESS; } +static int32_t translateTbUidColumn(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { + // pseudo column do not need to check parameters + pFunc->node.resType = + (SDataType){.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes, .type = TSDB_DATA_TYPE_BIGINT}; + return TSDB_CODE_SUCCESS; +} + +static int32_t translateVgIdColumn(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { + // pseudo column do not need to check parameters + pFunc->node.resType = + (SDataType){.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes, .type = TSDB_DATA_TYPE_INT}; + return TSDB_CODE_SUCCESS; +} + + static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList); if (2 != numOfParams) { @@ -3597,6 +3612,27 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = { .sprocessFunc = containsProperlyFunction, .finalizeFunc = NULL }, + { + .name = "_tbuid", + .type = FUNCTION_TYPE_TBUID, + .classification = FUNC_MGT_PSEUDO_COLUMN_FUNC | FUNC_MGT_SCAN_PC_FUNC | FUNC_MGT_KEEP_ORDER_FUNC, + .translateFunc = translateTbUidColumn, + .getEnvFunc = NULL, + .initFunc = NULL, + .sprocessFunc = qTbUidFunction, + .finalizeFunc = NULL + }, + { + .name = "_vgid", + .type = FUNCTION_TYPE_VGID, + .classification = FUNC_MGT_PSEUDO_COLUMN_FUNC | FUNC_MGT_SCAN_PC_FUNC | FUNC_MGT_KEEP_ORDER_FUNC, + .translateFunc = translateVgIdColumn, + .getEnvFunc = NULL, + .initFunc = NULL, + .sprocessFunc = qVgIdFunction, + .finalizeFunc = NULL + }, + }; // clang-format on diff --git a/source/libs/nodes/CMakeLists.txt b/source/libs/nodes/CMakeLists.txt index b8fdb32987..b6163e742e 100644 --- a/source/libs/nodes/CMakeLists.txt +++ b/source/libs/nodes/CMakeLists.txt @@ -7,9 +7,9 @@ target_include_directories( ) target_link_libraries( nodes - PRIVATE os util common qcom + PRIVATE os util common qcom function ) if(${BUILD_TEST}) ADD_SUBDIRECTORY(test) -endif(${BUILD_TEST}) \ No newline at end of file +endif(${BUILD_TEST}) diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index afb5ce6c9a..c62190b68a 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -259,6 +259,8 @@ static int32_t tempTableNodeCopy(const STempTableNode* pSrc, STempTableNode* pDs static int32_t joinTableNodeCopy(const SJoinTableNode* pSrc, SJoinTableNode* pDst) { COPY_BASE_OBJECT_FIELD(table, tableNodeCopy); COPY_SCALAR_FIELD(joinType); + COPY_SCALAR_FIELD(hasSubQuery); + COPY_SCALAR_FIELD(isLowLevelJoin); CLONE_NODE_FIELD(pLeft); CLONE_NODE_FIELD(pRight); CLONE_NODE_FIELD(pOnCond); @@ -348,6 +350,24 @@ static int32_t caseWhenNodeCopy(const SCaseWhenNode* pSrc, SCaseWhenNode* pDst) return TSDB_CODE_SUCCESS; } +static int32_t copyHintValue(const SHintNode* pSrc, SHintNode* pDst) { + if (NULL == pSrc->value) { + pDst->value = NULL; + return TSDB_CODE_SUCCESS; + } + switch (pSrc->option) { + default: + break; + } + return TSDB_CODE_SUCCESS; +} + +static int32_t hintNodeCopy(const SHintNode* pSrc, SHintNode* pDst) { + COPY_SCALAR_FIELD(type); + COPY_SCALAR_FIELD(option); + return copyHintValue(pSrc, pDst); +} + static int32_t logicNodeCopy(const SLogicNode* pSrc, SLogicNode* pDst) { CLONE_NODE_LIST_FIELD(pTargets); CLONE_NODE_FIELD(pConditions); @@ -361,7 +381,9 @@ static int32_t logicNodeCopy(const SLogicNode* pSrc, SLogicNode* pDst) { COPY_SCALAR_FIELD(groupAction); COPY_SCALAR_FIELD(inputTsOrder); COPY_SCALAR_FIELD(outputTsOrder); + COPY_SCALAR_FIELD(dynamicOp); COPY_SCALAR_FIELD(forceCreateNonBlockingOptr); + CLONE_NODE_LIST_FIELD(pHint); return TSDB_CODE_SUCCESS; } @@ -406,10 +428,14 @@ static int32_t logicScanCopy(const SScanLogicNode* pSrc, SScanLogicNode* pDst) { static int32_t logicJoinCopy(const SJoinLogicNode* pSrc, SJoinLogicNode* pDst) { COPY_BASE_OBJECT_FIELD(node, logicNodeCopy); COPY_SCALAR_FIELD(joinType); - CLONE_NODE_FIELD(pMergeCondition); - CLONE_NODE_FIELD(pOnConditions); - CLONE_NODE_FIELD(pColEqualOnConditions); + COPY_SCALAR_FIELD(joinAlgo); + CLONE_NODE_FIELD(pPrimKeyEqCond); + CLONE_NODE_FIELD(pColEqCond); + CLONE_NODE_FIELD(pTagEqCond); + CLONE_NODE_FIELD(pTagOnCond); + CLONE_NODE_FIELD(pOtherOnCond); COPY_SCALAR_FIELD(isSingleTableJoin); + COPY_SCALAR_FIELD(hasSubQuery); return TSDB_CODE_SUCCESS; } @@ -533,6 +559,26 @@ static int32_t logicInterpFuncCopy(const SInterpFuncLogicNode* pSrc, SInterpFunc return TSDB_CODE_SUCCESS; } +static int32_t logicGroupCacheCopy(const SGroupCacheLogicNode* pSrc, SGroupCacheLogicNode* pDst) { + COPY_BASE_OBJECT_FIELD(node, logicNodeCopy); + COPY_SCALAR_FIELD(grpColsMayBeNull); + COPY_SCALAR_FIELD(grpByUid); + COPY_SCALAR_FIELD(globalGrp); + COPY_SCALAR_FIELD(batchFetch); + CLONE_NODE_LIST_FIELD(pGroupCols); + return TSDB_CODE_SUCCESS; +} + +static int32_t logicDynQueryCtrlCopy(const SDynQueryCtrlLogicNode* pSrc, SDynQueryCtrlLogicNode* pDst) { + COPY_BASE_OBJECT_FIELD(node, logicNodeCopy); + COPY_SCALAR_FIELD(qType); + COPY_SCALAR_FIELD(stbJoin.batchFetch); + CLONE_NODE_LIST_FIELD(stbJoin.pVgList); + CLONE_NODE_LIST_FIELD(stbJoin.pUidList); + COPY_OBJECT_FIELD(stbJoin.srcScan, sizeof(pDst->stbJoin.srcScan)); + return TSDB_CODE_SUCCESS; +} + static int32_t logicSubplanCopy(const SLogicSubplan* pSrc, SLogicSubplan* pDst) { COPY_OBJECT_FIELD(id, sizeof(SSubplanId)); CLONE_NODE_FIELD_EX(pNode, SLogicNode*); @@ -548,6 +594,7 @@ static int32_t physiNodeCopy(const SPhysiNode* pSrc, SPhysiNode* pDst) { CLONE_NODE_LIST_FIELD(pChildren); COPY_SCALAR_FIELD(inputTsOrder); COPY_SCALAR_FIELD(outputTsOrder); + COPY_SCALAR_FIELD(dynamicOp); COPY_SCALAR_FIELD(forceCreateNonBlockingOptr); return TSDB_CODE_SUCCESS; } @@ -680,6 +727,7 @@ static int32_t selectStmtCopy(const SSelectStmt* pSrc, SSelectStmt* pDst) { COPY_SCALAR_FIELD(timeLineResMode); COPY_SCALAR_FIELD(hasAggFuncs); COPY_SCALAR_FIELD(hasRepeatScanFuncs); + CLONE_NODE_LIST_FIELD(pHint); return TSDB_CODE_SUCCESS; } @@ -768,6 +816,9 @@ SNode* nodesCloneNode(const SNode* pNode) { case QUERY_NODE_CASE_WHEN: code = caseWhenNodeCopy((const SCaseWhenNode*)pNode, (SCaseWhenNode*)pDst); break; + case QUERY_NODE_HINT: + code = hintNodeCopy((const SHintNode*)pNode, (SHintNode*)pDst); + break; case QUERY_NODE_SELECT_STMT: code = selectStmtCopy((const SSelectStmt*)pNode, (SSelectStmt*)pDst); break; @@ -810,6 +861,12 @@ SNode* nodesCloneNode(const SNode* pNode) { case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: code = logicInterpFuncCopy((const SInterpFuncLogicNode*)pNode, (SInterpFuncLogicNode*)pDst); break; + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: + code = logicGroupCacheCopy((const SGroupCacheLogicNode*)pNode, (SGroupCacheLogicNode*)pDst); + break; + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: + code = logicDynQueryCtrlCopy((const SDynQueryCtrlLogicNode*)pNode, (SDynQueryCtrlLogicNode*)pDst); + break; case QUERY_NODE_LOGIC_SUBPLAN: code = logicSubplanCopy((const SLogicSubplan*)pNode, (SLogicSubplan*)pDst); break; diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 1e4eb510d9..c72b03817b 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -197,10 +197,8 @@ const char* nodesNodeName(ENodeType type) { 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: @@ -297,6 +295,10 @@ const char* nodesNodeName(ENodeType type) { 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: @@ -326,7 +328,9 @@ const char* nodesNodeName(ENodeType type) { case QUERY_NODE_PHYSICAL_PLAN_PROJECT: return "PhysiProject"; case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - return "PhysiJoin"; + 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: @@ -378,6 +382,10 @@ const char* nodesNodeName(ENodeType type) { 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: @@ -1180,6 +1188,97 @@ static int32_t jsonToLogicInterpFuncNode(const SJson* pJson, void* pObj) { return code; } +static const char* jkGroupCacheLogicPlanGrpColsMayBeNull = "GroupColsMayBeNull"; +static const char* jkGroupCacheLogicPlanGroupByUid = "GroupByUid"; +static const char* jkGroupCacheLogicPlanGlobalGroup = "GlobalGroup"; +static const char* jkGroupCacheLogicPlanGroupCols = "GroupCols"; + +static int32_t logicGroupCacheNodeToJson(const void* pObj, SJson* pJson) { + const SGroupCacheLogicNode* pNode = (const SGroupCacheLogicNode*)pObj; + + int32_t code = logicPlanNodeToJson(pObj, pJson); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCacheLogicPlanGrpColsMayBeNull, pNode->grpColsMayBeNull); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCacheLogicPlanGroupByUid, pNode->grpByUid); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCacheLogicPlanGlobalGroup, pNode->globalGrp); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkGroupCacheLogicPlanGroupCols, pNode->pGroupCols); + } + + return code; +} + +static int32_t jsonToLogicGroupCacheNode(const SJson* pJson, void* pObj) { + SGroupCacheLogicNode* pNode = (SGroupCacheLogicNode*)pObj; + + int32_t code = jsonToLogicPlanNode(pJson, pObj); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCacheLogicPlanGrpColsMayBeNull, &pNode->grpColsMayBeNull); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCacheLogicPlanGroupByUid, &pNode->grpByUid); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCacheLogicPlanGlobalGroup, &pNode->globalGrp); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkGroupCacheLogicPlanGroupCols, &pNode->pGroupCols); + } + + return code; +} + +static const char* jkDynQueryCtrlLogicPlanQueryType = "QueryType"; +static const char* jkDynQueryCtrlLogicPlanStbJoinBatchFetch = "BatchFetch"; +static const char* jkDynQueryCtrlLogicPlanStbJoinVgList = "VgroupList"; +static const char* jkDynQueryCtrlLogicPlanStbJoinUidList = "UidList"; + +static int32_t logicDynQueryCtrlNodeToJson(const void* pObj, SJson* pJson) { + const SDynQueryCtrlLogicNode* pNode = (const SDynQueryCtrlLogicNode*)pObj; + + int32_t code = logicPlanNodeToJson(pObj, pJson); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlLogicPlanQueryType, pNode->qType); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, pNode->stbJoin.batchFetch); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkDynQueryCtrlLogicPlanStbJoinVgList, pNode->stbJoin.pVgList); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkDynQueryCtrlLogicPlanStbJoinUidList, pNode->stbJoin.pUidList); + } + + return code; +} + +static int32_t jsonToLogicDynQueryCtrlNode(const SJson* pJson, void* pObj) { + SDynQueryCtrlLogicNode* pNode = (SDynQueryCtrlLogicNode*)pObj; + + int32_t code = jsonToLogicPlanNode(pJson, pObj); + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkDynQueryCtrlLogicPlanQueryType, pNode->qType, code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, &pNode->stbJoin.batchFetch); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkDynQueryCtrlLogicPlanStbJoinVgList, &pNode->stbJoin.pVgList); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkDynQueryCtrlLogicPlanStbJoinUidList, &pNode->stbJoin.pUidList); + } + + return code; +} + + static const char* jkSubplanIdQueryId = "QueryId"; static const char* jkSubplanIdGroupId = "GroupId"; static const char* jkSubplanIdSubplanId = "SubplanId"; @@ -1434,9 +1533,11 @@ static int32_t jsonToLogicPlan(const SJson* pJson, void* pObj) { } static const char* jkJoinLogicPlanJoinType = "JoinType"; -static const char* jkJoinLogicPlanOnConditions = "OnConditions"; -static const char* jkJoinLogicPlanMergeCondition = "MergeConditions"; -static const char* jkJoinLogicPlanColEqualOnConditions = "ColumnEqualOnConditions"; +static const char* jkJoinLogicPlanJoinAlgo = "JoinAlgo"; +static const char* jkJoinLogicPlanOnConditions = "OtherOnCond"; +static const char* jkJoinLogicPlanPrimKeyEqCondition = "PrimKeyEqCond"; +static const char* jkJoinLogicPlanColEqCondition = "ColumnEqCond"; +static const char* jkJoinLogicPlanTagEqCondition = "TagEqCond"; static int32_t logicJoinNodeToJson(const void* pObj, SJson* pJson) { const SJoinLogicNode* pNode = (const SJoinLogicNode*)pObj; @@ -1446,13 +1547,19 @@ static int32_t logicJoinNodeToJson(const void* pObj, SJson* pJson) { code = tjsonAddIntegerToObject(pJson, jkJoinLogicPlanJoinType, pNode->joinType); } if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkJoinLogicPlanMergeCondition, nodeToJson, pNode->pMergeCondition); + code = tjsonAddIntegerToObject(pJson, jkJoinLogicPlanJoinAlgo, pNode->joinAlgo); } if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkJoinLogicPlanOnConditions, nodeToJson, pNode->pOnConditions); + code = tjsonAddObject(pJson, jkJoinLogicPlanPrimKeyEqCondition, nodeToJson, pNode->pPrimKeyEqCond); } if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkJoinLogicPlanColEqualOnConditions, nodeToJson, pNode->pColEqualOnConditions); + code = tjsonAddObject(pJson, jkJoinLogicPlanColEqCondition, nodeToJson, pNode->pColEqCond); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddObject(pJson, jkJoinLogicPlanTagEqCondition, nodeToJson, pNode->pTagEqCond); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddObject(pJson, jkJoinLogicPlanOnConditions, nodeToJson, pNode->pOtherOnCond); } return code; } @@ -1465,14 +1572,21 @@ static int32_t jsonToLogicJoinNode(const SJson* pJson, void* pObj) { tjsonGetNumberValue(pJson, jkJoinLogicPlanJoinType, pNode->joinType, code); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkJoinLogicPlanMergeCondition, &pNode->pMergeCondition); + tjsonGetNumberValue(pJson, jkJoinLogicPlanJoinAlgo, pNode->joinAlgo, code); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkJoinLogicPlanOnConditions, &pNode->pOnConditions); + code = jsonToNodeObject(pJson, jkJoinLogicPlanPrimKeyEqCondition, &pNode->pPrimKeyEqCond); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkJoinLogicPlanColEqualOnConditions, &pNode->pColEqualOnConditions); + code = jsonToNodeObject(pJson, jkJoinLogicPlanColEqCondition, &pNode->pColEqCond); } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeObject(pJson, jkJoinLogicPlanTagEqCondition, &pNode->pTagEqCond); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeObject(pJson, jkJoinLogicPlanOnConditions, &pNode->pOtherOnCond); + } + return code; } @@ -1931,12 +2045,16 @@ static int32_t jsonToPhysiProjectNode(const SJson* pJson, void* pObj) { static const char* jkJoinPhysiPlanJoinType = "JoinType"; static const char* jkJoinPhysiPlanInputTsOrder = "InputTsOrder"; -static const char* jkJoinPhysiPlanMergeCondition = "MergeCondition"; +static const char* jkJoinPhysiPlanOnLeftCols = "OnLeftColumns"; +static const char* jkJoinPhysiPlanOnRightCols = "OnRightColumns"; +static const char* jkJoinPhysiPlanPrimKeyCondition = "PrimKeyCondition"; static const char* jkJoinPhysiPlanOnConditions = "OnConditions"; static const char* jkJoinPhysiPlanTargets = "Targets"; static const char* jkJoinPhysiPlanColEqualOnConditions = "ColumnEqualOnConditions"; +static const char* jkJoinPhysiPlanInputRowNum = "InputRowNum"; +static const char* jkJoinPhysiPlanInputRowSize = "InputRowSize"; -static int32_t physiJoinNodeToJson(const void* pObj, SJson* pJson) { +static int32_t physiMergeJoinNodeToJson(const void* pObj, SJson* pJson) { const SSortMergeJoinPhysiNode* pNode = (const SSortMergeJoinPhysiNode*)pObj; int32_t code = physicPlanNodeToJson(pObj, pJson); @@ -1944,21 +2062,21 @@ static int32_t physiJoinNodeToJson(const void* pObj, SJson* pJson) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanJoinType, pNode->joinType); } if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkJoinPhysiPlanMergeCondition, nodeToJson, pNode->pMergeCondition); + code = tjsonAddObject(pJson, jkJoinPhysiPlanPrimKeyCondition, nodeToJson, pNode->pPrimKeyCond); } if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkJoinPhysiPlanOnConditions, nodeToJson, pNode->pOnConditions); + code = tjsonAddObject(pJson, jkJoinPhysiPlanOnConditions, nodeToJson, pNode->pOtherOnCond); } if (TSDB_CODE_SUCCESS == code) { code = nodeListToJson(pJson, jkJoinPhysiPlanTargets, pNode->pTargets); } if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkJoinPhysiPlanColEqualOnConditions, nodeToJson, pNode->pColEqualOnConditions); + code = tjsonAddObject(pJson, jkJoinPhysiPlanColEqualOnConditions, nodeToJson, pNode->pColEqCond); } return code; } -static int32_t jsonToPhysiJoinNode(const SJson* pJson, void* pObj) { +static int32_t jsonToPhysiMergeJoinNode(const SJson* pJson, void* pObj) { SSortMergeJoinPhysiNode* pNode = (SSortMergeJoinPhysiNode*)pObj; int32_t code = jsonToPhysicPlanNode(pJson, pObj); @@ -1966,20 +2084,90 @@ static int32_t jsonToPhysiJoinNode(const SJson* pJson, void* pObj) { tjsonGetNumberValue(pJson, jkJoinPhysiPlanJoinType, pNode->joinType, code); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkJoinPhysiPlanOnConditions, &pNode->pOnConditions); + code = jsonToNodeObject(pJson, jkJoinPhysiPlanOnConditions, &pNode->pOtherOnCond); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkJoinPhysiPlanMergeCondition, &pNode->pMergeCondition); + code = jsonToNodeObject(pJson, jkJoinPhysiPlanPrimKeyCondition, &pNode->pPrimKeyCond); } if (TSDB_CODE_SUCCESS == code) { code = jsonToNodeList(pJson, jkJoinPhysiPlanTargets, &pNode->pTargets); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkJoinPhysiPlanColEqualOnConditions, &pNode->pColEqualOnConditions); + code = jsonToNodeObject(pJson, jkJoinPhysiPlanColEqualOnConditions, &pNode->pColEqCond); } return code; } +static int32_t physiHashJoinNodeToJson(const void* pObj, SJson* pJson) { + const SHashJoinPhysiNode* pNode = (const SHashJoinPhysiNode*)pObj; + + int32_t code = physicPlanNodeToJson(pObj, pJson); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanJoinType, pNode->joinType); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkJoinPhysiPlanOnLeftCols, pNode->pOnLeft); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkJoinPhysiPlanOnRightCols, pNode->pOnRight); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddObject(pJson, jkJoinPhysiPlanOnConditions, nodeToJson, pNode->pFilterConditions); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkJoinPhysiPlanTargets, pNode->pTargets); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanInputRowNum, pNode->inputStat[0].inputRowNum); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanInputRowSize, pNode->inputStat[0].inputRowSize); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanInputRowNum, pNode->inputStat[1].inputRowNum); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanInputRowSize, pNode->inputStat[1].inputRowSize); + } + return code; +} + + +static int32_t jsonToPhysiHashJoinNode(const SJson* pJson, void* pObj) { + SHashJoinPhysiNode* pNode = (SHashJoinPhysiNode*)pObj; + + int32_t code = jsonToPhysicPlanNode(pJson, pObj); + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkJoinPhysiPlanJoinType, pNode->joinType, code); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkJoinPhysiPlanOnLeftCols, &pNode->pOnLeft); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkJoinPhysiPlanOnRightCols, &pNode->pOnRight); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeObject(pJson, jkJoinPhysiPlanOnConditions, &pNode->pFilterConditions); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkJoinPhysiPlanTargets, &pNode->pTargets); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkJoinPhysiPlanInputRowNum, pNode->inputStat[0].inputRowNum, code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkJoinPhysiPlanInputRowSize, pNode->inputStat[0].inputRowSize, code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkJoinPhysiPlanInputRowNum, pNode->inputStat[1].inputRowNum, code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkJoinPhysiPlanInputRowSize, pNode->inputStat[1].inputRowSize, code); + } + return code; +} + + static const char* jkAggPhysiPlanExprs = "Exprs"; static const char* jkAggPhysiPlanGroupKeys = "GroupKeys"; static const char* jkAggPhysiPlanAggFuncs = "AggFuncs"; @@ -2795,6 +2983,148 @@ static int32_t jsonToPhysiDeleteNode(const SJson* pJson, void* pObj) { return code; } +static const char* jkGroupCachePhysiPlanGroupCols = "GroupColumns"; +static const char* jkGroupCachePhysiPlanGrpColsMayBeNull = "GroupColumnsMayBeNull"; +static const char* jkGroupCachePhysiPlanGroupByUid = "GroupByUid"; +static const char* jkGroupCachePhysiPlanGlobalGroup = "GlobalGroup"; +static const char* jkGroupCachePhysiPlanBatchFetch = "BatchFetch"; + + +static int32_t physiGroupCacheNodeToJson(const void* pObj, SJson* pJson) { + const SGroupCachePhysiNode* pNode = (const SGroupCachePhysiNode*)pObj; + + int32_t code = physicPlanNodeToJson(pObj, pJson); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanGrpColsMayBeNull, pNode->grpColsMayBeNull); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanGroupByUid, pNode->grpByUid); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanGlobalGroup, pNode->globalGrp); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanBatchFetch, pNode->batchFetch); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodeListToJson(pJson, jkGroupCachePhysiPlanGroupCols, pNode->pGroupCols); + } + return code; +} + +static int32_t jsonToPhysiGroupCacheNode(const SJson* pJson, void* pObj) { + SGroupCachePhysiNode* pNode = (SGroupCachePhysiNode*)pObj; + + int32_t code = jsonToPhysicPlanNode(pJson, pObj); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanGrpColsMayBeNull, &pNode->grpColsMayBeNull); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanGroupByUid, &pNode->grpByUid); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanGlobalGroup, &pNode->globalGrp); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanBatchFetch, &pNode->batchFetch); + } + if (TSDB_CODE_SUCCESS == code) { + code = jsonToNodeList(pJson, jkGroupCachePhysiPlanGroupCols, &pNode->pGroupCols); + } + return code; +} + +static const char* jkDynQueryCtrlPhysiPlanQueryType = "QueryType"; +static const char* jkDynQueryCtrlPhysiPlanBatchFetch = "BatchFetch"; +static const char* jkDynQueryCtrlPhysiPlanVgSlot0 = "VgSlot[0]"; +static const char* jkDynQueryCtrlPhysiPlanVgSlot1 = "VgSlot[1]"; +static const char* jkDynQueryCtrlPhysiPlanUidSlot0 = "UidSlot[0]"; +static const char* jkDynQueryCtrlPhysiPlanUidSlot1 = "UidSlot[1]"; +static const char* jkDynQueryCtrlPhysiPlanSrcScan0 = "SrcScan[0]"; +static const char* jkDynQueryCtrlPhysiPlanSrcScan1 = "SrcScan[1]"; + +static int32_t physiDynQueryCtrlNodeToJson(const void* pObj, SJson* pJson) { + const SDynQueryCtrlPhysiNode* pNode = (const SDynQueryCtrlPhysiNode*)pObj; + + int32_t code = physicPlanNodeToJson(pObj, pJson); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlPhysiPlanQueryType, pNode->qType); + } + if (TSDB_CODE_SUCCESS == code) { + switch (pNode->qType) { + case DYN_QTYPE_STB_HASH: { + code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlPhysiPlanBatchFetch, pNode->stbJoin.batchFetch); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlPhysiPlanVgSlot0, pNode->stbJoin.vgSlot[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlPhysiPlanVgSlot1, pNode->stbJoin.vgSlot[1]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlPhysiPlanUidSlot0, pNode->stbJoin.uidSlot[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlPhysiPlanUidSlot1, pNode->stbJoin.uidSlot[1]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlPhysiPlanSrcScan0, pNode->stbJoin.srcScan[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlPhysiPlanSrcScan1, pNode->stbJoin.srcScan[1]); + } + break; + } + default: + return TSDB_CODE_INVALID_PARA; + } + } + return code; +} + +static int32_t jsonToPhysiDynQueryCtrlNode(const SJson* pJson, void* pObj) { + SDynQueryCtrlPhysiNode* pNode = (SDynQueryCtrlPhysiNode*)pObj; + + int32_t code = jsonToPhysicPlanNode(pJson, pObj); + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanQueryType, pNode->qType, code); + } + if (TSDB_CODE_SUCCESS == code) { + switch (pNode->qType) { + case DYN_QTYPE_STB_HASH: { + tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanQueryType, pNode->qType, code); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkDynQueryCtrlPhysiPlanBatchFetch, &pNode->stbJoin.batchFetch); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanVgSlot0, pNode->stbJoin.vgSlot[0], code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanVgSlot1, pNode->stbJoin.vgSlot[1], code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanUidSlot0, pNode->stbJoin.uidSlot[0], code); + } + if (TSDB_CODE_SUCCESS == code) { + tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanUidSlot1, pNode->stbJoin.uidSlot[1], code); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkDynQueryCtrlPhysiPlanSrcScan0, &pNode->stbJoin.srcScan[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tjsonGetBoolValue(pJson, jkDynQueryCtrlPhysiPlanSrcScan1, &pNode->stbJoin.srcScan[1]); + } + break; + } + default: + return TSDB_CODE_INVALID_PARA; + } + } + + return code; +} + + + static const char* jkQueryNodeAddrId = "Id"; static const char* jkQueryNodeAddrInUse = "InUse"; static const char* jkQueryNodeAddrNumOfEps = "NumOfEps"; @@ -6631,6 +6961,10 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) { 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: @@ -6651,7 +6985,9 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) { case QUERY_NODE_PHYSICAL_PLAN_PROJECT: return physiProjectNodeToJson(pObj, pJson); case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - return physiJoinNodeToJson(pObj, pJson); + 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: @@ -6697,6 +7033,10 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) { 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: @@ -6950,6 +7290,10 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { 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: @@ -6970,7 +7314,9 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { case QUERY_NODE_PHYSICAL_PLAN_PROJECT: return jsonToPhysiProjectNode(pJson, pObj); case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - return jsonToPhysiJoinNode(pJson, pObj); + 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: @@ -7014,6 +7360,10 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { 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: diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index 74d7aad6e8..bc037f05ec 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -1854,6 +1854,7 @@ enum { PHY_NODE_CODE_SLIMIT, PHY_NODE_CODE_INPUT_TS_ORDER, PHY_NODE_CODE_OUTPUT_TS_ORDER, + PHY_NODE_CODE_DYNAMIC_OP, PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR }; @@ -1880,6 +1881,9 @@ static int32_t physiNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { code = tlvEncodeEnum(pEncoder, PHY_NODE_CODE_OUTPUT_TS_ORDER, pNode->outputTsOrder); } if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_NODE_CODE_DYNAMIC_OP, pNode->dynamicOp); + } + if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeBool(pEncoder, PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR, pNode->forceCreateNonBlockingOptr); } @@ -1914,8 +1918,12 @@ static int32_t msgToPhysiNode(STlvDecoder* pDecoder, void* pObj) { case PHY_NODE_CODE_OUTPUT_TS_ORDER: code = tlvDecodeEnum(pTlv, &pNode->outputTsOrder, sizeof(pNode->outputTsOrder)); break; + case PHY_NODE_CODE_DYNAMIC_OP: + code = tlvDecodeBool(pTlv, &pNode->dynamicOp); + break; case PHY_NODE_CODE_FORCE_NONBLOCKING_OPTR: code = tlvDecodeBool(pTlv, &pNode->forceCreateNonBlockingOptr); + break; default: break; } @@ -2380,14 +2388,14 @@ static int32_t msgToPhysiProjectNode(STlvDecoder* pDecoder, void* pObj) { enum { PHY_SORT_MERGE_JOIN_CODE_BASE_NODE = 1, PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE, - PHY_SORT_MERGE_JOIN_CODE_MERGE_CONDITION, + PHY_SORT_MERGE_JOIN_CODE_PRIM_KEY_CONDITION, PHY_SORT_MERGE_JOIN_CODE_ON_CONDITIONS, PHY_SORT_MERGE_JOIN_CODE_TARGETS, PHY_SORT_MERGE_JOIN_CODE_INPUT_TS_ORDER, PHY_SORT_MERGE_JOIN_CODE_TAG_EQUAL_CONDITIONS }; -static int32_t physiJoinNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { +static int32_t physiMergeJoinNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { const SSortMergeJoinPhysiNode* pNode = (const SSortMergeJoinPhysiNode*)pObj; int32_t code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_BASE_NODE, physiNodeToMsg, &pNode->node); @@ -2395,21 +2403,21 @@ static int32_t physiJoinNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { code = tlvEncodeEnum(pEncoder, PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE, pNode->joinType); } if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_MERGE_CONDITION, nodeToMsg, pNode->pMergeCondition); + code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_PRIM_KEY_CONDITION, nodeToMsg, pNode->pPrimKeyCond); } if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_ON_CONDITIONS, nodeToMsg, pNode->pOnConditions); + code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_ON_CONDITIONS, nodeToMsg, pNode->pOtherOnCond); } if (TSDB_CODE_SUCCESS == code) { code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_TARGETS, nodeListToMsg, pNode->pTargets); } if (TSDB_CODE_SUCCESS == code) { - code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_TAG_EQUAL_CONDITIONS, nodeToMsg, pNode->pColEqualOnConditions); + code = tlvEncodeObj(pEncoder, PHY_SORT_MERGE_JOIN_CODE_TAG_EQUAL_CONDITIONS, nodeToMsg, pNode->pColEqCond); } return code; } -static int32_t msgToPhysiJoinNode(STlvDecoder* pDecoder, void* pObj) { +static int32_t msgToPhysiMergeJoinNode(STlvDecoder* pDecoder, void* pObj) { SSortMergeJoinPhysiNode* pNode = (SSortMergeJoinPhysiNode*)pObj; int32_t code = TSDB_CODE_SUCCESS; @@ -2422,17 +2430,17 @@ static int32_t msgToPhysiJoinNode(STlvDecoder* pDecoder, void* pObj) { case PHY_SORT_MERGE_JOIN_CODE_JOIN_TYPE: code = tlvDecodeEnum(pTlv, &pNode->joinType, sizeof(pNode->joinType)); break; - case PHY_SORT_MERGE_JOIN_CODE_MERGE_CONDITION: - code = msgToNodeFromTlv(pTlv, (void**)&pNode->pMergeCondition); + case PHY_SORT_MERGE_JOIN_CODE_PRIM_KEY_CONDITION: + code = msgToNodeFromTlv(pTlv, (void**)&pNode->pPrimKeyCond); break; case PHY_SORT_MERGE_JOIN_CODE_ON_CONDITIONS: - code = msgToNodeFromTlv(pTlv, (void**)&pNode->pOnConditions); + code = msgToNodeFromTlv(pTlv, (void**)&pNode->pOtherOnCond); break; case PHY_SORT_MERGE_JOIN_CODE_TARGETS: code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets); break; case PHY_SORT_MERGE_JOIN_CODE_TAG_EQUAL_CONDITIONS: - code = msgToNodeFromTlv(pTlv, (void**)&pNode->pColEqualOnConditions); + code = msgToNodeFromTlv(pTlv, (void**)&pNode->pColEqCond); break; default: break; @@ -2442,6 +2450,100 @@ static int32_t msgToPhysiJoinNode(STlvDecoder* pDecoder, void* pObj) { return code; } +enum { + PHY_HASH_JOIN_CODE_BASE_NODE = 1, + PHY_HASH_JOIN_CODE_JOIN_TYPE, + PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN, + PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN, + PHY_HASH_JOIN_CODE_ON_CONDITIONS, + PHY_HASH_JOIN_CODE_TARGETS, + PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0, + PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0, + PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1, + PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1 +}; + +static int32_t physiHashJoinNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SHashJoinPhysiNode* pNode = (const SHashJoinPhysiNode*)pObj; + + int32_t code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_BASE_NODE, physiNodeToMsg, &pNode->node); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeEnum(pEncoder, PHY_HASH_JOIN_CODE_JOIN_TYPE, pNode->joinType); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN, nodeListToMsg, pNode->pOnLeft); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN, nodeListToMsg, pNode->pOnRight); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_ON_CONDITIONS, nodeToMsg, pNode->pFilterConditions); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_HASH_JOIN_CODE_TARGETS, nodeListToMsg, pNode->pTargets); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI64(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0, pNode->inputStat[0].inputRowNum); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI64(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1, pNode->inputStat[1].inputRowNum); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0, pNode->inputStat[0].inputRowSize); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeI32(pEncoder, PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1, pNode->inputStat[1].inputRowSize); + } + return code; +} + + +static int32_t msgToPhysiHashJoinNode(STlvDecoder* pDecoder, void* pObj) { + SHashJoinPhysiNode* pNode = (SHashJoinPhysiNode*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case PHY_HASH_JOIN_CODE_BASE_NODE: + code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node); + break; + case PHY_HASH_JOIN_CODE_JOIN_TYPE: + code = tlvDecodeEnum(pTlv, &pNode->joinType, sizeof(pNode->joinType)); + break; + case PHY_HASH_JOIN_CODE_ON_LEFT_COLUMN: + code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pOnLeft); + break; + case PHY_HASH_JOIN_CODE_ON_RIGHT_COLUMN: + code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pOnRight); + break; + case PHY_HASH_JOIN_CODE_ON_CONDITIONS: + code = msgToNodeFromTlv(pTlv, (void**)&pNode->pFilterConditions); + break; + case PHY_HASH_JOIN_CODE_TARGETS: + code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets); + break; + case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM0: + code = tlvDecodeI64(pTlv, &pNode->inputStat[0].inputRowNum); + break; + case PHY_HASH_JOIN_CODE_INPUT_ROW_NUM1: + code = tlvDecodeI64(pTlv, &pNode->inputStat[1].inputRowNum); + break; + case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE0: + code = tlvDecodeI32(pTlv, &pNode->inputStat[0].inputRowSize); + break; + case PHY_HASH_JOIN_CODE_INPUT_ROW_SIZE1: + code = tlvDecodeI32(pTlv, &pNode->inputStat[1].inputRowSize); + break; + default: + break; + } + } + + return code; +} + + enum { PHY_AGG_CODE_BASE_NODE = 1, PHY_AGG_CODE_EXPR, @@ -3474,6 +3576,166 @@ static int32_t msgToPhysiDeleteNode(STlvDecoder* pDecoder, void* pObj) { return code; } +enum { + PHY_GROUP_CACHE_CODE_BASE_NODE = 1, + PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL, + PHY_GROUP_CACHE_CODE_GROUP_BY_UID, + PHY_GROUP_CACHE_CODE_GLOBAL_GROUP, + PHY_GROUP_CACHE_CODE_BATCH_FETCH, + PHY_GROUP_CACHE_CODE_GROUP_COLUMNS +}; + +static int32_t physiGroupCacheNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SGroupCachePhysiNode* pNode = (const SGroupCachePhysiNode*)pObj; + + int32_t code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_BASE_NODE, physiNodeToMsg, &pNode->node); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLUMNS, nodeListToMsg, pNode->pGroupCols); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL, pNode->grpColsMayBeNull); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_BY_UID, pNode->grpByUid); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GLOBAL_GROUP, pNode->globalGrp); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_BATCH_FETCH, pNode->batchFetch); + } + + return code; +} + +static int32_t msgToPhysiGroupCacheNode(STlvDecoder* pDecoder, void* pObj) { + SGroupCachePhysiNode* pNode = (SGroupCachePhysiNode*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case PHY_GROUP_CACHE_CODE_BASE_NODE: + code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node); + break; + case PHY_GROUP_CACHE_CODE_GROUP_COLUMNS: + code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pGroupCols); + break; + case PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL: + code = tlvDecodeBool(pTlv, &pNode->grpColsMayBeNull); + break; + case PHY_GROUP_CACHE_CODE_GROUP_BY_UID: + code = tlvDecodeBool(pTlv, &pNode->grpByUid); + break; + case PHY_GROUP_CACHE_CODE_GLOBAL_GROUP: + code = tlvDecodeBool(pTlv, &pNode->globalGrp); + break; + case PHY_GROUP_CACHE_CODE_BATCH_FETCH: + code = tlvDecodeBool(pTlv, &pNode->batchFetch); + break; + default: + break; + } + } + + return code; +} + + +enum { + PHY_DYN_QUERY_CTRL_CODE_BASE_NODE = 1, + PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0, + PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1, +}; + +static int32_t physiDynQueryCtrlNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { + const SDynQueryCtrlPhysiNode* pNode = (const SDynQueryCtrlPhysiNode*)pObj; + + int32_t code = tlvEncodeObj(pEncoder, PHY_DYN_QUERY_CTRL_CODE_BASE_NODE, physiNodeToMsg, &pNode->node); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE, pNode->qType); + } + if (TSDB_CODE_SUCCESS == code) { + switch (pNode->qType) { + case DYN_QTYPE_STB_HASH: { + code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH, pNode->stbJoin.batchFetch); + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0, pNode->stbJoin.vgSlot[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1, pNode->stbJoin.vgSlot[1]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0, pNode->stbJoin.uidSlot[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1, pNode->stbJoin.uidSlot[1]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0, pNode->stbJoin.srcScan[0]); + } + if (TSDB_CODE_SUCCESS == code) { + code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1, pNode->stbJoin.srcScan[1]); + } + break; + } + default: + return TSDB_CODE_INVALID_PARA; + } + } + return code; +} + +static int32_t msgToPhysiDynQueryCtrlNode(STlvDecoder* pDecoder, void* pObj) { + SDynQueryCtrlPhysiNode* pNode = (SDynQueryCtrlPhysiNode*)pObj; + + int32_t code = TSDB_CODE_SUCCESS; + STlv* pTlv = NULL; + tlvForEach(pDecoder, pTlv, code) { + switch (pTlv->type) { + case PHY_DYN_QUERY_CTRL_CODE_BASE_NODE: + code = tlvDecodeObjFromTlv(pTlv, msgToPhysiNode, &pNode->node); + break; + case PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE: + code = tlvDecodeEnum(pTlv, &pNode->qType, sizeof(pNode->qType)); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH: + code = tlvDecodeBool(pTlv, &pNode->stbJoin.batchFetch); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0: + code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[0], sizeof(pNode->stbJoin.vgSlot[0])); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1: + code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[1], sizeof(pNode->stbJoin.vgSlot[1])); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0: + code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[0], sizeof(pNode->stbJoin.uidSlot[0])); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT1: + code = tlvDecodeEnum(pTlv, &pNode->stbJoin.uidSlot[1], sizeof(pNode->stbJoin.uidSlot[1])); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN0: + code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[0]); + break; + case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_SRC_SCAN1: + code = tlvDecodeBool(pTlv, &pNode->stbJoin.srcScan[1]); + break; + default: + break; + } + } + + return code; +} + + + enum { SUBPLAN_ID_CODE_QUERY_ID = 1, SUBPLAN_ID_CODE_GROUP_ID, SUBPLAN_ID_CODE_SUBPLAN_ID }; static int32_t subplanIdInlineToMsg(const void* pObj, STlvEncoder* pEncoder) { @@ -3796,7 +4058,10 @@ static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { code = physiProjectNodeToMsg(pObj, pEncoder); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - code = physiJoinNodeToMsg(pObj, pEncoder); + code = physiMergeJoinNodeToMsg(pObj, pEncoder); + break; + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: + code = physiHashJoinNodeToMsg(pObj, pEncoder); break; case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: code = physiAggNodeToMsg(pObj, pEncoder); @@ -3857,6 +4122,12 @@ static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) { case QUERY_NODE_PHYSICAL_PLAN_DELETE: code = physiDeleteNodeToMsg(pObj, pEncoder); break; + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + code = physiGroupCacheNodeToMsg(pObj, pEncoder); + break; + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: + code = physiDynQueryCtrlNodeToMsg(pObj, pEncoder); + break; case QUERY_NODE_PHYSICAL_SUBPLAN: code = subplanToMsg(pObj, pEncoder); break; @@ -3941,7 +4212,10 @@ static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) { code = msgToPhysiProjectNode(pDecoder, pObj); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - code = msgToPhysiJoinNode(pDecoder, pObj); + code = msgToPhysiMergeJoinNode(pDecoder, pObj); + break; + case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: + code = msgToPhysiHashJoinNode(pDecoder, pObj); break; case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: code = msgToPhysiAggNode(pDecoder, pObj); @@ -4002,6 +4276,12 @@ static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) { case QUERY_NODE_PHYSICAL_PLAN_DELETE: code = msgToPhysiDeleteNode(pDecoder, pObj); break; + case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: + code = msgToPhysiGroupCacheNode(pDecoder, pObj); + break; + case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: + code = msgToPhysiDynQueryCtrlNode(pDecoder, pObj); + break; case QUERY_NODE_PHYSICAL_SUBPLAN: code = msgToSubplan(pDecoder, pObj); break; diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 75b63b9d34..77637757b1 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -22,6 +22,7 @@ #include "tdatablock.h" #include "thash.h" #include "tref.h" +#include "functionMgt.h" typedef struct SNodeMemChunk { int32_t availableSize; @@ -301,6 +302,8 @@ SNode* nodesMakeNode(ENodeType type) { 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_SET_OPERATOR: return makeNode(type, sizeof(SSetOperator)); case QUERY_NODE_SELECT_STMT: @@ -406,7 +409,7 @@ SNode* nodesMakeNode(ENodeType type) { 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_MODULES_STMT: case QUERY_NODE_SHOW_QNODES_STMT: case QUERY_NODE_SHOW_SNODES_STMT: case QUERY_NODE_SHOW_BNODES_STMT: @@ -490,6 +493,10 @@ SNode* nodesMakeNode(ENodeType type) { 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: @@ -516,6 +523,8 @@ SNode* nodesMakeNode(ENodeType type) { 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: @@ -571,6 +580,10 @@ SNode* nodesMakeNode(ENodeType type) { 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: @@ -598,6 +611,7 @@ static void destroyLogicNode(SLogicNode* pNode) { nodesDestroyList(pNode->pChildren); nodesDestroyNode(pNode->pLimit); nodesDestroyNode(pNode->pSlimit); + nodesDestroyList(pNode->pHint); } static void destroyPhysiNode(SPhysiNode* pNode) { @@ -646,6 +660,15 @@ static void destroyTableCfg(STableCfg* 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; @@ -804,6 +827,11 @@ void nodesDestroyNode(SNode* pNode) { nodesDestroyNode(pEvent->pEndCond); break; } + case QUERY_NODE_HINT: { + SHintNode* pHint = (SHintNode*)pNode; + destroyHintValue(pHint->option, pHint->value); + break; + } case QUERY_NODE_SET_OPERATOR: { SSetOperator* pStmt = (SSetOperator*)pNode; nodesDestroyList(pStmt->pProjectionList); @@ -830,6 +858,7 @@ void nodesDestroyNode(SNode* pNode) { nodesDestroyList(pStmt->pOrderByList); nodesDestroyNode((SNode*)pStmt->pLimit); nodesDestroyNode((SNode*)pStmt->pSlimit); + nodesDestroyList(pStmt->pHint); break; } case QUERY_NODE_VNODE_MODIFY_STMT: { @@ -982,7 +1011,7 @@ void nodesDestroyNode(SNode* pNode) { break; case QUERY_NODE_SHOW_DNODES_STMT: case QUERY_NODE_SHOW_MNODES_STMT: -// case QUERY_NODE_SHOW_MODULES_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: @@ -1095,9 +1124,9 @@ void nodesDestroyNode(SNode* pNode) { case QUERY_NODE_LOGIC_PLAN_JOIN: { SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode; destroyLogicNode((SLogicNode*)pLogicNode); - nodesDestroyNode(pLogicNode->pMergeCondition); - nodesDestroyNode(pLogicNode->pOnConditions); - nodesDestroyNode(pLogicNode->pColEqualOnConditions); + nodesDestroyNode(pLogicNode->pPrimKeyEqCond); + nodesDestroyNode(pLogicNode->pOtherOnCond); + nodesDestroyNode(pLogicNode->pColEqCond); break; } case QUERY_NODE_LOGIC_PLAN_AGG: { @@ -1183,6 +1212,17 @@ void nodesDestroyNode(SNode* pNode) { 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); @@ -1227,10 +1267,23 @@ void nodesDestroyNode(SNode* pNode) { case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: { SSortMergeJoinPhysiNode* pPhyNode = (SSortMergeJoinPhysiNode*)pNode; destroyPhysiNode((SPhysiNode*)pPhyNode); - nodesDestroyNode(pPhyNode->pMergeCondition); - nodesDestroyNode(pPhyNode->pOnConditions); + nodesDestroyNode(pPhyNode->pPrimKeyCond); + nodesDestroyNode(pPhyNode->pOtherOnCond); nodesDestroyList(pPhyNode->pTargets); - nodesDestroyNode(pPhyNode->pColEqualOnConditions); + 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: { @@ -1351,6 +1404,17 @@ void nodesDestroyNode(SNode* pNode) { 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); @@ -1857,7 +1921,7 @@ static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pN static bool isCollectType(ECollectColType collectType, EColumnType colType) { return COLLECT_COL_TYPE_ALL == collectType ? true - : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType : COLUMN_TYPE_TAG != colType); + : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType)); } static EDealRes collectColumns(SNode* pNode, void* pContext) { @@ -1936,6 +2000,7 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle typedef struct SCollectFuncsCxt { int32_t errCode; + char* tableAlias; FFuncClassifier classifier; SNodeList* pFuncs; SHashObj* pFuncsSet; @@ -1945,6 +2010,13 @@ static EDealRes collectFuncs(SNode* pNode, void* pContext) { SCollectFuncsCxt* pCxt = (SCollectFuncsCxt*)pContext; if (QUERY_NODE_FUNCTION == nodeType(pNode) && pCxt->classifier(((SFunctionNode*)pNode)->funcId) && !(((SExprNode*)pNode)->orderAlias)) { + SFunctionNode* pFunc = (SFunctionNode*)pNode; + if (FUNCTION_TYPE_TBNAME == pFunc->funcType && pCxt->tableAlias) { + SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0); + if (pVal && strcmp(pVal->literal, pCxt->tableAlias)) { + return DEAL_RES_CONTINUE; + } + } SExprNode* pExpr = (SExprNode*)pNode; if (NULL == taosHashGet(pCxt->pFuncsSet, &pExpr, sizeof(SExprNode*))) { pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, nodesCloneNode(pNode)); @@ -1967,13 +2039,14 @@ static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len) return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1; } -int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, FFuncClassifier classifier, SNodeList** pFuncs) { +int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) { if (NULL == pSelect || NULL == pFuncs) { return TSDB_CODE_FAILED; } SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .classifier = classifier, + .tableAlias = tableAlias, .pFuncs = (NULL == *pFuncs ? nodesMakeList() : *pFuncs), .pFuncsSet = taosHashInit(4, funcNodeHash, false, false)}; if (NULL == cxt.pFuncs || NULL == cxt.pFuncsSet) { diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index fd04b48086..d24bb1db4f 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -101,6 +101,7 @@ SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pColumnName); SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral); +SNodeList* createHintNodeList(SAstCreateContext* pCxt, const SToken* pLiteral); SNode* createIdentifierValueNode(SAstCreateContext* pCxt, SToken* pLiteral); SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral); SNode* createDefaultDatabaseCondValue(SAstCreateContext* pCxt); @@ -142,7 +143,7 @@ SNode* addLimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit); SNode* addRangeClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pRange); SNode* addEveryClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pEvery); SNode* addFillClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pFill); -SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable); +SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint); SNode* setSelectStmtTagMode(SAstCreateContext* pCxt, SNode* pStmt, bool bSelectTags); SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight); diff --git a/source/libs/parser/inc/parUtil.h b/source/libs/parser/inc/parUtil.h index d96bb9bba4..41cf45906f 100644 --- a/source/libs/parser/inc/parUtil.h +++ b/source/libs/parser/inc/parUtil.h @@ -116,7 +116,7 @@ int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput); int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes); void destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request); -SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable); +SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint); /** * @brief return a - b with overflow check diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index c6387c2787..2501ae8504 100755 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -1009,11 +1009,11 @@ join_type(A) ::= INNER. /************************************************ query_specification *************************************************/ query_specification(A) ::= - SELECT tag_mode_opt(M) set_quantifier_opt(B) select_list(C) from_clause_opt(D) + SELECT hint_list(M) tag_mode_opt(N) set_quantifier_opt(B) select_list(C) from_clause_opt(D) where_clause_opt(E) partition_by_clause_opt(F) range_opt(J) every_opt(K) fill_opt(L) twindow_clause_opt(G) group_by_clause_opt(H) having_clause_opt(I). { - A = createSelectStmt(pCxt, B, C, D); - A = setSelectStmtTagMode(pCxt, A, M); + A = createSelectStmt(pCxt, B, C, D, M); + A = setSelectStmtTagMode(pCxt, A, N); A = addWhereClause(pCxt, A, E); A = addPartitionByClause(pCxt, A, F); A = addWindowClauseClause(pCxt, A, G); @@ -1024,6 +1024,11 @@ query_specification(A) ::= A = addFillClause(pCxt, A, L); } +%type hint_list { SNodeList* } +%destructor hint_list { nodesDestroyList($$); } +hint_list(A) ::= . { A = createHintNodeList(pCxt, NULL); } +hint_list(A) ::= NK_HINT(B). { A = createHintNodeList(pCxt, &B); } + %type tag_mode_opt { bool } %destructor tag_mode_opt { } tag_mode_opt(A) ::= . { A = false; } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 3c31aae573..c51b442166 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -348,6 +348,123 @@ SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* return (SNode*)val; } +bool addHintNodeToList(SAstCreateContext* pCxt, SNodeList** ppHintList, EHintOption opt, SToken* paramList, int32_t paramNum) { + void* value = NULL; + switch (opt) { + case HINT_BATCH_SCAN: + case HINT_NO_BATCH_SCAN: { + if (paramNum > 0) { + return true; + } + break; + } + default: + return true; + } + + SHintNode* hint = (SHintNode*)nodesMakeNode(QUERY_NODE_HINT); + CHECK_OUT_OF_MEM(hint); + hint->option = opt; + hint->value = value; + + if (NULL == *ppHintList) { + *ppHintList = nodesMakeList(); + CHECK_OUT_OF_MEM(*ppHintList); + } + + pCxt->errCode = nodesListStrictAppend(*ppHintList, (SNode*)hint); + if (pCxt->errCode) { + return true; + } + + return false; +} + +SNodeList* createHintNodeList(SAstCreateContext* pCxt, const SToken* pLiteral) { + CHECK_PARSER_STATUS(pCxt); + if (NULL == pLiteral || pLiteral->n <= 5) { + return NULL; + } + SNodeList* pHintList = NULL; + char* hint = strndup(pLiteral->z + 3, pLiteral->n - 5); + int32_t i = 0; + bool quit = false; + bool inParamList = false; + bool lastComma = false; + EHintOption opt = 0; + int32_t paramNum = 0; + SToken paramList[10]; + while (!quit) { + SToken t0 = {0}; + if (hint[i] == 0) { + break; + } + t0.n = tGetToken(&hint[i], &t0.type); + t0.z = hint + i; + i += t0.n; + + switch (t0.type) { + case TK_BATCH_SCAN: + lastComma = false; + if (0 != opt || inParamList) { + quit = true; + break; + } + opt = HINT_BATCH_SCAN; + break; + case TK_NO_BATCH_SCAN: + lastComma = false; + if (0 != opt || inParamList) { + quit = true; + break; + } + opt = HINT_NO_BATCH_SCAN; + break; + case TK_NK_LP: + lastComma = false; + if (0 == opt || inParamList) { + quit = true; + } + inParamList = true; + break; + case TK_NK_RP: + lastComma = false; + if (0 == opt || !inParamList) { + quit = true; + } else { + quit = addHintNodeToList(pCxt, &pHintList, opt, paramList, paramNum); + inParamList = false; + paramNum = 0; + opt = 0; + } + break; + case TK_NK_ID: + lastComma = false; + if (0 == opt || !inParamList) { + quit = true; + } else { + paramList[paramNum++] = t0; + } + break; + case TK_NK_COMMA: + if (lastComma) { + quit = true; + } + lastComma = true; + break; + case TK_NK_SPACE: + break; + default: + lastComma = false; + quit = true; + break; + } + } + + taosMemoryFree(hint); + return pHintList; +} + SNode* createIdentifierValueNode(SAstCreateContext* pCxt, SToken* pLiteral) { trimEscape(pLiteral); return createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, pLiteral); @@ -845,9 +962,9 @@ SNode* addFillClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pFill) { return pStmt; } -SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable) { +SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint) { CHECK_PARSER_STATUS(pCxt); - SNode* select = createSelectStmtImpl(isDistinct, pProjectionList, pTable); + SNode* select = createSelectStmtImpl(isDistinct, pProjectionList, pTable, pHint); CHECK_OUT_OF_MEM(select); return select; } diff --git a/source/libs/parser/src/parAstParser.c b/source/libs/parser/src/parAstParser.c index 86b4566d37..fdec9cba79 100644 --- a/source/libs/parser/src/parAstParser.c +++ b/source/libs/parser/src/parAstParser.c @@ -690,10 +690,8 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) { return collectMetaKeyFromShowDnodes(pCxt, (SShowStmt*)pStmt); case QUERY_NODE_SHOW_MNODES_STMT: return collectMetaKeyFromShowMnodes(pCxt, (SShowStmt*)pStmt); -/* case QUERY_NODE_SHOW_MODULES_STMT: return collectMetaKeyFromShowModules(pCxt, (SShowStmt*)pStmt); -*/ case QUERY_NODE_SHOW_QNODES_STMT: return collectMetaKeyFromShowQnodes(pCxt, (SShowStmt*)pStmt); case QUERY_NODE_SHOW_SNODES_STMT: diff --git a/source/libs/parser/src/parAuthenticator.c b/source/libs/parser/src/parAuthenticator.c index 6a26dcfa8b..9b2ac662c8 100644 --- a/source/libs/parser/src/parAuthenticator.c +++ b/source/libs/parser/src/parAuthenticator.c @@ -263,7 +263,7 @@ static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) { return authAlterTable(pCxt, (SAlterTableStmt*)pStmt); case QUERY_NODE_SHOW_DNODES_STMT: case QUERY_NODE_SHOW_MNODES_STMT: -// case QUERY_NODE_SHOW_MODULES_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: diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index ca7ac1a0b6..2d3c309610 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -42,6 +42,7 @@ static SKeyword keywordTable[] = { {"ASC", TK_ASC}, {"AT_ONCE", TK_AT_ONCE}, {"BALANCE", TK_BALANCE}, + {"BATCH_SCAN", TK_BATCH_SCAN}, {"BETWEEN", TK_BETWEEN}, {"BIGINT", TK_BIGINT}, {"BINARY", TK_BINARY}, @@ -153,6 +154,7 @@ static SKeyword keywordTable[] = { {"NONE", TK_NONE}, {"NOT", TK_NOT}, {"NOW", TK_NOW}, + {"NO_BATCH_SCAN", TK_NO_BATCH_SCAN}, {"NULL", TK_NULL}, {"NULL_F", TK_NULL_F}, {"NULLS", TK_NULLS}, @@ -398,10 +400,14 @@ uint32_t tGetToken(const char* z, uint32_t* tokenId) { *tokenId = TK_NK_SLASH; return 1; } + bool isHint = false; + if (z[2] == '+') { + isHint = true; + } for (i = 3; z[i] && (z[i] != '/' || z[i - 1] != '*'); i++) { } if (z[i]) i++; - *tokenId = TK_NK_COMMENT; + *tokenId = isHint ? TK_NK_HINT : TK_NK_COMMENT; return i; } case '%': { diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index ea33103798..473d177066 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -92,7 +92,6 @@ static const SSysTableShowAdapter sysTableShowAdapter[] = { .numOfShowCols = 1, .pShowCols = {"*"} }, -/* { .showType = QUERY_NODE_SHOW_MODULES_STMT, .pDbName = TSDB_INFORMATION_SCHEMA_DB, @@ -100,7 +99,6 @@ static const SSysTableShowAdapter sysTableShowAdapter[] = { .numOfShowCols = 1, .pShowCols = {"*"} }, -*/ { .showType = QUERY_NODE_SHOW_QNODES_STMT, .pDbName = TSDB_INFORMATION_SCHEMA_DB, @@ -2810,6 +2808,13 @@ static int32_t translateTable(STranslateContext* pCxt, SNode* pTable) { pJoinTable->table.precision = calcJoinTablePrecision(pJoinTable); pJoinTable->table.singleTable = joinTableIsSingleTable(pJoinTable); code = translateExpr(pCxt, &pJoinTable->pOnCond); + pJoinTable->hasSubQuery = (nodeType(pJoinTable->pLeft) != QUERY_NODE_REAL_TABLE) || (nodeType(pJoinTable->pRight) != QUERY_NODE_REAL_TABLE); + if (nodeType(pJoinTable->pLeft) == QUERY_NODE_JOIN_TABLE) { + ((SJoinTableNode*)pJoinTable->pLeft)->isLowLevelJoin = true; + } + if (nodeType(pJoinTable->pRight) == QUERY_NODE_JOIN_TABLE) { + ((SJoinTableNode*)pJoinTable->pRight)->isLowLevelJoin = true; + } } break; } @@ -6178,7 +6183,7 @@ static int32_t buildQueryForTableTopic(STranslateContext* pCxt, SCreateTopicStmt strcpy(realTable->table.dbName, pStmt->subDbName); strcpy(realTable->table.tableName, pStmt->subSTbName); strcpy(realTable->table.tableAlias, pStmt->subSTbName); - *pSelect = createSelectStmtImpl(true, pProjection, (SNode*)realTable); + *pSelect = createSelectStmtImpl(true, pProjection, (SNode*)realTable, NULL); ((SSelectStmt*)*pSelect)->pWhere = nodesCloneNode(pStmt->pWhere); pCxt->pParseCxt->topicQuery = true; code = translateQuery(pCxt, *pSelect); @@ -9199,7 +9204,7 @@ static int32_t rewriteQuery(STranslateContext* pCxt, SQuery* pQuery) { case QUERY_NODE_SHOW_USERS_STMT: case QUERY_NODE_SHOW_DNODES_STMT: case QUERY_NODE_SHOW_MNODES_STMT: -// case QUERY_NODE_SHOW_MODULES_STMT: + case QUERY_NODE_SHOW_MODULES_STMT: case QUERY_NODE_SHOW_QNODES_STMT: case QUERY_NODE_SHOW_FUNCTIONS_STMT: case QUERY_NODE_SHOW_INDEXES_STMT: diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c index 1c292b1ec4..c30efcb18c 100644 --- a/source/libs/parser/src/parUtil.c +++ b/source/libs/parser/src/parUtil.c @@ -692,7 +692,7 @@ int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalog } -SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable) { +SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint) { SSelectStmt* select = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT); if (NULL == select) { return NULL; @@ -704,6 +704,7 @@ SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* select->timeLineResMode = select->isDistinct ? TIME_LINE_NONE : TIME_LINE_GLOBAL; select->onlyHasKeepOrderFunc = true; select->timeRange = TSWINDOW_INITIALIZER; + select->pHint = pHint; return (SNode*)select; } @@ -1157,3 +1158,5 @@ int64_t int64SafeSub(int64_t a, int64_t b) { } return res; } + + diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index d1fe6d9091..a19b986732 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -1,5 +1,3 @@ -/* This file is automatically generated by Lemon from input grammar -** source file "sql.y". */ /* ** 2000-05-29 ** @@ -24,8 +22,9 @@ ** The following is the concatenation of all %include directives from the ** input grammar file: */ +#include +#include /************ Begin %include sections from the grammar ************************/ -#line 11 "sql.y" #include #include @@ -42,350 +41,12 @@ #include "parAst.h" #define YYSTACKDEPTH 0 -#line 46 "sql.c" /**************** End of %include directives **********************************/ -/* These constants specify the various numeric values for terminal symbols. -***************** Begin token definitions *************************************/ -#ifndef TK_OR -#define TK_OR 1 -#define TK_AND 2 -#define TK_UNION 3 -#define TK_ALL 4 -#define TK_MINUS 5 -#define TK_EXCEPT 6 -#define TK_INTERSECT 7 -#define TK_NK_BITAND 8 -#define TK_NK_BITOR 9 -#define TK_NK_LSHIFT 10 -#define TK_NK_RSHIFT 11 -#define TK_NK_PLUS 12 -#define TK_NK_MINUS 13 -#define TK_NK_STAR 14 -#define TK_NK_SLASH 15 -#define TK_NK_REM 16 -#define TK_NK_CONCAT 17 -#define TK_CREATE 18 -#define TK_ACCOUNT 19 -#define TK_NK_ID 20 -#define TK_PASS 21 -#define TK_NK_STRING 22 -#define TK_ALTER 23 -#define TK_PPS 24 -#define TK_TSERIES 25 -#define TK_STORAGE 26 -#define TK_STREAMS 27 -#define TK_QTIME 28 -#define TK_DBS 29 -#define TK_USERS 30 -#define TK_CONNS 31 -#define TK_STATE 32 -#define TK_USER 33 -#define TK_ENABLE 34 -#define TK_NK_INTEGER 35 -#define TK_SYSINFO 36 -#define TK_DROP 37 -#define TK_GRANT 38 -#define TK_ON 39 -#define TK_TO 40 -#define TK_REVOKE 41 -#define TK_FROM 42 -#define TK_SUBSCRIBE 43 -#define TK_NK_COMMA 44 -#define TK_READ 45 -#define TK_WRITE 46 -#define TK_NK_DOT 47 -#define TK_WITH 48 -#define TK_DNODE 49 -#define TK_PORT 50 -#define TK_DNODES 51 -#define TK_RESTORE 52 -#define TK_NK_IPTOKEN 53 -#define TK_FORCE 54 -#define TK_UNSAFE 55 -#define TK_LOCAL 56 -#define TK_QNODE 57 -#define TK_BNODE 58 -#define TK_SNODE 59 -#define TK_MNODE 60 -#define TK_VNODE 61 -#define TK_DATABASE 62 -#define TK_USE 63 -#define TK_FLUSH 64 -#define TK_TRIM 65 -#define TK_COMPACT 66 -#define TK_IF 67 -#define TK_NOT 68 -#define TK_EXISTS 69 -#define TK_BUFFER 70 -#define TK_CACHEMODEL 71 -#define TK_CACHESIZE 72 -#define TK_COMP 73 -#define TK_DURATION 74 -#define TK_NK_VARIABLE 75 -#define TK_MAXROWS 76 -#define TK_MINROWS 77 -#define TK_KEEP 78 -#define TK_PAGES 79 -#define TK_PAGESIZE 80 -#define TK_TSDB_PAGESIZE 81 -#define TK_PRECISION 82 -#define TK_REPLICA 83 -#define TK_VGROUPS 84 -#define TK_SINGLE_STABLE 85 -#define TK_RETENTIONS 86 -#define TK_SCHEMALESS 87 -#define TK_WAL_LEVEL 88 -#define TK_WAL_FSYNC_PERIOD 89 -#define TK_WAL_RETENTION_PERIOD 90 -#define TK_WAL_RETENTION_SIZE 91 -#define TK_WAL_ROLL_PERIOD 92 -#define TK_WAL_SEGMENT_SIZE 93 -#define TK_STT_TRIGGER 94 -#define TK_TABLE_PREFIX 95 -#define TK_TABLE_SUFFIX 96 -#define TK_NK_COLON 97 -#define TK_MAX_SPEED 98 -#define TK_START 99 -#define TK_TIMESTAMP 100 -#define TK_END 101 -#define TK_TABLE 102 -#define TK_NK_LP 103 -#define TK_NK_RP 104 -#define TK_STABLE 105 -#define TK_ADD 106 -#define TK_COLUMN 107 -#define TK_MODIFY 108 -#define TK_RENAME 109 -#define TK_TAG 110 -#define TK_SET 111 -#define TK_NK_EQ 112 -#define TK_USING 113 -#define TK_TAGS 114 -#define TK_COMMENT 115 -#define TK_BOOL 116 -#define TK_TINYINT 117 -#define TK_SMALLINT 118 -#define TK_INT 119 -#define TK_INTEGER 120 -#define TK_BIGINT 121 -#define TK_FLOAT 122 -#define TK_DOUBLE 123 -#define TK_BINARY 124 -#define TK_NCHAR 125 -#define TK_UNSIGNED 126 -#define TK_JSON 127 -#define TK_VARCHAR 128 -#define TK_MEDIUMBLOB 129 -#define TK_BLOB 130 -#define TK_VARBINARY 131 -#define TK_GEOMETRY 132 -#define TK_DECIMAL 133 -#define TK_MAX_DELAY 134 -#define TK_WATERMARK 135 -#define TK_ROLLUP 136 -#define TK_TTL 137 -#define TK_SMA 138 -#define TK_DELETE_MARK 139 -#define TK_FIRST 140 -#define TK_LAST 141 -#define TK_SHOW 142 -#define TK_PRIVILEGES 143 -#define TK_DATABASES 144 -#define TK_TABLES 145 -#define TK_STABLES 146 -#define TK_MNODES 147 -#define TK_QNODES 148 -#define TK_FUNCTIONS 149 -#define TK_INDEXES 150 -#define TK_ACCOUNTS 151 -#define TK_APPS 152 -#define TK_CONNECTIONS 153 -#define TK_LICENCES 154 -#define TK_GRANTS 155 -#define TK_QUERIES 156 -#define TK_SCORES 157 -#define TK_TOPICS 158 -#define TK_VARIABLES 159 -#define TK_CLUSTER 160 -#define TK_BNODES 161 -#define TK_SNODES 162 -#define TK_TRANSACTIONS 163 -#define TK_DISTRIBUTED 164 -#define TK_CONSUMERS 165 -#define TK_SUBSCRIPTIONS 166 -#define TK_VNODES 167 -#define TK_ALIVE 168 -#define TK_LIKE 169 -#define TK_TBNAME 170 -#define TK_QTAGS 171 -#define TK_AS 172 -#define TK_INDEX 173 -#define TK_FUNCTION 174 -#define TK_INTERVAL 175 -#define TK_COUNT 176 -#define TK_LAST_ROW 177 -#define TK_META 178 -#define TK_ONLY 179 -#define TK_TOPIC 180 -#define TK_CONSUMER 181 -#define TK_GROUP 182 -#define TK_DESC 183 -#define TK_DESCRIBE 184 -#define TK_RESET 185 -#define TK_QUERY 186 -#define TK_CACHE 187 -#define TK_EXPLAIN 188 -#define TK_ANALYZE 189 -#define TK_VERBOSE 190 -#define TK_NK_BOOL 191 -#define TK_RATIO 192 -#define TK_NK_FLOAT 193 -#define TK_OUTPUTTYPE 194 -#define TK_AGGREGATE 195 -#define TK_BUFSIZE 196 -#define TK_LANGUAGE 197 -#define TK_REPLACE 198 -#define TK_STREAM 199 -#define TK_INTO 200 -#define TK_PAUSE 201 -#define TK_RESUME 202 -#define TK_TRIGGER 203 -#define TK_AT_ONCE 204 -#define TK_WINDOW_CLOSE 205 -#define TK_IGNORE 206 -#define TK_EXPIRED 207 -#define TK_FILL_HISTORY 208 -#define TK_UPDATE 209 -#define TK_SUBTABLE 210 -#define TK_UNTREATED 211 -#define TK_KILL 212 -#define TK_CONNECTION 213 -#define TK_TRANSACTION 214 -#define TK_BALANCE 215 -#define TK_VGROUP 216 -#define TK_LEADER 217 -#define TK_MERGE 218 -#define TK_REDISTRIBUTE 219 -#define TK_SPLIT 220 -#define TK_DELETE 221 -#define TK_INSERT 222 -#define TK_NULL 223 -#define TK_NK_QUESTION 224 -#define TK_NK_ARROW 225 -#define TK_ROWTS 226 -#define TK_QSTART 227 -#define TK_QEND 228 -#define TK_QDURATION 229 -#define TK_WSTART 230 -#define TK_WEND 231 -#define TK_WDURATION 232 -#define TK_IROWTS 233 -#define TK_ISFILLED 234 -#define TK_CAST 235 -#define TK_NOW 236 -#define TK_TODAY 237 -#define TK_TIMEZONE 238 -#define TK_CLIENT_VERSION 239 -#define TK_SERVER_VERSION 240 -#define TK_SERVER_STATUS 241 -#define TK_CURRENT_USER 242 -#define TK_CASE 243 -#define TK_WHEN 244 -#define TK_THEN 245 -#define TK_ELSE 246 -#define TK_BETWEEN 247 -#define TK_IS 248 -#define TK_NK_LT 249 -#define TK_NK_GT 250 -#define TK_NK_LE 251 -#define TK_NK_GE 252 -#define TK_NK_NE 253 -#define TK_MATCH 254 -#define TK_NMATCH 255 -#define TK_CONTAINS 256 -#define TK_IN 257 -#define TK_JOIN 258 -#define TK_INNER 259 -#define TK_SELECT 260 -#define TK_DISTINCT 261 -#define TK_WHERE 262 -#define TK_PARTITION 263 -#define TK_BY 264 -#define TK_SESSION 265 -#define TK_STATE_WINDOW 266 -#define TK_EVENT_WINDOW 267 -#define TK_SLIDING 268 -#define TK_FILL 269 -#define TK_VALUE 270 -#define TK_VALUE_F 271 -#define TK_NONE 272 -#define TK_PREV 273 -#define TK_NULL_F 274 -#define TK_LINEAR 275 -#define TK_NEXT 276 -#define TK_HAVING 277 -#define TK_RANGE 278 -#define TK_EVERY 279 -#define TK_ORDER 280 -#define TK_SLIMIT 281 -#define TK_SOFFSET 282 -#define TK_LIMIT 283 -#define TK_OFFSET 284 -#define TK_ASC 285 -#define TK_NULLS 286 -#define TK_ABORT 287 -#define TK_AFTER 288 -#define TK_ATTACH 289 -#define TK_BEFORE 290 -#define TK_BEGIN 291 -#define TK_BITAND 292 -#define TK_BITNOT 293 -#define TK_BITOR 294 -#define TK_BLOCKS 295 -#define TK_CHANGE 296 -#define TK_COMMA 297 -#define TK_CONCAT 298 -#define TK_CONFLICT 299 -#define TK_COPY 300 -#define TK_DEFERRED 301 -#define TK_DELIMITERS 302 -#define TK_DETACH 303 -#define TK_DIVIDE 304 -#define TK_DOT 305 -#define TK_EACH 306 -#define TK_FAIL 307 -#define TK_FILE 308 -#define TK_FOR 309 -#define TK_GLOB 310 -#define TK_ID 311 -#define TK_IMMEDIATE 312 -#define TK_IMPORT 313 -#define TK_INITIALLY 314 -#define TK_INSTEAD 315 -#define TK_ISNULL 316 -#define TK_KEY 317 -#define TK_MODULES 318 -#define TK_NK_BITNOT 319 -#define TK_NK_SEMI 320 -#define TK_NOTNULL 321 -#define TK_OF 322 -#define TK_PLUS 323 -#define TK_PRIVILEGE 324 -#define TK_RAISE 325 -#define TK_RESTRICT 326 -#define TK_ROW 327 -#define TK_SEMI 328 -#define TK_STAR 329 -#define TK_STATEMENT 330 -#define TK_STRICT 331 -#define TK_STRING 332 -#define TK_TIMES 333 -#define TK_VALUES 334 -#define TK_VARIABLE 335 -#define TK_VIEW 336 -#define TK_WAL 337 -#endif -/**************** End token definitions ***************************************/ +/* These constants specify the various numeric values for terminal symbols +** in a format understandable to "makeheaders". This section is blank unless +** "lemon" is run with the "-m" command-line option. +***************** Begin makeheaders token definitions *************************/ +/**************** End makeheaders token definitions ***************************/ /* The next sections is a series of control #defines. ** various aspects of the generated parser. @@ -443,27 +104,27 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 488 +#define YYNOCODE 490 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - SNodeList* yy56; - EOperatorType yy76; - EOrder yy82; - SToken yy129; - int8_t yy215; - bool yy313; - int32_t yy356; - SAlterOption yy461; - STokenPair yy505; - ENullOrder yy521; - EFillMode yy694; - EJoinType yy708; - int64_t yy717; - SDataType yy784; - SNode* yy840; + SAlterOption yy25; + SDataType yy84; + SToken yy169; + EFillMode yy214; + int8_t yy243; + int32_t yy480; + EOrder yy498; + EOperatorType yy520; + STokenPair yy637; + SNodeList* yy824; + EJoinType yy932; + int64_t yy949; + SNode* yy952; + bool yy957; + ENullOrder yy977; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -479,18 +140,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 800 -#define YYNRULE 603 -#define YYNRULE_WITH_ACTION 603 -#define YYNTOKEN 338 -#define YY_MAX_SHIFT 799 -#define YY_MIN_SHIFTREDUCE 1181 -#define YY_MAX_SHIFTREDUCE 1783 -#define YY_ERROR_ACTION 1784 -#define YY_ACCEPT_ACTION 1785 -#define YY_NO_ACTION 1786 -#define YY_MIN_REDUCE 1787 -#define YY_MAX_REDUCE 2389 +#define YYNSTATE 801 +#define YYNRULE 605 +#define YYNRULE_WITH_ACTION 605 +#define YYNTOKEN 339 +#define YY_MAX_SHIFT 800 +#define YY_MIN_SHIFTREDUCE 1183 +#define YY_MAX_SHIFTREDUCE 1787 +#define YY_ERROR_ACTION 1788 +#define YY_ACCEPT_ACTION 1789 +#define YY_NO_ACTION 1790 +#define YY_MIN_REDUCE 1791 +#define YY_MAX_REDUCE 2395 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -557,854 +218,843 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (3028) +#define YY_ACTTAB_COUNT (2957) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 735, 2198, 2176, 532, 2018, 2159, 533, 1823, 90, 450, - /* 10 */ 364, 705, 48, 46, 1710, 169, 2184, 1799, 2016, 181, - /* 20 */ 398, 2087, 1557, 41, 40, 368, 2180, 47, 45, 44, - /* 30 */ 43, 42, 66, 1638, 1959, 1555, 2085, 675, 366, 2070, - /* 40 */ 2216, 146, 41, 40, 2257, 2087, 47, 45, 44, 43, - /* 50 */ 42, 2166, 628, 704, 345, 2360, 2176, 391, 401, 2198, - /* 60 */ 2084, 675, 1633, 1582, 2182, 395, 1966, 163, 19, 668, - /* 70 */ 1955, 2366, 188, 380, 698, 1563, 2361, 654, 30, 687, - /* 80 */ 2180, 2016, 653, 358, 537, 2360, 2059, 2197, 2365, 2233, - /* 90 */ 534, 2360, 170, 2199, 708, 2201, 2202, 703, 2216, 698, - /* 100 */ 796, 652, 188, 15, 38, 303, 2361, 654, 2364, 2166, - /* 110 */ 673, 704, 2361, 2363, 2012, 2013, 48, 46, 2182, 47, - /* 120 */ 45, 44, 43, 42, 398, 453, 1557, 1667, 698, 688, - /* 130 */ 1964, 62, 62, 629, 2325, 407, 406, 1638, 1750, 1555, - /* 140 */ 1640, 1641, 221, 1242, 1243, 2197, 535, 2233, 1830, 135, - /* 150 */ 112, 2199, 708, 2201, 2202, 703, 572, 698, 1564, 223, - /* 160 */ 688, 1964, 185, 535, 2286, 1830, 1633, 674, 394, 2282, - /* 170 */ 1613, 1623, 19, 1582, 688, 1964, 1639, 1642, 168, 1563, - /* 180 */ 135, 549, 190, 627, 1668, 1788, 1905, 577, 568, 567, - /* 190 */ 2314, 1558, 125, 1556, 193, 124, 123, 122, 121, 120, - /* 200 */ 119, 118, 117, 116, 796, 745, 125, 15, 2198, 124, - /* 210 */ 123, 122, 121, 120, 119, 118, 117, 116, 705, 547, - /* 220 */ 1669, 2080, 648, 1561, 1562, 1787, 1612, 1615, 1616, 1617, - /* 230 */ 1618, 1619, 1620, 1621, 1622, 700, 696, 1631, 1632, 1634, - /* 240 */ 1635, 1636, 1637, 2, 1640, 1641, 687, 2216, 1583, 134, - /* 250 */ 133, 132, 131, 130, 129, 128, 127, 126, 2166, 1239, - /* 260 */ 704, 1238, 37, 396, 1662, 1663, 1664, 1665, 1666, 1670, - /* 270 */ 1671, 1672, 1673, 540, 1613, 1623, 533, 1823, 41, 40, - /* 280 */ 1639, 1642, 47, 45, 44, 43, 42, 248, 285, 285, - /* 290 */ 1585, 247, 1240, 687, 2197, 1558, 2233, 1556, 35, 112, - /* 300 */ 2199, 708, 2201, 2202, 703, 643, 698, 60, 1674, 147, - /* 310 */ 184, 155, 2257, 2286, 625, 2198, 1567, 394, 2282, 44, - /* 320 */ 43, 42, 2005, 1466, 1467, 668, 103, 1561, 1562, 51, - /* 330 */ 1612, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 700, - /* 340 */ 696, 1631, 1632, 1634, 1635, 1636, 1637, 2, 12, 48, - /* 350 */ 46, 1957, 93, 737, 2216, 353, 2009, 398, 378, 1557, - /* 360 */ 606, 1373, 1583, 529, 9, 2166, 1582, 704, 1408, 1409, - /* 370 */ 1638, 527, 1555, 647, 523, 519, 51, 1364, 733, 732, - /* 380 */ 731, 1368, 730, 1370, 1371, 729, 726, 2365, 1379, 723, - /* 390 */ 1381, 1382, 720, 717, 714, 649, 644, 637, 2160, 1633, - /* 400 */ 611, 2197, 2216, 2233, 1584, 19, 112, 2199, 708, 2201, - /* 410 */ 2202, 703, 1563, 698, 590, 589, 588, 207, 185, 576, - /* 420 */ 2286, 580, 141, 584, 394, 2282, 371, 583, 12, 2198, - /* 430 */ 570, 569, 582, 587, 374, 373, 2301, 796, 581, 705, - /* 440 */ 15, 575, 262, 392, 595, 628, 2315, 628, 2360, 62, - /* 450 */ 2360, 1966, 166, 48, 46, 1643, 646, 86, 674, 605, - /* 460 */ 85, 398, 2298, 1557, 2366, 188, 2366, 188, 2216, 2361, - /* 470 */ 654, 2361, 654, 246, 1638, 2301, 1555, 1640, 1641, 2166, - /* 480 */ 1785, 704, 1483, 1484, 455, 2066, 41, 40, 1773, 598, - /* 490 */ 47, 45, 44, 43, 42, 372, 592, 370, 369, 2198, - /* 500 */ 574, 2297, 245, 1633, 576, 461, 2066, 1613, 1623, 705, - /* 510 */ 672, 1832, 2080, 1639, 1642, 2197, 1563, 2233, 1482, 1485, - /* 520 */ 113, 2199, 708, 2201, 2202, 703, 575, 698, 1558, 2018, - /* 530 */ 1556, 202, 255, 285, 2286, 379, 665, 144, 2216, 2283, - /* 540 */ 1584, 796, 70, 2016, 49, 69, 12, 1214, 10, 2166, - /* 550 */ 1585, 704, 205, 413, 488, 2066, 284, 1810, 412, 1316, - /* 560 */ 1561, 1562, 674, 1612, 1615, 1616, 1617, 1618, 1619, 1620, - /* 570 */ 1621, 1622, 700, 696, 1631, 1632, 1634, 1635, 1636, 1637, - /* 580 */ 2, 1640, 1641, 604, 1701, 2197, 1216, 2233, 1219, 1220, - /* 590 */ 112, 2199, 708, 2201, 2202, 703, 602, 698, 600, 1318, - /* 600 */ 628, 210, 2380, 2360, 2286, 1809, 285, 2166, 394, 2282, - /* 610 */ 2049, 1613, 1623, 1239, 683, 1238, 2080, 1639, 1642, 2366, - /* 620 */ 188, 586, 585, 1327, 2361, 654, 62, 237, 140, 613, - /* 630 */ 688, 1964, 1558, 1866, 1556, 2176, 1326, 688, 1964, 667, - /* 640 */ 186, 2294, 2295, 173, 142, 2299, 1240, 249, 2198, 2185, - /* 650 */ 56, 566, 562, 558, 554, 2166, 236, 448, 705, 2180, - /* 660 */ 2322, 1780, 767, 765, 1561, 1562, 1563, 1612, 1615, 1616, - /* 670 */ 1617, 1618, 1619, 1620, 1621, 1622, 700, 696, 1631, 1632, - /* 680 */ 1634, 1635, 1636, 1637, 2, 48, 46, 2216, 495, 688, - /* 690 */ 1964, 736, 284, 398, 2301, 1557, 91, 2182, 2166, 234, - /* 700 */ 704, 504, 203, 590, 589, 588, 1638, 698, 1555, 449, - /* 710 */ 580, 141, 584, 442, 444, 441, 583, 1528, 1529, 443, - /* 720 */ 2296, 582, 587, 374, 373, 41, 40, 581, 52, 47, - /* 730 */ 45, 44, 43, 42, 2197, 1633, 2233, 669, 432, 112, - /* 740 */ 2199, 708, 2201, 2202, 703, 440, 698, 158, 1563, 212, - /* 750 */ 211, 2380, 403, 2286, 699, 2011, 2013, 394, 2282, 688, - /* 760 */ 1964, 628, 401, 1779, 2360, 434, 430, 233, 227, 473, - /* 770 */ 1966, 166, 494, 796, 232, 545, 49, 1738, 472, 463, - /* 780 */ 2366, 188, 2149, 285, 628, 2361, 654, 2360, 2018, 48, - /* 790 */ 46, 1953, 166, 225, 388, 1808, 2198, 398, 181, 1557, - /* 800 */ 688, 1964, 2016, 2366, 188, 2018, 705, 55, 2361, 654, - /* 810 */ 1638, 393, 1555, 1640, 1641, 665, 144, 1714, 2071, 2016, - /* 820 */ 478, 1749, 1941, 1582, 640, 639, 1736, 1737, 1739, 1740, - /* 830 */ 1741, 2365, 2131, 404, 2360, 2216, 1807, 665, 144, 1633, - /* 840 */ 2364, 1966, 166, 1613, 1623, 2166, 2166, 755, 704, 1639, - /* 850 */ 1642, 2364, 1563, 41, 40, 2361, 2362, 47, 45, 44, - /* 860 */ 43, 42, 34, 258, 1558, 1940, 1556, 741, 41, 40, - /* 870 */ 2009, 1906, 47, 45, 44, 43, 42, 796, 688, 1964, - /* 880 */ 15, 250, 2197, 2198, 2233, 285, 2166, 171, 2199, 708, - /* 890 */ 2201, 2202, 703, 705, 698, 2335, 1561, 1562, 479, 1612, - /* 900 */ 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 700, 696, - /* 910 */ 1631, 1632, 1634, 1635, 1636, 1637, 2, 1640, 1641, 187, - /* 920 */ 2294, 2295, 2216, 142, 2299, 90, 690, 109, 2258, 1707, - /* 930 */ 688, 1964, 745, 2166, 692, 704, 2258, 743, 1800, 655, - /* 940 */ 2381, 189, 2294, 2295, 145, 142, 2299, 1613, 1623, 1726, - /* 950 */ 548, 1960, 1956, 1639, 1642, 279, 160, 159, 740, 739, - /* 960 */ 738, 157, 688, 1964, 742, 688, 1964, 2009, 1558, 2197, - /* 970 */ 1556, 2233, 2328, 1614, 112, 2199, 708, 2201, 2202, 703, - /* 980 */ 2187, 698, 1961, 1648, 36, 685, 2380, 1939, 2286, 1582, - /* 990 */ 41, 40, 394, 2282, 47, 45, 44, 43, 42, 427, - /* 1000 */ 1561, 1562, 1863, 1612, 1615, 1616, 1617, 1618, 1619, 1620, - /* 1010 */ 1621, 1622, 700, 696, 1631, 1632, 1634, 1635, 1636, 1637, - /* 1020 */ 2, 2018, 349, 167, 1580, 688, 1964, 402, 324, 688, - /* 1030 */ 1964, 486, 688, 1964, 502, 2016, 2189, 501, 688, 1964, - /* 1040 */ 14, 13, 321, 73, 1582, 251, 72, 688, 1964, 259, - /* 1050 */ 1331, 273, 671, 469, 1806, 503, 317, 346, 298, 1995, - /* 1060 */ 471, 1219, 1220, 1330, 1805, 1804, 139, 686, 219, 514, - /* 1070 */ 512, 509, 773, 772, 771, 770, 410, 1803, 769, 768, - /* 1080 */ 148, 763, 762, 761, 760, 759, 758, 757, 162, 753, - /* 1090 */ 752, 751, 409, 408, 748, 747, 746, 176, 175, 1802, - /* 1100 */ 688, 1964, 743, 657, 2166, 1585, 367, 1222, 62, 688, - /* 1110 */ 1964, 294, 295, 1581, 2166, 2166, 293, 656, 457, 1557, - /* 1120 */ 304, 160, 159, 740, 739, 738, 157, 2166, 506, 405, - /* 1130 */ 41, 40, 1555, 2152, 47, 45, 44, 43, 42, 1614, - /* 1140 */ 665, 144, 54, 1681, 3, 1801, 1798, 111, 499, 2166, - /* 1150 */ 1797, 493, 492, 491, 490, 485, 484, 483, 482, 481, - /* 1160 */ 477, 476, 475, 474, 348, 466, 465, 464, 1796, 459, - /* 1170 */ 458, 365, 1563, 41, 40, 1949, 166, 47, 45, 44, - /* 1180 */ 43, 42, 420, 1795, 1794, 1793, 1706, 1792, 81, 80, - /* 1190 */ 447, 2198, 743, 200, 1614, 2166, 2166, 796, 1951, 166, - /* 1200 */ 2166, 705, 756, 635, 1791, 1926, 439, 437, 1947, 166, - /* 1210 */ 158, 160, 159, 740, 739, 738, 157, 347, 2166, 2198, - /* 1220 */ 428, 2306, 1701, 426, 422, 418, 415, 440, 1790, 705, - /* 1230 */ 2216, 2353, 1942, 2166, 2166, 2166, 653, 2166, 83, 2360, - /* 1240 */ 137, 2166, 74, 704, 282, 2294, 664, 242, 136, 663, - /* 1250 */ 240, 2360, 2198, 695, 2166, 652, 188, 261, 2216, 578, - /* 1260 */ 2361, 654, 705, 158, 2305, 285, 2018, 652, 188, 2166, - /* 1270 */ 1523, 704, 2361, 654, 1967, 166, 149, 2197, 2166, 2233, - /* 1280 */ 2017, 1314, 112, 2199, 708, 2201, 2202, 703, 1558, 698, - /* 1290 */ 1556, 2216, 84, 260, 2380, 151, 2286, 608, 150, 607, - /* 1300 */ 394, 2282, 2166, 579, 704, 2197, 244, 2233, 1850, 243, - /* 1310 */ 112, 2199, 708, 2201, 2202, 703, 153, 698, 50, 152, - /* 1320 */ 1561, 1562, 2380, 1526, 2286, 1312, 50, 1566, 394, 2282, - /* 1330 */ 591, 266, 1782, 1783, 1565, 660, 94, 165, 2197, 158, - /* 1340 */ 2233, 658, 2198, 112, 2199, 708, 2201, 2202, 703, 1841, - /* 1350 */ 698, 1839, 705, 407, 406, 2380, 641, 2286, 50, 291, - /* 1360 */ 1904, 394, 2282, 1571, 71, 156, 158, 14, 13, 64, - /* 1370 */ 2198, 593, 108, 596, 1638, 1903, 1564, 2217, 1735, 411, - /* 1380 */ 705, 2216, 105, 50, 50, 381, 1734, 1273, 749, 712, - /* 1390 */ 156, 268, 2166, 2075, 704, 750, 1833, 158, 1824, 670, - /* 1400 */ 138, 1829, 2006, 1633, 2318, 666, 281, 156, 1659, 2216, - /* 1410 */ 1292, 278, 1, 5, 419, 1588, 1563, 1290, 1480, 296, - /* 1420 */ 2166, 414, 704, 362, 680, 300, 1357, 1274, 2197, 1675, - /* 1430 */ 2233, 436, 2198, 112, 2199, 708, 2201, 2202, 703, 435, - /* 1440 */ 698, 694, 705, 1624, 316, 2261, 791, 2286, 195, 1386, - /* 1450 */ 1390, 394, 2282, 196, 438, 198, 2197, 1397, 2233, 1504, - /* 1460 */ 1395, 112, 2199, 708, 2201, 2202, 703, 161, 698, 311, - /* 1470 */ 1581, 2216, 454, 2259, 209, 2286, 456, 1585, 460, 394, - /* 1480 */ 2282, 2076, 2166, 467, 704, 1569, 462, 497, 1580, 480, - /* 1490 */ 489, 2068, 1568, 487, 496, 498, 214, 508, 507, 2198, - /* 1500 */ 505, 510, 216, 513, 515, 213, 511, 1586, 4, 705, - /* 1510 */ 530, 614, 538, 1583, 224, 531, 541, 539, 2197, 542, - /* 1520 */ 2233, 226, 1587, 112, 2199, 708, 2201, 2202, 703, 799, - /* 1530 */ 698, 543, 1572, 1589, 1567, 691, 544, 2286, 2216, 229, - /* 1540 */ 231, 394, 2282, 310, 550, 546, 88, 571, 89, 2166, - /* 1550 */ 235, 704, 573, 1954, 239, 1950, 241, 1952, 1948, 180, - /* 1560 */ 114, 2198, 2140, 612, 1575, 1577, 352, 789, 785, 781, - /* 1570 */ 777, 705, 308, 2137, 2136, 661, 92, 696, 1631, 1632, - /* 1580 */ 1634, 1635, 1636, 1637, 610, 2197, 154, 2233, 616, 615, - /* 1590 */ 113, 2199, 708, 2201, 2202, 703, 252, 698, 620, 256, - /* 1600 */ 2216, 1511, 622, 623, 2286, 312, 617, 2319, 2285, 2282, - /* 1610 */ 678, 2166, 110, 704, 254, 301, 621, 2329, 632, 642, - /* 1620 */ 264, 638, 651, 267, 2198, 2334, 384, 2333, 645, 276, - /* 1630 */ 272, 8, 2308, 631, 705, 630, 633, 277, 1701, 143, - /* 1640 */ 1584, 659, 662, 2383, 385, 1704, 2302, 2197, 684, 2233, - /* 1650 */ 178, 286, 113, 2199, 708, 2201, 2202, 703, 98, 698, - /* 1660 */ 1590, 2081, 313, 2216, 676, 174, 2286, 274, 275, 677, - /* 1670 */ 693, 2282, 2095, 191, 2166, 2094, 704, 2093, 314, 681, - /* 1680 */ 390, 100, 2359, 288, 315, 2198, 102, 280, 682, 1965, - /* 1690 */ 287, 61, 2267, 104, 710, 702, 2010, 1927, 318, 792, - /* 1700 */ 307, 342, 2158, 2198, 354, 793, 327, 795, 53, 253, - /* 1710 */ 706, 355, 2233, 705, 2157, 113, 2199, 708, 2201, 2202, - /* 1720 */ 703, 2156, 698, 322, 2216, 78, 2153, 320, 416, 2286, - /* 1730 */ 417, 1548, 1549, 357, 2282, 2166, 194, 704, 421, 2151, - /* 1740 */ 341, 331, 2216, 423, 424, 425, 2150, 2148, 363, 2147, - /* 1750 */ 429, 431, 2146, 2166, 433, 704, 1539, 2127, 197, 2126, - /* 1760 */ 199, 1507, 79, 1506, 2198, 2108, 2107, 2106, 445, 446, - /* 1770 */ 2105, 2197, 2104, 2233, 705, 1457, 339, 2199, 708, 2201, - /* 1780 */ 2202, 703, 701, 698, 689, 2251, 2058, 452, 451, 2197, - /* 1790 */ 2055, 2233, 201, 2054, 170, 2199, 708, 2201, 2202, 703, - /* 1800 */ 82, 698, 2053, 2216, 206, 2045, 468, 382, 2052, 2057, - /* 1810 */ 204, 2056, 2051, 2050, 2166, 2048, 704, 2047, 2046, 470, - /* 1820 */ 2061, 2044, 2198, 2043, 2042, 2041, 2040, 2039, 2038, 2037, - /* 1830 */ 2036, 2035, 705, 2034, 2033, 2032, 2326, 2031, 2030, 208, - /* 1840 */ 2029, 2198, 87, 2028, 2027, 2026, 2060, 2025, 2024, 2023, - /* 1850 */ 2197, 705, 2233, 2022, 1459, 340, 2199, 708, 2201, 2202, - /* 1860 */ 703, 2216, 698, 2021, 2020, 383, 500, 2019, 1869, 215, - /* 1870 */ 350, 1868, 2166, 1328, 704, 1867, 1332, 1324, 217, 1865, - /* 1880 */ 2216, 218, 1862, 1861, 351, 516, 1854, 520, 517, 1843, - /* 1890 */ 521, 2166, 524, 704, 518, 522, 528, 1819, 526, 1221, - /* 1900 */ 1818, 2125, 220, 2115, 76, 2103, 222, 525, 2197, 77, - /* 1910 */ 2233, 2102, 228, 340, 2199, 708, 2201, 2202, 703, 2186, - /* 1920 */ 698, 2198, 182, 183, 536, 230, 2079, 2197, 1943, 2233, - /* 1930 */ 1864, 705, 333, 2199, 708, 2201, 2202, 703, 1266, 698, - /* 1940 */ 1860, 551, 2198, 553, 552, 1858, 557, 555, 556, 1856, - /* 1950 */ 559, 560, 705, 561, 1853, 563, 565, 564, 1838, 1836, - /* 1960 */ 2216, 1837, 1835, 1815, 1945, 1401, 1402, 1944, 1315, 1313, - /* 1970 */ 1311, 2166, 1310, 704, 1309, 1302, 650, 1308, 1851, 1307, - /* 1980 */ 764, 2216, 766, 1304, 1842, 389, 63, 1303, 375, 1840, - /* 1990 */ 238, 1301, 2166, 376, 704, 377, 1814, 594, 1813, 1812, - /* 2000 */ 597, 603, 115, 599, 601, 1533, 2124, 2197, 2198, 2233, - /* 2010 */ 1535, 1532, 171, 2199, 708, 2201, 2202, 703, 702, 698, - /* 2020 */ 1537, 29, 67, 1513, 1515, 2114, 618, 2101, 2197, 2100, - /* 2030 */ 2233, 2365, 17, 340, 2199, 708, 2201, 2202, 703, 20, - /* 2040 */ 698, 21, 6, 23, 31, 2198, 65, 2216, 7, 636, - /* 2050 */ 271, 1752, 22, 57, 263, 705, 634, 270, 2166, 2187, - /* 2060 */ 704, 265, 619, 1492, 1733, 2382, 2198, 257, 1491, 283, - /* 2070 */ 624, 1767, 1766, 386, 33, 172, 705, 269, 24, 1771, - /* 2080 */ 32, 164, 1517, 95, 2216, 1725, 1770, 626, 397, 1772, - /* 2090 */ 1773, 387, 59, 177, 2197, 2166, 2233, 704, 97, 339, - /* 2100 */ 2199, 708, 2201, 2202, 703, 2216, 698, 2099, 2252, 399, - /* 2110 */ 2078, 1698, 289, 2077, 1697, 290, 2166, 96, 704, 25, - /* 2120 */ 99, 1731, 292, 297, 2198, 302, 68, 101, 105, 26, - /* 2130 */ 13, 2197, 1650, 2233, 705, 2236, 340, 2199, 708, 2201, - /* 2140 */ 2202, 703, 1649, 698, 1573, 2198, 58, 1660, 179, 1628, - /* 2150 */ 697, 192, 2197, 1626, 2233, 705, 299, 340, 2199, 708, - /* 2160 */ 2201, 2202, 703, 2216, 698, 679, 11, 39, 1605, 709, - /* 2170 */ 1625, 16, 27, 28, 2166, 1597, 704, 18, 1387, 711, - /* 2180 */ 400, 1384, 713, 715, 2216, 716, 718, 1383, 1380, 719, - /* 2190 */ 721, 722, 724, 1374, 725, 2166, 1372, 704, 727, 728, - /* 2200 */ 1363, 1378, 1377, 2198, 305, 734, 1376, 1396, 106, 107, - /* 2210 */ 609, 75, 2233, 705, 1392, 335, 2199, 708, 2201, 2202, - /* 2220 */ 703, 1375, 698, 1264, 1296, 1295, 707, 744, 1294, 1293, - /* 2230 */ 1291, 2197, 1289, 2233, 1288, 2198, 325, 2199, 708, 2201, - /* 2240 */ 2202, 703, 2216, 698, 1287, 705, 1322, 754, 306, 1282, - /* 2250 */ 1285, 1284, 1283, 2166, 1281, 704, 1280, 1279, 1319, 1317, - /* 2260 */ 1276, 1275, 1270, 2198, 1272, 1271, 1269, 1859, 774, 775, - /* 2270 */ 1857, 776, 778, 705, 2216, 1855, 782, 779, 780, 1852, - /* 2280 */ 786, 784, 788, 783, 787, 2166, 1834, 704, 790, 2197, - /* 2290 */ 1211, 2233, 1811, 309, 323, 2199, 708, 2201, 2202, 703, - /* 2300 */ 1559, 698, 2216, 794, 798, 319, 797, 1786, 1786, 1786, - /* 2310 */ 1786, 1786, 1786, 2166, 1786, 704, 1786, 1786, 1786, 1786, - /* 2320 */ 1786, 2197, 1786, 2233, 1786, 1786, 326, 2199, 708, 2201, - /* 2330 */ 2202, 703, 1786, 698, 2198, 1786, 1786, 1786, 1786, 1786, - /* 2340 */ 1786, 1786, 1786, 1786, 705, 1786, 1786, 1786, 1786, 2197, - /* 2350 */ 2198, 2233, 1786, 1786, 332, 2199, 708, 2201, 2202, 703, - /* 2360 */ 705, 698, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2370 */ 1786, 1786, 1786, 2216, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2380 */ 1786, 1786, 1786, 1786, 2166, 1786, 704, 1786, 1786, 2216, - /* 2390 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2400 */ 2166, 1786, 704, 1786, 1786, 1786, 1786, 1786, 2198, 1786, - /* 2410 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 705, 1786, - /* 2420 */ 2197, 1786, 2233, 1786, 1786, 336, 2199, 708, 2201, 2202, - /* 2430 */ 703, 1786, 698, 1786, 1786, 1786, 2197, 1786, 2233, 2198, - /* 2440 */ 1786, 328, 2199, 708, 2201, 2202, 703, 2216, 698, 705, - /* 2450 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2166, 1786, - /* 2460 */ 704, 1786, 1786, 1786, 1786, 1786, 2198, 1786, 1786, 1786, - /* 2470 */ 1786, 1786, 1786, 1786, 1786, 1786, 705, 1786, 2216, 1786, - /* 2480 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2166, - /* 2490 */ 1786, 704, 1786, 1786, 2197, 1786, 2233, 2198, 1786, 337, - /* 2500 */ 2199, 708, 2201, 2202, 703, 2216, 698, 705, 1786, 1786, - /* 2510 */ 1786, 1786, 1786, 1786, 1786, 1786, 2166, 1786, 704, 1786, - /* 2520 */ 1786, 1786, 1786, 1786, 1786, 2197, 1786, 2233, 1786, 1786, - /* 2530 */ 329, 2199, 708, 2201, 2202, 703, 2216, 698, 1786, 1786, - /* 2540 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2166, 1786, 704, - /* 2550 */ 1786, 1786, 2197, 1786, 2233, 2198, 1786, 338, 2199, 708, - /* 2560 */ 2201, 2202, 703, 1786, 698, 705, 1786, 1786, 1786, 1786, - /* 2570 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2198, 1786, 1786, - /* 2580 */ 1786, 1786, 1786, 2197, 1786, 2233, 1786, 705, 330, 2199, - /* 2590 */ 708, 2201, 2202, 703, 2216, 698, 1786, 1786, 1786, 1786, - /* 2600 */ 1786, 1786, 1786, 1786, 1786, 2166, 1786, 704, 1786, 1786, - /* 2610 */ 1786, 1786, 1786, 1786, 1786, 1786, 2216, 1786, 1786, 1786, - /* 2620 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2166, 1786, 704, - /* 2630 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2640 */ 1786, 2197, 1786, 2233, 2198, 1786, 343, 2199, 708, 2201, - /* 2650 */ 2202, 703, 1786, 698, 705, 1786, 1786, 1786, 1786, 1786, - /* 2660 */ 1786, 1786, 1786, 2197, 1786, 2233, 1786, 1786, 344, 2199, - /* 2670 */ 708, 2201, 2202, 703, 1786, 698, 2198, 1786, 1786, 1786, - /* 2680 */ 1786, 1786, 1786, 2216, 1786, 1786, 705, 1786, 1786, 1786, - /* 2690 */ 1786, 1786, 1786, 1786, 2166, 1786, 704, 1786, 1786, 1786, - /* 2700 */ 1786, 1786, 2198, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2710 */ 1786, 1786, 705, 1786, 1786, 2216, 1786, 1786, 1786, 1786, - /* 2720 */ 1786, 1786, 1786, 1786, 1786, 1786, 2166, 1786, 704, 1786, - /* 2730 */ 2197, 1786, 2233, 1786, 1786, 2210, 2199, 708, 2201, 2202, - /* 2740 */ 703, 2216, 698, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2750 */ 1786, 1786, 2166, 1786, 704, 1786, 1786, 1786, 1786, 1786, - /* 2760 */ 1786, 1786, 2197, 1786, 2233, 1786, 1786, 2209, 2199, 708, - /* 2770 */ 2201, 2202, 703, 1786, 698, 1786, 1786, 1786, 1786, 1786, - /* 2780 */ 1786, 2198, 1786, 1786, 1786, 1786, 1786, 1786, 2197, 1786, - /* 2790 */ 2233, 705, 1786, 2208, 2199, 708, 2201, 2202, 703, 1786, - /* 2800 */ 698, 1786, 2198, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2810 */ 1786, 1786, 705, 1786, 1786, 1786, 1786, 1786, 2198, 1786, - /* 2820 */ 2216, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 705, 1786, - /* 2830 */ 1786, 2166, 1786, 704, 1786, 1786, 1786, 1786, 1786, 2198, - /* 2840 */ 1786, 2216, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 705, - /* 2850 */ 1786, 1786, 2166, 1786, 704, 1786, 1786, 2216, 1786, 1786, - /* 2860 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2197, 2166, 2233, - /* 2870 */ 704, 1786, 359, 2199, 708, 2201, 2202, 703, 2216, 698, - /* 2880 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2197, 2166, - /* 2890 */ 2233, 704, 1786, 360, 2199, 708, 2201, 2202, 703, 1786, - /* 2900 */ 698, 1786, 1786, 1786, 2197, 1786, 2233, 2198, 1786, 356, - /* 2910 */ 2199, 708, 2201, 2202, 703, 1786, 698, 705, 1786, 1786, - /* 2920 */ 1786, 1786, 1786, 1786, 1786, 2197, 1786, 2233, 1786, 2198, - /* 2930 */ 361, 2199, 708, 2201, 2202, 703, 1786, 698, 1786, 705, - /* 2940 */ 1786, 1786, 1786, 1786, 1786, 1786, 2216, 1786, 1786, 1786, - /* 2950 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2166, 1786, 704, - /* 2960 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2216, 1786, - /* 2970 */ 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2166, - /* 2980 */ 1786, 704, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, - /* 2990 */ 1786, 1786, 1786, 706, 1786, 2233, 1786, 1786, 335, 2199, - /* 3000 */ 708, 2201, 2202, 703, 1786, 698, 1786, 1786, 1786, 1786, - /* 3010 */ 1786, 1786, 1786, 1786, 1786, 2197, 1786, 2233, 1786, 1786, - /* 3020 */ 334, 2199, 708, 2201, 2202, 703, 1786, 698, + /* 0 */ 736, 2202, 2180, 2091, 738, 689, 1968, 2013, 1216, 38, + /* 10 */ 304, 669, 48, 46, 1714, 392, 2188, 1946, 2088, 676, + /* 20 */ 399, 255, 1559, 41, 40, 135, 2184, 47, 45, 44, + /* 30 */ 43, 42, 573, 1640, 2022, 1557, 689, 1968, 41, 40, + /* 40 */ 2220, 2163, 47, 45, 44, 43, 42, 1218, 2021, 1221, + /* 50 */ 1222, 2170, 1241, 705, 1240, 1584, 135, 2180, 2180, 666, + /* 60 */ 144, 149, 1635, 578, 2186, 396, 533, 140, 19, 534, + /* 70 */ 1827, 1959, 2189, 451, 699, 1565, 541, 666, 144, 534, + /* 80 */ 1827, 2184, 2184, 359, 2022, 1242, 688, 2201, 629, 2237, + /* 90 */ 380, 2366, 112, 2203, 709, 2205, 2206, 704, 2020, 699, + /* 100 */ 797, 689, 1968, 15, 185, 2135, 2290, 2091, 2372, 188, + /* 110 */ 395, 2286, 2153, 2367, 655, 181, 48, 46, 346, 2186, + /* 120 */ 2186, 193, 2089, 676, 399, 190, 1559, 1669, 1375, 699, + /* 130 */ 699, 1584, 221, 2320, 367, 2074, 536, 1640, 1834, 1557, + /* 140 */ 1642, 1643, 456, 2070, 1366, 734, 733, 732, 1370, 731, + /* 150 */ 1372, 1373, 730, 727, 250, 1381, 724, 1383, 1384, 721, + /* 160 */ 718, 715, 668, 186, 2298, 2299, 1635, 142, 2303, 51, + /* 170 */ 1615, 1625, 19, 169, 223, 1803, 1641, 1644, 536, 1565, + /* 180 */ 1834, 282, 2298, 665, 1670, 136, 664, 1585, 2366, 202, + /* 190 */ 688, 1560, 125, 1558, 62, 124, 123, 122, 121, 120, + /* 200 */ 119, 118, 117, 116, 797, 653, 188, 15, 2202, 530, + /* 210 */ 2367, 655, 52, 1784, 62, 666, 144, 528, 706, 674, + /* 220 */ 524, 520, 249, 1563, 1564, 1792, 1614, 1617, 1618, 1619, + /* 230 */ 1620, 1621, 1622, 1623, 1624, 701, 697, 1633, 1634, 1636, + /* 240 */ 1637, 1638, 1639, 2, 1642, 1643, 125, 2220, 550, 124, + /* 250 */ 123, 122, 121, 120, 119, 118, 117, 116, 2170, 1791, + /* 260 */ 705, 66, 37, 397, 1664, 1665, 1666, 1667, 1668, 1672, + /* 270 */ 1673, 1674, 1675, 404, 1615, 1625, 2015, 2017, 689, 1968, + /* 280 */ 1641, 1644, 649, 134, 133, 132, 131, 130, 129, 128, + /* 290 */ 127, 126, 1530, 1531, 2201, 1560, 2237, 1558, 56, 112, + /* 300 */ 2203, 709, 2205, 2206, 704, 644, 699, 1410, 1411, 147, + /* 310 */ 1586, 155, 2261, 2290, 746, 2202, 1783, 395, 2286, 187, + /* 320 */ 2298, 2299, 1584, 142, 2303, 669, 286, 1563, 1564, 428, + /* 330 */ 1614, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 701, + /* 340 */ 697, 1633, 1634, 1636, 1637, 1638, 1639, 2, 12, 48, + /* 350 */ 46, 286, 2371, 402, 2220, 2366, 168, 399, 372, 1559, + /* 360 */ 62, 1970, 163, 184, 1909, 2170, 1814, 705, 381, 286, + /* 370 */ 1640, 286, 1557, 2370, 675, 2009, 2020, 2367, 2369, 41, + /* 380 */ 40, 496, 614, 47, 45, 44, 43, 42, 462, 2070, + /* 390 */ 1565, 1587, 666, 144, 2202, 12, 650, 645, 638, 1635, + /* 400 */ 688, 2201, 737, 2237, 703, 19, 112, 2203, 709, 2205, + /* 410 */ 2206, 704, 1565, 699, 689, 1968, 2170, 1813, 185, 756, + /* 420 */ 2290, 689, 1968, 596, 395, 2286, 548, 373, 2084, 371, + /* 430 */ 370, 2305, 575, 2220, 449, 205, 577, 797, 606, 109, + /* 440 */ 15, 450, 212, 211, 2170, 2022, 705, 2321, 1870, 689, + /* 450 */ 1968, 389, 246, 48, 46, 1645, 145, 2302, 576, 2020, + /* 460 */ 2202, 399, 284, 1559, 1960, 495, 648, 2170, 599, 464, + /* 470 */ 706, 1318, 1468, 1469, 1640, 593, 1557, 1642, 1643, 1812, + /* 480 */ 2201, 245, 2237, 51, 1811, 340, 2203, 709, 2205, 2206, + /* 490 */ 704, 702, 699, 690, 2255, 2220, 189, 2298, 2299, 2220, + /* 500 */ 142, 2303, 181, 1635, 12, 433, 10, 1615, 1625, 538, + /* 510 */ 2170, 1320, 705, 1641, 1644, 535, 1565, 286, 591, 590, + /* 520 */ 589, 70, 2075, 2371, 69, 581, 141, 585, 1560, 2170, + /* 530 */ 1558, 584, 435, 431, 2170, 675, 583, 588, 375, 374, + /* 540 */ 1586, 797, 582, 262, 49, 1810, 2201, 2202, 2237, 647, + /* 550 */ 2053, 170, 2203, 709, 2205, 2206, 704, 706, 699, 1836, + /* 560 */ 1563, 1564, 90, 1614, 1617, 1618, 1619, 1620, 1621, 1622, + /* 570 */ 1623, 1624, 701, 697, 1633, 1634, 1636, 1637, 1638, 1639, + /* 580 */ 2, 1642, 1643, 591, 590, 589, 2220, 673, 1964, 2084, + /* 590 */ 581, 141, 585, 630, 2331, 2170, 584, 2170, 691, 705, + /* 600 */ 2262, 583, 588, 375, 374, 654, 700, 582, 2366, 689, + /* 610 */ 1968, 1615, 1625, 2022, 408, 407, 628, 1641, 1644, 365, + /* 620 */ 2016, 2017, 2022, 1789, 1777, 653, 188, 2020, 394, 479, + /* 630 */ 2367, 655, 1560, 2201, 1558, 2237, 2020, 1566, 112, 2203, + /* 640 */ 709, 2205, 2206, 704, 2370, 699, 689, 1968, 295, 296, + /* 650 */ 2386, 675, 2290, 294, 41, 40, 395, 2286, 47, 45, + /* 660 */ 44, 43, 42, 258, 1563, 1564, 480, 1614, 1617, 1618, + /* 670 */ 1619, 1620, 1621, 1622, 1623, 1624, 701, 697, 1633, 1634, + /* 680 */ 1636, 1637, 1638, 1639, 2, 48, 46, 689, 1968, 2202, + /* 690 */ 30, 654, 284, 399, 2366, 1559, 414, 1585, 1944, 706, + /* 700 */ 693, 413, 2262, 684, 1742, 2084, 1640, 549, 1557, 474, + /* 710 */ 2202, 653, 188, 103, 489, 2070, 2367, 655, 473, 90, + /* 720 */ 706, 1945, 62, 2022, 689, 1968, 41, 40, 2220, 403, + /* 730 */ 47, 45, 44, 43, 42, 1635, 369, 2020, 1961, 2170, + /* 740 */ 60, 705, 1809, 629, 1965, 1963, 2366, 626, 1565, 2220, + /* 750 */ 1754, 207, 641, 640, 1740, 1741, 1743, 1744, 1745, 605, + /* 760 */ 2170, 210, 705, 2372, 188, 746, 689, 1968, 2367, 655, + /* 770 */ 393, 577, 603, 797, 601, 2201, 49, 2237, 1970, 166, + /* 780 */ 171, 2203, 709, 2205, 2206, 704, 251, 699, 1808, 48, + /* 790 */ 46, 86, 2170, 576, 85, 1569, 2201, 399, 2237, 1559, + /* 800 */ 1910, 113, 2203, 709, 2205, 2206, 704, 1804, 699, 443, + /* 810 */ 1640, 442, 1557, 1642, 1643, 2290, 2305, 1485, 1486, 2289, + /* 820 */ 2286, 445, 1753, 41, 40, 2305, 444, 47, 45, 44, + /* 830 */ 43, 42, 2334, 656, 2387, 2202, 744, 1943, 2170, 1635, + /* 840 */ 1224, 441, 2301, 1615, 1625, 706, 1583, 689, 1968, 1641, + /* 850 */ 1644, 2300, 1565, 1484, 1487, 160, 159, 741, 740, 739, + /* 860 */ 157, 402, 689, 1968, 1560, 279, 1558, 672, 629, 1970, + /* 870 */ 166, 2366, 689, 1968, 2220, 689, 1968, 797, 146, 286, + /* 880 */ 15, 2261, 259, 742, 1718, 2170, 2013, 705, 2372, 188, + /* 890 */ 1584, 642, 299, 2367, 655, 686, 1563, 1564, 2063, 1614, + /* 900 */ 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 701, 697, + /* 910 */ 1633, 1634, 1636, 1637, 1638, 1639, 2, 1642, 1643, 1730, + /* 920 */ 139, 2201, 657, 2237, 587, 586, 113, 2203, 709, 2205, + /* 930 */ 2206, 704, 743, 699, 405, 2013, 744, 454, 14, 13, + /* 940 */ 2290, 2371, 1970, 166, 2366, 2287, 1807, 1615, 1625, 689, + /* 950 */ 1968, 1329, 744, 1641, 1644, 160, 159, 741, 740, 739, + /* 960 */ 157, 1711, 2370, 237, 1328, 2191, 2367, 2368, 1560, 687, + /* 970 */ 1558, 160, 159, 741, 740, 739, 157, 689, 1968, 173, + /* 980 */ 47, 45, 44, 43, 42, 1650, 1806, 567, 563, 559, + /* 990 */ 555, 1584, 236, 1241, 273, 1240, 2170, 305, 1244, 1245, + /* 1000 */ 1563, 1564, 1867, 1614, 1617, 1618, 1619, 1620, 1621, 1622, + /* 1010 */ 1623, 1624, 701, 697, 1633, 1634, 1636, 1637, 1638, 1639, + /* 1020 */ 2, 2193, 350, 167, 1582, 382, 1242, 1805, 325, 505, + /* 1030 */ 318, 487, 91, 1999, 503, 234, 2170, 502, 34, 1587, + /* 1040 */ 1616, 1683, 322, 73, 41, 40, 72, 9, 47, 45, + /* 1050 */ 44, 43, 42, 470, 54, 504, 3, 347, 41, 40, + /* 1060 */ 472, 1908, 47, 45, 44, 43, 42, 2164, 219, 515, + /* 1070 */ 513, 510, 774, 773, 772, 771, 411, 2170, 770, 769, + /* 1080 */ 148, 764, 763, 762, 761, 760, 759, 758, 162, 754, + /* 1090 */ 753, 752, 410, 409, 749, 748, 747, 176, 175, 44, + /* 1100 */ 43, 42, 757, 233, 227, 1930, 368, 1587, 62, 36, + /* 1110 */ 232, 546, 689, 1968, 629, 41, 40, 2366, 458, 47, + /* 1120 */ 45, 44, 43, 42, 1671, 1802, 569, 568, 83, 225, + /* 1130 */ 137, 1559, 406, 1333, 2372, 188, 1584, 1801, 658, 2367, + /* 1140 */ 655, 1616, 571, 570, 1557, 1800, 1332, 111, 500, 1799, + /* 1150 */ 661, 494, 493, 492, 491, 486, 485, 484, 483, 482, + /* 1160 */ 478, 477, 476, 475, 349, 467, 466, 465, 612, 460, + /* 1170 */ 459, 366, 41, 40, 579, 2170, 47, 45, 44, 43, + /* 1180 */ 42, 248, 2202, 74, 1565, 247, 1568, 2170, 81, 80, + /* 1190 */ 448, 203, 706, 200, 2328, 2170, 1316, 1798, 1797, 2170, + /* 1200 */ 1796, 1795, 35, 768, 766, 242, 440, 438, 240, 797, + /* 1210 */ 1794, 507, 1676, 1221, 1222, 629, 670, 348, 2366, 1710, + /* 1220 */ 429, 2220, 165, 427, 423, 419, 416, 441, 1957, 166, + /* 1230 */ 1953, 166, 2170, 84, 705, 2372, 188, 1955, 166, 158, + /* 1240 */ 2367, 655, 580, 2202, 1951, 166, 93, 2170, 2170, 354, + /* 1250 */ 2170, 2170, 379, 706, 607, 2341, 1971, 166, 2156, 261, + /* 1260 */ 2170, 2310, 1703, 629, 1314, 286, 2366, 1703, 2201, 2221, + /* 1270 */ 2237, 260, 696, 112, 2203, 709, 2205, 2206, 704, 609, + /* 1280 */ 699, 608, 2220, 2372, 188, 2386, 1616, 2290, 2367, 655, + /* 1290 */ 1854, 395, 2286, 2170, 1845, 705, 1843, 158, 151, 55, + /* 1300 */ 1560, 150, 1558, 244, 158, 153, 243, 421, 152, 50, + /* 1310 */ 50, 2202, 592, 266, 94, 158, 594, 1567, 597, 1786, + /* 1320 */ 1787, 706, 50, 636, 1907, 292, 1275, 71, 156, 2201, + /* 1330 */ 158, 2237, 1563, 1564, 112, 2203, 709, 2205, 2206, 704, + /* 1340 */ 412, 699, 2079, 1828, 1571, 1837, 2386, 1833, 2290, 2010, + /* 1350 */ 2220, 64, 395, 2286, 14, 13, 2324, 1525, 50, 50, + /* 1360 */ 667, 2170, 281, 705, 1528, 713, 1276, 750, 156, 1739, + /* 1370 */ 1738, 108, 158, 268, 2202, 671, 138, 659, 156, 751, + /* 1380 */ 278, 105, 1482, 5, 706, 297, 2359, 681, 301, 1294, + /* 1390 */ 1359, 662, 415, 1, 363, 792, 420, 2201, 1590, 2237, + /* 1400 */ 2202, 1292, 112, 2203, 709, 2205, 2206, 704, 437, 699, + /* 1410 */ 706, 1677, 2309, 2220, 2386, 195, 2290, 436, 1626, 317, + /* 1420 */ 395, 2286, 196, 439, 2170, 1388, 705, 1661, 1392, 1506, + /* 1430 */ 198, 312, 1399, 455, 1583, 2202, 1397, 209, 161, 2220, + /* 1440 */ 457, 1587, 2080, 461, 463, 706, 498, 1582, 468, 488, + /* 1450 */ 2170, 481, 705, 2072, 490, 506, 497, 499, 508, 509, + /* 1460 */ 2201, 214, 2237, 511, 213, 112, 2203, 709, 2205, 2206, + /* 1470 */ 704, 1588, 699, 216, 2220, 1570, 512, 2386, 514, 2290, + /* 1480 */ 516, 531, 4, 395, 2286, 2170, 2201, 705, 2237, 532, + /* 1490 */ 539, 112, 2203, 709, 2205, 2206, 704, 540, 699, 542, + /* 1500 */ 224, 408, 407, 2386, 2202, 2290, 1585, 543, 226, 395, + /* 1510 */ 2286, 1573, 1589, 544, 706, 1591, 229, 545, 547, 231, + /* 1520 */ 551, 2201, 1640, 2237, 1566, 572, 112, 2203, 709, 2205, + /* 1530 */ 2206, 704, 2202, 699, 88, 89, 235, 114, 2265, 574, + /* 1540 */ 2290, 353, 706, 2220, 395, 2286, 2144, 1958, 239, 2141, + /* 1550 */ 611, 1635, 1954, 241, 2170, 2140, 705, 613, 1956, 1952, + /* 1560 */ 92, 313, 154, 252, 1565, 617, 618, 2202, 616, 1513, + /* 1570 */ 254, 2220, 256, 624, 621, 2325, 633, 706, 643, 679, + /* 1580 */ 639, 385, 2170, 623, 705, 2335, 646, 2340, 2339, 695, + /* 1590 */ 2201, 8, 2237, 652, 264, 112, 2203, 709, 2205, 2206, + /* 1600 */ 704, 622, 699, 2312, 272, 174, 2220, 2263, 267, 2290, + /* 1610 */ 634, 274, 632, 395, 2286, 275, 631, 2170, 2201, 705, + /* 1620 */ 2237, 277, 276, 112, 2203, 709, 2205, 2206, 704, 1703, + /* 1630 */ 699, 386, 2389, 663, 280, 692, 2365, 2290, 1586, 143, + /* 1640 */ 660, 395, 2286, 1708, 2306, 1706, 178, 287, 1592, 191, + /* 1650 */ 98, 2085, 314, 2201, 2202, 2237, 285, 315, 113, 2203, + /* 1660 */ 709, 2205, 2206, 704, 706, 699, 677, 678, 2099, 100, + /* 1670 */ 682, 2098, 2290, 61, 683, 316, 694, 2286, 102, 1969, + /* 1680 */ 1574, 2271, 1569, 104, 2202, 711, 1931, 2097, 319, 391, + /* 1690 */ 2014, 793, 796, 2220, 706, 794, 308, 328, 321, 342, + /* 1700 */ 332, 53, 323, 343, 2170, 2162, 705, 2161, 355, 2160, + /* 1710 */ 356, 78, 1577, 1579, 2157, 417, 418, 1550, 1551, 194, + /* 1720 */ 422, 2155, 424, 2220, 425, 697, 1633, 1634, 1636, 1637, + /* 1730 */ 1638, 1639, 426, 2154, 2170, 364, 705, 2152, 430, 2151, + /* 1740 */ 707, 432, 2237, 434, 1541, 113, 2203, 709, 2205, 2206, + /* 1750 */ 704, 2150, 699, 2131, 197, 2202, 2130, 199, 1509, 2290, + /* 1760 */ 79, 2112, 1508, 358, 2286, 706, 2111, 2110, 446, 447, + /* 1770 */ 2201, 2109, 2237, 2108, 1459, 170, 2203, 709, 2205, 2206, + /* 1780 */ 704, 2062, 699, 452, 453, 2059, 2058, 201, 82, 2057, + /* 1790 */ 2056, 2061, 204, 2060, 2220, 2055, 2054, 2052, 383, 2051, + /* 1800 */ 2050, 206, 2049, 469, 471, 2170, 2065, 705, 2048, 2047, + /* 1810 */ 2046, 2045, 2044, 2202, 2043, 2042, 2041, 2040, 2332, 2039, + /* 1820 */ 2038, 2037, 2036, 706, 2035, 2034, 208, 2202, 2033, 87, + /* 1830 */ 2032, 2031, 2030, 2064, 2029, 2028, 2027, 706, 2026, 2025, + /* 1840 */ 1461, 2201, 501, 2237, 2202, 2024, 341, 2203, 709, 2205, + /* 1850 */ 2206, 704, 2220, 699, 706, 2023, 384, 230, 2106, 1330, + /* 1860 */ 1873, 351, 1334, 2170, 1326, 705, 2220, 215, 1872, 217, + /* 1870 */ 1871, 352, 1869, 1866, 1865, 1858, 517, 2170, 1847, 705, + /* 1880 */ 1823, 1223, 521, 2220, 525, 519, 1822, 523, 218, 527, + /* 1890 */ 2129, 529, 518, 522, 2170, 220, 705, 2119, 182, 2201, + /* 1900 */ 526, 2237, 76, 77, 341, 2203, 709, 2205, 2206, 704, + /* 1910 */ 2107, 699, 2190, 2201, 2202, 2237, 183, 222, 334, 2203, + /* 1920 */ 709, 2205, 2206, 704, 706, 699, 537, 228, 2083, 1947, + /* 1930 */ 2201, 1268, 2237, 2202, 1868, 171, 2203, 709, 2205, 2206, + /* 1940 */ 704, 1864, 699, 703, 552, 553, 554, 1862, 556, 2202, + /* 1950 */ 557, 558, 1860, 2220, 560, 561, 562, 390, 1857, 706, + /* 1960 */ 564, 1842, 566, 651, 2170, 565, 705, 1840, 1841, 1839, + /* 1970 */ 1819, 1949, 2220, 63, 1404, 1403, 238, 1948, 1317, 1315, + /* 1980 */ 1313, 1312, 765, 2170, 1311, 705, 1310, 1304, 2220, 2388, + /* 1990 */ 1309, 1306, 398, 1855, 767, 1305, 376, 1303, 1846, 2170, + /* 2000 */ 2201, 705, 2237, 377, 1844, 341, 2203, 709, 2205, 2206, + /* 2010 */ 704, 378, 699, 598, 595, 1818, 1817, 600, 602, 2201, + /* 2020 */ 2202, 2237, 1816, 604, 340, 2203, 709, 2205, 2206, 704, + /* 2030 */ 706, 699, 615, 2256, 115, 2201, 1539, 2237, 1535, 29, + /* 2040 */ 341, 2203, 709, 2205, 2206, 704, 1537, 699, 1534, 2128, + /* 2050 */ 800, 67, 1515, 57, 1517, 2202, 2118, 1519, 619, 2220, + /* 2060 */ 2105, 620, 2104, 400, 311, 706, 257, 1494, 2371, 625, + /* 2070 */ 2170, 1493, 705, 20, 6, 31, 164, 635, 627, 1756, + /* 2080 */ 180, 21, 263, 7, 637, 2202, 22, 172, 790, 786, + /* 2090 */ 782, 778, 17, 309, 2220, 706, 265, 270, 1737, 269, + /* 2100 */ 32, 271, 2191, 1729, 1776, 2170, 2201, 705, 2237, 95, + /* 2110 */ 33, 341, 2203, 709, 2205, 2206, 704, 23, 699, 65, + /* 2120 */ 24, 1771, 2202, 1777, 2220, 1770, 387, 1775, 1774, 388, + /* 2130 */ 283, 1700, 706, 110, 1699, 2170, 302, 705, 2103, 59, + /* 2140 */ 2082, 610, 58, 2237, 177, 290, 336, 2203, 709, 2205, + /* 2150 */ 2206, 704, 18, 699, 96, 25, 97, 2081, 99, 300, + /* 2160 */ 293, 2220, 291, 1735, 298, 680, 68, 101, 303, 685, + /* 2170 */ 26, 2201, 2170, 2237, 705, 1652, 326, 2203, 709, 2205, + /* 2180 */ 2206, 704, 105, 699, 2202, 11, 1651, 13, 1575, 1662, + /* 2190 */ 2240, 179, 1630, 1628, 706, 192, 710, 1607, 712, 2202, + /* 2200 */ 1627, 1380, 698, 39, 289, 16, 27, 28, 2201, 706, + /* 2210 */ 2237, 288, 1599, 324, 2203, 709, 2205, 2206, 704, 1389, + /* 2220 */ 699, 401, 1386, 2220, 716, 714, 719, 708, 717, 722, + /* 2230 */ 253, 1385, 720, 723, 2170, 1382, 705, 1376, 2220, 725, + /* 2240 */ 1374, 728, 726, 1365, 729, 306, 1379, 1398, 106, 2170, + /* 2250 */ 2202, 705, 107, 75, 1378, 1394, 1266, 735, 1377, 1298, + /* 2260 */ 706, 745, 1297, 1296, 2202, 1295, 1293, 1291, 755, 1290, + /* 2270 */ 2201, 1289, 2237, 1324, 706, 327, 2203, 709, 2205, 2206, + /* 2280 */ 704, 307, 699, 1287, 1286, 2201, 1285, 2237, 1284, 2220, + /* 2290 */ 333, 2203, 709, 2205, 2206, 704, 1863, 699, 1283, 1282, + /* 2300 */ 2170, 1321, 705, 2220, 1281, 1319, 1278, 1277, 1274, 1273, + /* 2310 */ 1272, 1271, 775, 1861, 2170, 2202, 705, 776, 777, 779, + /* 2320 */ 781, 1859, 783, 1856, 785, 706, 787, 780, 789, 784, + /* 2330 */ 1838, 788, 791, 1213, 1815, 795, 2201, 310, 2237, 1561, + /* 2340 */ 320, 337, 2203, 709, 2205, 2206, 704, 798, 699, 799, + /* 2350 */ 2201, 1790, 2237, 1790, 2220, 329, 2203, 709, 2205, 2206, + /* 2360 */ 704, 1790, 699, 1790, 1790, 2170, 1790, 705, 1790, 1790, + /* 2370 */ 1790, 1790, 1790, 1790, 1790, 2202, 1790, 1790, 1790, 1790, + /* 2380 */ 1790, 1790, 1790, 1790, 1790, 706, 1790, 1790, 1790, 1790, + /* 2390 */ 2202, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2400 */ 706, 2201, 1790, 2237, 1790, 1790, 338, 2203, 709, 2205, + /* 2410 */ 2206, 704, 1790, 699, 2220, 1790, 1790, 1790, 1790, 1790, + /* 2420 */ 1790, 1790, 1790, 1790, 1790, 2170, 1790, 705, 1790, 2220, + /* 2430 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2440 */ 2170, 1790, 705, 1790, 1790, 1790, 1790, 1790, 2202, 1790, + /* 2450 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 706, 1790, + /* 2460 */ 1790, 2201, 1790, 2237, 1790, 2202, 330, 2203, 709, 2205, + /* 2470 */ 2206, 704, 1790, 699, 1790, 706, 2201, 1790, 2237, 2202, + /* 2480 */ 1790, 339, 2203, 709, 2205, 2206, 704, 2220, 699, 706, + /* 2490 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2170, 1790, + /* 2500 */ 705, 1790, 1790, 1790, 2220, 1790, 1790, 1790, 1790, 1790, + /* 2510 */ 1790, 1790, 1790, 1790, 1790, 2170, 2202, 705, 2220, 1790, + /* 2520 */ 1790, 1790, 1790, 1790, 1790, 1790, 706, 1790, 1790, 2170, + /* 2530 */ 1790, 705, 1790, 1790, 2201, 1790, 2237, 2202, 1790, 331, + /* 2540 */ 2203, 709, 2205, 2206, 704, 1790, 699, 706, 1790, 1790, + /* 2550 */ 1790, 2201, 1790, 2237, 1790, 2220, 344, 2203, 709, 2205, + /* 2560 */ 2206, 704, 1790, 699, 1790, 2201, 2170, 2237, 705, 1790, + /* 2570 */ 345, 2203, 709, 2205, 2206, 704, 2220, 699, 1790, 1790, + /* 2580 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2170, 1790, 705, + /* 2590 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2600 */ 1790, 1790, 2201, 2202, 2237, 1790, 1790, 2214, 2203, 709, + /* 2610 */ 2205, 2206, 704, 706, 699, 1790, 1790, 2202, 1790, 1790, + /* 2620 */ 1790, 1790, 1790, 2201, 1790, 2237, 1790, 706, 2213, 2203, + /* 2630 */ 709, 2205, 2206, 704, 2202, 699, 1790, 1790, 1790, 1790, + /* 2640 */ 1790, 1790, 2220, 1790, 706, 1790, 1790, 1790, 1790, 1790, + /* 2650 */ 1790, 1790, 1790, 2170, 1790, 705, 2220, 1790, 1790, 1790, + /* 2660 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2170, 1790, 705, + /* 2670 */ 1790, 1790, 1790, 2220, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2680 */ 1790, 1790, 1790, 1790, 2170, 1790, 705, 1790, 1790, 2201, + /* 2690 */ 1790, 2237, 1790, 1790, 2212, 2203, 709, 2205, 2206, 704, + /* 2700 */ 1790, 699, 1790, 2201, 1790, 2237, 1790, 1790, 360, 2203, + /* 2710 */ 709, 2205, 2206, 704, 1790, 699, 1790, 1790, 1790, 1790, + /* 2720 */ 2201, 1790, 2237, 1790, 1790, 361, 2203, 709, 2205, 2206, + /* 2730 */ 704, 1790, 699, 2202, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2740 */ 1790, 1790, 1790, 706, 1790, 1790, 1790, 1790, 1790, 2202, + /* 2750 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 706, + /* 2760 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2202, 1790, + /* 2770 */ 1790, 1790, 2220, 1790, 1790, 1790, 1790, 1790, 706, 1790, + /* 2780 */ 1790, 1790, 1790, 2170, 1790, 705, 1790, 1790, 2220, 1790, + /* 2790 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2170, + /* 2800 */ 1790, 705, 1790, 1790, 1790, 1790, 1790, 2220, 1790, 1790, + /* 2810 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2170, 2201, + /* 2820 */ 705, 2237, 1790, 1790, 357, 2203, 709, 2205, 2206, 704, + /* 2830 */ 1790, 699, 1790, 1790, 1790, 2201, 1790, 2237, 1790, 1790, + /* 2840 */ 362, 2203, 709, 2205, 2206, 704, 1790, 699, 1790, 1790, + /* 2850 */ 1790, 1790, 1790, 1790, 707, 1790, 2237, 1790, 2202, 336, + /* 2860 */ 2203, 709, 2205, 2206, 704, 1790, 699, 1790, 706, 1790, + /* 2870 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2880 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2890 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2220, 1790, 1790, + /* 2900 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 2170, 1790, + /* 2910 */ 705, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2920 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2930 */ 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, 1790, + /* 2940 */ 1790, 1790, 1790, 1790, 2201, 1790, 2237, 1790, 1790, 335, + /* 2950 */ 2203, 709, 2205, 2206, 704, 1790, 699, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 387, 341, 367, 345, 380, 411, 348, 349, 359, 350, - /* 10 */ 386, 351, 12, 13, 14, 340, 381, 342, 394, 380, - /* 20 */ 20, 393, 22, 8, 9, 376, 391, 12, 13, 14, - /* 30 */ 15, 16, 4, 33, 385, 35, 408, 409, 399, 400, - /* 40 */ 380, 442, 8, 9, 445, 393, 12, 13, 14, 15, - /* 50 */ 16, 391, 458, 393, 395, 461, 367, 405, 371, 341, - /* 60 */ 408, 409, 62, 20, 429, 430, 379, 380, 68, 351, - /* 70 */ 381, 477, 478, 386, 439, 75, 482, 483, 44, 20, - /* 80 */ 391, 394, 458, 68, 14, 461, 0, 427, 458, 429, - /* 90 */ 20, 461, 432, 433, 434, 435, 436, 437, 380, 439, - /* 100 */ 100, 477, 478, 103, 447, 448, 482, 483, 478, 391, - /* 110 */ 20, 393, 482, 483, 392, 393, 12, 13, 429, 12, - /* 120 */ 13, 14, 15, 16, 20, 39, 22, 112, 439, 350, - /* 130 */ 351, 103, 103, 473, 474, 12, 13, 33, 104, 35, - /* 140 */ 140, 141, 346, 54, 55, 427, 350, 429, 352, 370, - /* 150 */ 432, 433, 434, 435, 436, 437, 377, 439, 35, 346, - /* 160 */ 350, 351, 444, 350, 446, 352, 62, 350, 450, 451, - /* 170 */ 170, 171, 68, 20, 350, 351, 176, 177, 360, 75, - /* 180 */ 370, 67, 464, 48, 169, 0, 368, 377, 355, 356, - /* 190 */ 472, 191, 21, 193, 370, 24, 25, 26, 27, 28, - /* 200 */ 29, 30, 31, 32, 100, 67, 21, 103, 341, 24, - /* 210 */ 25, 26, 27, 28, 29, 30, 31, 32, 351, 402, - /* 220 */ 169, 404, 20, 223, 224, 0, 226, 227, 228, 229, + /* 0 */ 388, 342, 368, 394, 389, 351, 352, 392, 4, 448, + /* 10 */ 449, 352, 12, 13, 14, 406, 382, 0, 409, 410, + /* 20 */ 20, 388, 22, 8, 9, 371, 392, 12, 13, 14, + /* 30 */ 15, 16, 378, 33, 381, 35, 351, 352, 8, 9, + /* 40 */ 381, 412, 12, 13, 14, 15, 16, 43, 395, 45, + /* 50 */ 46, 392, 20, 394, 22, 20, 371, 368, 368, 351, + /* 60 */ 352, 44, 62, 378, 430, 431, 346, 35, 68, 349, + /* 70 */ 350, 382, 382, 351, 440, 75, 346, 351, 352, 349, + /* 80 */ 350, 392, 392, 68, 381, 53, 20, 428, 459, 430, + /* 90 */ 387, 462, 433, 434, 435, 436, 437, 438, 395, 440, + /* 100 */ 100, 351, 352, 103, 445, 376, 447, 394, 479, 480, + /* 110 */ 451, 452, 0, 484, 485, 381, 12, 13, 396, 430, + /* 120 */ 430, 371, 409, 410, 20, 466, 22, 112, 100, 440, + /* 130 */ 440, 20, 347, 474, 400, 401, 351, 33, 353, 35, + /* 140 */ 140, 141, 351, 352, 116, 117, 118, 119, 120, 121, + /* 150 */ 122, 123, 124, 125, 425, 127, 128, 129, 130, 131, + /* 160 */ 132, 133, 454, 455, 456, 457, 62, 459, 460, 103, + /* 170 */ 170, 171, 68, 341, 347, 343, 176, 177, 351, 75, + /* 180 */ 353, 455, 456, 457, 169, 459, 460, 20, 462, 398, + /* 190 */ 20, 191, 21, 193, 103, 24, 25, 26, 27, 28, + /* 200 */ 29, 30, 31, 32, 100, 479, 480, 103, 342, 49, + /* 210 */ 484, 485, 103, 183, 103, 351, 352, 57, 352, 20, + /* 220 */ 60, 61, 134, 223, 224, 0, 226, 227, 228, 229, /* 230 */ 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - /* 240 */ 240, 241, 242, 243, 140, 141, 20, 380, 20, 24, - /* 250 */ 25, 26, 27, 28, 29, 30, 31, 32, 391, 20, - /* 260 */ 393, 22, 247, 248, 249, 250, 251, 252, 253, 254, - /* 270 */ 255, 256, 257, 345, 170, 171, 348, 349, 8, 9, - /* 280 */ 176, 177, 12, 13, 14, 15, 16, 135, 260, 260, - /* 290 */ 20, 139, 53, 20, 427, 191, 429, 193, 247, 432, - /* 300 */ 433, 434, 435, 436, 437, 175, 439, 172, 257, 442, - /* 310 */ 378, 444, 445, 446, 179, 341, 193, 450, 451, 14, - /* 320 */ 15, 16, 390, 170, 171, 351, 357, 223, 224, 103, + /* 240 */ 240, 241, 242, 243, 140, 141, 21, 381, 67, 24, + /* 250 */ 25, 26, 27, 28, 29, 30, 31, 32, 392, 0, + /* 260 */ 394, 4, 247, 248, 249, 250, 251, 252, 253, 254, + /* 270 */ 255, 256, 257, 390, 170, 171, 393, 394, 351, 352, + /* 280 */ 176, 177, 20, 24, 25, 26, 27, 28, 29, 30, + /* 290 */ 31, 32, 204, 205, 428, 191, 430, 193, 371, 433, + /* 300 */ 434, 435, 436, 437, 438, 175, 440, 140, 141, 443, + /* 310 */ 20, 445, 446, 447, 67, 342, 286, 451, 452, 455, + /* 320 */ 456, 457, 20, 459, 460, 352, 260, 223, 224, 217, /* 330 */ 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, /* 340 */ 236, 237, 238, 239, 240, 241, 242, 243, 244, 12, - /* 350 */ 13, 382, 200, 388, 380, 203, 391, 20, 206, 22, - /* 360 */ 208, 100, 20, 49, 39, 391, 20, 393, 140, 141, - /* 370 */ 33, 57, 35, 351, 60, 61, 103, 116, 117, 118, - /* 380 */ 119, 120, 121, 122, 123, 124, 125, 3, 127, 128, - /* 390 */ 129, 130, 131, 132, 133, 265, 266, 267, 411, 62, - /* 400 */ 411, 427, 380, 429, 20, 68, 432, 433, 434, 435, - /* 410 */ 436, 437, 75, 439, 70, 71, 72, 62, 444, 115, - /* 420 */ 446, 77, 78, 79, 450, 451, 37, 83, 244, 341, - /* 430 */ 355, 356, 88, 89, 90, 91, 431, 100, 94, 351, - /* 440 */ 103, 137, 172, 371, 4, 458, 472, 458, 461, 103, - /* 450 */ 461, 379, 380, 12, 13, 14, 434, 102, 350, 19, - /* 460 */ 105, 20, 457, 22, 477, 478, 477, 478, 380, 482, - /* 470 */ 483, 482, 483, 33, 33, 431, 35, 140, 141, 391, - /* 480 */ 338, 393, 140, 141, 350, 351, 8, 9, 104, 49, - /* 490 */ 12, 13, 14, 15, 16, 106, 56, 108, 109, 341, - /* 500 */ 111, 457, 62, 62, 115, 350, 351, 170, 171, 351, - /* 510 */ 402, 353, 404, 176, 177, 427, 75, 429, 176, 177, - /* 520 */ 432, 433, 434, 435, 436, 437, 137, 439, 191, 380, - /* 530 */ 193, 397, 387, 260, 446, 386, 350, 351, 380, 451, - /* 540 */ 20, 100, 102, 394, 103, 105, 244, 4, 246, 391, - /* 550 */ 20, 393, 397, 411, 350, 351, 172, 341, 416, 35, - /* 560 */ 223, 224, 350, 226, 227, 228, 229, 230, 231, 232, + /* 350 */ 13, 260, 459, 372, 381, 462, 361, 20, 37, 22, + /* 360 */ 103, 380, 381, 379, 369, 392, 342, 394, 387, 260, + /* 370 */ 33, 260, 35, 480, 351, 391, 395, 484, 485, 8, + /* 380 */ 9, 84, 114, 12, 13, 14, 15, 16, 351, 352, + /* 390 */ 75, 20, 351, 352, 342, 244, 266, 267, 268, 62, + /* 400 */ 20, 428, 114, 430, 352, 68, 433, 434, 435, 436, + /* 410 */ 437, 438, 75, 440, 351, 352, 392, 342, 445, 75, + /* 420 */ 447, 351, 352, 4, 451, 452, 403, 106, 405, 108, + /* 430 */ 109, 432, 111, 381, 371, 398, 115, 100, 19, 358, + /* 440 */ 103, 371, 145, 146, 392, 381, 394, 474, 0, 351, + /* 450 */ 352, 387, 33, 12, 13, 14, 375, 458, 137, 395, + /* 460 */ 342, 20, 172, 22, 383, 168, 352, 392, 49, 371, + /* 470 */ 352, 35, 170, 171, 33, 56, 35, 140, 141, 342, + /* 480 */ 428, 62, 430, 103, 342, 433, 434, 435, 436, 437, + /* 490 */ 438, 439, 440, 441, 442, 381, 455, 456, 457, 381, + /* 500 */ 459, 460, 381, 62, 244, 186, 246, 170, 171, 14, + /* 510 */ 392, 75, 394, 176, 177, 20, 75, 260, 70, 71, + /* 520 */ 72, 102, 401, 3, 105, 77, 78, 79, 191, 392, + /* 530 */ 193, 83, 213, 214, 392, 351, 88, 89, 90, 91, + /* 540 */ 20, 100, 94, 172, 103, 342, 428, 342, 430, 435, + /* 550 */ 0, 433, 434, 435, 436, 437, 438, 352, 440, 354, + /* 560 */ 223, 224, 360, 226, 227, 228, 229, 230, 231, 232, /* 570 */ 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - /* 580 */ 243, 140, 141, 21, 259, 427, 43, 429, 45, 46, - /* 590 */ 432, 433, 434, 435, 436, 437, 34, 439, 36, 75, - /* 600 */ 458, 397, 444, 461, 446, 341, 260, 391, 450, 451, - /* 610 */ 0, 170, 171, 20, 402, 22, 404, 176, 177, 477, - /* 620 */ 478, 364, 365, 22, 482, 483, 103, 33, 35, 114, - /* 630 */ 350, 351, 191, 0, 193, 367, 35, 350, 351, 453, - /* 640 */ 454, 455, 456, 49, 458, 459, 53, 134, 341, 381, - /* 650 */ 370, 57, 58, 59, 60, 391, 62, 370, 351, 391, - /* 660 */ 353, 183, 364, 365, 223, 224, 75, 226, 227, 228, + /* 580 */ 243, 140, 141, 70, 71, 72, 381, 403, 386, 405, + /* 590 */ 77, 78, 79, 475, 476, 392, 83, 392, 444, 394, + /* 600 */ 446, 88, 89, 90, 91, 459, 388, 94, 462, 351, + /* 610 */ 352, 170, 171, 381, 12, 13, 48, 176, 177, 387, + /* 620 */ 393, 394, 381, 339, 104, 479, 480, 395, 387, 371, + /* 630 */ 484, 485, 191, 428, 193, 430, 395, 35, 433, 434, + /* 640 */ 435, 436, 437, 438, 3, 440, 351, 352, 134, 135, + /* 650 */ 445, 351, 447, 139, 8, 9, 451, 452, 12, 13, + /* 660 */ 14, 15, 16, 418, 223, 224, 371, 226, 227, 228, /* 670 */ 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - /* 680 */ 239, 240, 241, 242, 243, 12, 13, 380, 84, 350, - /* 690 */ 351, 114, 172, 20, 431, 22, 102, 429, 391, 105, - /* 700 */ 393, 100, 172, 70, 71, 72, 33, 439, 35, 370, - /* 710 */ 77, 78, 79, 190, 411, 192, 83, 204, 205, 416, - /* 720 */ 457, 88, 89, 90, 91, 8, 9, 94, 103, 12, - /* 730 */ 13, 14, 15, 16, 427, 62, 429, 411, 186, 432, - /* 740 */ 433, 434, 435, 436, 437, 222, 439, 44, 75, 145, - /* 750 */ 146, 444, 389, 446, 387, 392, 393, 450, 451, 350, - /* 760 */ 351, 458, 371, 285, 461, 213, 214, 173, 174, 159, - /* 770 */ 379, 380, 168, 100, 180, 181, 103, 223, 168, 370, - /* 780 */ 477, 478, 0, 260, 458, 482, 483, 461, 380, 12, - /* 790 */ 13, 379, 380, 199, 386, 341, 341, 20, 380, 22, - /* 800 */ 350, 351, 394, 477, 478, 380, 351, 104, 482, 483, - /* 810 */ 33, 386, 35, 140, 141, 350, 351, 14, 400, 394, - /* 820 */ 370, 104, 0, 20, 270, 271, 272, 273, 274, 275, - /* 830 */ 276, 458, 375, 371, 461, 380, 341, 350, 351, 62, - /* 840 */ 3, 379, 380, 170, 171, 391, 391, 75, 393, 176, - /* 850 */ 177, 478, 75, 8, 9, 482, 483, 12, 13, 14, - /* 860 */ 15, 16, 2, 417, 191, 0, 193, 388, 8, 9, - /* 870 */ 391, 368, 12, 13, 14, 15, 16, 100, 350, 351, - /* 880 */ 103, 424, 427, 341, 429, 260, 391, 432, 433, 434, - /* 890 */ 435, 436, 437, 351, 439, 353, 223, 224, 370, 226, + /* 680 */ 239, 240, 241, 242, 243, 12, 13, 351, 352, 342, + /* 690 */ 44, 459, 172, 20, 462, 22, 412, 20, 0, 352, + /* 700 */ 444, 417, 446, 403, 223, 405, 33, 371, 35, 159, + /* 710 */ 342, 479, 480, 358, 351, 352, 484, 485, 168, 360, + /* 720 */ 352, 0, 103, 381, 351, 352, 8, 9, 381, 387, + /* 730 */ 12, 13, 14, 15, 16, 62, 377, 395, 383, 392, + /* 740 */ 172, 394, 342, 459, 371, 386, 462, 179, 75, 381, + /* 750 */ 104, 62, 271, 272, 273, 274, 275, 276, 277, 21, + /* 760 */ 392, 398, 394, 479, 480, 67, 351, 352, 484, 485, + /* 770 */ 372, 115, 34, 100, 36, 428, 103, 430, 380, 381, + /* 780 */ 433, 434, 435, 436, 437, 438, 371, 440, 342, 12, + /* 790 */ 13, 102, 392, 137, 105, 193, 428, 20, 430, 22, + /* 800 */ 369, 433, 434, 435, 436, 437, 438, 343, 440, 190, + /* 810 */ 33, 192, 35, 140, 141, 447, 432, 140, 141, 451, + /* 820 */ 452, 412, 104, 8, 9, 432, 417, 12, 13, 14, + /* 830 */ 15, 16, 402, 486, 487, 342, 115, 0, 392, 62, + /* 840 */ 14, 222, 458, 170, 171, 352, 20, 351, 352, 176, + /* 850 */ 177, 458, 75, 176, 177, 134, 135, 136, 137, 138, + /* 860 */ 139, 372, 351, 352, 191, 488, 193, 371, 459, 380, + /* 870 */ 381, 462, 351, 352, 381, 351, 352, 100, 443, 260, + /* 880 */ 103, 446, 371, 389, 14, 392, 392, 394, 479, 480, + /* 890 */ 20, 477, 371, 484, 485, 371, 223, 224, 0, 226, /* 900 */ 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - /* 910 */ 237, 238, 239, 240, 241, 242, 243, 140, 141, 454, - /* 920 */ 455, 456, 380, 458, 459, 359, 443, 357, 445, 4, - /* 930 */ 350, 351, 67, 391, 443, 393, 445, 115, 342, 484, - /* 940 */ 485, 454, 455, 456, 374, 458, 459, 170, 171, 104, - /* 950 */ 370, 385, 382, 176, 177, 486, 134, 135, 136, 137, - /* 960 */ 138, 139, 350, 351, 388, 350, 351, 391, 191, 427, - /* 970 */ 193, 429, 401, 170, 432, 433, 434, 435, 436, 437, - /* 980 */ 47, 439, 370, 14, 2, 370, 444, 0, 446, 20, - /* 990 */ 8, 9, 450, 451, 12, 13, 14, 15, 16, 217, + /* 910 */ 237, 238, 239, 240, 241, 242, 243, 140, 141, 104, + /* 920 */ 355, 428, 281, 430, 365, 366, 433, 434, 435, 436, + /* 930 */ 437, 438, 389, 440, 372, 392, 115, 39, 1, 2, + /* 940 */ 447, 459, 380, 381, 462, 452, 342, 170, 171, 351, + /* 950 */ 352, 22, 115, 176, 177, 134, 135, 136, 137, 138, + /* 960 */ 139, 4, 480, 33, 35, 47, 484, 485, 191, 371, + /* 970 */ 193, 134, 135, 136, 137, 138, 139, 351, 352, 49, + /* 980 */ 12, 13, 14, 15, 16, 14, 342, 57, 58, 59, + /* 990 */ 60, 20, 62, 20, 471, 22, 392, 371, 54, 55, /* 1000 */ 223, 224, 0, 226, 227, 228, 229, 230, 231, 232, /* 1010 */ 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - /* 1020 */ 243, 380, 18, 18, 20, 350, 351, 386, 23, 350, - /* 1030 */ 351, 27, 350, 351, 30, 394, 103, 33, 350, 351, - /* 1040 */ 1, 2, 37, 38, 20, 370, 41, 350, 351, 370, - /* 1050 */ 22, 469, 370, 49, 341, 51, 372, 52, 370, 375, - /* 1060 */ 56, 45, 46, 35, 341, 341, 354, 370, 63, 64, - /* 1070 */ 65, 66, 70, 71, 72, 73, 74, 341, 76, 77, + /* 1020 */ 243, 103, 18, 18, 20, 411, 53, 342, 23, 100, + /* 1030 */ 373, 27, 102, 376, 30, 105, 392, 33, 2, 20, + /* 1040 */ 170, 104, 37, 38, 8, 9, 41, 39, 12, 13, + /* 1050 */ 14, 15, 16, 49, 42, 51, 44, 52, 8, 9, + /* 1060 */ 56, 368, 12, 13, 14, 15, 16, 412, 63, 64, + /* 1070 */ 65, 66, 70, 71, 72, 73, 74, 392, 76, 77, /* 1080 */ 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - /* 1090 */ 88, 89, 90, 91, 92, 93, 94, 95, 96, 341, - /* 1100 */ 350, 351, 115, 44, 391, 20, 102, 14, 103, 350, - /* 1110 */ 351, 134, 135, 20, 391, 391, 139, 280, 114, 22, - /* 1120 */ 370, 134, 135, 136, 137, 138, 139, 391, 100, 370, - /* 1130 */ 8, 9, 35, 0, 12, 13, 14, 15, 16, 170, - /* 1140 */ 350, 351, 42, 104, 44, 341, 341, 142, 144, 391, - /* 1150 */ 341, 147, 148, 149, 150, 151, 152, 153, 154, 155, - /* 1160 */ 156, 157, 158, 159, 160, 161, 162, 163, 341, 165, - /* 1170 */ 166, 167, 75, 8, 9, 379, 380, 12, 13, 14, - /* 1180 */ 15, 16, 49, 341, 341, 341, 261, 341, 183, 184, - /* 1190 */ 185, 341, 115, 188, 170, 391, 391, 100, 379, 380, - /* 1200 */ 391, 351, 366, 353, 341, 369, 201, 202, 379, 380, - /* 1210 */ 44, 134, 135, 136, 137, 138, 139, 212, 391, 341, - /* 1220 */ 215, 258, 259, 218, 219, 220, 221, 222, 341, 351, - /* 1230 */ 380, 353, 0, 391, 391, 391, 458, 391, 42, 461, - /* 1240 */ 44, 391, 114, 393, 454, 455, 456, 107, 458, 459, - /* 1250 */ 110, 461, 341, 68, 391, 477, 478, 172, 380, 13, - /* 1260 */ 482, 483, 351, 44, 353, 260, 380, 477, 478, 391, - /* 1270 */ 104, 393, 482, 483, 379, 380, 44, 427, 391, 429, - /* 1280 */ 394, 35, 432, 433, 434, 435, 436, 437, 191, 439, - /* 1290 */ 193, 380, 164, 62, 444, 107, 446, 207, 110, 209, - /* 1300 */ 450, 451, 391, 13, 393, 427, 107, 429, 0, 110, - /* 1310 */ 432, 433, 434, 435, 436, 437, 107, 439, 44, 110, - /* 1320 */ 223, 224, 444, 104, 446, 35, 44, 35, 450, 451, - /* 1330 */ 22, 44, 140, 141, 35, 44, 105, 172, 427, 44, - /* 1340 */ 429, 282, 341, 432, 433, 434, 435, 436, 437, 0, - /* 1350 */ 439, 0, 351, 12, 13, 444, 475, 446, 44, 44, - /* 1360 */ 367, 450, 451, 22, 44, 44, 44, 1, 2, 44, - /* 1370 */ 341, 22, 103, 22, 33, 367, 35, 380, 104, 354, - /* 1380 */ 351, 380, 113, 44, 44, 410, 104, 35, 13, 44, - /* 1390 */ 44, 104, 391, 401, 393, 13, 0, 44, 349, 104, - /* 1400 */ 44, 351, 390, 62, 401, 460, 479, 44, 223, 380, - /* 1410 */ 35, 452, 463, 262, 49, 20, 75, 35, 104, 104, - /* 1420 */ 391, 412, 393, 428, 104, 104, 104, 75, 427, 104, - /* 1430 */ 429, 421, 341, 432, 433, 434, 435, 436, 437, 206, - /* 1440 */ 439, 100, 351, 104, 104, 444, 50, 446, 426, 104, - /* 1450 */ 104, 450, 451, 359, 421, 359, 427, 104, 429, 189, - /* 1460 */ 104, 432, 433, 434, 435, 436, 437, 104, 439, 414, - /* 1470 */ 20, 380, 351, 444, 42, 446, 398, 20, 351, 450, - /* 1480 */ 451, 401, 391, 396, 393, 193, 398, 169, 20, 350, - /* 1490 */ 398, 350, 193, 351, 396, 396, 350, 363, 101, 341, - /* 1500 */ 99, 98, 350, 350, 350, 362, 361, 20, 48, 351, - /* 1510 */ 343, 1, 343, 20, 359, 347, 421, 347, 427, 393, - /* 1520 */ 429, 359, 20, 432, 433, 434, 435, 436, 437, 19, - /* 1530 */ 439, 352, 191, 20, 193, 444, 413, 446, 380, 359, - /* 1540 */ 359, 450, 451, 33, 350, 352, 359, 343, 359, 391, - /* 1550 */ 359, 393, 380, 380, 380, 380, 380, 380, 380, 49, - /* 1560 */ 350, 341, 391, 425, 223, 224, 343, 57, 58, 59, - /* 1570 */ 60, 351, 62, 391, 391, 284, 103, 236, 237, 238, - /* 1580 */ 239, 240, 241, 242, 210, 427, 423, 429, 197, 196, - /* 1590 */ 432, 433, 434, 435, 436, 437, 357, 439, 393, 357, - /* 1600 */ 380, 195, 412, 350, 446, 421, 420, 401, 450, 451, - /* 1610 */ 268, 391, 102, 393, 419, 105, 418, 401, 391, 269, - /* 1620 */ 406, 391, 182, 406, 341, 468, 391, 468, 391, 465, - /* 1630 */ 470, 277, 471, 278, 351, 263, 279, 412, 259, 351, - /* 1640 */ 20, 281, 283, 487, 286, 114, 431, 427, 138, 429, - /* 1650 */ 352, 357, 432, 433, 434, 435, 436, 437, 357, 439, - /* 1660 */ 20, 404, 406, 380, 391, 468, 446, 467, 466, 391, - /* 1670 */ 450, 451, 391, 462, 391, 391, 393, 391, 406, 174, - /* 1680 */ 391, 357, 481, 173, 375, 341, 357, 480, 403, 351, - /* 1690 */ 180, 103, 449, 103, 383, 351, 391, 369, 350, 36, - /* 1700 */ 357, 422, 0, 341, 407, 344, 373, 343, 415, 199, - /* 1710 */ 427, 407, 429, 351, 0, 432, 433, 434, 435, 436, - /* 1720 */ 437, 0, 439, 339, 380, 42, 0, 358, 35, 446, - /* 1730 */ 216, 35, 35, 450, 451, 391, 35, 393, 216, 0, - /* 1740 */ 373, 373, 380, 35, 35, 216, 0, 0, 216, 0, - /* 1750 */ 35, 22, 0, 391, 35, 393, 211, 0, 199, 0, - /* 1760 */ 199, 193, 200, 191, 341, 0, 0, 0, 187, 186, - /* 1770 */ 0, 427, 0, 429, 351, 47, 432, 433, 434, 435, - /* 1780 */ 436, 437, 438, 439, 440, 441, 0, 49, 35, 427, - /* 1790 */ 0, 429, 47, 0, 432, 433, 434, 435, 436, 437, - /* 1800 */ 42, 439, 0, 380, 159, 0, 35, 384, 0, 0, - /* 1810 */ 47, 0, 0, 0, 391, 0, 393, 0, 0, 159, - /* 1820 */ 0, 0, 341, 0, 0, 0, 0, 0, 0, 0, - /* 1830 */ 0, 0, 351, 0, 0, 0, 474, 0, 0, 47, - /* 1840 */ 0, 341, 42, 0, 0, 0, 0, 0, 0, 0, - /* 1850 */ 427, 351, 429, 0, 22, 432, 433, 434, 435, 436, - /* 1860 */ 437, 380, 439, 0, 0, 384, 143, 0, 0, 62, - /* 1870 */ 48, 0, 391, 22, 393, 0, 22, 35, 62, 0, - /* 1880 */ 380, 62, 0, 0, 48, 35, 0, 35, 49, 0, - /* 1890 */ 49, 391, 35, 393, 39, 39, 35, 0, 39, 14, - /* 1900 */ 0, 0, 42, 0, 39, 0, 40, 49, 427, 39, - /* 1910 */ 429, 0, 39, 432, 433, 434, 435, 436, 437, 47, - /* 1920 */ 439, 341, 44, 47, 47, 182, 0, 427, 0, 429, - /* 1930 */ 0, 351, 432, 433, 434, 435, 436, 437, 69, 439, - /* 1940 */ 0, 35, 341, 39, 49, 0, 39, 35, 49, 0, - /* 1950 */ 35, 49, 351, 39, 0, 35, 39, 49, 0, 0, - /* 1960 */ 380, 0, 0, 0, 0, 22, 35, 0, 35, 35, - /* 1970 */ 35, 391, 35, 393, 35, 22, 476, 35, 0, 35, - /* 1980 */ 44, 380, 44, 35, 0, 384, 112, 35, 22, 0, - /* 1990 */ 110, 35, 391, 22, 393, 22, 0, 51, 0, 0, - /* 2000 */ 35, 22, 20, 35, 35, 35, 0, 427, 341, 429, - /* 2010 */ 35, 35, 432, 433, 434, 435, 436, 437, 351, 439, - /* 2020 */ 104, 103, 103, 35, 22, 0, 22, 0, 427, 0, - /* 2030 */ 429, 3, 264, 432, 433, 434, 435, 436, 437, 44, - /* 2040 */ 439, 44, 48, 264, 103, 341, 3, 380, 48, 99, - /* 2050 */ 47, 104, 44, 172, 103, 351, 101, 44, 391, 47, - /* 2060 */ 393, 104, 172, 172, 104, 485, 341, 174, 172, 47, - /* 2070 */ 178, 35, 35, 35, 44, 103, 351, 103, 44, 35, - /* 2080 */ 103, 194, 198, 103, 380, 104, 35, 178, 384, 104, - /* 2090 */ 104, 35, 44, 47, 427, 391, 429, 393, 39, 432, - /* 2100 */ 433, 434, 435, 436, 437, 380, 439, 0, 441, 384, - /* 2110 */ 0, 104, 47, 0, 104, 104, 391, 103, 393, 103, - /* 2120 */ 39, 104, 103, 103, 341, 47, 103, 103, 113, 44, - /* 2130 */ 2, 427, 101, 429, 351, 103, 432, 433, 434, 435, - /* 2140 */ 436, 437, 101, 439, 22, 341, 258, 223, 47, 104, - /* 2150 */ 103, 47, 427, 104, 429, 351, 173, 432, 433, 434, - /* 2160 */ 435, 436, 437, 380, 439, 175, 245, 103, 22, 114, - /* 2170 */ 104, 103, 103, 103, 391, 104, 393, 264, 104, 35, - /* 2180 */ 35, 104, 103, 35, 380, 103, 35, 104, 104, 103, - /* 2190 */ 35, 103, 35, 104, 103, 391, 104, 393, 35, 103, - /* 2200 */ 22, 126, 126, 341, 44, 115, 126, 35, 103, 103, - /* 2210 */ 427, 103, 429, 351, 22, 432, 433, 434, 435, 436, - /* 2220 */ 437, 126, 439, 69, 35, 35, 225, 68, 35, 35, - /* 2230 */ 35, 427, 35, 429, 35, 341, 432, 433, 434, 435, - /* 2240 */ 436, 437, 380, 439, 35, 351, 75, 97, 44, 22, - /* 2250 */ 35, 35, 35, 391, 35, 393, 35, 35, 75, 35, - /* 2260 */ 35, 35, 22, 341, 35, 35, 35, 0, 35, 49, - /* 2270 */ 0, 39, 35, 351, 380, 0, 35, 49, 39, 0, - /* 2280 */ 35, 39, 39, 49, 49, 391, 0, 393, 35, 427, - /* 2290 */ 35, 429, 0, 22, 432, 433, 434, 435, 436, 437, - /* 2300 */ 22, 439, 380, 21, 20, 22, 21, 488, 488, 488, - /* 2310 */ 488, 488, 488, 391, 488, 393, 488, 488, 488, 488, - /* 2320 */ 488, 427, 488, 429, 488, 488, 432, 433, 434, 435, - /* 2330 */ 436, 437, 488, 439, 341, 488, 488, 488, 488, 488, - /* 2340 */ 488, 488, 488, 488, 351, 488, 488, 488, 488, 427, - /* 2350 */ 341, 429, 488, 488, 432, 433, 434, 435, 436, 437, - /* 2360 */ 351, 439, 488, 488, 488, 488, 488, 488, 488, 488, - /* 2370 */ 488, 488, 488, 380, 488, 488, 488, 488, 488, 488, - /* 2380 */ 488, 488, 488, 488, 391, 488, 393, 488, 488, 380, - /* 2390 */ 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, - /* 2400 */ 391, 488, 393, 488, 488, 488, 488, 488, 341, 488, - /* 2410 */ 488, 488, 488, 488, 488, 488, 488, 488, 351, 488, - /* 2420 */ 427, 488, 429, 488, 488, 432, 433, 434, 435, 436, - /* 2430 */ 437, 488, 439, 488, 488, 488, 427, 488, 429, 341, - /* 2440 */ 488, 432, 433, 434, 435, 436, 437, 380, 439, 351, - /* 2450 */ 488, 488, 488, 488, 488, 488, 488, 488, 391, 488, - /* 2460 */ 393, 488, 488, 488, 488, 488, 341, 488, 488, 488, - /* 2470 */ 488, 488, 488, 488, 488, 488, 351, 488, 380, 488, - /* 2480 */ 488, 488, 488, 488, 488, 488, 488, 488, 488, 391, - /* 2490 */ 488, 393, 488, 488, 427, 488, 429, 341, 488, 432, - /* 2500 */ 433, 434, 435, 436, 437, 380, 439, 351, 488, 488, - /* 2510 */ 488, 488, 488, 488, 488, 488, 391, 488, 393, 488, - /* 2520 */ 488, 488, 488, 488, 488, 427, 488, 429, 488, 488, - /* 2530 */ 432, 433, 434, 435, 436, 437, 380, 439, 488, 488, - /* 2540 */ 488, 488, 488, 488, 488, 488, 488, 391, 488, 393, - /* 2550 */ 488, 488, 427, 488, 429, 341, 488, 432, 433, 434, - /* 2560 */ 435, 436, 437, 488, 439, 351, 488, 488, 488, 488, - /* 2570 */ 488, 488, 488, 488, 488, 488, 488, 341, 488, 488, - /* 2580 */ 488, 488, 488, 427, 488, 429, 488, 351, 432, 433, - /* 2590 */ 434, 435, 436, 437, 380, 439, 488, 488, 488, 488, - /* 2600 */ 488, 488, 488, 488, 488, 391, 488, 393, 488, 488, - /* 2610 */ 488, 488, 488, 488, 488, 488, 380, 488, 488, 488, - /* 2620 */ 488, 488, 488, 488, 488, 488, 488, 391, 488, 393, - /* 2630 */ 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, - /* 2640 */ 488, 427, 488, 429, 341, 488, 432, 433, 434, 435, - /* 2650 */ 436, 437, 488, 439, 351, 488, 488, 488, 488, 488, - /* 2660 */ 488, 488, 488, 427, 488, 429, 488, 488, 432, 433, - /* 2670 */ 434, 435, 436, 437, 488, 439, 341, 488, 488, 488, - /* 2680 */ 488, 488, 488, 380, 488, 488, 351, 488, 488, 488, - /* 2690 */ 488, 488, 488, 488, 391, 488, 393, 488, 488, 488, - /* 2700 */ 488, 488, 341, 488, 488, 488, 488, 488, 488, 488, - /* 2710 */ 488, 488, 351, 488, 488, 380, 488, 488, 488, 488, - /* 2720 */ 488, 488, 488, 488, 488, 488, 391, 488, 393, 488, - /* 2730 */ 427, 488, 429, 488, 488, 432, 433, 434, 435, 436, - /* 2740 */ 437, 380, 439, 488, 488, 488, 488, 488, 488, 488, - /* 2750 */ 488, 488, 391, 488, 393, 488, 488, 488, 488, 488, - /* 2760 */ 488, 488, 427, 488, 429, 488, 488, 432, 433, 434, - /* 2770 */ 435, 436, 437, 488, 439, 488, 488, 488, 488, 488, - /* 2780 */ 488, 341, 488, 488, 488, 488, 488, 488, 427, 488, - /* 2790 */ 429, 351, 488, 432, 433, 434, 435, 436, 437, 488, - /* 2800 */ 439, 488, 341, 488, 488, 488, 488, 488, 488, 488, - /* 2810 */ 488, 488, 351, 488, 488, 488, 488, 488, 341, 488, - /* 2820 */ 380, 488, 488, 488, 488, 488, 488, 488, 351, 488, - /* 2830 */ 488, 391, 488, 393, 488, 488, 488, 488, 488, 341, - /* 2840 */ 488, 380, 488, 488, 488, 488, 488, 488, 488, 351, - /* 2850 */ 488, 488, 391, 488, 393, 488, 488, 380, 488, 488, - /* 2860 */ 488, 488, 488, 488, 488, 488, 488, 427, 391, 429, - /* 2870 */ 393, 488, 432, 433, 434, 435, 436, 437, 380, 439, - /* 2880 */ 488, 488, 488, 488, 488, 488, 488, 488, 427, 391, - /* 2890 */ 429, 393, 488, 432, 433, 434, 435, 436, 437, 488, - /* 2900 */ 439, 488, 488, 488, 427, 488, 429, 341, 488, 432, - /* 2910 */ 433, 434, 435, 436, 437, 488, 439, 351, 488, 488, - /* 2920 */ 488, 488, 488, 488, 488, 427, 488, 429, 488, 341, - /* 2930 */ 432, 433, 434, 435, 436, 437, 488, 439, 488, 351, - /* 2940 */ 488, 488, 488, 488, 488, 488, 380, 488, 488, 488, - /* 2950 */ 488, 488, 488, 488, 488, 488, 488, 391, 488, 393, - /* 2960 */ 488, 488, 488, 488, 488, 488, 488, 488, 380, 488, - /* 2970 */ 488, 488, 488, 488, 488, 488, 488, 488, 488, 391, - /* 2980 */ 488, 393, 488, 488, 488, 488, 488, 488, 488, 488, - /* 2990 */ 488, 488, 488, 427, 488, 429, 488, 488, 432, 433, - /* 3000 */ 434, 435, 436, 437, 488, 439, 488, 488, 488, 488, - /* 3010 */ 488, 488, 488, 488, 488, 427, 488, 429, 488, 488, - /* 3020 */ 432, 433, 434, 435, 436, 437, 488, 439, 338, 338, - /* 3030 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3040 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3050 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3060 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3070 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3080 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3090 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3100 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3110 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3120 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3130 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3140 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3150 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3160 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3170 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3180 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3190 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3200 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3210 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3220 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3230 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3240 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3250 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3260 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3270 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3280 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3290 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3300 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3310 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3320 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3330 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3340 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3350 */ 338, 338, 338, 338, 338, 338, 338, 338, 338, 338, - /* 3360 */ 338, 338, 338, 338, 338, 338, + /* 1090 */ 88, 89, 90, 91, 92, 93, 94, 95, 96, 14, + /* 1100 */ 15, 16, 367, 173, 174, 370, 102, 20, 103, 2, + /* 1110 */ 180, 181, 351, 352, 459, 8, 9, 462, 114, 12, + /* 1120 */ 13, 14, 15, 16, 169, 342, 356, 357, 42, 199, + /* 1130 */ 44, 22, 371, 22, 479, 480, 20, 342, 44, 484, + /* 1140 */ 485, 170, 356, 357, 35, 342, 35, 142, 144, 342, + /* 1150 */ 44, 147, 148, 149, 150, 151, 152, 153, 154, 155, + /* 1160 */ 156, 157, 158, 159, 160, 161, 162, 163, 412, 165, + /* 1170 */ 166, 167, 8, 9, 13, 392, 12, 13, 14, 15, + /* 1180 */ 16, 135, 342, 114, 75, 139, 35, 392, 183, 184, + /* 1190 */ 185, 172, 352, 188, 354, 392, 35, 342, 342, 392, + /* 1200 */ 342, 342, 247, 365, 366, 107, 201, 202, 110, 100, + /* 1210 */ 342, 100, 257, 45, 46, 459, 412, 212, 462, 262, + /* 1220 */ 215, 381, 172, 218, 219, 220, 221, 222, 380, 381, + /* 1230 */ 380, 381, 392, 164, 394, 479, 480, 380, 381, 44, + /* 1240 */ 484, 485, 13, 342, 380, 381, 200, 392, 392, 203, + /* 1250 */ 392, 392, 206, 352, 208, 354, 380, 381, 0, 172, + /* 1260 */ 392, 258, 259, 459, 35, 260, 462, 259, 428, 381, + /* 1270 */ 430, 62, 68, 433, 434, 435, 436, 437, 438, 207, + /* 1280 */ 440, 209, 381, 479, 480, 445, 170, 447, 484, 485, + /* 1290 */ 0, 451, 452, 392, 0, 394, 0, 44, 107, 104, + /* 1300 */ 191, 110, 193, 107, 44, 107, 110, 49, 110, 44, + /* 1310 */ 44, 342, 22, 44, 105, 44, 22, 35, 22, 140, + /* 1320 */ 141, 352, 44, 354, 368, 44, 35, 44, 44, 428, + /* 1330 */ 44, 430, 223, 224, 433, 434, 435, 436, 437, 438, + /* 1340 */ 355, 440, 402, 350, 193, 0, 445, 352, 447, 391, + /* 1350 */ 381, 44, 451, 452, 1, 2, 402, 104, 44, 44, + /* 1360 */ 461, 392, 481, 394, 104, 44, 75, 13, 44, 104, + /* 1370 */ 104, 103, 44, 104, 342, 104, 44, 283, 44, 13, + /* 1380 */ 453, 113, 104, 263, 352, 104, 354, 104, 104, 35, + /* 1390 */ 104, 285, 413, 465, 429, 50, 49, 428, 20, 430, + /* 1400 */ 342, 35, 433, 434, 435, 436, 437, 438, 422, 440, + /* 1410 */ 352, 104, 354, 381, 445, 427, 447, 206, 104, 104, + /* 1420 */ 451, 452, 360, 422, 392, 104, 394, 223, 104, 189, + /* 1430 */ 360, 415, 104, 352, 20, 342, 104, 42, 104, 381, + /* 1440 */ 399, 20, 402, 352, 399, 352, 169, 20, 397, 352, + /* 1450 */ 392, 351, 394, 351, 399, 99, 397, 397, 101, 364, + /* 1460 */ 428, 351, 430, 98, 363, 433, 434, 435, 436, 437, + /* 1470 */ 438, 20, 440, 351, 381, 193, 362, 445, 351, 447, + /* 1480 */ 351, 344, 48, 451, 452, 392, 428, 394, 430, 348, + /* 1490 */ 344, 433, 434, 435, 436, 437, 438, 348, 440, 422, + /* 1500 */ 360, 12, 13, 445, 342, 447, 20, 394, 360, 451, + /* 1510 */ 452, 22, 20, 353, 352, 20, 360, 414, 353, 360, + /* 1520 */ 351, 428, 33, 430, 35, 344, 433, 434, 435, 436, + /* 1530 */ 437, 438, 342, 440, 360, 360, 360, 351, 445, 381, + /* 1540 */ 447, 344, 352, 381, 451, 452, 392, 381, 381, 392, + /* 1550 */ 210, 62, 381, 381, 392, 392, 394, 426, 381, 381, + /* 1560 */ 103, 422, 424, 358, 75, 197, 421, 342, 196, 195, + /* 1570 */ 420, 381, 358, 351, 394, 402, 392, 352, 270, 269, + /* 1580 */ 392, 392, 392, 413, 394, 402, 392, 470, 470, 100, + /* 1590 */ 428, 278, 430, 182, 407, 433, 434, 435, 436, 437, + /* 1600 */ 438, 419, 440, 473, 472, 470, 381, 445, 407, 447, + /* 1610 */ 280, 469, 279, 451, 452, 468, 264, 392, 428, 394, + /* 1620 */ 430, 413, 467, 433, 434, 435, 436, 437, 438, 259, + /* 1630 */ 440, 287, 489, 284, 482, 445, 483, 447, 20, 352, + /* 1640 */ 282, 451, 452, 114, 432, 261, 353, 358, 20, 464, + /* 1650 */ 358, 405, 407, 428, 342, 430, 463, 407, 433, 434, + /* 1660 */ 435, 436, 437, 438, 352, 440, 392, 392, 392, 358, + /* 1670 */ 174, 392, 447, 103, 404, 376, 451, 452, 358, 352, + /* 1680 */ 191, 450, 193, 103, 342, 384, 370, 392, 351, 392, + /* 1690 */ 392, 36, 344, 381, 352, 345, 358, 374, 359, 374, + /* 1700 */ 374, 416, 340, 423, 392, 0, 394, 0, 408, 0, + /* 1710 */ 408, 42, 223, 224, 0, 35, 216, 35, 35, 35, + /* 1720 */ 216, 0, 35, 381, 35, 236, 237, 238, 239, 240, + /* 1730 */ 241, 242, 216, 0, 392, 216, 394, 0, 35, 0, + /* 1740 */ 428, 22, 430, 35, 211, 433, 434, 435, 436, 437, + /* 1750 */ 438, 0, 440, 0, 199, 342, 0, 199, 193, 447, + /* 1760 */ 200, 0, 191, 451, 452, 352, 0, 0, 187, 186, + /* 1770 */ 428, 0, 430, 0, 47, 433, 434, 435, 436, 437, + /* 1780 */ 438, 0, 440, 35, 49, 0, 0, 47, 42, 0, + /* 1790 */ 0, 0, 47, 0, 381, 0, 0, 0, 385, 0, + /* 1800 */ 0, 159, 0, 35, 159, 392, 0, 394, 0, 0, + /* 1810 */ 0, 0, 0, 342, 0, 0, 0, 0, 476, 0, + /* 1820 */ 0, 0, 0, 352, 0, 0, 47, 342, 0, 42, + /* 1830 */ 0, 0, 0, 0, 0, 0, 0, 352, 0, 0, + /* 1840 */ 22, 428, 143, 430, 342, 0, 433, 434, 435, 436, + /* 1850 */ 437, 438, 381, 440, 352, 0, 385, 182, 0, 22, + /* 1860 */ 0, 48, 22, 392, 35, 394, 381, 62, 0, 62, + /* 1870 */ 0, 48, 0, 0, 0, 0, 35, 392, 0, 394, + /* 1880 */ 0, 14, 35, 381, 35, 39, 0, 39, 62, 39, + /* 1890 */ 0, 35, 49, 49, 392, 42, 394, 0, 44, 428, + /* 1900 */ 49, 430, 39, 39, 433, 434, 435, 436, 437, 438, + /* 1910 */ 0, 440, 47, 428, 342, 430, 47, 40, 433, 434, + /* 1920 */ 435, 436, 437, 438, 352, 440, 47, 39, 0, 0, + /* 1930 */ 428, 69, 430, 342, 0, 433, 434, 435, 436, 437, + /* 1940 */ 438, 0, 440, 352, 35, 49, 39, 0, 35, 342, + /* 1950 */ 49, 39, 0, 381, 35, 49, 39, 385, 0, 352, + /* 1960 */ 35, 0, 39, 478, 392, 49, 394, 0, 0, 0, + /* 1970 */ 0, 0, 381, 112, 35, 22, 110, 0, 35, 35, + /* 1980 */ 35, 35, 44, 392, 35, 394, 35, 22, 381, 487, + /* 1990 */ 35, 35, 385, 0, 44, 35, 22, 35, 0, 392, + /* 2000 */ 428, 394, 430, 22, 0, 433, 434, 435, 436, 437, + /* 2010 */ 438, 22, 440, 35, 51, 0, 0, 35, 35, 428, + /* 2020 */ 342, 430, 0, 22, 433, 434, 435, 436, 437, 438, + /* 2030 */ 352, 440, 1, 442, 20, 428, 104, 430, 35, 103, + /* 2040 */ 433, 434, 435, 436, 437, 438, 35, 440, 35, 0, + /* 2050 */ 19, 103, 35, 172, 22, 342, 0, 198, 22, 381, + /* 2060 */ 0, 172, 0, 385, 33, 352, 174, 172, 3, 178, + /* 2070 */ 392, 172, 394, 44, 48, 103, 194, 101, 178, 104, + /* 2080 */ 49, 44, 103, 48, 99, 342, 44, 103, 57, 58, + /* 2090 */ 59, 60, 265, 62, 381, 352, 104, 44, 104, 103, + /* 2100 */ 103, 47, 47, 104, 104, 392, 428, 394, 430, 103, + /* 2110 */ 44, 433, 434, 435, 436, 437, 438, 265, 440, 3, + /* 2120 */ 44, 35, 342, 104, 381, 35, 35, 35, 35, 35, + /* 2130 */ 47, 104, 352, 102, 104, 392, 105, 394, 0, 44, + /* 2140 */ 0, 428, 258, 430, 47, 47, 433, 434, 435, 436, + /* 2150 */ 437, 438, 265, 440, 103, 103, 39, 0, 39, 173, + /* 2160 */ 103, 381, 104, 104, 103, 175, 103, 103, 47, 138, + /* 2170 */ 44, 428, 392, 430, 394, 101, 433, 434, 435, 436, + /* 2180 */ 437, 438, 113, 440, 342, 245, 101, 2, 22, 223, + /* 2190 */ 103, 47, 104, 104, 352, 47, 114, 22, 35, 342, + /* 2200 */ 104, 126, 103, 103, 173, 103, 103, 103, 428, 352, + /* 2210 */ 430, 180, 104, 433, 434, 435, 436, 437, 438, 104, + /* 2220 */ 440, 35, 104, 381, 35, 103, 35, 225, 103, 35, + /* 2230 */ 199, 104, 103, 103, 392, 104, 394, 104, 381, 35, + /* 2240 */ 104, 35, 103, 22, 103, 44, 126, 35, 103, 392, + /* 2250 */ 342, 394, 103, 103, 126, 22, 69, 115, 126, 35, + /* 2260 */ 352, 68, 35, 35, 342, 35, 35, 35, 97, 35, + /* 2270 */ 428, 35, 430, 75, 352, 433, 434, 435, 436, 437, + /* 2280 */ 438, 44, 440, 35, 35, 428, 35, 430, 22, 381, + /* 2290 */ 433, 434, 435, 436, 437, 438, 0, 440, 35, 35, + /* 2300 */ 392, 75, 394, 381, 35, 35, 35, 35, 35, 35, + /* 2310 */ 22, 35, 35, 0, 392, 342, 394, 49, 39, 35, + /* 2320 */ 39, 0, 35, 0, 39, 352, 35, 49, 39, 49, + /* 2330 */ 0, 49, 35, 35, 0, 21, 428, 22, 430, 22, + /* 2340 */ 22, 433, 434, 435, 436, 437, 438, 21, 440, 20, + /* 2350 */ 428, 490, 430, 490, 381, 433, 434, 435, 436, 437, + /* 2360 */ 438, 490, 440, 490, 490, 392, 490, 394, 490, 490, + /* 2370 */ 490, 490, 490, 490, 490, 342, 490, 490, 490, 490, + /* 2380 */ 490, 490, 490, 490, 490, 352, 490, 490, 490, 490, + /* 2390 */ 342, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2400 */ 352, 428, 490, 430, 490, 490, 433, 434, 435, 436, + /* 2410 */ 437, 438, 490, 440, 381, 490, 490, 490, 490, 490, + /* 2420 */ 490, 490, 490, 490, 490, 392, 490, 394, 490, 381, + /* 2430 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2440 */ 392, 490, 394, 490, 490, 490, 490, 490, 342, 490, + /* 2450 */ 490, 490, 490, 490, 490, 490, 490, 490, 352, 490, + /* 2460 */ 490, 428, 490, 430, 490, 342, 433, 434, 435, 436, + /* 2470 */ 437, 438, 490, 440, 490, 352, 428, 490, 430, 342, + /* 2480 */ 490, 433, 434, 435, 436, 437, 438, 381, 440, 352, + /* 2490 */ 490, 490, 490, 490, 490, 490, 490, 490, 392, 490, + /* 2500 */ 394, 490, 490, 490, 381, 490, 490, 490, 490, 490, + /* 2510 */ 490, 490, 490, 490, 490, 392, 342, 394, 381, 490, + /* 2520 */ 490, 490, 490, 490, 490, 490, 352, 490, 490, 392, + /* 2530 */ 490, 394, 490, 490, 428, 490, 430, 342, 490, 433, + /* 2540 */ 434, 435, 436, 437, 438, 490, 440, 352, 490, 490, + /* 2550 */ 490, 428, 490, 430, 490, 381, 433, 434, 435, 436, + /* 2560 */ 437, 438, 490, 440, 490, 428, 392, 430, 394, 490, + /* 2570 */ 433, 434, 435, 436, 437, 438, 381, 440, 490, 490, + /* 2580 */ 490, 490, 490, 490, 490, 490, 490, 392, 490, 394, + /* 2590 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2600 */ 490, 490, 428, 342, 430, 490, 490, 433, 434, 435, + /* 2610 */ 436, 437, 438, 352, 440, 490, 490, 342, 490, 490, + /* 2620 */ 490, 490, 490, 428, 490, 430, 490, 352, 433, 434, + /* 2630 */ 435, 436, 437, 438, 342, 440, 490, 490, 490, 490, + /* 2640 */ 490, 490, 381, 490, 352, 490, 490, 490, 490, 490, + /* 2650 */ 490, 490, 490, 392, 490, 394, 381, 490, 490, 490, + /* 2660 */ 490, 490, 490, 490, 490, 490, 490, 392, 490, 394, + /* 2670 */ 490, 490, 490, 381, 490, 490, 490, 490, 490, 490, + /* 2680 */ 490, 490, 490, 490, 392, 490, 394, 490, 490, 428, + /* 2690 */ 490, 430, 490, 490, 433, 434, 435, 436, 437, 438, + /* 2700 */ 490, 440, 490, 428, 490, 430, 490, 490, 433, 434, + /* 2710 */ 435, 436, 437, 438, 490, 440, 490, 490, 490, 490, + /* 2720 */ 428, 490, 430, 490, 490, 433, 434, 435, 436, 437, + /* 2730 */ 438, 490, 440, 342, 490, 490, 490, 490, 490, 490, + /* 2740 */ 490, 490, 490, 352, 490, 490, 490, 490, 490, 342, + /* 2750 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 352, + /* 2760 */ 490, 490, 490, 490, 490, 490, 490, 490, 342, 490, + /* 2770 */ 490, 490, 381, 490, 490, 490, 490, 490, 352, 490, + /* 2780 */ 490, 490, 490, 392, 490, 394, 490, 490, 381, 490, + /* 2790 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 392, + /* 2800 */ 490, 394, 490, 490, 490, 490, 490, 381, 490, 490, + /* 2810 */ 490, 490, 490, 490, 490, 490, 490, 490, 392, 428, + /* 2820 */ 394, 430, 490, 490, 433, 434, 435, 436, 437, 438, + /* 2830 */ 490, 440, 490, 490, 490, 428, 490, 430, 490, 490, + /* 2840 */ 433, 434, 435, 436, 437, 438, 490, 440, 490, 490, + /* 2850 */ 490, 490, 490, 490, 428, 490, 430, 490, 342, 433, + /* 2860 */ 434, 435, 436, 437, 438, 490, 440, 490, 352, 490, + /* 2870 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2880 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2890 */ 490, 490, 490, 490, 490, 490, 490, 381, 490, 490, + /* 2900 */ 490, 490, 490, 490, 490, 490, 490, 490, 392, 490, + /* 2910 */ 394, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2920 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2930 */ 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + /* 2940 */ 490, 490, 490, 490, 428, 490, 430, 490, 490, 433, + /* 2950 */ 434, 435, 436, 437, 438, 490, 440, 339, 339, 339, + /* 2960 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 2970 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 2980 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 2990 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3000 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3010 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3020 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3030 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3040 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3050 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3060 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3070 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3080 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3090 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3100 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3110 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3120 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3130 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3140 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3150 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3160 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3170 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3180 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3190 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3200 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3210 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3220 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3230 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3240 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3250 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3260 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3270 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3280 */ 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, + /* 3290 */ 339, 339, 339, 339, 339, 339, }; -#define YY_SHIFT_COUNT (799) +#define YY_SHIFT_COUNT (800) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2292) +#define YY_SHIFT_MAX (2334) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 1005, 0, 104, 0, 337, 337, 337, 337, 337, 337, /* 10 */ 337, 337, 337, 337, 337, 337, 441, 673, 673, 777, /* 20 */ 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, /* 30 */ 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, /* 40 */ 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, - /* 50 */ 673, 273, 346, 523, 226, 29, 625, 29, 226, 226, - /* 60 */ 29, 1341, 29, 1341, 1341, 28, 29, 43, 342, 59, - /* 70 */ 59, 342, 543, 543, 153, 228, 70, 70, 59, 59, - /* 80 */ 59, 59, 59, 59, 59, 59, 59, 59, 90, 59, - /* 90 */ 59, 114, 43, 59, 59, 202, 43, 59, 90, 59, - /* 100 */ 90, 43, 59, 59, 43, 59, 43, 43, 43, 59, - /* 110 */ 138, 1004, 15, 15, 344, 171, 1097, 1097, 1097, 1097, - /* 120 */ 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, - /* 130 */ 1097, 1097, 1097, 1097, 1097, 389, 384, 153, 228, 89, - /* 140 */ 89, 524, 520, 520, 520, 865, 302, 302, 524, 114, - /* 150 */ 43, 43, 43, 43, 515, 184, 43, 591, 43, 591, - /* 160 */ 591, 577, 772, 261, 261, 261, 261, 1510, 633, 185, - /* 170 */ 270, 478, 554, 593, 130, 123, 123, 803, 135, 969, - /* 180 */ 239, 530, 1016, 1093, 304, 1085, 963, 325, 837, 963, - /* 190 */ 1100, 925, 1024, 1151, 1365, 1395, 1233, 114, 1395, 114, - /* 200 */ 1270, 1450, 1432, 1457, 1450, 1432, 1318, 1468, 1450, 1468, - /* 210 */ 1432, 1318, 1318, 1397, 1401, 1468, 1403, 1468, 1468, 1468, - /* 220 */ 1487, 1460, 1487, 1460, 1395, 114, 1493, 114, 1502, 1513, - /* 230 */ 114, 1502, 114, 114, 114, 1468, 114, 1487, 43, 43, - /* 240 */ 43, 43, 43, 43, 43, 1468, 1487, 591, 591, 591, - /* 250 */ 1374, 1473, 1395, 138, 1391, 1393, 1493, 138, 1406, 1151, - /* 260 */ 1468, 1457, 1457, 591, 1350, 1342, 591, 1350, 1342, 591, - /* 270 */ 591, 43, 1354, 1440, 1350, 1357, 1355, 1372, 1151, 1358, - /* 280 */ 1359, 1360, 1379, 1450, 1620, 1531, 1502, 138, 138, 1640, - /* 290 */ 1342, 591, 591, 591, 591, 591, 1342, 591, 1505, 138, - /* 300 */ 577, 138, 1450, 1588, 1590, 591, 772, 1468, 138, 1663, - /* 310 */ 1487, 3028, 3028, 3028, 3028, 3028, 3028, 3028, 3028, 3028, - /* 320 */ 1002, 594, 225, 34, 440, 717, 845, 822, 860, 982, - /* 330 */ 1165, 987, 1122, 1122, 1122, 1122, 1122, 1122, 1122, 1122, - /* 340 */ 1122, 1077, 152, 107, 107, 604, 314, 552, 610, 355, - /* 350 */ 601, 1028, 562, 513, 977, 977, 305, 1039, 51, 305, - /* 360 */ 305, 305, 1133, 782, 703, 86, 1196, 1128, 1232, 1140, - /* 370 */ 1188, 1199, 1209, 1246, 1290, 1308, 1349, 1351, 1090, 1166, - /* 380 */ 1219, 1231, 1274, 1282, 1287, 1192, 1059, 1291, 1295, 1314, - /* 390 */ 1315, 1320, 1321, 1322, 1366, 1325, 1185, 1339, 933, 1340, - /* 400 */ 1345, 1346, 1353, 1356, 1363, 1269, 1292, 1299, 1375, 1382, - /* 410 */ 1352, 1396, 1702, 1714, 1721, 1683, 1726, 1693, 1514, 1696, - /* 420 */ 1697, 1701, 1522, 1739, 1708, 1709, 1529, 1746, 1532, 1747, - /* 430 */ 1715, 1749, 1729, 1752, 1719, 1545, 1757, 1559, 1759, 1561, - /* 440 */ 1562, 1568, 1572, 1765, 1766, 1767, 1581, 1583, 1770, 1772, - /* 450 */ 1728, 1786, 1753, 1738, 1790, 1745, 1793, 1758, 1802, 1808, - /* 460 */ 1809, 1763, 1811, 1812, 1813, 1815, 1817, 1818, 1645, 1771, - /* 470 */ 1805, 1660, 1820, 1821, 1823, 1824, 1825, 1826, 1827, 1828, - /* 480 */ 1829, 1830, 1831, 1833, 1834, 1835, 1837, 1838, 1792, 1840, - /* 490 */ 1800, 1843, 1844, 1845, 1846, 1847, 1848, 1832, 1849, 1853, - /* 500 */ 1863, 1723, 1864, 1867, 1851, 1822, 1854, 1836, 1868, 1807, - /* 510 */ 1842, 1871, 1816, 1875, 1819, 1879, 1882, 1850, 1839, 1855, - /* 520 */ 1883, 1852, 1841, 1856, 1886, 1857, 1858, 1859, 1889, 1861, - /* 530 */ 1897, 1860, 1865, 1878, 1872, 1876, 1885, 1877, 1900, 1866, - /* 540 */ 1870, 1901, 1903, 1905, 1873, 1743, 1911, 1926, 1928, 1869, - /* 550 */ 1930, 1940, 1906, 1895, 1904, 1945, 1912, 1899, 1907, 1949, - /* 560 */ 1915, 1902, 1914, 1954, 1920, 1908, 1917, 1958, 1959, 1961, - /* 570 */ 1962, 1963, 1964, 1874, 1880, 1931, 1943, 1967, 1933, 1934, - /* 580 */ 1935, 1937, 1939, 1942, 1944, 1936, 1938, 1948, 1952, 1953, - /* 590 */ 1956, 1978, 1966, 1984, 1971, 1946, 1989, 1973, 1965, 1996, - /* 600 */ 1968, 1998, 1969, 1999, 1979, 1982, 1970, 1975, 1976, 1916, - /* 610 */ 1918, 2006, 1881, 1919, 1884, 1988, 2002, 2025, 1887, 2004, - /* 620 */ 1890, 1893, 2027, 2029, 1891, 1892, 1896, 1909, 2028, 1995, - /* 630 */ 1768, 1941, 1947, 1951, 1994, 1955, 2000, 1950, 1957, 1997, - /* 640 */ 2008, 1960, 1972, 1974, 1977, 1981, 2013, 2003, 2012, 1980, - /* 650 */ 2030, 1779, 1985, 1986, 2043, 2034, 1913, 2036, 2037, 2038, - /* 660 */ 2044, 2051, 2056, 2007, 2010, 2022, 1888, 2048, 2046, 2107, - /* 670 */ 2110, 2014, 2059, 1872, 2065, 2016, 2011, 2017, 2019, 2020, - /* 680 */ 1990, 2023, 2113, 2081, 1983, 2024, 2015, 1872, 2078, 2085, - /* 690 */ 2031, 1921, 2041, 2128, 2122, 1924, 2032, 2045, 2047, 2049, - /* 700 */ 2064, 2066, 2101, 2068, 2069, 2104, 2071, 2146, 2001, 2070, - /* 710 */ 2055, 2074, 2144, 2145, 2079, 2077, 2148, 2082, 2083, 2151, - /* 720 */ 2086, 2084, 2155, 2088, 2089, 2157, 2091, 2092, 2163, 2096, - /* 730 */ 2075, 2076, 2080, 2095, 2178, 2090, 2105, 2160, 2106, 2172, - /* 740 */ 2108, 2160, 2160, 2192, 2154, 2159, 2189, 2190, 2193, 2194, - /* 750 */ 2195, 2197, 2199, 2209, 2171, 2150, 2204, 2215, 2216, 2217, - /* 760 */ 2227, 2219, 2221, 2222, 2183, 1936, 2224, 1938, 2225, 2226, - /* 770 */ 2229, 2230, 2240, 2231, 2267, 2233, 2220, 2232, 2270, 2237, - /* 780 */ 2228, 2239, 2275, 2241, 2234, 2242, 2279, 2245, 2235, 2243, - /* 790 */ 2286, 2253, 2255, 2292, 2271, 2282, 2278, 2283, 2285, 2284, + /* 50 */ 673, 66, 111, 619, 380, 91, 109, 91, 380, 380, + /* 60 */ 91, 1489, 91, 1489, 1489, 257, 91, 35, 677, 170, + /* 70 */ 170, 677, 4, 4, 302, 167, 495, 495, 170, 170, + /* 80 */ 170, 170, 170, 170, 170, 170, 170, 170, 199, 170, + /* 90 */ 170, 181, 35, 170, 170, 262, 35, 170, 199, 170, + /* 100 */ 199, 35, 170, 170, 35, 170, 35, 35, 35, 170, + /* 110 */ 247, 1004, 15, 15, 513, 171, 1109, 1109, 1109, 1109, + /* 120 */ 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + /* 130 */ 1109, 1109, 1109, 1109, 1109, 321, 520, 302, 167, 944, + /* 140 */ 944, 436, 290, 290, 290, 698, 260, 260, 436, 181, + /* 150 */ 35, 35, 35, 35, 268, 151, 35, 315, 35, 315, + /* 160 */ 315, 288, 344, 28, 28, 28, 28, 2031, 448, 225, + /* 170 */ 371, 30, 481, 32, 130, 602, 602, 870, 568, 971, + /* 180 */ 973, 1019, 1168, 826, 656, 1087, 1003, 1008, 641, 1003, + /* 190 */ 1012, 957, 1116, 1120, 1347, 1378, 1211, 181, 1378, 181, + /* 200 */ 1240, 1414, 1395, 1421, 1414, 1395, 1277, 1427, 1414, 1427, + /* 210 */ 1395, 1277, 1277, 1357, 1356, 1427, 1365, 1427, 1427, 1427, + /* 220 */ 1451, 1434, 1451, 1434, 1378, 181, 1486, 181, 1492, 1495, + /* 230 */ 181, 1492, 181, 181, 181, 1427, 181, 1451, 35, 35, + /* 240 */ 35, 35, 35, 35, 35, 1427, 1451, 315, 315, 315, + /* 250 */ 1340, 1457, 1378, 247, 1368, 1372, 1486, 247, 1374, 1120, + /* 260 */ 1427, 1421, 1421, 315, 1308, 1310, 315, 1308, 1310, 315, + /* 270 */ 315, 35, 1313, 1411, 1308, 1330, 1333, 1352, 1120, 1344, + /* 280 */ 1349, 1358, 1370, 1414, 1618, 1529, 1384, 1492, 247, 247, + /* 290 */ 1628, 1310, 315, 315, 315, 315, 315, 1310, 315, 1496, + /* 300 */ 247, 288, 247, 1414, 1570, 1580, 315, 344, 1427, 247, + /* 310 */ 1655, 1451, 2957, 2957, 2957, 2957, 2957, 2957, 2957, 2957, + /* 320 */ 2957, 1002, 930, 259, 646, 419, 718, 815, 721, 1036, + /* 330 */ 1107, 1050, 837, 1164, 1164, 1164, 1164, 1164, 1164, 1164, + /* 340 */ 1164, 1164, 821, 1046, 968, 968, 297, 160, 319, 550, + /* 350 */ 689, 929, 1111, 738, 88, 514, 514, 1085, 937, 955, + /* 360 */ 1085, 1085, 1085, 1258, 112, 1195, 898, 1086, 1069, 17, + /* 370 */ 1098, 1191, 1196, 1198, 1161, 1229, 1290, 1294, 1296, 1072, + /* 380 */ 1253, 1260, 1209, 1265, 1266, 1269, 1179, 1094, 1106, 1271, + /* 390 */ 1278, 1281, 1283, 1284, 1286, 1353, 1307, 1204, 1314, 918, + /* 400 */ 1315, 1321, 1324, 1328, 1332, 1334, 1268, 1151, 1282, 1354, + /* 410 */ 1366, 1291, 1345, 1705, 1707, 1709, 1669, 1714, 1680, 1500, + /* 420 */ 1682, 1683, 1684, 1504, 1721, 1687, 1689, 1516, 1733, 1519, + /* 430 */ 1737, 1703, 1739, 1719, 1751, 1708, 1533, 1753, 1555, 1756, + /* 440 */ 1558, 1560, 1565, 1571, 1761, 1766, 1767, 1581, 1583, 1771, + /* 450 */ 1773, 1727, 1781, 1748, 1735, 1785, 1740, 1786, 1746, 1789, + /* 460 */ 1790, 1791, 1745, 1793, 1795, 1796, 1797, 1799, 1800, 1642, + /* 470 */ 1768, 1802, 1645, 1806, 1808, 1809, 1810, 1811, 1812, 1814, + /* 480 */ 1815, 1816, 1817, 1819, 1820, 1821, 1822, 1824, 1825, 1779, + /* 490 */ 1828, 1787, 1830, 1831, 1832, 1833, 1834, 1835, 1818, 1836, + /* 500 */ 1838, 1839, 1699, 1845, 1855, 1837, 1813, 1840, 1823, 1860, + /* 510 */ 1805, 1829, 1868, 1807, 1870, 1826, 1872, 1873, 1841, 1843, + /* 520 */ 1846, 1874, 1847, 1844, 1848, 1875, 1849, 1851, 1850, 1878, + /* 530 */ 1856, 1880, 1853, 1863, 1854, 1865, 1869, 1867, 1879, 1886, + /* 540 */ 1877, 1864, 1890, 1897, 1910, 1888, 1675, 1858, 1928, 1929, + /* 550 */ 1862, 1934, 1941, 1909, 1896, 1907, 1947, 1913, 1901, 1912, + /* 560 */ 1952, 1919, 1906, 1917, 1958, 1925, 1916, 1923, 1961, 1967, + /* 570 */ 1968, 1969, 1970, 1971, 1861, 1866, 1939, 1953, 1977, 1943, + /* 580 */ 1944, 1945, 1946, 1949, 1951, 1955, 1938, 1950, 1956, 1960, + /* 590 */ 1965, 1962, 1993, 1974, 1998, 1981, 1963, 2004, 1989, 1978, + /* 600 */ 2015, 1982, 2016, 1983, 2022, 2001, 2014, 2003, 2011, 2013, + /* 610 */ 1932, 1936, 2049, 1881, 1948, 1859, 2017, 2032, 2056, 1882, + /* 620 */ 2036, 1889, 1892, 2060, 2062, 1895, 1891, 1899, 1900, 2065, + /* 630 */ 2029, 1827, 1972, 1975, 1979, 2026, 1976, 2035, 1985, 1992, + /* 640 */ 2037, 2042, 1994, 1984, 1996, 1997, 1999, 2053, 2054, 2055, + /* 650 */ 2006, 2066, 1852, 2000, 2019, 2116, 2076, 1887, 2086, 2090, + /* 660 */ 2091, 2092, 2093, 2094, 2027, 2030, 2083, 1884, 2095, 2097, + /* 670 */ 2138, 2140, 2051, 2117, 1865, 2098, 2052, 2058, 2059, 2057, + /* 680 */ 2061, 1990, 2063, 2157, 2119, 1986, 2064, 2069, 1865, 2121, + /* 690 */ 2126, 2074, 1940, 2085, 2185, 2166, 1966, 2087, 2088, 2099, + /* 700 */ 2089, 2100, 2096, 2144, 2102, 2103, 2148, 2108, 2175, 2002, + /* 710 */ 2104, 2082, 2115, 2163, 2186, 2122, 2118, 2189, 2125, 2127, + /* 720 */ 2191, 2129, 2131, 2194, 2130, 2133, 2204, 2139, 2136, 2206, + /* 730 */ 2141, 2075, 2120, 2128, 2132, 2221, 2142, 2145, 2201, 2149, + /* 740 */ 2212, 2150, 2201, 2201, 2233, 2187, 2193, 2224, 2227, 2228, + /* 750 */ 2230, 2231, 2232, 2234, 2236, 2198, 2171, 2237, 2248, 2249, + /* 760 */ 2251, 2266, 2263, 2264, 2269, 2226, 1938, 2270, 1950, 2271, + /* 770 */ 2272, 2273, 2274, 2288, 2276, 2296, 2277, 2268, 2279, 2313, + /* 780 */ 2284, 2278, 2281, 2321, 2287, 2280, 2285, 2323, 2291, 2282, + /* 790 */ 2289, 2330, 2297, 2298, 2334, 2315, 2314, 2317, 2318, 2326, + /* 800 */ 2329, }; -#define YY_REDUCE_COUNT (319) -#define YY_REDUCE_MIN (-406) -#define YY_REDUCE_MAX (2588) +#define YY_REDUCE_COUNT (320) +#define YY_REDUCE_MIN (-439) +#define YY_REDUCE_MAX (2516) static const short yy_reduce_ofst[] = { - /* 0 */ 142, -282, -133, -26, 158, 307, 542, 850, 878, 911, - /* 10 */ 1001, 1029, 1091, 1158, 1220, 1283, 1344, -340, 455, 88, - /* 20 */ 1362, 1423, 1481, 1500, 1580, 1601, 1667, 1704, 1725, 1783, - /* 30 */ 1804, 1862, 1894, 1922, 1993, 2009, 2067, 2098, 2125, 2156, - /* 40 */ 2214, 2236, 2303, 2335, 2361, 2440, 2461, 2477, 2498, 2566, - /* 50 */ 2588, 790, -376, 303, 186, -406, -13, -11, 465, 487, - /* 60 */ 326, -365, 778, -311, 268, -370, 373, -313, -348, -221, - /* 70 */ -190, -372, -342, -72, -361, 363, -204, -187, -176, 280, - /* 80 */ 287, 339, 134, 155, 409, 450, 528, 204, -183, 580, - /* 90 */ 612, -351, 149, 675, 679, 22, 408, 682, 108, 688, - /* 100 */ 212, 72, 615, 697, 425, 750, 391, 641, 462, 759, - /* 110 */ 570, -341, -343, -343, -182, -325, 216, 264, 454, 495, - /* 120 */ 713, 723, 724, 736, 758, 804, 805, 809, 827, 842, - /* 130 */ 843, 844, 846, 863, 887, -68, 5, 418, -278, -167, - /* 140 */ 75, 257, 5, 44, 263, -31, 483, 491, 298, 566, - /* 150 */ 412, 796, 819, 829, 457, -401, 895, -35, 886, 479, - /* 160 */ 576, 684, 836, -387, 145, 367, -387, 446, 503, 596, - /* 170 */ 571, 469, 881, 712, 582, 993, 1008, 997, 975, 997, - /* 180 */ 1025, 992, 1049, 1050, 1012, 1003, 945, 945, 927, 945, - /* 190 */ 959, 949, 997, 1009, 995, 1010, 1022, 1094, 1033, 1096, - /* 200 */ 1055, 1121, 1078, 1080, 1127, 1088, 1087, 1139, 1142, 1141, - /* 210 */ 1092, 1098, 1099, 1134, 1143, 1146, 1145, 1152, 1153, 1154, - /* 220 */ 1167, 1168, 1169, 1170, 1095, 1155, 1126, 1162, 1179, 1123, - /* 230 */ 1180, 1193, 1181, 1187, 1189, 1194, 1191, 1204, 1172, 1173, - /* 240 */ 1174, 1175, 1176, 1177, 1178, 1210, 1223, 1171, 1182, 1183, - /* 250 */ 1138, 1163, 1184, 1239, 1186, 1195, 1205, 1242, 1198, 1190, - /* 260 */ 1253, 1206, 1216, 1227, 1157, 1214, 1230, 1159, 1217, 1235, - /* 270 */ 1237, 997, 1161, 1160, 1197, 1200, 1202, 1164, 1225, 1156, - /* 280 */ 1201, 1207, 945, 1288, 1215, 1211, 1298, 1294, 1301, 1257, - /* 290 */ 1256, 1273, 1278, 1281, 1284, 1286, 1272, 1289, 1285, 1324, - /* 300 */ 1309, 1329, 1338, 1243, 1311, 1305, 1328, 1348, 1343, 1361, - /* 310 */ 1364, 1293, 1279, 1297, 1304, 1333, 1367, 1368, 1369, 1384, + /* 0 */ 284, -341, -134, -27, 205, 840, 901, 969, 1032, 1058, + /* 10 */ 1093, 1162, 1190, 368, 1225, 1312, 52, 118, 347, 493, + /* 20 */ 1342, 1413, 1471, 1485, 1502, 1572, 1591, 1607, 1678, 1713, + /* 30 */ 1743, 1780, 1842, 1857, 1908, 1922, 1973, 2033, 2048, 2106, + /* 40 */ 2123, 2137, 2174, 2195, 2261, 2275, 2292, 2391, 2407, 2426, + /* 50 */ 2516, -274, 232, 409, -292, -371, 655, 756, -136, 41, + /* 60 */ 804, -366, 146, -311, -310, -107, 482, -19, -391, -346, + /* 70 */ -315, -287, -280, -270, -266, -117, -215, -173, -250, -73, + /* 80 */ 63, 70, -209, 37, 98, 258, 295, 363, 23, 336, + /* 90 */ 373, 359, -297, 415, 511, 114, 64, 496, 184, 521, + /* 100 */ 300, 398, 524, 598, 241, 626, 489, 342, 562, 761, + /* 110 */ 81, -278, -439, -439, -5, -168, 24, 75, 137, 142, + /* 120 */ 203, 400, 446, 604, 644, 685, 783, 795, 803, 807, + /* 130 */ 855, 856, 858, 859, 868, -16, -1, 121, 227, 770, + /* 140 */ 786, 559, -1, 384, 393, 355, 154, 256, 838, 202, + /* 150 */ 848, 850, 857, 864, -271, 435, 876, -385, -347, 494, + /* 160 */ 543, 657, 735, -388, -367, 218, -388, 245, 431, 464, + /* 170 */ 430, 377, 414, 565, 523, 693, 956, 888, 614, 888, + /* 180 */ 985, 940, 993, 995, 958, 954, 899, 899, 881, 899, + /* 190 */ 927, 928, 888, 979, 965, 986, 988, 1062, 1001, 1070, + /* 200 */ 1016, 1081, 1041, 1040, 1091, 1045, 1051, 1100, 1097, 1102, + /* 210 */ 1055, 1059, 1060, 1095, 1101, 1110, 1114, 1122, 1127, 1129, + /* 220 */ 1137, 1141, 1146, 1149, 1077, 1140, 1113, 1148, 1160, 1103, + /* 230 */ 1156, 1165, 1159, 1174, 1175, 1169, 1176, 1181, 1158, 1166, + /* 240 */ 1167, 1171, 1172, 1177, 1178, 1186, 1197, 1154, 1157, 1163, + /* 250 */ 1131, 1138, 1139, 1205, 1145, 1150, 1180, 1214, 1182, 1170, + /* 260 */ 1222, 1173, 1183, 1184, 1117, 1187, 1188, 1118, 1201, 1189, + /* 270 */ 1194, 888, 1130, 1132, 1135, 1142, 1147, 1155, 1208, 1143, + /* 280 */ 1153, 1152, 899, 1287, 1212, 1185, 1193, 1293, 1289, 1292, + /* 290 */ 1246, 1245, 1274, 1275, 1276, 1279, 1295, 1250, 1297, 1270, + /* 300 */ 1311, 1299, 1320, 1327, 1231, 1301, 1298, 1316, 1337, 1338, + /* 310 */ 1350, 1348, 1285, 1280, 1300, 1302, 1323, 1325, 1326, 1339, + /* 320 */ 1362, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 10 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 20 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 30 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 40 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 50 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 60 */ 2096, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 70 */ 1784, 1784, 1784, 1784, 2069, 1784, 1784, 1784, 1784, 1784, - /* 80 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 90 */ 1784, 1873, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 100 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 110 */ 1871, 2062, 2288, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 120 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 130 */ 1784, 1784, 1784, 1784, 1784, 1784, 2300, 1784, 1784, 1847, - /* 140 */ 1847, 1784, 2300, 2300, 2300, 1871, 2260, 2260, 1784, 1873, - /* 150 */ 1784, 1784, 1784, 1784, 2130, 1784, 1784, 1784, 1784, 1784, - /* 160 */ 1784, 1994, 1784, 2018, 1784, 1784, 1784, 2122, 1784, 1784, - /* 170 */ 2327, 2384, 1784, 1784, 2330, 1784, 1784, 1784, 1784, 1784, - /* 180 */ 1784, 2074, 1784, 1784, 1946, 2317, 2292, 2306, 2368, 2293, - /* 190 */ 2290, 2311, 1784, 2321, 1784, 1784, 2144, 1873, 1784, 1873, - /* 200 */ 2109, 1784, 2067, 1784, 1784, 2067, 2064, 1784, 1784, 1784, - /* 210 */ 2067, 2064, 2064, 1935, 1931, 1784, 1929, 1784, 1784, 1784, - /* 220 */ 1784, 1831, 1784, 1831, 1784, 1873, 1784, 1873, 1784, 1784, - /* 230 */ 1873, 1784, 1873, 1873, 1873, 1784, 1873, 1784, 1784, 1784, - /* 240 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 250 */ 2142, 2128, 1784, 1871, 2120, 2118, 1784, 1871, 2116, 2321, - /* 260 */ 1784, 1784, 1784, 1784, 2338, 2336, 1784, 2338, 2336, 1784, - /* 270 */ 1784, 1784, 2352, 2348, 2338, 2357, 2354, 2323, 2321, 2387, - /* 280 */ 2374, 2370, 2306, 1784, 1784, 2309, 1784, 1871, 1871, 1784, - /* 290 */ 2336, 1784, 1784, 1784, 1784, 1784, 2336, 1784, 1784, 1871, - /* 300 */ 1784, 1871, 1784, 1784, 1962, 1784, 1784, 1784, 1871, 1816, - /* 310 */ 1784, 2111, 2133, 2092, 2092, 1997, 1997, 1997, 1874, 1789, - /* 320 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 330 */ 1784, 1784, 2351, 2350, 2215, 1784, 2264, 2263, 2262, 2253, - /* 340 */ 2214, 1958, 1784, 2213, 2212, 1784, 1784, 1784, 1784, 1784, - /* 350 */ 1784, 1784, 1784, 1784, 2083, 2082, 2206, 1784, 1784, 2207, - /* 360 */ 2205, 2204, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 370 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 380 */ 1784, 1784, 1784, 1784, 1784, 1784, 2371, 2375, 1784, 1784, - /* 390 */ 1784, 1784, 1784, 1784, 2289, 1784, 1784, 1784, 2188, 1784, - /* 400 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 410 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 420 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 430 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 440 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 450 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 460 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 470 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 480 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 490 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 500 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 510 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 520 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 530 */ 1784, 1784, 1784, 1821, 2193, 1784, 1784, 1784, 1784, 1784, - /* 540 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 550 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 560 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 570 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 580 */ 1784, 1784, 1784, 1784, 1784, 1912, 1911, 1784, 1784, 1784, - /* 590 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 600 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 2197, - /* 610 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 620 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 2367, 2324, - /* 630 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 640 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 2188, 1784, - /* 650 */ 2349, 1784, 1784, 2365, 1784, 2369, 1784, 1784, 1784, 1784, - /* 660 */ 1784, 1784, 1784, 2299, 2295, 1784, 1784, 2291, 1784, 1784, - /* 670 */ 1784, 1784, 1784, 2196, 1784, 1784, 1784, 1784, 1784, 1784, - /* 680 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 2187, 1784, 2250, - /* 690 */ 1784, 1784, 1784, 2284, 1784, 1784, 2235, 1784, 1784, 1784, - /* 700 */ 1784, 1784, 1784, 1784, 1784, 1784, 2197, 1784, 2200, 1784, - /* 710 */ 1784, 1784, 1784, 1784, 1991, 1784, 1784, 1784, 1784, 1784, - /* 720 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 730 */ 1975, 1973, 1972, 1971, 1784, 1968, 1784, 2004, 1784, 1784, - /* 740 */ 1784, 2000, 1999, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 750 */ 1784, 1784, 1784, 1784, 1784, 1784, 1892, 1784, 1784, 1784, - /* 760 */ 1784, 1784, 1784, 1784, 1784, 1884, 1784, 1883, 1784, 1784, - /* 770 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 780 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, - /* 790 */ 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, + /* 0 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 10 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 20 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 30 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 40 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 50 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 60 */ 2100, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 70 */ 1788, 1788, 1788, 1788, 2073, 1788, 1788, 1788, 1788, 1788, + /* 80 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 90 */ 1788, 1877, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 100 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 110 */ 1875, 2066, 2292, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 120 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 130 */ 1788, 1788, 1788, 1788, 1788, 1788, 2304, 1788, 1788, 1851, + /* 140 */ 1851, 1788, 2304, 2304, 2304, 1875, 2264, 2264, 1788, 1877, + /* 150 */ 1788, 1788, 1788, 1788, 2134, 1788, 1788, 1788, 1788, 1788, + /* 160 */ 1788, 1998, 1788, 2022, 1788, 1788, 1788, 2126, 1788, 1788, + /* 170 */ 2333, 2390, 1788, 1788, 2336, 1788, 1788, 1788, 1788, 1788, + /* 180 */ 1788, 2078, 1788, 1788, 1950, 2323, 2296, 2310, 2374, 2297, + /* 190 */ 2294, 2317, 1788, 2327, 1788, 1788, 2148, 1877, 1788, 1877, + /* 200 */ 2113, 1788, 2071, 1788, 1788, 2071, 2068, 1788, 1788, 1788, + /* 210 */ 2071, 2068, 2068, 1939, 1935, 1788, 1933, 1788, 1788, 1788, + /* 220 */ 1788, 1835, 1788, 1835, 1788, 1877, 1788, 1877, 1788, 1788, + /* 230 */ 1877, 1788, 1877, 1877, 1877, 1788, 1877, 1788, 1788, 1788, + /* 240 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 250 */ 2146, 2132, 1788, 1875, 2124, 2122, 1788, 1875, 2120, 2327, + /* 260 */ 1788, 1788, 1788, 1788, 2344, 2342, 1788, 2344, 2342, 1788, + /* 270 */ 1788, 1788, 2358, 2354, 2344, 2363, 2360, 2329, 2327, 2393, + /* 280 */ 2380, 2376, 2310, 1788, 1788, 2315, 2313, 1788, 1875, 1875, + /* 290 */ 1788, 2342, 1788, 1788, 1788, 1788, 1788, 2342, 1788, 1788, + /* 300 */ 1875, 1788, 1875, 1788, 1788, 1966, 1788, 1788, 1788, 1875, + /* 310 */ 1820, 1788, 2115, 2137, 2096, 2096, 2001, 2001, 2001, 1878, + /* 320 */ 1793, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 330 */ 1788, 1788, 1788, 2357, 2356, 2219, 1788, 2268, 2267, 2266, + /* 340 */ 2257, 2218, 1962, 1788, 2217, 2216, 1788, 1788, 1788, 1788, + /* 350 */ 1788, 1788, 1788, 1788, 1788, 2087, 2086, 2210, 1788, 1788, + /* 360 */ 2211, 2209, 2208, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 370 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 380 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 2377, 2381, 1788, + /* 390 */ 1788, 1788, 1788, 1788, 1788, 2293, 1788, 1788, 1788, 2192, + /* 400 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 410 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 420 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 430 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 440 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 450 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 460 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 470 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 480 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 490 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 500 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 510 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 520 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 530 */ 1788, 1788, 1788, 1788, 1825, 2197, 1788, 1788, 1788, 1788, + /* 540 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 550 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 560 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 570 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 580 */ 1788, 1788, 1788, 1788, 1788, 1788, 1916, 1915, 1788, 1788, + /* 590 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 600 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 610 */ 2201, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 620 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 2373, + /* 630 */ 2330, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 640 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 2192, + /* 650 */ 1788, 2355, 1788, 1788, 2371, 1788, 2375, 1788, 1788, 1788, + /* 660 */ 1788, 1788, 1788, 1788, 2303, 2299, 1788, 1788, 2295, 1788, + /* 670 */ 1788, 1788, 1788, 1788, 2200, 1788, 1788, 1788, 1788, 1788, + /* 680 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 2191, 1788, + /* 690 */ 2254, 1788, 1788, 1788, 2288, 1788, 1788, 2239, 1788, 1788, + /* 700 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 2201, 1788, 2204, + /* 710 */ 1788, 1788, 1788, 1788, 1788, 1995, 1788, 1788, 1788, 1788, + /* 720 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 730 */ 1788, 1979, 1977, 1976, 1975, 1788, 1972, 1788, 2008, 1788, + /* 740 */ 1788, 1788, 2004, 2003, 1788, 1788, 1788, 1788, 1788, 1788, + /* 750 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1896, 1788, 1788, + /* 760 */ 1788, 1788, 1788, 1788, 1788, 1788, 1888, 1788, 1887, 1788, + /* 770 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 780 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 790 */ 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, 1788, + /* 800 */ 1788, }; /********** End of lemon-generated parsing tables *****************************/ @@ -1525,7 +1175,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* MAX_SPEED => nothing */ 0, /* START => nothing */ 0, /* TIMESTAMP => nothing */ - 287, /* END => ABORT */ + 288, /* END => ABORT */ 0, /* TABLE => nothing */ 0, /* NK_LP => nothing */ 0, /* NK_RP => nothing */ @@ -1685,6 +1335,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* JOIN => nothing */ 0, /* INNER => nothing */ 0, /* SELECT => nothing */ + 0, /* NK_HINT => nothing */ 0, /* DISTINCT => nothing */ 0, /* WHERE => nothing */ 0, /* PARTITION => nothing */ @@ -1712,56 +1363,56 @@ static const YYCODETYPE yyFallback[] = { 0, /* ASC => nothing */ 0, /* NULLS => nothing */ 0, /* ABORT => nothing */ - 287, /* AFTER => ABORT */ - 287, /* ATTACH => ABORT */ - 287, /* BEFORE => ABORT */ - 287, /* BEGIN => ABORT */ - 287, /* BITAND => ABORT */ - 287, /* BITNOT => ABORT */ - 287, /* BITOR => ABORT */ - 287, /* BLOCKS => ABORT */ - 287, /* CHANGE => ABORT */ - 287, /* COMMA => ABORT */ - 287, /* CONCAT => ABORT */ - 287, /* CONFLICT => ABORT */ - 287, /* COPY => ABORT */ - 287, /* DEFERRED => ABORT */ - 287, /* DELIMITERS => ABORT */ - 287, /* DETACH => ABORT */ - 287, /* DIVIDE => ABORT */ - 287, /* DOT => ABORT */ - 287, /* EACH => ABORT */ - 287, /* FAIL => ABORT */ - 287, /* FILE => ABORT */ - 287, /* FOR => ABORT */ - 287, /* GLOB => ABORT */ - 287, /* ID => ABORT */ - 287, /* IMMEDIATE => ABORT */ - 287, /* IMPORT => ABORT */ - 287, /* INITIALLY => ABORT */ - 287, /* INSTEAD => ABORT */ - 287, /* ISNULL => ABORT */ - 287, /* KEY => ABORT */ - 287, /* MODULES => ABORT */ - 287, /* NK_BITNOT => ABORT */ - 287, /* NK_SEMI => ABORT */ - 287, /* NOTNULL => ABORT */ - 287, /* OF => ABORT */ - 287, /* PLUS => ABORT */ - 287, /* PRIVILEGE => ABORT */ - 287, /* RAISE => ABORT */ - 287, /* RESTRICT => ABORT */ - 287, /* ROW => ABORT */ - 287, /* SEMI => ABORT */ - 287, /* STAR => ABORT */ - 287, /* STATEMENT => ABORT */ - 287, /* STRICT => ABORT */ - 287, /* STRING => ABORT */ - 287, /* TIMES => ABORT */ - 287, /* VALUES => ABORT */ - 287, /* VARIABLE => ABORT */ - 287, /* VIEW => ABORT */ - 287, /* WAL => ABORT */ + 288, /* AFTER => ABORT */ + 288, /* ATTACH => ABORT */ + 288, /* BEFORE => ABORT */ + 288, /* BEGIN => ABORT */ + 288, /* BITAND => ABORT */ + 288, /* BITNOT => ABORT */ + 288, /* BITOR => ABORT */ + 288, /* BLOCKS => ABORT */ + 288, /* CHANGE => ABORT */ + 288, /* COMMA => ABORT */ + 288, /* CONCAT => ABORT */ + 288, /* CONFLICT => ABORT */ + 288, /* COPY => ABORT */ + 288, /* DEFERRED => ABORT */ + 288, /* DELIMITERS => ABORT */ + 288, /* DETACH => ABORT */ + 288, /* DIVIDE => ABORT */ + 288, /* DOT => ABORT */ + 288, /* EACH => ABORT */ + 288, /* FAIL => ABORT */ + 288, /* FILE => ABORT */ + 288, /* FOR => ABORT */ + 288, /* GLOB => ABORT */ + 288, /* ID => ABORT */ + 288, /* IMMEDIATE => ABORT */ + 288, /* IMPORT => ABORT */ + 288, /* INITIALLY => ABORT */ + 288, /* INSTEAD => ABORT */ + 288, /* ISNULL => ABORT */ + 288, /* KEY => ABORT */ + 288, /* MODULES => ABORT */ + 288, /* NK_BITNOT => ABORT */ + 288, /* NK_SEMI => ABORT */ + 288, /* NOTNULL => ABORT */ + 288, /* OF => ABORT */ + 288, /* PLUS => ABORT */ + 288, /* PRIVILEGE => ABORT */ + 288, /* RAISE => ABORT */ + 288, /* RESTRICT => ABORT */ + 288, /* ROW => ABORT */ + 288, /* SEMI => ABORT */ + 288, /* STAR => ABORT */ + 288, /* STATEMENT => ABORT */ + 288, /* STRICT => ABORT */ + 288, /* STRING => ABORT */ + 288, /* TIMES => ABORT */ + 288, /* VALUES => ABORT */ + 288, /* VARIABLE => ABORT */ + 288, /* VIEW => ABORT */ + 288, /* WAL => ABORT */ }; #endif /* YYFALLBACK */ @@ -1813,7 +1464,6 @@ struct yyParser { }; typedef struct yyParser yyParser; -#include #ifndef NDEBUG #include static FILE *yyTraceFILE = 0; @@ -2111,233 +1761,235 @@ static const char *const yyTokenName[] = { /* 258 */ "JOIN", /* 259 */ "INNER", /* 260 */ "SELECT", - /* 261 */ "DISTINCT", - /* 262 */ "WHERE", - /* 263 */ "PARTITION", - /* 264 */ "BY", - /* 265 */ "SESSION", - /* 266 */ "STATE_WINDOW", - /* 267 */ "EVENT_WINDOW", - /* 268 */ "SLIDING", - /* 269 */ "FILL", - /* 270 */ "VALUE", - /* 271 */ "VALUE_F", - /* 272 */ "NONE", - /* 273 */ "PREV", - /* 274 */ "NULL_F", - /* 275 */ "LINEAR", - /* 276 */ "NEXT", - /* 277 */ "HAVING", - /* 278 */ "RANGE", - /* 279 */ "EVERY", - /* 280 */ "ORDER", - /* 281 */ "SLIMIT", - /* 282 */ "SOFFSET", - /* 283 */ "LIMIT", - /* 284 */ "OFFSET", - /* 285 */ "ASC", - /* 286 */ "NULLS", - /* 287 */ "ABORT", - /* 288 */ "AFTER", - /* 289 */ "ATTACH", - /* 290 */ "BEFORE", - /* 291 */ "BEGIN", - /* 292 */ "BITAND", - /* 293 */ "BITNOT", - /* 294 */ "BITOR", - /* 295 */ "BLOCKS", - /* 296 */ "CHANGE", - /* 297 */ "COMMA", - /* 298 */ "CONCAT", - /* 299 */ "CONFLICT", - /* 300 */ "COPY", - /* 301 */ "DEFERRED", - /* 302 */ "DELIMITERS", - /* 303 */ "DETACH", - /* 304 */ "DIVIDE", - /* 305 */ "DOT", - /* 306 */ "EACH", - /* 307 */ "FAIL", - /* 308 */ "FILE", - /* 309 */ "FOR", - /* 310 */ "GLOB", - /* 311 */ "ID", - /* 312 */ "IMMEDIATE", - /* 313 */ "IMPORT", - /* 314 */ "INITIALLY", - /* 315 */ "INSTEAD", - /* 316 */ "ISNULL", - /* 317 */ "KEY", - /* 318 */ "MODULES", - /* 319 */ "NK_BITNOT", - /* 320 */ "NK_SEMI", - /* 321 */ "NOTNULL", - /* 322 */ "OF", - /* 323 */ "PLUS", - /* 324 */ "PRIVILEGE", - /* 325 */ "RAISE", - /* 326 */ "RESTRICT", - /* 327 */ "ROW", - /* 328 */ "SEMI", - /* 329 */ "STAR", - /* 330 */ "STATEMENT", - /* 331 */ "STRICT", - /* 332 */ "STRING", - /* 333 */ "TIMES", - /* 334 */ "VALUES", - /* 335 */ "VARIABLE", - /* 336 */ "VIEW", - /* 337 */ "WAL", - /* 338 */ "cmd", - /* 339 */ "account_options", - /* 340 */ "alter_account_options", - /* 341 */ "literal", - /* 342 */ "alter_account_option", - /* 343 */ "user_name", - /* 344 */ "sysinfo_opt", - /* 345 */ "privileges", - /* 346 */ "priv_level", - /* 347 */ "with_opt", - /* 348 */ "priv_type_list", - /* 349 */ "priv_type", - /* 350 */ "db_name", - /* 351 */ "table_name", - /* 352 */ "topic_name", - /* 353 */ "search_condition", - /* 354 */ "dnode_endpoint", - /* 355 */ "force_opt", - /* 356 */ "unsafe_opt", - /* 357 */ "not_exists_opt", - /* 358 */ "db_options", - /* 359 */ "exists_opt", - /* 360 */ "alter_db_options", - /* 361 */ "speed_opt", - /* 362 */ "start_opt", - /* 363 */ "end_opt", - /* 364 */ "integer_list", - /* 365 */ "variable_list", - /* 366 */ "retention_list", - /* 367 */ "signed", - /* 368 */ "alter_db_option", - /* 369 */ "retention", - /* 370 */ "full_table_name", - /* 371 */ "column_def_list", - /* 372 */ "tags_def_opt", - /* 373 */ "table_options", - /* 374 */ "multi_create_clause", - /* 375 */ "tags_def", - /* 376 */ "multi_drop_clause", - /* 377 */ "alter_table_clause", - /* 378 */ "alter_table_options", - /* 379 */ "column_def", - /* 380 */ "column_name", - /* 381 */ "signed_literal", - /* 382 */ "create_subtable_clause", - /* 383 */ "specific_cols_opt", - /* 384 */ "expression_list", - /* 385 */ "drop_table_clause", - /* 386 */ "col_name_list", - /* 387 */ "type_name", - /* 388 */ "duration_list", - /* 389 */ "rollup_func_list", - /* 390 */ "alter_table_option", - /* 391 */ "duration_literal", - /* 392 */ "rollup_func_name", - /* 393 */ "function_name", - /* 394 */ "col_name", - /* 395 */ "db_name_cond_opt", - /* 396 */ "like_pattern_opt", - /* 397 */ "table_name_cond", - /* 398 */ "from_db_opt", - /* 399 */ "tag_list_opt", - /* 400 */ "tag_item", - /* 401 */ "column_alias", - /* 402 */ "full_index_name", - /* 403 */ "index_options", - /* 404 */ "index_name", - /* 405 */ "func_list", - /* 406 */ "sliding_opt", - /* 407 */ "sma_stream_opt", - /* 408 */ "func", - /* 409 */ "sma_func_name", - /* 410 */ "with_meta", - /* 411 */ "query_or_subquery", - /* 412 */ "where_clause_opt", - /* 413 */ "cgroup_name", - /* 414 */ "analyze_opt", - /* 415 */ "explain_options", - /* 416 */ "insert_query", - /* 417 */ "or_replace_opt", - /* 418 */ "agg_func_opt", - /* 419 */ "bufsize_opt", - /* 420 */ "language_opt", - /* 421 */ "stream_name", - /* 422 */ "stream_options", - /* 423 */ "col_list_opt", - /* 424 */ "tag_def_or_ref_opt", - /* 425 */ "subtable_opt", - /* 426 */ "ignore_opt", - /* 427 */ "expression", - /* 428 */ "dnode_list", - /* 429 */ "literal_func", - /* 430 */ "literal_list", - /* 431 */ "table_alias", - /* 432 */ "expr_or_subquery", - /* 433 */ "pseudo_column", - /* 434 */ "column_reference", - /* 435 */ "function_expression", - /* 436 */ "case_when_expression", - /* 437 */ "star_func", - /* 438 */ "star_func_para_list", - /* 439 */ "noarg_func", - /* 440 */ "other_para_list", - /* 441 */ "star_func_para", - /* 442 */ "when_then_list", - /* 443 */ "case_when_else_opt", - /* 444 */ "common_expression", - /* 445 */ "when_then_expr", - /* 446 */ "predicate", - /* 447 */ "compare_op", - /* 448 */ "in_op", - /* 449 */ "in_predicate_value", - /* 450 */ "boolean_value_expression", - /* 451 */ "boolean_primary", - /* 452 */ "from_clause_opt", - /* 453 */ "table_reference_list", - /* 454 */ "table_reference", - /* 455 */ "table_primary", - /* 456 */ "joined_table", - /* 457 */ "alias_opt", - /* 458 */ "subquery", - /* 459 */ "parenthesized_joined_table", - /* 460 */ "join_type", - /* 461 */ "query_specification", - /* 462 */ "tag_mode_opt", - /* 463 */ "set_quantifier_opt", - /* 464 */ "select_list", - /* 465 */ "partition_by_clause_opt", - /* 466 */ "range_opt", - /* 467 */ "every_opt", - /* 468 */ "fill_opt", - /* 469 */ "twindow_clause_opt", - /* 470 */ "group_by_clause_opt", - /* 471 */ "having_clause_opt", - /* 472 */ "select_item", - /* 473 */ "partition_list", - /* 474 */ "partition_item", - /* 475 */ "fill_mode", - /* 476 */ "group_by_list", - /* 477 */ "query_expression", - /* 478 */ "query_simple", - /* 479 */ "order_by_clause_opt", - /* 480 */ "slimit_clause_opt", - /* 481 */ "limit_clause_opt", - /* 482 */ "union_query_expression", - /* 483 */ "query_simple_or_subquery", - /* 484 */ "sort_specification_list", - /* 485 */ "sort_specification", - /* 486 */ "ordering_specification_opt", - /* 487 */ "null_ordering_opt", + /* 261 */ "NK_HINT", + /* 262 */ "DISTINCT", + /* 263 */ "WHERE", + /* 264 */ "PARTITION", + /* 265 */ "BY", + /* 266 */ "SESSION", + /* 267 */ "STATE_WINDOW", + /* 268 */ "EVENT_WINDOW", + /* 269 */ "SLIDING", + /* 270 */ "FILL", + /* 271 */ "VALUE", + /* 272 */ "VALUE_F", + /* 273 */ "NONE", + /* 274 */ "PREV", + /* 275 */ "NULL_F", + /* 276 */ "LINEAR", + /* 277 */ "NEXT", + /* 278 */ "HAVING", + /* 279 */ "RANGE", + /* 280 */ "EVERY", + /* 281 */ "ORDER", + /* 282 */ "SLIMIT", + /* 283 */ "SOFFSET", + /* 284 */ "LIMIT", + /* 285 */ "OFFSET", + /* 286 */ "ASC", + /* 287 */ "NULLS", + /* 288 */ "ABORT", + /* 289 */ "AFTER", + /* 290 */ "ATTACH", + /* 291 */ "BEFORE", + /* 292 */ "BEGIN", + /* 293 */ "BITAND", + /* 294 */ "BITNOT", + /* 295 */ "BITOR", + /* 296 */ "BLOCKS", + /* 297 */ "CHANGE", + /* 298 */ "COMMA", + /* 299 */ "CONCAT", + /* 300 */ "CONFLICT", + /* 301 */ "COPY", + /* 302 */ "DEFERRED", + /* 303 */ "DELIMITERS", + /* 304 */ "DETACH", + /* 305 */ "DIVIDE", + /* 306 */ "DOT", + /* 307 */ "EACH", + /* 308 */ "FAIL", + /* 309 */ "FILE", + /* 310 */ "FOR", + /* 311 */ "GLOB", + /* 312 */ "ID", + /* 313 */ "IMMEDIATE", + /* 314 */ "IMPORT", + /* 315 */ "INITIALLY", + /* 316 */ "INSTEAD", + /* 317 */ "ISNULL", + /* 318 */ "KEY", + /* 319 */ "MODULES", + /* 320 */ "NK_BITNOT", + /* 321 */ "NK_SEMI", + /* 322 */ "NOTNULL", + /* 323 */ "OF", + /* 324 */ "PLUS", + /* 325 */ "PRIVILEGE", + /* 326 */ "RAISE", + /* 327 */ "RESTRICT", + /* 328 */ "ROW", + /* 329 */ "SEMI", + /* 330 */ "STAR", + /* 331 */ "STATEMENT", + /* 332 */ "STRICT", + /* 333 */ "STRING", + /* 334 */ "TIMES", + /* 335 */ "VALUES", + /* 336 */ "VARIABLE", + /* 337 */ "VIEW", + /* 338 */ "WAL", + /* 339 */ "cmd", + /* 340 */ "account_options", + /* 341 */ "alter_account_options", + /* 342 */ "literal", + /* 343 */ "alter_account_option", + /* 344 */ "user_name", + /* 345 */ "sysinfo_opt", + /* 346 */ "privileges", + /* 347 */ "priv_level", + /* 348 */ "with_opt", + /* 349 */ "priv_type_list", + /* 350 */ "priv_type", + /* 351 */ "db_name", + /* 352 */ "table_name", + /* 353 */ "topic_name", + /* 354 */ "search_condition", + /* 355 */ "dnode_endpoint", + /* 356 */ "force_opt", + /* 357 */ "unsafe_opt", + /* 358 */ "not_exists_opt", + /* 359 */ "db_options", + /* 360 */ "exists_opt", + /* 361 */ "alter_db_options", + /* 362 */ "speed_opt", + /* 363 */ "start_opt", + /* 364 */ "end_opt", + /* 365 */ "integer_list", + /* 366 */ "variable_list", + /* 367 */ "retention_list", + /* 368 */ "signed", + /* 369 */ "alter_db_option", + /* 370 */ "retention", + /* 371 */ "full_table_name", + /* 372 */ "column_def_list", + /* 373 */ "tags_def_opt", + /* 374 */ "table_options", + /* 375 */ "multi_create_clause", + /* 376 */ "tags_def", + /* 377 */ "multi_drop_clause", + /* 378 */ "alter_table_clause", + /* 379 */ "alter_table_options", + /* 380 */ "column_def", + /* 381 */ "column_name", + /* 382 */ "signed_literal", + /* 383 */ "create_subtable_clause", + /* 384 */ "specific_cols_opt", + /* 385 */ "expression_list", + /* 386 */ "drop_table_clause", + /* 387 */ "col_name_list", + /* 388 */ "type_name", + /* 389 */ "duration_list", + /* 390 */ "rollup_func_list", + /* 391 */ "alter_table_option", + /* 392 */ "duration_literal", + /* 393 */ "rollup_func_name", + /* 394 */ "function_name", + /* 395 */ "col_name", + /* 396 */ "db_name_cond_opt", + /* 397 */ "like_pattern_opt", + /* 398 */ "table_name_cond", + /* 399 */ "from_db_opt", + /* 400 */ "tag_list_opt", + /* 401 */ "tag_item", + /* 402 */ "column_alias", + /* 403 */ "full_index_name", + /* 404 */ "index_options", + /* 405 */ "index_name", + /* 406 */ "func_list", + /* 407 */ "sliding_opt", + /* 408 */ "sma_stream_opt", + /* 409 */ "func", + /* 410 */ "sma_func_name", + /* 411 */ "with_meta", + /* 412 */ "query_or_subquery", + /* 413 */ "where_clause_opt", + /* 414 */ "cgroup_name", + /* 415 */ "analyze_opt", + /* 416 */ "explain_options", + /* 417 */ "insert_query", + /* 418 */ "or_replace_opt", + /* 419 */ "agg_func_opt", + /* 420 */ "bufsize_opt", + /* 421 */ "language_opt", + /* 422 */ "stream_name", + /* 423 */ "stream_options", + /* 424 */ "col_list_opt", + /* 425 */ "tag_def_or_ref_opt", + /* 426 */ "subtable_opt", + /* 427 */ "ignore_opt", + /* 428 */ "expression", + /* 429 */ "dnode_list", + /* 430 */ "literal_func", + /* 431 */ "literal_list", + /* 432 */ "table_alias", + /* 433 */ "expr_or_subquery", + /* 434 */ "pseudo_column", + /* 435 */ "column_reference", + /* 436 */ "function_expression", + /* 437 */ "case_when_expression", + /* 438 */ "star_func", + /* 439 */ "star_func_para_list", + /* 440 */ "noarg_func", + /* 441 */ "other_para_list", + /* 442 */ "star_func_para", + /* 443 */ "when_then_list", + /* 444 */ "case_when_else_opt", + /* 445 */ "common_expression", + /* 446 */ "when_then_expr", + /* 447 */ "predicate", + /* 448 */ "compare_op", + /* 449 */ "in_op", + /* 450 */ "in_predicate_value", + /* 451 */ "boolean_value_expression", + /* 452 */ "boolean_primary", + /* 453 */ "from_clause_opt", + /* 454 */ "table_reference_list", + /* 455 */ "table_reference", + /* 456 */ "table_primary", + /* 457 */ "joined_table", + /* 458 */ "alias_opt", + /* 459 */ "subquery", + /* 460 */ "parenthesized_joined_table", + /* 461 */ "join_type", + /* 462 */ "query_specification", + /* 463 */ "hint_list", + /* 464 */ "tag_mode_opt", + /* 465 */ "set_quantifier_opt", + /* 466 */ "select_list", + /* 467 */ "partition_by_clause_opt", + /* 468 */ "range_opt", + /* 469 */ "every_opt", + /* 470 */ "fill_opt", + /* 471 */ "twindow_clause_opt", + /* 472 */ "group_by_clause_opt", + /* 473 */ "having_clause_opt", + /* 474 */ "select_item", + /* 475 */ "partition_list", + /* 476 */ "partition_item", + /* 477 */ "fill_mode", + /* 478 */ "group_by_list", + /* 479 */ "query_expression", + /* 480 */ "query_simple", + /* 481 */ "order_by_clause_opt", + /* 482 */ "slimit_clause_opt", + /* 483 */ "limit_clause_opt", + /* 484 */ "union_query_expression", + /* 485 */ "query_simple_or_subquery", + /* 486 */ "sort_specification_list", + /* 487 */ "sort_specification", + /* 488 */ "ordering_specification_opt", + /* 489 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -2866,88 +2518,90 @@ static const char *const yyRuleName[] = { /* 518 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", /* 519 */ "join_type ::=", /* 520 */ "join_type ::= INNER", - /* 521 */ "query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 522 */ "tag_mode_opt ::=", - /* 523 */ "tag_mode_opt ::= TAGS", - /* 524 */ "set_quantifier_opt ::=", - /* 525 */ "set_quantifier_opt ::= DISTINCT", - /* 526 */ "set_quantifier_opt ::= ALL", - /* 527 */ "select_list ::= select_item", - /* 528 */ "select_list ::= select_list NK_COMMA select_item", - /* 529 */ "select_item ::= NK_STAR", - /* 530 */ "select_item ::= common_expression", - /* 531 */ "select_item ::= common_expression column_alias", - /* 532 */ "select_item ::= common_expression AS column_alias", - /* 533 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 534 */ "where_clause_opt ::=", - /* 535 */ "where_clause_opt ::= WHERE search_condition", - /* 536 */ "partition_by_clause_opt ::=", - /* 537 */ "partition_by_clause_opt ::= PARTITION BY partition_list", - /* 538 */ "partition_list ::= partition_item", - /* 539 */ "partition_list ::= partition_list NK_COMMA partition_item", - /* 540 */ "partition_item ::= expr_or_subquery", - /* 541 */ "partition_item ::= expr_or_subquery column_alias", - /* 542 */ "partition_item ::= expr_or_subquery AS column_alias", - /* 543 */ "twindow_clause_opt ::=", - /* 544 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 545 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", - /* 546 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 547 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 548 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", - /* 549 */ "sliding_opt ::=", - /* 550 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 551 */ "fill_opt ::=", - /* 552 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 553 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", - /* 554 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", - /* 555 */ "fill_mode ::= NONE", - /* 556 */ "fill_mode ::= PREV", - /* 557 */ "fill_mode ::= NULL", - /* 558 */ "fill_mode ::= NULL_F", - /* 559 */ "fill_mode ::= LINEAR", - /* 560 */ "fill_mode ::= NEXT", - /* 561 */ "group_by_clause_opt ::=", - /* 562 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 563 */ "group_by_list ::= expr_or_subquery", - /* 564 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", - /* 565 */ "having_clause_opt ::=", - /* 566 */ "having_clause_opt ::= HAVING search_condition", - /* 567 */ "range_opt ::=", - /* 568 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", - /* 569 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", - /* 570 */ "every_opt ::=", - /* 571 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 572 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 573 */ "query_simple ::= query_specification", - /* 574 */ "query_simple ::= union_query_expression", - /* 575 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", - /* 576 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", - /* 577 */ "query_simple_or_subquery ::= query_simple", - /* 578 */ "query_simple_or_subquery ::= subquery", - /* 579 */ "query_or_subquery ::= query_expression", - /* 580 */ "query_or_subquery ::= subquery", - /* 581 */ "order_by_clause_opt ::=", - /* 582 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 583 */ "slimit_clause_opt ::=", - /* 584 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 585 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 586 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 587 */ "limit_clause_opt ::=", - /* 588 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 589 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 590 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 591 */ "subquery ::= NK_LP query_expression NK_RP", - /* 592 */ "subquery ::= NK_LP subquery NK_RP", - /* 593 */ "search_condition ::= common_expression", - /* 594 */ "sort_specification_list ::= sort_specification", - /* 595 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 596 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", - /* 597 */ "ordering_specification_opt ::=", - /* 598 */ "ordering_specification_opt ::= ASC", - /* 599 */ "ordering_specification_opt ::= DESC", - /* 600 */ "null_ordering_opt ::=", - /* 601 */ "null_ordering_opt ::= NULLS FIRST", - /* 602 */ "null_ordering_opt ::= NULLS LAST", + /* 521 */ "query_specification ::= SELECT hint_list tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 522 */ "hint_list ::=", + /* 523 */ "hint_list ::= NK_HINT", + /* 524 */ "tag_mode_opt ::=", + /* 525 */ "tag_mode_opt ::= TAGS", + /* 526 */ "set_quantifier_opt ::=", + /* 527 */ "set_quantifier_opt ::= DISTINCT", + /* 528 */ "set_quantifier_opt ::= ALL", + /* 529 */ "select_list ::= select_item", + /* 530 */ "select_list ::= select_list NK_COMMA select_item", + /* 531 */ "select_item ::= NK_STAR", + /* 532 */ "select_item ::= common_expression", + /* 533 */ "select_item ::= common_expression column_alias", + /* 534 */ "select_item ::= common_expression AS column_alias", + /* 535 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 536 */ "where_clause_opt ::=", + /* 537 */ "where_clause_opt ::= WHERE search_condition", + /* 538 */ "partition_by_clause_opt ::=", + /* 539 */ "partition_by_clause_opt ::= PARTITION BY partition_list", + /* 540 */ "partition_list ::= partition_item", + /* 541 */ "partition_list ::= partition_list NK_COMMA partition_item", + /* 542 */ "partition_item ::= expr_or_subquery", + /* 543 */ "partition_item ::= expr_or_subquery column_alias", + /* 544 */ "partition_item ::= expr_or_subquery AS column_alias", + /* 545 */ "twindow_clause_opt ::=", + /* 546 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 547 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", + /* 548 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 549 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 550 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", + /* 551 */ "sliding_opt ::=", + /* 552 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 553 */ "fill_opt ::=", + /* 554 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 555 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", + /* 556 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", + /* 557 */ "fill_mode ::= NONE", + /* 558 */ "fill_mode ::= PREV", + /* 559 */ "fill_mode ::= NULL", + /* 560 */ "fill_mode ::= NULL_F", + /* 561 */ "fill_mode ::= LINEAR", + /* 562 */ "fill_mode ::= NEXT", + /* 563 */ "group_by_clause_opt ::=", + /* 564 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 565 */ "group_by_list ::= expr_or_subquery", + /* 566 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", + /* 567 */ "having_clause_opt ::=", + /* 568 */ "having_clause_opt ::= HAVING search_condition", + /* 569 */ "range_opt ::=", + /* 570 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", + /* 571 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", + /* 572 */ "every_opt ::=", + /* 573 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 574 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 575 */ "query_simple ::= query_specification", + /* 576 */ "query_simple ::= union_query_expression", + /* 577 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", + /* 578 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", + /* 579 */ "query_simple_or_subquery ::= query_simple", + /* 580 */ "query_simple_or_subquery ::= subquery", + /* 581 */ "query_or_subquery ::= query_expression", + /* 582 */ "query_or_subquery ::= subquery", + /* 583 */ "order_by_clause_opt ::=", + /* 584 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 585 */ "slimit_clause_opt ::=", + /* 586 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 587 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 588 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 589 */ "limit_clause_opt ::=", + /* 590 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 591 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 592 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 593 */ "subquery ::= NK_LP query_expression NK_RP", + /* 594 */ "subquery ::= NK_LP subquery NK_RP", + /* 595 */ "search_condition ::= common_expression", + /* 596 */ "sort_specification_list ::= sort_specification", + /* 597 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 598 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", + /* 599 */ "ordering_specification_opt ::=", + /* 600 */ "ordering_specification_opt ::= ASC", + /* 601 */ "ordering_specification_opt ::= DESC", + /* 602 */ "null_ordering_opt ::=", + /* 603 */ "null_ordering_opt ::= NULLS FIRST", + /* 604 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -3074,244 +2728,215 @@ static void yy_destructor( */ /********* Begin destructor definitions ***************************************/ /* Default NON-TERMINAL Destructor */ - case 338: /* cmd */ - case 341: /* literal */ - case 347: /* with_opt */ - case 353: /* search_condition */ - case 358: /* db_options */ - case 360: /* alter_db_options */ - case 362: /* start_opt */ - case 363: /* end_opt */ - case 367: /* signed */ - case 369: /* retention */ - case 370: /* full_table_name */ - case 373: /* table_options */ - case 377: /* alter_table_clause */ - case 378: /* alter_table_options */ - case 379: /* column_def */ - case 381: /* signed_literal */ - case 382: /* create_subtable_clause */ - case 385: /* drop_table_clause */ - case 391: /* duration_literal */ - case 392: /* rollup_func_name */ - case 394: /* col_name */ - case 395: /* db_name_cond_opt */ - case 396: /* like_pattern_opt */ - case 397: /* table_name_cond */ - case 398: /* from_db_opt */ - case 400: /* tag_item */ - case 402: /* full_index_name */ - case 403: /* index_options */ - case 406: /* sliding_opt */ - case 407: /* sma_stream_opt */ - case 408: /* func */ - case 411: /* query_or_subquery */ - case 412: /* where_clause_opt */ - case 415: /* explain_options */ - case 416: /* insert_query */ - case 422: /* stream_options */ - case 425: /* subtable_opt */ - case 427: /* expression */ - case 429: /* literal_func */ - case 432: /* expr_or_subquery */ - case 433: /* pseudo_column */ - case 434: /* column_reference */ - case 435: /* function_expression */ - case 436: /* case_when_expression */ - case 441: /* star_func_para */ - case 443: /* case_when_else_opt */ - case 444: /* common_expression */ - case 445: /* when_then_expr */ - case 446: /* predicate */ - case 449: /* in_predicate_value */ - case 450: /* boolean_value_expression */ - case 451: /* boolean_primary */ - case 452: /* from_clause_opt */ - case 453: /* table_reference_list */ - case 454: /* table_reference */ - case 455: /* table_primary */ - case 456: /* joined_table */ - case 458: /* subquery */ - case 459: /* parenthesized_joined_table */ - case 461: /* query_specification */ - case 466: /* range_opt */ - case 467: /* every_opt */ - case 468: /* fill_opt */ - case 469: /* twindow_clause_opt */ - case 471: /* having_clause_opt */ - case 472: /* select_item */ - case 474: /* partition_item */ - case 477: /* query_expression */ - case 478: /* query_simple */ - case 480: /* slimit_clause_opt */ - case 481: /* limit_clause_opt */ - case 482: /* union_query_expression */ - case 483: /* query_simple_or_subquery */ - case 485: /* sort_specification */ + case 339: /* cmd */ + case 342: /* literal */ + case 348: /* with_opt */ + case 354: /* search_condition */ + case 359: /* db_options */ + case 361: /* alter_db_options */ + case 363: /* start_opt */ + case 364: /* end_opt */ + case 368: /* signed */ + case 370: /* retention */ + case 371: /* full_table_name */ + case 374: /* table_options */ + case 378: /* alter_table_clause */ + case 379: /* alter_table_options */ + case 380: /* column_def */ + case 382: /* signed_literal */ + case 383: /* create_subtable_clause */ + case 386: /* drop_table_clause */ + case 392: /* duration_literal */ + case 393: /* rollup_func_name */ + case 395: /* col_name */ + case 396: /* db_name_cond_opt */ + case 397: /* like_pattern_opt */ + case 398: /* table_name_cond */ + case 399: /* from_db_opt */ + case 401: /* tag_item */ + case 403: /* full_index_name */ + case 404: /* index_options */ + case 407: /* sliding_opt */ + case 408: /* sma_stream_opt */ + case 409: /* func */ + case 412: /* query_or_subquery */ + case 413: /* where_clause_opt */ + case 416: /* explain_options */ + case 417: /* insert_query */ + case 423: /* stream_options */ + case 426: /* subtable_opt */ + case 428: /* expression */ + case 430: /* literal_func */ + case 433: /* expr_or_subquery */ + case 434: /* pseudo_column */ + case 435: /* column_reference */ + case 436: /* function_expression */ + case 437: /* case_when_expression */ + case 442: /* star_func_para */ + case 444: /* case_when_else_opt */ + case 445: /* common_expression */ + case 446: /* when_then_expr */ + case 447: /* predicate */ + case 450: /* in_predicate_value */ + case 451: /* boolean_value_expression */ + case 452: /* boolean_primary */ + case 453: /* from_clause_opt */ + case 454: /* table_reference_list */ + case 455: /* table_reference */ + case 456: /* table_primary */ + case 457: /* joined_table */ + case 459: /* subquery */ + case 460: /* parenthesized_joined_table */ + case 462: /* query_specification */ + case 468: /* range_opt */ + case 469: /* every_opt */ + case 470: /* fill_opt */ + case 471: /* twindow_clause_opt */ + case 473: /* having_clause_opt */ + case 474: /* select_item */ + case 476: /* partition_item */ + case 479: /* query_expression */ + case 480: /* query_simple */ + case 482: /* slimit_clause_opt */ + case 483: /* limit_clause_opt */ + case 484: /* union_query_expression */ + case 485: /* query_simple_or_subquery */ + case 487: /* sort_specification */ { -#line 7 "sql.y" - nodesDestroyNode((yypminor->yy840)); -#line 3154 "sql.c" + nodesDestroyNode((yypminor->yy952)); } break; - case 339: /* account_options */ - case 340: /* alter_account_options */ - case 342: /* alter_account_option */ - case 361: /* speed_opt */ - case 410: /* with_meta */ - case 419: /* bufsize_opt */ + case 340: /* account_options */ + case 341: /* alter_account_options */ + case 343: /* alter_account_option */ + case 362: /* speed_opt */ + case 411: /* with_meta */ + case 420: /* bufsize_opt */ { -#line 54 "sql.y" -#line 3166 "sql.c" } break; - case 343: /* user_name */ - case 350: /* db_name */ - case 351: /* table_name */ - case 352: /* topic_name */ - case 354: /* dnode_endpoint */ - case 380: /* column_name */ - case 393: /* function_name */ - case 401: /* column_alias */ - case 404: /* index_name */ - case 409: /* sma_func_name */ - case 413: /* cgroup_name */ - case 420: /* language_opt */ - case 421: /* stream_name */ - case 431: /* table_alias */ - case 437: /* star_func */ - case 439: /* noarg_func */ - case 457: /* alias_opt */ + case 344: /* user_name */ + case 351: /* db_name */ + case 352: /* table_name */ + case 353: /* topic_name */ + case 355: /* dnode_endpoint */ + case 381: /* column_name */ + case 394: /* function_name */ + case 402: /* column_alias */ + case 405: /* index_name */ + case 410: /* sma_func_name */ + case 414: /* cgroup_name */ + case 421: /* language_opt */ + case 422: /* stream_name */ + case 432: /* table_alias */ + case 438: /* star_func */ + case 440: /* noarg_func */ + case 458: /* alias_opt */ { -#line 742 "sql.y" -#line 3189 "sql.c" } break; - case 344: /* sysinfo_opt */ + case 345: /* sysinfo_opt */ { -#line 92 "sql.y" -#line 3196 "sql.c" } break; - case 345: /* privileges */ - case 348: /* priv_type_list */ - case 349: /* priv_type */ + case 346: /* privileges */ + case 349: /* priv_type_list */ + case 350: /* priv_type */ { -#line 101 "sql.y" -#line 3205 "sql.c" } break; - case 346: /* priv_level */ + case 347: /* priv_level */ { -#line 117 "sql.y" -#line 3212 "sql.c" } break; - case 355: /* force_opt */ - case 356: /* unsafe_opt */ - case 357: /* not_exists_opt */ - case 359: /* exists_opt */ - case 414: /* analyze_opt */ - case 417: /* or_replace_opt */ - case 418: /* agg_func_opt */ - case 426: /* ignore_opt */ - case 462: /* tag_mode_opt */ - case 463: /* set_quantifier_opt */ + case 356: /* force_opt */ + case 357: /* unsafe_opt */ + case 358: /* not_exists_opt */ + case 360: /* exists_opt */ + case 415: /* analyze_opt */ + case 418: /* or_replace_opt */ + case 419: /* agg_func_opt */ + case 427: /* ignore_opt */ + case 464: /* tag_mode_opt */ + case 465: /* set_quantifier_opt */ { -#line 146 "sql.y" -#line 3228 "sql.c" } break; - case 364: /* integer_list */ - case 365: /* variable_list */ - case 366: /* retention_list */ - case 371: /* column_def_list */ - case 372: /* tags_def_opt */ - case 374: /* multi_create_clause */ - case 375: /* tags_def */ - case 376: /* multi_drop_clause */ - case 383: /* specific_cols_opt */ - case 384: /* expression_list */ - case 386: /* col_name_list */ - case 388: /* duration_list */ - case 389: /* rollup_func_list */ - case 399: /* tag_list_opt */ - case 405: /* func_list */ - case 423: /* col_list_opt */ - case 424: /* tag_def_or_ref_opt */ - case 428: /* dnode_list */ - case 430: /* literal_list */ - case 438: /* star_func_para_list */ - case 440: /* other_para_list */ - case 442: /* when_then_list */ - case 464: /* select_list */ - case 465: /* partition_by_clause_opt */ - case 470: /* group_by_clause_opt */ - case 473: /* partition_list */ - case 476: /* group_by_list */ - case 479: /* order_by_clause_opt */ - case 484: /* sort_specification_list */ + case 365: /* integer_list */ + case 366: /* variable_list */ + case 367: /* retention_list */ + case 372: /* column_def_list */ + case 373: /* tags_def_opt */ + case 375: /* multi_create_clause */ + case 376: /* tags_def */ + case 377: /* multi_drop_clause */ + case 384: /* specific_cols_opt */ + case 385: /* expression_list */ + case 387: /* col_name_list */ + case 389: /* duration_list */ + case 390: /* rollup_func_list */ + case 400: /* tag_list_opt */ + case 406: /* func_list */ + case 424: /* col_list_opt */ + case 425: /* tag_def_or_ref_opt */ + case 429: /* dnode_list */ + case 431: /* literal_list */ + case 439: /* star_func_para_list */ + case 441: /* other_para_list */ + case 443: /* when_then_list */ + case 463: /* hint_list */ + case 466: /* select_list */ + case 467: /* partition_by_clause_opt */ + case 472: /* group_by_clause_opt */ + case 475: /* partition_list */ + case 478: /* group_by_list */ + case 481: /* order_by_clause_opt */ + case 486: /* sort_specification_list */ { -#line 270 "sql.y" - nodesDestroyList((yypminor->yy56)); -#line 3263 "sql.c" + nodesDestroyList((yypminor->yy824)); } break; - case 368: /* alter_db_option */ - case 390: /* alter_table_option */ + case 369: /* alter_db_option */ + case 391: /* alter_table_option */ { -#line 243 "sql.y" -#line 3271 "sql.c" } break; - case 387: /* type_name */ + case 388: /* type_name */ { -#line 364 "sql.y" -#line 3278 "sql.c" } break; - case 447: /* compare_op */ - case 448: /* in_op */ + case 448: /* compare_op */ + case 449: /* in_op */ { -#line 930 "sql.y" -#line 3286 "sql.c" } break; - case 460: /* join_type */ + case 461: /* join_type */ { -#line 1006 "sql.y" -#line 3293 "sql.c" } break; - case 475: /* fill_mode */ + case 477: /* fill_mode */ { -#line 1087 "sql.y" -#line 3300 "sql.c" } break; - case 486: /* ordering_specification_opt */ + case 488: /* ordering_specification_opt */ { -#line 1172 "sql.y" -#line 3307 "sql.c" } break; - case 487: /* null_ordering_opt */ + case 489: /* null_ordering_opt */ { -#line 1178 "sql.y" -#line 3314 "sql.c" } break; /********* End destructor definitions *****************************************/ @@ -3478,7 +3103,7 @@ static YYACTIONTYPE yy_find_shift_action( #endif /* YYWILDCARD */ return yy_default[stateno]; }else{ - assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) ); + assert( i>=0 && iyytos; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + yysize = yyRuleInfoNRhs[yyruleno]; + if( yysize ){ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", + yyTracePrompt, + yyruleno, yyRuleName[yyruleno], + yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } + yymsp = yypParser->yytos; + } +#endif + } switch( yyruleno ){ /* Beginning here are the reduction cases. A typical example @@ -4853,21 +4530,15 @@ static YYACTIONTYPE yy_reduce( /********** Begin reduce actions **********************************************/ YYMINORTYPE yylhsminor; case 0: /* cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ -#line 50 "sql.y" { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } -#line 4858 "sql.c" - yy_destructor(yypParser,339,&yymsp[0].minor); - break; - case 1: /* cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ -#line 51 "sql.y" -{ pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } -#line 4864 "sql.c" yy_destructor(yypParser,340,&yymsp[0].minor); break; + case 1: /* cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ +{ pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } + yy_destructor(yypParser,341,&yymsp[0].minor); + break; case 2: /* account_options ::= */ -#line 55 "sql.y" { } -#line 4870 "sql.c" break; case 3: /* account_options ::= account_options PPS literal */ case 4: /* account_options ::= account_options TSERIES literal */ yytestcase(yyruleno==4); @@ -4878,26 +4549,20 @@ static YYACTIONTYPE yy_reduce( case 9: /* account_options ::= account_options USERS literal */ yytestcase(yyruleno==9); case 10: /* account_options ::= account_options CONNS literal */ yytestcase(yyruleno==10); case 11: /* account_options ::= account_options STATE literal */ yytestcase(yyruleno==11); -{ yy_destructor(yypParser,339,&yymsp[-2].minor); -#line 56 "sql.y" +{ yy_destructor(yypParser,340,&yymsp[-2].minor); { } -#line 4884 "sql.c" - yy_destructor(yypParser,341,&yymsp[0].minor); + yy_destructor(yypParser,342,&yymsp[0].minor); } break; case 12: /* alter_account_options ::= alter_account_option */ -{ yy_destructor(yypParser,342,&yymsp[0].minor); -#line 68 "sql.y" +{ yy_destructor(yypParser,343,&yymsp[0].minor); { } -#line 4892 "sql.c" } break; case 13: /* alter_account_options ::= alter_account_options alter_account_option */ -{ yy_destructor(yypParser,340,&yymsp[-1].minor); -#line 69 "sql.y" +{ yy_destructor(yypParser,341,&yymsp[-1].minor); { } -#line 4899 "sql.c" - yy_destructor(yypParser,342,&yymsp[0].minor); + yy_destructor(yypParser,343,&yymsp[0].minor); } break; case 14: /* alter_account_option ::= PASS literal */ @@ -4910,112 +4575,72 @@ static YYACTIONTYPE yy_reduce( case 21: /* alter_account_option ::= USERS literal */ yytestcase(yyruleno==21); case 22: /* alter_account_option ::= CONNS literal */ yytestcase(yyruleno==22); case 23: /* alter_account_option ::= STATE literal */ yytestcase(yyruleno==23); -#line 73 "sql.y" { } -#line 4915 "sql.c" - yy_destructor(yypParser,341,&yymsp[0].minor); + yy_destructor(yypParser,342,&yymsp[0].minor); break; case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt */ -#line 85 "sql.y" -{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy129, &yymsp[-1].minor.yy0, yymsp[0].minor.yy215); } -#line 4921 "sql.c" +{ pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy169, &yymsp[-1].minor.yy0, yymsp[0].minor.yy243); } break; case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */ -#line 86 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy129, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } -#line 4926 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy169, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } break; case 26: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ -#line 87 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy129, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } -#line 4931 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy169, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } break; case 27: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ -#line 88 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy129, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } -#line 4936 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy169, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } break; case 28: /* cmd ::= DROP USER user_name */ -#line 89 "sql.y" -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy129); } -#line 4941 "sql.c" +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy169); } break; case 29: /* sysinfo_opt ::= */ -#line 93 "sql.y" -{ yymsp[1].minor.yy215 = 1; } -#line 4946 "sql.c" +{ yymsp[1].minor.yy243 = 1; } break; case 30: /* sysinfo_opt ::= SYSINFO NK_INTEGER */ -#line 94 "sql.y" -{ yymsp[-1].minor.yy215 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } -#line 4951 "sql.c" +{ yymsp[-1].minor.yy243 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } break; case 31: /* cmd ::= GRANT privileges ON priv_level with_opt TO user_name */ -#line 97 "sql.y" -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy717, &yymsp[-3].minor.yy505, &yymsp[0].minor.yy129, yymsp[-2].minor.yy840); } -#line 4956 "sql.c" +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy949, &yymsp[-3].minor.yy637, &yymsp[0].minor.yy169, yymsp[-2].minor.yy952); } break; case 32: /* cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */ -#line 98 "sql.y" -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy717, &yymsp[-3].minor.yy505, &yymsp[0].minor.yy129, yymsp[-2].minor.yy840); } -#line 4961 "sql.c" +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy949, &yymsp[-3].minor.yy637, &yymsp[0].minor.yy169, yymsp[-2].minor.yy952); } break; case 33: /* privileges ::= ALL */ -#line 102 "sql.y" -{ yymsp[0].minor.yy717 = PRIVILEGE_TYPE_ALL; } -#line 4966 "sql.c" +{ yymsp[0].minor.yy949 = PRIVILEGE_TYPE_ALL; } break; case 34: /* privileges ::= priv_type_list */ case 36: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==36); -#line 103 "sql.y" -{ yylhsminor.yy717 = yymsp[0].minor.yy717; } -#line 4972 "sql.c" - yymsp[0].minor.yy717 = yylhsminor.yy717; +{ yylhsminor.yy949 = yymsp[0].minor.yy949; } + yymsp[0].minor.yy949 = yylhsminor.yy949; break; case 35: /* privileges ::= SUBSCRIBE */ -#line 104 "sql.y" -{ yymsp[0].minor.yy717 = PRIVILEGE_TYPE_SUBSCRIBE; } -#line 4978 "sql.c" +{ yymsp[0].minor.yy949 = PRIVILEGE_TYPE_SUBSCRIBE; } break; case 37: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ -#line 109 "sql.y" -{ yylhsminor.yy717 = yymsp[-2].minor.yy717 | yymsp[0].minor.yy717; } -#line 4983 "sql.c" - yymsp[-2].minor.yy717 = yylhsminor.yy717; +{ yylhsminor.yy949 = yymsp[-2].minor.yy949 | yymsp[0].minor.yy949; } + yymsp[-2].minor.yy949 = yylhsminor.yy949; break; case 38: /* priv_type ::= READ */ -#line 113 "sql.y" -{ yymsp[0].minor.yy717 = PRIVILEGE_TYPE_READ; } -#line 4989 "sql.c" +{ yymsp[0].minor.yy949 = PRIVILEGE_TYPE_READ; } break; case 39: /* priv_type ::= WRITE */ -#line 114 "sql.y" -{ yymsp[0].minor.yy717 = PRIVILEGE_TYPE_WRITE; } -#line 4994 "sql.c" +{ yymsp[0].minor.yy949 = PRIVILEGE_TYPE_WRITE; } break; case 40: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ -#line 118 "sql.y" -{ yylhsminor.yy505.first = yymsp[-2].minor.yy0; yylhsminor.yy505.second = yymsp[0].minor.yy0; } -#line 4999 "sql.c" - yymsp[-2].minor.yy505 = yylhsminor.yy505; +{ yylhsminor.yy637.first = yymsp[-2].minor.yy0; yylhsminor.yy637.second = yymsp[0].minor.yy0; } + yymsp[-2].minor.yy637 = yylhsminor.yy637; break; case 41: /* priv_level ::= db_name NK_DOT NK_STAR */ -#line 119 "sql.y" -{ yylhsminor.yy505.first = yymsp[-2].minor.yy129; yylhsminor.yy505.second = yymsp[0].minor.yy0; } -#line 5005 "sql.c" - yymsp[-2].minor.yy505 = yylhsminor.yy505; +{ yylhsminor.yy637.first = yymsp[-2].minor.yy169; yylhsminor.yy637.second = yymsp[0].minor.yy0; } + yymsp[-2].minor.yy637 = yylhsminor.yy637; break; case 42: /* priv_level ::= db_name NK_DOT table_name */ -#line 120 "sql.y" -{ yylhsminor.yy505.first = yymsp[-2].minor.yy129; yylhsminor.yy505.second = yymsp[0].minor.yy129; } -#line 5011 "sql.c" - yymsp[-2].minor.yy505 = yylhsminor.yy505; +{ yylhsminor.yy637.first = yymsp[-2].minor.yy169; yylhsminor.yy637.second = yymsp[0].minor.yy169; } + yymsp[-2].minor.yy637 = yylhsminor.yy637; break; case 43: /* priv_level ::= topic_name */ -#line 121 "sql.y" -{ yylhsminor.yy505.first = yymsp[0].minor.yy129; yylhsminor.yy505.second = nil_token; } -#line 5017 "sql.c" - yymsp[0].minor.yy505 = yylhsminor.yy505; +{ yylhsminor.yy637.first = yymsp[0].minor.yy169; yylhsminor.yy637.second = nil_token; } + yymsp[0].minor.yy637 = yylhsminor.yy637; break; case 44: /* with_opt ::= */ case 144: /* start_opt ::= */ yytestcase(yyruleno==144); @@ -5024,81 +4649,55 @@ static YYACTIONTYPE yy_reduce( case 355: /* subtable_opt ::= */ yytestcase(yyruleno==355); case 473: /* case_when_else_opt ::= */ yytestcase(yyruleno==473); case 503: /* from_clause_opt ::= */ yytestcase(yyruleno==503); - case 534: /* where_clause_opt ::= */ yytestcase(yyruleno==534); - case 543: /* twindow_clause_opt ::= */ yytestcase(yyruleno==543); - case 549: /* sliding_opt ::= */ yytestcase(yyruleno==549); - case 551: /* fill_opt ::= */ yytestcase(yyruleno==551); - case 565: /* having_clause_opt ::= */ yytestcase(yyruleno==565); - case 567: /* range_opt ::= */ yytestcase(yyruleno==567); - case 570: /* every_opt ::= */ yytestcase(yyruleno==570); - case 583: /* slimit_clause_opt ::= */ yytestcase(yyruleno==583); - case 587: /* limit_clause_opt ::= */ yytestcase(yyruleno==587); -#line 123 "sql.y" -{ yymsp[1].minor.yy840 = NULL; } -#line 5038 "sql.c" + case 536: /* where_clause_opt ::= */ yytestcase(yyruleno==536); + case 545: /* twindow_clause_opt ::= */ yytestcase(yyruleno==545); + case 551: /* sliding_opt ::= */ yytestcase(yyruleno==551); + case 553: /* fill_opt ::= */ yytestcase(yyruleno==553); + case 567: /* having_clause_opt ::= */ yytestcase(yyruleno==567); + case 569: /* range_opt ::= */ yytestcase(yyruleno==569); + case 572: /* every_opt ::= */ yytestcase(yyruleno==572); + case 585: /* slimit_clause_opt ::= */ yytestcase(yyruleno==585); + case 589: /* limit_clause_opt ::= */ yytestcase(yyruleno==589); +{ yymsp[1].minor.yy952 = NULL; } break; case 45: /* with_opt ::= WITH search_condition */ case 504: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==504); - case 535: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==535); - case 566: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==566); -#line 124 "sql.y" -{ yymsp[-1].minor.yy840 = yymsp[0].minor.yy840; } -#line 5046 "sql.c" + case 537: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==537); + case 568: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==568); +{ yymsp[-1].minor.yy952 = yymsp[0].minor.yy952; } break; case 46: /* cmd ::= CREATE DNODE dnode_endpoint */ -#line 127 "sql.y" -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy129, NULL); } -#line 5051 "sql.c" +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy169, NULL); } break; case 47: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ -#line 128 "sql.y" -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0); } -#line 5056 "sql.c" +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy0); } break; case 48: /* cmd ::= DROP DNODE NK_INTEGER force_opt */ -#line 129 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy313, false); } -#line 5061 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy957, false); } break; case 49: /* cmd ::= DROP DNODE dnode_endpoint force_opt */ -#line 130 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy313, false); } -#line 5066 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy169, yymsp[0].minor.yy957, false); } break; case 50: /* cmd ::= DROP DNODE NK_INTEGER unsafe_opt */ -#line 131 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy313); } -#line 5071 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy957); } break; case 51: /* cmd ::= DROP DNODE dnode_endpoint unsafe_opt */ -#line 132 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy129, false, yymsp[0].minor.yy313); } -#line 5076 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy169, false, yymsp[0].minor.yy957); } break; case 52: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ -#line 133 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } -#line 5081 "sql.c" break; case 53: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ -#line 134 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5086 "sql.c" break; case 54: /* cmd ::= ALTER ALL DNODES NK_STRING */ -#line 135 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, NULL, &yymsp[0].minor.yy0, NULL); } -#line 5091 "sql.c" break; case 55: /* cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ -#line 136 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, NULL, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5096 "sql.c" break; case 56: /* cmd ::= RESTORE DNODE NK_INTEGER */ -#line 137 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_DNODE_STMT, &yymsp[0].minor.yy0); } -#line 5101 "sql.c" break; case 57: /* dnode_endpoint ::= NK_STRING */ case 58: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==58); @@ -5131,10 +4730,8 @@ static YYACTIONTYPE yy_reduce( case 459: /* star_func ::= FIRST */ yytestcase(yyruleno==459); case 460: /* star_func ::= LAST */ yytestcase(yyruleno==460); case 461: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==461); -#line 141 "sql.y" -{ yylhsminor.yy129 = yymsp[0].minor.yy0; } -#line 5136 "sql.c" - yymsp[0].minor.yy129 = yylhsminor.yy129; +{ yylhsminor.yy169 = yymsp[0].minor.yy0; } + yymsp[0].minor.yy169 = yylhsminor.yy169; break; case 60: /* force_opt ::= */ case 84: /* not_exists_opt ::= */ yytestcase(yyruleno==84); @@ -5143,432 +4740,286 @@ static YYACTIONTYPE yy_reduce( case 329: /* agg_func_opt ::= */ yytestcase(yyruleno==329); case 335: /* or_replace_opt ::= */ yytestcase(yyruleno==335); case 357: /* ignore_opt ::= */ yytestcase(yyruleno==357); - case 522: /* tag_mode_opt ::= */ yytestcase(yyruleno==522); - case 524: /* set_quantifier_opt ::= */ yytestcase(yyruleno==524); -#line 147 "sql.y" -{ yymsp[1].minor.yy313 = false; } -#line 5150 "sql.c" + case 524: /* tag_mode_opt ::= */ yytestcase(yyruleno==524); + case 526: /* set_quantifier_opt ::= */ yytestcase(yyruleno==526); +{ yymsp[1].minor.yy957 = false; } break; case 61: /* force_opt ::= FORCE */ case 62: /* unsafe_opt ::= UNSAFE */ yytestcase(yyruleno==62); case 323: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==323); case 330: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==330); - case 523: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==523); - case 525: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==525); -#line 148 "sql.y" -{ yymsp[0].minor.yy313 = true; } -#line 5160 "sql.c" + case 525: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==525); + case 527: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==527); +{ yymsp[0].minor.yy957 = true; } break; case 63: /* cmd ::= ALTER LOCAL NK_STRING */ -#line 155 "sql.y" { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 5165 "sql.c" break; case 64: /* cmd ::= ALTER LOCAL NK_STRING NK_STRING */ -#line 156 "sql.y" { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5170 "sql.c" break; case 65: /* cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ -#line 159 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_QNODE_STMT, &yymsp[0].minor.yy0); } -#line 5175 "sql.c" break; case 66: /* cmd ::= DROP QNODE ON DNODE NK_INTEGER */ -#line 160 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_QNODE_STMT, &yymsp[0].minor.yy0); } -#line 5180 "sql.c" break; case 67: /* cmd ::= RESTORE QNODE ON DNODE NK_INTEGER */ -#line 161 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_QNODE_STMT, &yymsp[0].minor.yy0); } -#line 5185 "sql.c" break; case 68: /* cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ -#line 164 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_BNODE_STMT, &yymsp[0].minor.yy0); } -#line 5190 "sql.c" break; case 69: /* cmd ::= DROP BNODE ON DNODE NK_INTEGER */ -#line 165 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_BNODE_STMT, &yymsp[0].minor.yy0); } -#line 5195 "sql.c" break; case 70: /* cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ -#line 168 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_SNODE_STMT, &yymsp[0].minor.yy0); } -#line 5200 "sql.c" break; case 71: /* cmd ::= DROP SNODE ON DNODE NK_INTEGER */ -#line 169 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_SNODE_STMT, &yymsp[0].minor.yy0); } -#line 5205 "sql.c" break; case 72: /* cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ -#line 172 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_MNODE_STMT, &yymsp[0].minor.yy0); } -#line 5210 "sql.c" break; case 73: /* cmd ::= DROP MNODE ON DNODE NK_INTEGER */ -#line 173 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); } -#line 5215 "sql.c" break; case 74: /* cmd ::= RESTORE MNODE ON DNODE NK_INTEGER */ -#line 174 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_MNODE_STMT, &yymsp[0].minor.yy0); } -#line 5220 "sql.c" break; case 75: /* cmd ::= RESTORE VNODE ON DNODE NK_INTEGER */ -#line 177 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_VNODE_STMT, &yymsp[0].minor.yy0); } -#line 5225 "sql.c" break; case 76: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ -#line 180 "sql.y" -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy313, &yymsp[-1].minor.yy129, yymsp[0].minor.yy840); } -#line 5230 "sql.c" +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy957, &yymsp[-1].minor.yy169, yymsp[0].minor.yy952); } break; case 77: /* cmd ::= DROP DATABASE exists_opt db_name */ -#line 181 "sql.y" -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); } -#line 5235 "sql.c" +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy169); } break; case 78: /* cmd ::= USE db_name */ -#line 182 "sql.y" -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy129); } -#line 5240 "sql.c" +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy169); } break; case 79: /* cmd ::= ALTER DATABASE db_name alter_db_options */ -#line 183 "sql.y" -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy840); } -#line 5245 "sql.c" +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy169, yymsp[0].minor.yy952); } break; case 80: /* cmd ::= FLUSH DATABASE db_name */ -#line 184 "sql.y" -{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy129); } -#line 5250 "sql.c" +{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy169); } break; case 81: /* cmd ::= TRIM DATABASE db_name speed_opt */ -#line 185 "sql.y" -{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy356); } -#line 5255 "sql.c" +{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy169, yymsp[0].minor.yy480); } break; case 82: /* cmd ::= COMPACT DATABASE db_name start_opt end_opt */ -#line 186 "sql.y" -{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy129, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 5260 "sql.c" +{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy169, yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; case 83: /* not_exists_opt ::= IF NOT EXISTS */ -#line 190 "sql.y" -{ yymsp[-2].minor.yy313 = true; } -#line 5265 "sql.c" +{ yymsp[-2].minor.yy957 = true; } break; case 85: /* exists_opt ::= IF EXISTS */ case 336: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==336); case 358: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==358); -#line 195 "sql.y" -{ yymsp[-1].minor.yy313 = true; } -#line 5272 "sql.c" +{ yymsp[-1].minor.yy957 = true; } break; case 87: /* db_options ::= */ -#line 198 "sql.y" -{ yymsp[1].minor.yy840 = createDefaultDatabaseOptions(pCxt); } -#line 5277 "sql.c" +{ yymsp[1].minor.yy952 = createDefaultDatabaseOptions(pCxt); } break; case 88: /* db_options ::= db_options BUFFER NK_INTEGER */ -#line 199 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } -#line 5282 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 89: /* db_options ::= db_options CACHEMODEL NK_STRING */ -#line 200 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } -#line 5288 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 90: /* db_options ::= db_options CACHESIZE NK_INTEGER */ -#line 201 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } -#line 5294 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 91: /* db_options ::= db_options COMP NK_INTEGER */ -#line 202 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_COMP, &yymsp[0].minor.yy0); } -#line 5300 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_COMP, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 92: /* db_options ::= db_options DURATION NK_INTEGER */ case 93: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==93); -#line 203 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } -#line 5307 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 94: /* db_options ::= db_options MAXROWS NK_INTEGER */ -#line 205 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } -#line 5313 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 95: /* db_options ::= db_options MINROWS NK_INTEGER */ -#line 206 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } -#line 5319 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 96: /* db_options ::= db_options KEEP integer_list */ case 97: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==97); -#line 207 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_KEEP, yymsp[0].minor.yy56); } -#line 5326 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_KEEP, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 98: /* db_options ::= db_options PAGES NK_INTEGER */ -#line 209 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } -#line 5332 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 99: /* db_options ::= db_options PAGESIZE NK_INTEGER */ -#line 210 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } -#line 5338 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 100: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ -#line 211 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } -#line 5344 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 101: /* db_options ::= db_options PRECISION NK_STRING */ -#line 212 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } -#line 5350 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 102: /* db_options ::= db_options REPLICA NK_INTEGER */ -#line 213 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } -#line 5356 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 103: /* db_options ::= db_options VGROUPS NK_INTEGER */ -#line 215 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } -#line 5362 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 104: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ -#line 216 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } -#line 5368 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 105: /* db_options ::= db_options RETENTIONS retention_list */ -#line 217 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_RETENTIONS, yymsp[0].minor.yy56); } -#line 5374 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_RETENTIONS, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 106: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ -#line 218 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } -#line 5380 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 107: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ -#line 219 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL, &yymsp[0].minor.yy0); } -#line 5386 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_WAL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 108: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ -#line 220 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } -#line 5392 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 109: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ -#line 221 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } -#line 5398 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 110: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ -#line 222 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-3].minor.yy840, DB_OPTION_WAL_RETENTION_PERIOD, &t); + yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-3].minor.yy952, DB_OPTION_WAL_RETENTION_PERIOD, &t); } -#line 5408 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 111: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ -#line 227 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } -#line 5414 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 112: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ -#line 228 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-3].minor.yy840, DB_OPTION_WAL_RETENTION_SIZE, &t); + yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-3].minor.yy952, DB_OPTION_WAL_RETENTION_SIZE, &t); } -#line 5424 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 113: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ -#line 233 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } -#line 5430 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 114: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ -#line 234 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } -#line 5436 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 115: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ -#line 235 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } -#line 5442 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 116: /* db_options ::= db_options TABLE_PREFIX signed */ -#line 236 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy840); } -#line 5448 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy952); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 117: /* db_options ::= db_options TABLE_SUFFIX signed */ -#line 237 "sql.y" -{ yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy840); } -#line 5454 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setDatabaseOption(pCxt, yymsp[-2].minor.yy952, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy952); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 118: /* alter_db_options ::= alter_db_option */ -#line 239 "sql.y" -{ yylhsminor.yy840 = createAlterDatabaseOptions(pCxt); yylhsminor.yy840 = setAlterDatabaseOption(pCxt, yylhsminor.yy840, &yymsp[0].minor.yy461); } -#line 5460 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterDatabaseOptions(pCxt); yylhsminor.yy952 = setAlterDatabaseOption(pCxt, yylhsminor.yy952, &yymsp[0].minor.yy25); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 119: /* alter_db_options ::= alter_db_options alter_db_option */ -#line 240 "sql.y" -{ yylhsminor.yy840 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy840, &yymsp[0].minor.yy461); } -#line 5466 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy952, &yymsp[0].minor.yy25); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 120: /* alter_db_option ::= BUFFER NK_INTEGER */ -#line 244 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5472 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 121: /* alter_db_option ::= CACHEMODEL NK_STRING */ -#line 245 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5477 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 122: /* alter_db_option ::= CACHESIZE NK_INTEGER */ -#line 246 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5482 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 123: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ -#line 247 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5487 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 124: /* alter_db_option ::= KEEP integer_list */ case 125: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==125); -#line 248 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_KEEP; yymsp[-1].minor.yy461.pList = yymsp[0].minor.yy56; } -#line 5493 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_KEEP; yymsp[-1].minor.yy25.pList = yymsp[0].minor.yy824; } break; case 126: /* alter_db_option ::= PAGES NK_INTEGER */ -#line 250 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_PAGES; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5498 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_PAGES; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 127: /* alter_db_option ::= REPLICA NK_INTEGER */ -#line 251 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5503 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 128: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ -#line 253 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_WAL; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5508 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_WAL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 129: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ -#line 254 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5513 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 130: /* alter_db_option ::= MINROWS NK_INTEGER */ -#line 255 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5518 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 131: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ -#line 256 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5523 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 132: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ -#line 257 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yymsp[-2].minor.yy461.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy461.val = t; + yymsp[-2].minor.yy25.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy25.val = t; } -#line 5532 "sql.c" break; case 133: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ -#line 262 "sql.y" -{ yymsp[-1].minor.yy461.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5537 "sql.c" +{ yymsp[-1].minor.yy25.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 134: /* alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ -#line 263 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yymsp[-2].minor.yy461.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy461.val = t; + yymsp[-2].minor.yy25.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy25.val = t; } -#line 5546 "sql.c" break; case 135: /* integer_list ::= NK_INTEGER */ -#line 271 "sql.y" -{ yylhsminor.yy56 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 5551 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; case 136: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ case 368: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==368); -#line 272 "sql.y" -{ yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 5558 "sql.c" - yymsp[-2].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; case 137: /* variable_list ::= NK_VARIABLE */ -#line 276 "sql.y" -{ yylhsminor.yy56 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 5564 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; case 138: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ -#line 277 "sql.y" -{ yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 5570 "sql.c" - yymsp[-2].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; case 139: /* retention_list ::= retention */ case 169: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==169); @@ -5581,13 +5032,11 @@ static YYACTIONTYPE yy_reduce( case 397: /* literal_list ::= signed_literal */ yytestcase(yyruleno==397); case 464: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==464); case 470: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==470); - case 527: /* select_list ::= select_item */ yytestcase(yyruleno==527); - case 538: /* partition_list ::= partition_item */ yytestcase(yyruleno==538); - case 594: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==594); -#line 281 "sql.y" -{ yylhsminor.yy56 = createNodeList(pCxt, yymsp[0].minor.yy840); } -#line 5589 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; + case 529: /* select_list ::= select_item */ yytestcase(yyruleno==529); + case 540: /* partition_list ::= partition_item */ yytestcase(yyruleno==540); + case 596: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==596); +{ yylhsminor.yy824 = createNodeList(pCxt, yymsp[0].minor.yy952); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; case 140: /* retention_list ::= retention_list NK_COMMA retention */ case 173: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==173); @@ -5598,1018 +5047,652 @@ static YYACTIONTYPE yy_reduce( case 298: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==298); case 398: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==398); case 465: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==465); - case 528: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==528); - case 539: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==539); - case 595: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==595); -#line 282 "sql.y" -{ yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, yymsp[0].minor.yy840); } -#line 5606 "sql.c" - yymsp[-2].minor.yy56 = yylhsminor.yy56; + case 530: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==530); + case 541: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==541); + case 597: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==597); +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, yymsp[0].minor.yy952); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; case 141: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ -#line 284 "sql.y" -{ yylhsminor.yy840 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 5612 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 142: /* speed_opt ::= */ case 331: /* bufsize_opt ::= */ yytestcase(yyruleno==331); -#line 288 "sql.y" -{ yymsp[1].minor.yy356 = 0; } -#line 5619 "sql.c" +{ yymsp[1].minor.yy480 = 0; } break; case 143: /* speed_opt ::= MAX_SPEED NK_INTEGER */ case 332: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==332); -#line 289 "sql.y" -{ yymsp[-1].minor.yy356 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } -#line 5625 "sql.c" +{ yymsp[-1].minor.yy480 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; case 145: /* start_opt ::= START WITH NK_INTEGER */ case 149: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==149); -#line 292 "sql.y" -{ yymsp[-2].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } -#line 5631 "sql.c" +{ yymsp[-2].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; case 146: /* start_opt ::= START WITH NK_STRING */ case 150: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==150); -#line 293 "sql.y" -{ yymsp[-2].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } -#line 5637 "sql.c" +{ yymsp[-2].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 147: /* start_opt ::= START WITH TIMESTAMP NK_STRING */ case 151: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==151); -#line 294 "sql.y" -{ yymsp[-3].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } -#line 5643 "sql.c" +{ yymsp[-3].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 152: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ case 154: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==154); -#line 303 "sql.y" -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy313, yymsp[-5].minor.yy840, yymsp[-3].minor.yy56, yymsp[-1].minor.yy56, yymsp[0].minor.yy840); } -#line 5649 "sql.c" +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy957, yymsp[-5].minor.yy952, yymsp[-3].minor.yy824, yymsp[-1].minor.yy824, yymsp[0].minor.yy952); } break; case 153: /* cmd ::= CREATE TABLE multi_create_clause */ -#line 304 "sql.y" -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy56); } -#line 5654 "sql.c" +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy824); } break; case 155: /* cmd ::= DROP TABLE multi_drop_clause */ -#line 307 "sql.y" -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy56); } -#line 5659 "sql.c" +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy824); } break; case 156: /* cmd ::= DROP STABLE exists_opt full_table_name */ -#line 308 "sql.y" -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); } -#line 5664 "sql.c" +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy952); } break; case 157: /* cmd ::= ALTER TABLE alter_table_clause */ case 370: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==370); case 371: /* cmd ::= insert_query */ yytestcase(yyruleno==371); -#line 310 "sql.y" -{ pCxt->pRootNode = yymsp[0].minor.yy840; } -#line 5671 "sql.c" +{ pCxt->pRootNode = yymsp[0].minor.yy952; } break; case 158: /* cmd ::= ALTER STABLE alter_table_clause */ -#line 311 "sql.y" -{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy840); } -#line 5676 "sql.c" +{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy952); } break; case 159: /* alter_table_clause ::= full_table_name alter_table_options */ -#line 313 "sql.y" -{ yylhsminor.yy840 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 5681 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 160: /* alter_table_clause ::= full_table_name ADD COLUMN column_def */ -#line 315 "sql.y" -{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_ADD_COLUMN, yymsp[0].minor.yy840); } -#line 5687 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy952, TSDB_ALTER_TABLE_ADD_COLUMN, yymsp[0].minor.yy952); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 161: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ -#line 316 "sql.y" -{ yylhsminor.yy840 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy129); } -#line 5693 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy952, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy169); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 162: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_def */ -#line 318 "sql.y" -{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, yymsp[0].minor.yy840); } -#line 5699 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy952, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, yymsp[0].minor.yy952); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 163: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ -#line 320 "sql.y" -{ yylhsminor.yy840 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); } -#line 5705 "sql.c" - yymsp[-4].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy952, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy169, &yymsp[0].minor.yy169); } + yymsp[-4].minor.yy952 = yylhsminor.yy952; break; case 164: /* alter_table_clause ::= full_table_name ADD TAG column_def */ -#line 322 "sql.y" -{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_ADD_TAG, yymsp[0].minor.yy840); } -#line 5711 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy952, TSDB_ALTER_TABLE_ADD_TAG, yymsp[0].minor.yy952); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 165: /* alter_table_clause ::= full_table_name DROP TAG column_name */ -#line 323 "sql.y" -{ yylhsminor.yy840 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy129); } -#line 5717 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy952, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy169); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 166: /* alter_table_clause ::= full_table_name MODIFY TAG column_def */ -#line 325 "sql.y" -{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, yymsp[0].minor.yy840); } -#line 5723 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy952, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, yymsp[0].minor.yy952); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 167: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ -#line 327 "sql.y" -{ yylhsminor.yy840 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); } -#line 5729 "sql.c" - yymsp[-4].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy952, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy169, &yymsp[0].minor.yy169); } + yymsp[-4].minor.yy952 = yylhsminor.yy952; break; case 168: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ -#line 329 "sql.y" -{ yylhsminor.yy840 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy840, &yymsp[-2].minor.yy129, yymsp[0].minor.yy840); } -#line 5735 "sql.c" - yymsp[-5].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy952, &yymsp[-2].minor.yy169, yymsp[0].minor.yy952); } + yymsp[-5].minor.yy952 = yylhsminor.yy952; break; case 170: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ case 471: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==471); -#line 334 "sql.y" -{ yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-1].minor.yy56, yymsp[0].minor.yy840); } -#line 5742 "sql.c" - yymsp[-1].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-1].minor.yy824, yymsp[0].minor.yy952); } + yymsp[-1].minor.yy824 = yylhsminor.yy824; break; case 171: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ -#line 338 "sql.y" -{ yylhsminor.yy840 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy313, yymsp[-8].minor.yy840, yymsp[-6].minor.yy840, yymsp[-5].minor.yy56, yymsp[-2].minor.yy56, yymsp[0].minor.yy840); } -#line 5748 "sql.c" - yymsp[-9].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy957, yymsp[-8].minor.yy952, yymsp[-6].minor.yy952, yymsp[-5].minor.yy824, yymsp[-2].minor.yy824, yymsp[0].minor.yy952); } + yymsp[-9].minor.yy952 = yylhsminor.yy952; break; case 174: /* drop_table_clause ::= exists_opt full_table_name */ -#line 345 "sql.y" -{ yylhsminor.yy840 = createDropTableClause(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); } -#line 5754 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createDropTableClause(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy952); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 175: /* specific_cols_opt ::= */ case 207: /* tags_def_opt ::= */ yytestcase(yyruleno==207); case 282: /* tag_list_opt ::= */ yytestcase(yyruleno==282); case 341: /* col_list_opt ::= */ yytestcase(yyruleno==341); case 343: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==343); - case 536: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==536); - case 561: /* group_by_clause_opt ::= */ yytestcase(yyruleno==561); - case 581: /* order_by_clause_opt ::= */ yytestcase(yyruleno==581); -#line 349 "sql.y" -{ yymsp[1].minor.yy56 = NULL; } -#line 5767 "sql.c" + case 538: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==538); + case 563: /* group_by_clause_opt ::= */ yytestcase(yyruleno==563); + case 583: /* order_by_clause_opt ::= */ yytestcase(yyruleno==583); +{ yymsp[1].minor.yy824 = NULL; } break; case 176: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ case 342: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==342); -#line 350 "sql.y" -{ yymsp[-2].minor.yy56 = yymsp[-1].minor.yy56; } -#line 5773 "sql.c" +{ yymsp[-2].minor.yy824 = yymsp[-1].minor.yy824; } break; case 177: /* full_table_name ::= table_name */ -#line 352 "sql.y" -{ yylhsminor.yy840 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy129, NULL); } -#line 5778 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy169, NULL); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 178: /* full_table_name ::= db_name NK_DOT table_name */ -#line 353 "sql.y" -{ yylhsminor.yy840 = createRealTableNode(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129, NULL); } -#line 5784 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRealTableNode(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy169, NULL); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 181: /* column_def ::= column_name type_name */ -#line 360 "sql.y" -{ yylhsminor.yy840 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy784, NULL); } -#line 5790 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy169, yymsp[0].minor.yy84, NULL); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 182: /* column_def ::= column_name type_name COMMENT NK_STRING */ -#line 361 "sql.y" -{ yylhsminor.yy840 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy129, yymsp[-2].minor.yy784, &yymsp[0].minor.yy0); } -#line 5796 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy169, yymsp[-2].minor.yy84, &yymsp[0].minor.yy0); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 183: /* type_name ::= BOOL */ -#line 365 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BOOL); } -#line 5802 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_BOOL); } break; case 184: /* type_name ::= TINYINT */ -#line 366 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TINYINT); } -#line 5807 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; case 185: /* type_name ::= SMALLINT */ -#line 367 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_SMALLINT); } -#line 5812 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; case 186: /* type_name ::= INT */ case 187: /* type_name ::= INTEGER */ yytestcase(yyruleno==187); -#line 368 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_INT); } -#line 5818 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_INT); } break; case 188: /* type_name ::= BIGINT */ -#line 370 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BIGINT); } -#line 5823 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; case 189: /* type_name ::= FLOAT */ -#line 371 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_FLOAT); } -#line 5828 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; case 190: /* type_name ::= DOUBLE */ -#line 372 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DOUBLE); } -#line 5833 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; case 191: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ -#line 373 "sql.y" -{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } -#line 5838 "sql.c" +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; case 192: /* type_name ::= TIMESTAMP */ -#line 374 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } -#line 5843 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; case 193: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ -#line 375 "sql.y" -{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } -#line 5848 "sql.c" +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; case 194: /* type_name ::= TINYINT UNSIGNED */ -#line 376 "sql.y" -{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UTINYINT); } -#line 5853 "sql.c" +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; case 195: /* type_name ::= SMALLINT UNSIGNED */ -#line 377 "sql.y" -{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_USMALLINT); } -#line 5858 "sql.c" +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; case 196: /* type_name ::= INT UNSIGNED */ -#line 378 "sql.y" -{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UINT); } -#line 5863 "sql.c" +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_UINT); } break; case 197: /* type_name ::= BIGINT UNSIGNED */ -#line 379 "sql.y" -{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UBIGINT); } -#line 5868 "sql.c" +{ yymsp[-1].minor.yy84 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; case 198: /* type_name ::= JSON */ -#line 380 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_JSON); } -#line 5873 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_JSON); } break; case 199: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ -#line 381 "sql.y" -{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } -#line 5878 "sql.c" +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; case 200: /* type_name ::= MEDIUMBLOB */ -#line 382 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } -#line 5883 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; case 201: /* type_name ::= BLOB */ -#line 383 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BLOB); } -#line 5888 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_BLOB); } break; case 202: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ -#line 384 "sql.y" -{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } -#line 5893 "sql.c" +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; case 203: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ -#line 385 "sql.y" -{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } -#line 5898 "sql.c" +{ yymsp[-3].minor.yy84 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } break; case 204: /* type_name ::= DECIMAL */ -#line 386 "sql.y" -{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); } -#line 5903 "sql.c" +{ yymsp[0].minor.yy84 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 205: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -#line 387 "sql.y" -{ yymsp[-3].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); } -#line 5908 "sql.c" +{ yymsp[-3].minor.yy84 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 206: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -#line 388 "sql.y" -{ yymsp[-5].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); } -#line 5913 "sql.c" +{ yymsp[-5].minor.yy84 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 208: /* tags_def_opt ::= tags_def */ case 344: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==344); case 463: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==463); -#line 393 "sql.y" -{ yylhsminor.yy56 = yymsp[0].minor.yy56; } -#line 5920 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = yymsp[0].minor.yy824; } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; case 209: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ case 345: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==345); -#line 397 "sql.y" -{ yymsp[-3].minor.yy56 = yymsp[-1].minor.yy56; } -#line 5927 "sql.c" +{ yymsp[-3].minor.yy824 = yymsp[-1].minor.yy824; } break; case 210: /* table_options ::= */ -#line 399 "sql.y" -{ yymsp[1].minor.yy840 = createDefaultTableOptions(pCxt); } -#line 5932 "sql.c" +{ yymsp[1].minor.yy952 = createDefaultTableOptions(pCxt); } break; case 211: /* table_options ::= table_options COMMENT NK_STRING */ -#line 400 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } -#line 5937 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-2].minor.yy952, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 212: /* table_options ::= table_options MAX_DELAY duration_list */ -#line 401 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy56); } -#line 5943 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-2].minor.yy952, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 213: /* table_options ::= table_options WATERMARK duration_list */ -#line 402 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy56); } -#line 5949 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-2].minor.yy952, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 214: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ -#line 403 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy56); } -#line 5955 "sql.c" - yymsp[-4].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-4].minor.yy952, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy824); } + yymsp[-4].minor.yy952 = yylhsminor.yy952; break; case 215: /* table_options ::= table_options TTL NK_INTEGER */ -#line 404 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } -#line 5961 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-2].minor.yy952, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 216: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -#line 405 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_SMA, yymsp[-1].minor.yy56); } -#line 5967 "sql.c" - yymsp[-4].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-4].minor.yy952, TABLE_OPTION_SMA, yymsp[-1].minor.yy824); } + yymsp[-4].minor.yy952 = yylhsminor.yy952; break; case 217: /* table_options ::= table_options DELETE_MARK duration_list */ -#line 406 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy56); } -#line 5973 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-2].minor.yy952, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy824); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 218: /* alter_table_options ::= alter_table_option */ -#line 408 "sql.y" -{ yylhsminor.yy840 = createAlterTableOptions(pCxt); yylhsminor.yy840 = setTableOption(pCxt, yylhsminor.yy840, yymsp[0].minor.yy461.type, &yymsp[0].minor.yy461.val); } -#line 5979 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createAlterTableOptions(pCxt); yylhsminor.yy952 = setTableOption(pCxt, yylhsminor.yy952, yymsp[0].minor.yy25.type, &yymsp[0].minor.yy25.val); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 219: /* alter_table_options ::= alter_table_options alter_table_option */ -#line 409 "sql.y" -{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy461.type, &yymsp[0].minor.yy461.val); } -#line 5985 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setTableOption(pCxt, yymsp[-1].minor.yy952, yymsp[0].minor.yy25.type, &yymsp[0].minor.yy25.val); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 220: /* alter_table_option ::= COMMENT NK_STRING */ -#line 413 "sql.y" -{ yymsp[-1].minor.yy461.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5991 "sql.c" +{ yymsp[-1].minor.yy25.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 221: /* alter_table_option ::= TTL NK_INTEGER */ -#line 414 "sql.y" -{ yymsp[-1].minor.yy461.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; } -#line 5996 "sql.c" +{ yymsp[-1].minor.yy25.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy25.val = yymsp[0].minor.yy0; } break; case 222: /* duration_list ::= duration_literal */ case 427: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==427); -#line 418 "sql.y" -{ yylhsminor.yy56 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); } -#line 6002 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; case 223: /* duration_list ::= duration_list NK_COMMA duration_literal */ case 428: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==428); -#line 419 "sql.y" -{ yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); } -#line 6009 "sql.c" - yymsp[-2].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; case 226: /* rollup_func_name ::= function_name */ -#line 426 "sql.y" -{ yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[0].minor.yy129, NULL); } -#line 6015 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createFunctionNode(pCxt, &yymsp[0].minor.yy169, NULL); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 227: /* rollup_func_name ::= FIRST */ case 228: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==228); case 286: /* tag_item ::= QTAGS */ yytestcase(yyruleno==286); -#line 427 "sql.y" -{ yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 6023 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 231: /* col_name ::= column_name */ case 287: /* tag_item ::= column_name */ yytestcase(yyruleno==287); -#line 435 "sql.y" -{ yylhsminor.yy840 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy129); } -#line 6030 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy169); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 232: /* cmd ::= SHOW DNODES */ -#line 438 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } -#line 6036 "sql.c" break; case 233: /* cmd ::= SHOW USERS */ -#line 439 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT); } -#line 6041 "sql.c" break; case 234: /* cmd ::= SHOW USER PRIVILEGES */ -#line 440 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USER_PRIVILEGES_STMT); } -#line 6046 "sql.c" break; case 235: /* cmd ::= SHOW DATABASES */ -#line 441 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); } -#line 6051 "sql.c" break; case 236: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ -#line 442 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, OP_TYPE_LIKE); } -#line 6056 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy952, yymsp[0].minor.yy952, OP_TYPE_LIKE); } break; case 237: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -#line 443 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, OP_TYPE_LIKE); } -#line 6061 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy952, yymsp[0].minor.yy952, OP_TYPE_LIKE); } break; case 238: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -#line 444 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy840, NULL, OP_TYPE_LIKE); } -#line 6066 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy952, NULL, OP_TYPE_LIKE); } break; case 239: /* cmd ::= SHOW MNODES */ -#line 445 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } -#line 6071 "sql.c" break; case 240: /* cmd ::= SHOW QNODES */ -#line 447 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); } -#line 6076 "sql.c" break; case 241: /* cmd ::= SHOW FUNCTIONS */ -#line 448 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } -#line 6081 "sql.c" break; case 242: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -#line 449 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy840, yymsp[-1].minor.yy840, OP_TYPE_EQUAL); } -#line 6086 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy952, yymsp[-1].minor.yy952, OP_TYPE_EQUAL); } break; case 243: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ -#line 450 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy129), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129), OP_TYPE_EQUAL); } -#line 6091 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy169), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy169), OP_TYPE_EQUAL); } break; case 244: /* cmd ::= SHOW STREAMS */ -#line 451 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } -#line 6096 "sql.c" break; case 245: /* cmd ::= SHOW ACCOUNTS */ -#line 452 "sql.y" { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } -#line 6101 "sql.c" break; case 246: /* cmd ::= SHOW APPS */ -#line 453 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); } -#line 6106 "sql.c" break; case 247: /* cmd ::= SHOW CONNECTIONS */ -#line 454 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); } -#line 6111 "sql.c" break; case 248: /* cmd ::= SHOW LICENCES */ case 249: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==249); -#line 455 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } -#line 6117 "sql.c" break; case 250: /* cmd ::= SHOW CREATE DATABASE db_name */ -#line 457 "sql.y" -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy129); } -#line 6122 "sql.c" +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy169); } break; case 251: /* cmd ::= SHOW CREATE TABLE full_table_name */ -#line 458 "sql.y" -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy840); } -#line 6127 "sql.c" +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy952); } break; case 252: /* cmd ::= SHOW CREATE STABLE full_table_name */ -#line 459 "sql.y" -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy840); } -#line 6132 "sql.c" +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy952); } break; case 253: /* cmd ::= SHOW QUERIES */ -#line 460 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } -#line 6137 "sql.c" break; case 254: /* cmd ::= SHOW SCORES */ -#line 461 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); } -#line 6142 "sql.c" break; case 255: /* cmd ::= SHOW TOPICS */ -#line 462 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); } -#line 6147 "sql.c" break; case 256: /* cmd ::= SHOW VARIABLES */ case 257: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==257); -#line 463 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); } -#line 6153 "sql.c" break; case 258: /* cmd ::= SHOW LOCAL VARIABLES */ -#line 465 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } -#line 6158 "sql.c" break; case 259: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ -#line 466 "sql.y" -{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy840); } -#line 6163 "sql.c" +{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy952); } break; case 260: /* cmd ::= SHOW BNODES */ -#line 467 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } -#line 6168 "sql.c" break; case 261: /* cmd ::= SHOW SNODES */ -#line 468 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); } -#line 6173 "sql.c" break; case 262: /* cmd ::= SHOW CLUSTER */ -#line 469 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); } -#line 6178 "sql.c" break; case 263: /* cmd ::= SHOW TRANSACTIONS */ -#line 470 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } -#line 6183 "sql.c" break; case 264: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ -#line 471 "sql.y" -{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy840); } -#line 6188 "sql.c" +{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy952); } break; case 265: /* cmd ::= SHOW CONSUMERS */ -#line 472 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } -#line 6193 "sql.c" break; case 266: /* cmd ::= SHOW SUBSCRIPTIONS */ -#line 473 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } -#line 6198 "sql.c" break; case 267: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ -#line 474 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy840, yymsp[-1].minor.yy840, OP_TYPE_EQUAL); } -#line 6203 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy952, yymsp[-1].minor.yy952, OP_TYPE_EQUAL); } break; case 268: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ -#line 475 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy129), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129), OP_TYPE_EQUAL); } -#line 6208 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy169), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy169), OP_TYPE_EQUAL); } break; case 269: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ -#line 476 "sql.y" -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840, yymsp[-3].minor.yy56); } -#line 6213 "sql.c" +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy952, yymsp[0].minor.yy952, yymsp[-3].minor.yy824); } break; case 270: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ -#line 477 "sql.y" -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy129), yymsp[-4].minor.yy56); } -#line 6218 "sql.c" +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy169), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy169), yymsp[-4].minor.yy824); } break; case 271: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ -#line 478 "sql.y" { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } -#line 6223 "sql.c" break; case 272: /* cmd ::= SHOW VNODES */ -#line 479 "sql.y" { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, NULL); } -#line 6228 "sql.c" break; case 273: /* cmd ::= SHOW db_name_cond_opt ALIVE */ -#line 481 "sql.y" -{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy840, QUERY_NODE_SHOW_DB_ALIVE_STMT); } -#line 6233 "sql.c" +{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy952, QUERY_NODE_SHOW_DB_ALIVE_STMT); } break; case 274: /* cmd ::= SHOW CLUSTER ALIVE */ -#line 482 "sql.y" { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } -#line 6238 "sql.c" break; case 275: /* db_name_cond_opt ::= */ case 280: /* from_db_opt ::= */ yytestcase(yyruleno==280); -#line 484 "sql.y" -{ yymsp[1].minor.yy840 = createDefaultDatabaseCondValue(pCxt); } -#line 6244 "sql.c" +{ yymsp[1].minor.yy952 = createDefaultDatabaseCondValue(pCxt); } break; case 276: /* db_name_cond_opt ::= db_name NK_DOT */ -#line 485 "sql.y" -{ yylhsminor.yy840 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy129); } -#line 6249 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy169); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 278: /* like_pattern_opt ::= LIKE NK_STRING */ -#line 488 "sql.y" -{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } -#line 6255 "sql.c" +{ yymsp[-1].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; case 279: /* table_name_cond ::= table_name */ -#line 490 "sql.y" -{ yylhsminor.yy840 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129); } -#line 6260 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy169); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 281: /* from_db_opt ::= FROM db_name */ -#line 493 "sql.y" -{ yymsp[-1].minor.yy840 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129); } -#line 6266 "sql.c" +{ yymsp[-1].minor.yy952 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy169); } break; case 285: /* tag_item ::= TBNAME */ -#line 501 "sql.y" -{ yylhsminor.yy840 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } -#line 6271 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 288: /* tag_item ::= column_name column_alias */ -#line 504 "sql.y" -{ yylhsminor.yy840 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy129), &yymsp[0].minor.yy129); } -#line 6277 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy169), &yymsp[0].minor.yy169); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 289: /* tag_item ::= column_name AS column_alias */ -#line 505 "sql.y" -{ yylhsminor.yy840 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy129), &yymsp[0].minor.yy129); } -#line 6283 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy169), &yymsp[0].minor.yy169); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 290: /* cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */ -#line 509 "sql.y" -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy313, yymsp[-3].minor.yy840, yymsp[-1].minor.yy840, NULL, yymsp[0].minor.yy840); } -#line 6289 "sql.c" +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy957, yymsp[-3].minor.yy952, yymsp[-1].minor.yy952, NULL, yymsp[0].minor.yy952); } break; case 291: /* cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */ -#line 511 "sql.y" -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy313, yymsp[-5].minor.yy840, yymsp[-3].minor.yy840, yymsp[-1].minor.yy56, NULL); } -#line 6294 "sql.c" +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy957, yymsp[-5].minor.yy952, yymsp[-3].minor.yy952, yymsp[-1].minor.yy824, NULL); } break; case 292: /* cmd ::= DROP INDEX exists_opt full_index_name */ -#line 512 "sql.y" -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); } -#line 6299 "sql.c" +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy957, yymsp[0].minor.yy952); } break; case 293: /* full_index_name ::= index_name */ -#line 514 "sql.y" -{ yylhsminor.yy840 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy129); } -#line 6304 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy169); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 294: /* full_index_name ::= db_name NK_DOT index_name */ -#line 515 "sql.y" -{ yylhsminor.yy840 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129); } -#line 6310 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy169); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 295: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ -#line 518 "sql.y" -{ yymsp[-9].minor.yy840 = createIndexOption(pCxt, yymsp[-7].minor.yy56, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 6316 "sql.c" +{ yymsp[-9].minor.yy952 = createIndexOption(pCxt, yymsp[-7].minor.yy824, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), NULL, yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; case 296: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ -#line 521 "sql.y" -{ yymsp[-11].minor.yy840 = createIndexOption(pCxt, yymsp[-9].minor.yy56, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 6321 "sql.c" +{ yymsp[-11].minor.yy952 = createIndexOption(pCxt, yymsp[-9].minor.yy824, releaseRawExprNode(pCxt, yymsp[-5].minor.yy952), releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; case 299: /* func ::= sma_func_name NK_LP expression_list NK_RP */ -#line 528 "sql.y" -{ yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[-3].minor.yy129, yymsp[-1].minor.yy56); } -#line 6326 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createFunctionNode(pCxt, &yymsp[-3].minor.yy169, yymsp[-1].minor.yy824); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 300: /* sma_func_name ::= function_name */ case 514: /* alias_opt ::= table_alias */ yytestcase(yyruleno==514); -#line 532 "sql.y" -{ yylhsminor.yy129 = yymsp[0].minor.yy129; } -#line 6333 "sql.c" - yymsp[0].minor.yy129 = yylhsminor.yy129; +{ yylhsminor.yy169 = yymsp[0].minor.yy169; } + yymsp[0].minor.yy169 = yylhsminor.yy169; break; case 305: /* sma_stream_opt ::= */ case 346: /* stream_options ::= */ yytestcase(yyruleno==346); -#line 538 "sql.y" -{ yymsp[1].minor.yy840 = createStreamOptions(pCxt); } -#line 6340 "sql.c" +{ yymsp[1].minor.yy952 = createStreamOptions(pCxt); } break; case 306: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ -#line 539 "sql.y" -{ ((SStreamOptions*)yymsp[-2].minor.yy840)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; } -#line 6345 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ ((SStreamOptions*)yymsp[-2].minor.yy952)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy952); yylhsminor.yy952 = yymsp[-2].minor.yy952; } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 307: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ -#line 540 "sql.y" -{ ((SStreamOptions*)yymsp[-2].minor.yy840)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; } -#line 6351 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ ((SStreamOptions*)yymsp[-2].minor.yy952)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy952); yylhsminor.yy952 = yymsp[-2].minor.yy952; } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 308: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ -#line 541 "sql.y" -{ ((SStreamOptions*)yymsp[-2].minor.yy840)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; } -#line 6357 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ ((SStreamOptions*)yymsp[-2].minor.yy952)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy952); yylhsminor.yy952 = yymsp[-2].minor.yy952; } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 309: /* with_meta ::= AS */ -#line 546 "sql.y" -{ yymsp[0].minor.yy356 = 0; } -#line 6363 "sql.c" +{ yymsp[0].minor.yy480 = 0; } break; case 310: /* with_meta ::= WITH META AS */ -#line 547 "sql.y" -{ yymsp[-2].minor.yy356 = 1; } -#line 6368 "sql.c" +{ yymsp[-2].minor.yy480 = 1; } break; case 311: /* with_meta ::= ONLY META AS */ -#line 548 "sql.y" -{ yymsp[-2].minor.yy356 = 2; } -#line 6373 "sql.c" +{ yymsp[-2].minor.yy480 = 2; } break; case 312: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ -#line 550 "sql.y" -{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy313, &yymsp[-2].minor.yy129, yymsp[0].minor.yy840); } -#line 6378 "sql.c" +{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy957, &yymsp[-2].minor.yy169, yymsp[0].minor.yy952); } break; case 313: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ -#line 552 "sql.y" -{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy313, &yymsp[-3].minor.yy129, &yymsp[0].minor.yy129, yymsp[-2].minor.yy356); } -#line 6383 "sql.c" +{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy957, &yymsp[-3].minor.yy169, &yymsp[0].minor.yy169, yymsp[-2].minor.yy480); } break; case 314: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ -#line 554 "sql.y" -{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy313, &yymsp[-4].minor.yy129, yymsp[-1].minor.yy840, yymsp[-3].minor.yy356, yymsp[0].minor.yy840); } -#line 6388 "sql.c" +{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy957, &yymsp[-4].minor.yy169, yymsp[-1].minor.yy952, yymsp[-3].minor.yy480, yymsp[0].minor.yy952); } break; case 315: /* cmd ::= DROP TOPIC exists_opt topic_name */ -#line 556 "sql.y" -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); } -#line 6393 "sql.c" +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy169); } break; case 316: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ -#line 557 "sql.y" -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy313, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129); } -#line 6398 "sql.c" +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy957, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy169); } break; case 317: /* cmd ::= DESC full_table_name */ case 318: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==318); -#line 560 "sql.y" -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy840); } -#line 6404 "sql.c" +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy952); } break; case 319: /* cmd ::= RESET QUERY CACHE */ -#line 564 "sql.y" { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } -#line 6409 "sql.c" break; case 320: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ case 321: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==321); -#line 567 "sql.y" -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy313, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 6415 "sql.c" +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy957, yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; case 324: /* explain_options ::= */ -#line 575 "sql.y" -{ yymsp[1].minor.yy840 = createDefaultExplainOptions(pCxt); } -#line 6420 "sql.c" +{ yymsp[1].minor.yy952 = createDefaultExplainOptions(pCxt); } break; case 325: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -#line 576 "sql.y" -{ yylhsminor.yy840 = setExplainVerbose(pCxt, yymsp[-2].minor.yy840, &yymsp[0].minor.yy0); } -#line 6425 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setExplainVerbose(pCxt, yymsp[-2].minor.yy952, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 326: /* explain_options ::= explain_options RATIO NK_FLOAT */ -#line 577 "sql.y" -{ yylhsminor.yy840 = setExplainRatio(pCxt, yymsp[-2].minor.yy840, &yymsp[0].minor.yy0); } -#line 6431 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setExplainRatio(pCxt, yymsp[-2].minor.yy952, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 327: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ -#line 582 "sql.y" -{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy313, yymsp[-9].minor.yy313, &yymsp[-6].minor.yy129, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy784, yymsp[-1].minor.yy356, &yymsp[0].minor.yy129, yymsp[-10].minor.yy313); } -#line 6437 "sql.c" +{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy957, yymsp[-9].minor.yy957, &yymsp[-6].minor.yy169, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy84, yymsp[-1].minor.yy480, &yymsp[0].minor.yy169, yymsp[-10].minor.yy957); } break; case 328: /* cmd ::= DROP FUNCTION exists_opt function_name */ -#line 583 "sql.y" -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); } -#line 6442 "sql.c" +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy169); } break; case 333: /* language_opt ::= */ -#line 597 "sql.y" -{ yymsp[1].minor.yy129 = nil_token; } -#line 6447 "sql.c" +{ yymsp[1].minor.yy169 = nil_token; } break; case 334: /* language_opt ::= LANGUAGE NK_STRING */ -#line 598 "sql.y" -{ yymsp[-1].minor.yy129 = yymsp[0].minor.yy0; } -#line 6452 "sql.c" +{ yymsp[-1].minor.yy169 = yymsp[0].minor.yy0; } break; case 337: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ -#line 608 "sql.y" -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy313, &yymsp[-8].minor.yy129, yymsp[-5].minor.yy840, yymsp[-7].minor.yy840, yymsp[-3].minor.yy56, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, yymsp[-4].minor.yy56); } -#line 6457 "sql.c" +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy957, &yymsp[-8].minor.yy169, yymsp[-5].minor.yy952, yymsp[-7].minor.yy952, yymsp[-3].minor.yy824, yymsp[-2].minor.yy952, yymsp[0].minor.yy952, yymsp[-4].minor.yy824); } break; case 338: /* cmd ::= DROP STREAM exists_opt stream_name */ -#line 609 "sql.y" -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); } -#line 6462 "sql.c" +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy169); } break; case 339: /* cmd ::= PAUSE STREAM exists_opt stream_name */ -#line 610 "sql.y" -{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); } -#line 6467 "sql.c" +{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy957, &yymsp[0].minor.yy169); } break; case 340: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ -#line 611 "sql.y" -{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy313, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); } -#line 6472 "sql.c" +{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy957, yymsp[-1].minor.yy957, &yymsp[0].minor.yy169); } break; case 347: /* stream_options ::= stream_options TRIGGER AT_ONCE */ case 348: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==348); -#line 625 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } -#line 6478 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-2].minor.yy952, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 349: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ -#line 627 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); } -#line 6484 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-3].minor.yy952, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 350: /* stream_options ::= stream_options WATERMARK duration_literal */ -#line 628 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); } -#line 6490 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-2].minor.yy952, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 351: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ -#line 629 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } -#line 6496 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-3].minor.yy952, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 352: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ -#line 630 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } -#line 6502 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-2].minor.yy952, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 353: /* stream_options ::= stream_options DELETE_MARK duration_literal */ -#line 631 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); } -#line 6508 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-2].minor.yy952, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 354: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ -#line 632 "sql.y" -{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } -#line 6514 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = setStreamOptions(pCxt, yymsp[-3].minor.yy952, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 356: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - case 550: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ yytestcase(yyruleno==550); - case 571: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==571); -#line 635 "sql.y" -{ yymsp[-3].minor.yy840 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy840); } -#line 6522 "sql.c" + case 552: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ yytestcase(yyruleno==552); + case 573: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==573); +{ yymsp[-3].minor.yy952 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy952); } break; case 359: /* cmd ::= KILL CONNECTION NK_INTEGER */ -#line 643 "sql.y" { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } -#line 6527 "sql.c" break; case 360: /* cmd ::= KILL QUERY NK_STRING */ -#line 644 "sql.y" { pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); } -#line 6532 "sql.c" break; case 361: /* cmd ::= KILL TRANSACTION NK_INTEGER */ -#line 645 "sql.y" { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } -#line 6537 "sql.c" break; case 362: /* cmd ::= BALANCE VGROUP */ -#line 648 "sql.y" { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } -#line 6542 "sql.c" break; case 363: /* cmd ::= BALANCE VGROUP LEADER */ -#line 649 "sql.y" { pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt); } -#line 6547 "sql.c" break; case 364: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ -#line 650 "sql.y" { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 6552 "sql.c" break; case 365: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -#line 651 "sql.y" -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy56); } -#line 6557 "sql.c" +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy824); } break; case 366: /* cmd ::= SPLIT VGROUP NK_INTEGER */ -#line 652 "sql.y" { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } -#line 6562 "sql.c" break; case 367: /* dnode_list ::= DNODE NK_INTEGER */ -#line 656 "sql.y" -{ yymsp[-1].minor.yy56 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 6567 "sql.c" +{ yymsp[-1].minor.yy824 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; case 369: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ -#line 663 "sql.y" -{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 6572 "sql.c" +{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; case 372: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ -#line 672 "sql.y" -{ yymsp[-6].minor.yy840 = createInsertStmt(pCxt, yymsp[-4].minor.yy840, yymsp[-2].minor.yy56, yymsp[0].minor.yy840); } -#line 6577 "sql.c" +{ yymsp[-6].minor.yy952 = createInsertStmt(pCxt, yymsp[-4].minor.yy952, yymsp[-2].minor.yy824, yymsp[0].minor.yy952); } break; case 373: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ -#line 673 "sql.y" -{ yymsp[-3].minor.yy840 = createInsertStmt(pCxt, yymsp[-1].minor.yy840, NULL, yymsp[0].minor.yy840); } -#line 6582 "sql.c" +{ yymsp[-3].minor.yy952 = createInsertStmt(pCxt, yymsp[-1].minor.yy952, NULL, yymsp[0].minor.yy952); } break; case 374: /* literal ::= NK_INTEGER */ -#line 676 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } -#line 6587 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 375: /* literal ::= NK_FLOAT */ -#line 677 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } -#line 6593 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 376: /* literal ::= NK_STRING */ -#line 678 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } -#line 6599 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 377: /* literal ::= NK_BOOL */ -#line 679 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } -#line 6605 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 378: /* literal ::= TIMESTAMP NK_STRING */ -#line 680 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } -#line 6611 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 379: /* literal ::= duration_literal */ case 389: /* signed_literal ::= signed */ yytestcase(yyruleno==389); @@ -6628,233 +5711,175 @@ static YYACTIONTYPE yy_reduce( case 507: /* table_reference ::= table_primary */ yytestcase(yyruleno==507); case 508: /* table_reference ::= joined_table */ yytestcase(yyruleno==508); case 512: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==512); - case 573: /* query_simple ::= query_specification */ yytestcase(yyruleno==573); - case 574: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==574); - case 577: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==577); - case 579: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==579); -#line 681 "sql.y" -{ yylhsminor.yy840 = yymsp[0].minor.yy840; } -#line 6637 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; + case 575: /* query_simple ::= query_specification */ yytestcase(yyruleno==575); + case 576: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==576); + case 579: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==579); + case 581: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==581); +{ yylhsminor.yy952 = yymsp[0].minor.yy952; } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 380: /* literal ::= NULL */ -#line 682 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } -#line 6643 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 381: /* literal ::= NK_QUESTION */ -#line 683 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 6649 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 382: /* duration_literal ::= NK_VARIABLE */ -#line 685 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 6655 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 383: /* signed ::= NK_INTEGER */ -#line 687 "sql.y" -{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } -#line 6661 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 384: /* signed ::= NK_PLUS NK_INTEGER */ -#line 688 "sql.y" -{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } -#line 6667 "sql.c" +{ yymsp[-1].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } break; case 385: /* signed ::= NK_MINUS NK_INTEGER */ -#line 689 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } -#line 6676 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 386: /* signed ::= NK_FLOAT */ -#line 694 "sql.y" -{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } -#line 6682 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 387: /* signed ::= NK_PLUS NK_FLOAT */ -#line 695 "sql.y" -{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } -#line 6688 "sql.c" +{ yymsp[-1].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; case 388: /* signed ::= NK_MINUS NK_FLOAT */ -#line 696 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } -#line 6697 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 390: /* signed_literal ::= NK_STRING */ -#line 703 "sql.y" -{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } -#line 6703 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 391: /* signed_literal ::= NK_BOOL */ -#line 704 "sql.y" -{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } -#line 6709 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 392: /* signed_literal ::= TIMESTAMP NK_STRING */ -#line 705 "sql.y" -{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } -#line 6715 "sql.c" +{ yymsp[-1].minor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; case 393: /* signed_literal ::= duration_literal */ case 395: /* signed_literal ::= literal_func */ yytestcase(yyruleno==395); case 466: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==466); - case 530: /* select_item ::= common_expression */ yytestcase(yyruleno==530); - case 540: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==540); - case 578: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==578); - case 580: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==580); - case 593: /* search_condition ::= common_expression */ yytestcase(yyruleno==593); -#line 706 "sql.y" -{ yylhsminor.yy840 = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); } -#line 6727 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; + case 532: /* select_item ::= common_expression */ yytestcase(yyruleno==532); + case 542: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==542); + case 580: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==580); + case 582: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==582); + case 595: /* search_condition ::= common_expression */ yytestcase(yyruleno==595); +{ yylhsminor.yy952 = releaseRawExprNode(pCxt, yymsp[0].minor.yy952); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 394: /* signed_literal ::= NULL */ -#line 707 "sql.y" -{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } -#line 6733 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 396: /* signed_literal ::= NK_QUESTION */ -#line 709 "sql.y" -{ yylhsminor.yy840 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } -#line 6739 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 416: /* expression ::= NK_LP expression NK_RP */ case 500: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==500); - case 592: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==592); -#line 770 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); } -#line 6747 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + case 594: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==594); +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy952)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 417: /* expression ::= NK_PLUS expr_or_subquery */ -#line 771 "sql.y" { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } -#line 6756 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 418: /* expression ::= NK_MINUS expr_or_subquery */ -#line 775 "sql.y" { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy840), NULL)); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy952), NULL)); } -#line 6765 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 419: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ -#line 779 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6775 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 420: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ -#line 784 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6785 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 421: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ -#line 789 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6795 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 422: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ -#line 794 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6805 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 423: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ -#line 799 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6815 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 424: /* expression ::= column_reference NK_ARROW NK_STRING */ -#line 804 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } -#line 6824 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 425: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ -#line 808 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6834 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 426: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ -#line 813 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6844 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 429: /* column_reference ::= column_name */ -#line 824 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy129, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy129)); } -#line 6850 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy169, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy169)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 430: /* column_reference ::= table_name NK_DOT column_name */ -#line 825 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129, createColumnNode(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129)); } -#line 6856 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy169, createColumnNode(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy169)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 431: /* pseudo_column ::= ROWTS */ case 432: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==432); @@ -6868,497 +5893,342 @@ static YYACTIONTYPE yy_reduce( case 441: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==441); case 442: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==442); case 448: /* literal_func ::= NOW */ yytestcase(yyruleno==448); -#line 827 "sql.y" -{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } -#line 6873 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; case 433: /* pseudo_column ::= table_name NK_DOT TBNAME */ -#line 829 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy129)))); } -#line 6879 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy169)))); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 443: /* function_expression ::= function_name NK_LP expression_list NK_RP */ case 444: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==444); -#line 840 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy129, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy129, yymsp[-1].minor.yy56)); } -#line 6886 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy169, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy169, yymsp[-1].minor.yy824)); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 445: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ -#line 843 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy784)); } -#line 6892 "sql.c" - yymsp[-5].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), yymsp[-1].minor.yy84)); } + yymsp[-5].minor.yy952 = yylhsminor.yy952; break; case 447: /* literal_func ::= noarg_func NK_LP NK_RP */ -#line 846 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy129, NULL)); } -#line 6898 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy169, NULL)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 462: /* star_func_para_list ::= NK_STAR */ -#line 870 "sql.y" -{ yylhsminor.yy56 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } -#line 6904 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; +{ yylhsminor.yy824 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; case 467: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 533: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==533); -#line 879 "sql.y" -{ yylhsminor.yy840 = createColumnNode(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0); } -#line 6911 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + case 535: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==535); +{ yylhsminor.yy952 = createColumnNode(pCxt, &yymsp[-2].minor.yy169, &yymsp[0].minor.yy0); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 468: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ -#line 882 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy56, yymsp[-1].minor.yy840)); } -#line 6917 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy824, yymsp[-1].minor.yy952)); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 469: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ -#line 884 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-2].minor.yy56, yymsp[-1].minor.yy840)); } -#line 6923 "sql.c" - yymsp[-4].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), yymsp[-2].minor.yy824, yymsp[-1].minor.yy952)); } + yymsp[-4].minor.yy952 = yylhsminor.yy952; break; case 472: /* when_then_expr ::= WHEN common_expression THEN common_expression */ -#line 891 "sql.y" -{ yymsp[-3].minor.yy840 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); } -#line 6929 "sql.c" +{ yymsp[-3].minor.yy952 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952)); } break; case 474: /* case_when_else_opt ::= ELSE common_expression */ -#line 894 "sql.y" -{ yymsp[-1].minor.yy840 = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); } -#line 6934 "sql.c" +{ yymsp[-1].minor.yy952 = releaseRawExprNode(pCxt, yymsp[0].minor.yy952); } break; case 475: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ case 480: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==480); -#line 897 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy76, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy520, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6944 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 476: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ -#line 904 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy840), releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy952), releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6954 "sql.c" - yymsp[-4].minor.yy840 = yylhsminor.yy840; + yymsp[-4].minor.yy952 = yylhsminor.yy952; break; case 477: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ -#line 910 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy952), releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 6964 "sql.c" - yymsp[-5].minor.yy840 = yylhsminor.yy840; + yymsp[-5].minor.yy952 = yylhsminor.yy952; break; case 478: /* predicate ::= expr_or_subquery IS NULL */ -#line 915 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), NULL)); } -#line 6973 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 479: /* predicate ::= expr_or_subquery IS NOT NULL */ -#line 919 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), NULL)); } -#line 6982 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 481: /* compare_op ::= NK_LT */ -#line 931 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_LOWER_THAN; } -#line 6988 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_LOWER_THAN; } break; case 482: /* compare_op ::= NK_GT */ -#line 932 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_GREATER_THAN; } -#line 6993 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_GREATER_THAN; } break; case 483: /* compare_op ::= NK_LE */ -#line 933 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_LOWER_EQUAL; } -#line 6998 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_LOWER_EQUAL; } break; case 484: /* compare_op ::= NK_GE */ -#line 934 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_GREATER_EQUAL; } -#line 7003 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_GREATER_EQUAL; } break; case 485: /* compare_op ::= NK_NE */ -#line 935 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_NOT_EQUAL; } -#line 7008 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_NOT_EQUAL; } break; case 486: /* compare_op ::= NK_EQ */ -#line 936 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_EQUAL; } -#line 7013 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_EQUAL; } break; case 487: /* compare_op ::= LIKE */ -#line 937 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_LIKE; } -#line 7018 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_LIKE; } break; case 488: /* compare_op ::= NOT LIKE */ -#line 938 "sql.y" -{ yymsp[-1].minor.yy76 = OP_TYPE_NOT_LIKE; } -#line 7023 "sql.c" +{ yymsp[-1].minor.yy520 = OP_TYPE_NOT_LIKE; } break; case 489: /* compare_op ::= MATCH */ -#line 939 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_MATCH; } -#line 7028 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_MATCH; } break; case 490: /* compare_op ::= NMATCH */ -#line 940 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_NMATCH; } -#line 7033 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_NMATCH; } break; case 491: /* compare_op ::= CONTAINS */ -#line 941 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_JSON_CONTAINS; } -#line 7038 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_JSON_CONTAINS; } break; case 492: /* in_op ::= IN */ -#line 945 "sql.y" -{ yymsp[0].minor.yy76 = OP_TYPE_IN; } -#line 7043 "sql.c" +{ yymsp[0].minor.yy520 = OP_TYPE_IN; } break; case 493: /* in_op ::= NOT IN */ -#line 946 "sql.y" -{ yymsp[-1].minor.yy76 = OP_TYPE_NOT_IN; } -#line 7048 "sql.c" +{ yymsp[-1].minor.yy520 = OP_TYPE_NOT_IN; } break; case 494: /* in_predicate_value ::= NK_LP literal_list NK_RP */ -#line 948 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy56)); } -#line 7053 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy824)); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 496: /* boolean_value_expression ::= NOT boolean_primary */ -#line 952 "sql.y" { - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy840), NULL)); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy952), NULL)); } -#line 7062 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 497: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ -#line 957 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 7072 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 498: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ -#line 963 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840); - yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy952); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy952); + yylhsminor.yy952 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } -#line 7082 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 506: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -#line 981 "sql.y" -{ yylhsminor.yy840 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, NULL); } -#line 7088 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy952, yymsp[0].minor.yy952, NULL); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; case 509: /* table_primary ::= table_name alias_opt */ -#line 987 "sql.y" -{ yylhsminor.yy840 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); } -#line 7094 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy169, &yymsp[0].minor.yy169); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 510: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -#line 988 "sql.y" -{ yylhsminor.yy840 = createRealTableNode(pCxt, &yymsp[-3].minor.yy129, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); } -#line 7100 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createRealTableNode(pCxt, &yymsp[-3].minor.yy169, &yymsp[-1].minor.yy169, &yymsp[0].minor.yy169); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; case 511: /* table_primary ::= subquery alias_opt */ -#line 989 "sql.y" -{ yylhsminor.yy840 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840), &yymsp[0].minor.yy129); } -#line 7106 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy952), &yymsp[0].minor.yy169); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; case 513: /* alias_opt ::= */ -#line 994 "sql.y" -{ yymsp[1].minor.yy129 = nil_token; } -#line 7112 "sql.c" +{ yymsp[1].minor.yy169 = nil_token; } break; case 515: /* alias_opt ::= AS table_alias */ -#line 996 "sql.y" -{ yymsp[-1].minor.yy129 = yymsp[0].minor.yy129; } -#line 7117 "sql.c" +{ yymsp[-1].minor.yy169 = yymsp[0].minor.yy169; } break; case 516: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ case 517: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==517); -#line 998 "sql.y" -{ yymsp[-2].minor.yy840 = yymsp[-1].minor.yy840; } -#line 7123 "sql.c" +{ yymsp[-2].minor.yy952 = yymsp[-1].minor.yy952; } break; case 518: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ -#line 1003 "sql.y" -{ yylhsminor.yy840 = createJoinTableNode(pCxt, yymsp[-4].minor.yy708, yymsp[-5].minor.yy840, yymsp[-2].minor.yy840, yymsp[0].minor.yy840); } -#line 7128 "sql.c" - yymsp[-5].minor.yy840 = yylhsminor.yy840; +{ yylhsminor.yy952 = createJoinTableNode(pCxt, yymsp[-4].minor.yy932, yymsp[-5].minor.yy952, yymsp[-2].minor.yy952, yymsp[0].minor.yy952); } + yymsp[-5].minor.yy952 = yylhsminor.yy952; break; case 519: /* join_type ::= */ -#line 1007 "sql.y" -{ yymsp[1].minor.yy708 = JOIN_TYPE_INNER; } -#line 7134 "sql.c" +{ yymsp[1].minor.yy932 = JOIN_TYPE_INNER; } break; case 520: /* join_type ::= INNER */ -#line 1008 "sql.y" -{ yymsp[0].minor.yy708 = JOIN_TYPE_INNER; } -#line 7139 "sql.c" +{ yymsp[0].minor.yy932 = JOIN_TYPE_INNER; } break; - case 521: /* query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ -#line 1014 "sql.y" + case 521: /* query_specification ::= SELECT hint_list tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { - yymsp[-12].minor.yy840 = createSelectStmt(pCxt, yymsp[-10].minor.yy313, yymsp[-9].minor.yy56, yymsp[-8].minor.yy840); - yymsp[-12].minor.yy840 = setSelectStmtTagMode(pCxt, yymsp[-12].minor.yy840, yymsp[-11].minor.yy313); - yymsp[-12].minor.yy840 = addWhereClause(pCxt, yymsp[-12].minor.yy840, yymsp[-7].minor.yy840); - yymsp[-12].minor.yy840 = addPartitionByClause(pCxt, yymsp[-12].minor.yy840, yymsp[-6].minor.yy56); - yymsp[-12].minor.yy840 = addWindowClauseClause(pCxt, yymsp[-12].minor.yy840, yymsp[-2].minor.yy840); - yymsp[-12].minor.yy840 = addGroupByClause(pCxt, yymsp[-12].minor.yy840, yymsp[-1].minor.yy56); - yymsp[-12].minor.yy840 = addHavingClause(pCxt, yymsp[-12].minor.yy840, yymsp[0].minor.yy840); - yymsp[-12].minor.yy840 = addRangeClause(pCxt, yymsp[-12].minor.yy840, yymsp[-5].minor.yy840); - yymsp[-12].minor.yy840 = addEveryClause(pCxt, yymsp[-12].minor.yy840, yymsp[-4].minor.yy840); - yymsp[-12].minor.yy840 = addFillClause(pCxt, yymsp[-12].minor.yy840, yymsp[-3].minor.yy840); + yymsp[-13].minor.yy952 = createSelectStmt(pCxt, yymsp[-10].minor.yy957, yymsp[-9].minor.yy824, yymsp[-8].minor.yy952, yymsp[-12].minor.yy824); + yymsp[-13].minor.yy952 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy952, yymsp[-11].minor.yy957); + yymsp[-13].minor.yy952 = addWhereClause(pCxt, yymsp[-13].minor.yy952, yymsp[-7].minor.yy952); + yymsp[-13].minor.yy952 = addPartitionByClause(pCxt, yymsp[-13].minor.yy952, yymsp[-6].minor.yy824); + yymsp[-13].minor.yy952 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy952, yymsp[-2].minor.yy952); + yymsp[-13].minor.yy952 = addGroupByClause(pCxt, yymsp[-13].minor.yy952, yymsp[-1].minor.yy824); + yymsp[-13].minor.yy952 = addHavingClause(pCxt, yymsp[-13].minor.yy952, yymsp[0].minor.yy952); + yymsp[-13].minor.yy952 = addRangeClause(pCxt, yymsp[-13].minor.yy952, yymsp[-5].minor.yy952); + yymsp[-13].minor.yy952 = addEveryClause(pCxt, yymsp[-13].minor.yy952, yymsp[-4].minor.yy952); + yymsp[-13].minor.yy952 = addFillClause(pCxt, yymsp[-13].minor.yy952, yymsp[-3].minor.yy952); } -#line 7155 "sql.c" break; - case 526: /* set_quantifier_opt ::= ALL */ -#line 1036 "sql.y" -{ yymsp[0].minor.yy313 = false; } -#line 7160 "sql.c" + case 522: /* hint_list ::= */ +{ yymsp[1].minor.yy824 = createHintNodeList(pCxt, NULL); } break; - case 529: /* select_item ::= NK_STAR */ -#line 1043 "sql.y" -{ yylhsminor.yy840 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } -#line 7165 "sql.c" - yymsp[0].minor.yy840 = yylhsminor.yy840; + case 523: /* hint_list ::= NK_HINT */ +{ yylhsminor.yy824 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; - case 531: /* select_item ::= common_expression column_alias */ - case 541: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==541); -#line 1045 "sql.y" -{ yylhsminor.yy840 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840), &yymsp[0].minor.yy129); } -#line 7172 "sql.c" - yymsp[-1].minor.yy840 = yylhsminor.yy840; + case 528: /* set_quantifier_opt ::= ALL */ +{ yymsp[0].minor.yy957 = false; } break; - case 532: /* select_item ::= common_expression AS column_alias */ - case 542: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==542); -#line 1046 "sql.y" -{ yylhsminor.yy840 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), &yymsp[0].minor.yy129); } -#line 7179 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + case 531: /* select_item ::= NK_STAR */ +{ yylhsminor.yy952 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy952 = yylhsminor.yy952; break; - case 537: /* partition_by_clause_opt ::= PARTITION BY partition_list */ - case 562: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==562); - case 582: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==582); -#line 1055 "sql.y" -{ yymsp[-2].minor.yy56 = yymsp[0].minor.yy56; } -#line 7187 "sql.c" + case 533: /* select_item ::= common_expression column_alias */ + case 543: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==543); +{ yylhsminor.yy952 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy952), &yymsp[0].minor.yy169); } + yymsp[-1].minor.yy952 = yylhsminor.yy952; break; - case 544: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ -#line 1068 "sql.y" -{ yymsp[-5].minor.yy840 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); } -#line 7192 "sql.c" + case 534: /* select_item ::= common_expression AS column_alias */ + case 544: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==544); +{ yylhsminor.yy952 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), &yymsp[0].minor.yy169); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; - case 545: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ -#line 1069 "sql.y" -{ yymsp[-3].minor.yy840 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); } -#line 7197 "sql.c" + case 539: /* partition_by_clause_opt ::= PARTITION BY partition_list */ + case 564: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==564); + case 584: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==584); +{ yymsp[-2].minor.yy824 = yymsp[0].minor.yy824; } break; - case 546: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ -#line 1071 "sql.y" -{ yymsp[-5].minor.yy840 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 7202 "sql.c" + case 546: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ +{ yymsp[-5].minor.yy952 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), releaseRawExprNode(pCxt, yymsp[-1].minor.yy952)); } break; - case 547: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ -#line 1074 "sql.y" -{ yymsp[-7].minor.yy840 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy840, yymsp[0].minor.yy840); } -#line 7207 "sql.c" + case 547: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ +{ yymsp[-3].minor.yy952 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy952)); } break; - case 548: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ -#line 1076 "sql.y" -{ yymsp[-6].minor.yy840 = createEventWindowNode(pCxt, yymsp[-3].minor.yy840, yymsp[0].minor.yy840); } -#line 7212 "sql.c" + case 548: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-5].minor.yy952 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), NULL, yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; - case 552: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -#line 1082 "sql.y" -{ yymsp[-3].minor.yy840 = createFillNode(pCxt, yymsp[-1].minor.yy694, NULL); } -#line 7217 "sql.c" + case 549: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ +{ yymsp[-7].minor.yy952 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy952), releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), yymsp[-1].minor.yy952, yymsp[0].minor.yy952); } break; - case 553: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ -#line 1083 "sql.y" -{ yymsp[-5].minor.yy840 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy56)); } -#line 7222 "sql.c" + case 550: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ +{ yymsp[-6].minor.yy952 = createEventWindowNode(pCxt, yymsp[-3].minor.yy952, yymsp[0].minor.yy952); } break; - case 554: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ -#line 1084 "sql.y" -{ yymsp[-5].minor.yy840 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy56)); } -#line 7227 "sql.c" + case 554: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +{ yymsp[-3].minor.yy952 = createFillNode(pCxt, yymsp[-1].minor.yy214, NULL); } break; - case 555: /* fill_mode ::= NONE */ -#line 1088 "sql.y" -{ yymsp[0].minor.yy694 = FILL_MODE_NONE; } -#line 7232 "sql.c" + case 555: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ +{ yymsp[-5].minor.yy952 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy824)); } break; - case 556: /* fill_mode ::= PREV */ -#line 1089 "sql.y" -{ yymsp[0].minor.yy694 = FILL_MODE_PREV; } -#line 7237 "sql.c" + case 556: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ +{ yymsp[-5].minor.yy952 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy824)); } break; - case 557: /* fill_mode ::= NULL */ -#line 1090 "sql.y" -{ yymsp[0].minor.yy694 = FILL_MODE_NULL; } -#line 7242 "sql.c" + case 557: /* fill_mode ::= NONE */ +{ yymsp[0].minor.yy214 = FILL_MODE_NONE; } break; - case 558: /* fill_mode ::= NULL_F */ -#line 1091 "sql.y" -{ yymsp[0].minor.yy694 = FILL_MODE_NULL_F; } -#line 7247 "sql.c" + case 558: /* fill_mode ::= PREV */ +{ yymsp[0].minor.yy214 = FILL_MODE_PREV; } break; - case 559: /* fill_mode ::= LINEAR */ -#line 1092 "sql.y" -{ yymsp[0].minor.yy694 = FILL_MODE_LINEAR; } -#line 7252 "sql.c" + case 559: /* fill_mode ::= NULL */ +{ yymsp[0].minor.yy214 = FILL_MODE_NULL; } break; - case 560: /* fill_mode ::= NEXT */ -#line 1093 "sql.y" -{ yymsp[0].minor.yy694 = FILL_MODE_NEXT; } -#line 7257 "sql.c" + case 560: /* fill_mode ::= NULL_F */ +{ yymsp[0].minor.yy214 = FILL_MODE_NULL_F; } break; - case 563: /* group_by_list ::= expr_or_subquery */ -#line 1102 "sql.y" -{ yylhsminor.yy56 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); } -#line 7262 "sql.c" - yymsp[0].minor.yy56 = yylhsminor.yy56; + case 561: /* fill_mode ::= LINEAR */ +{ yymsp[0].minor.yy214 = FILL_MODE_LINEAR; } break; - case 564: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ -#line 1103 "sql.y" -{ yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); } -#line 7268 "sql.c" - yymsp[-2].minor.yy56 = yylhsminor.yy56; + case 562: /* fill_mode ::= NEXT */ +{ yymsp[0].minor.yy214 = FILL_MODE_NEXT; } break; - case 568: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ -#line 1110 "sql.y" -{ yymsp[-5].minor.yy840 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); } -#line 7274 "sql.c" + case 565: /* group_by_list ::= expr_or_subquery */ +{ yylhsminor.yy824 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } + yymsp[0].minor.yy824 = yylhsminor.yy824; break; - case 569: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ -#line 1112 "sql.y" -{ yymsp[-3].minor.yy840 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); } -#line 7279 "sql.c" + case 566: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ +{ yylhsminor.yy824 = addNodeToList(pCxt, yymsp[-2].minor.yy824, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy952))); } + yymsp[-2].minor.yy824 = yylhsminor.yy824; break; - case 572: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ -#line 1119 "sql.y" + case 570: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ +{ yymsp[-5].minor.yy952 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy952), releaseRawExprNode(pCxt, yymsp[-1].minor.yy952)); } + break; + case 571: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ +{ yymsp[-3].minor.yy952 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy952)); } + break; + case 574: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ { - yylhsminor.yy840 = addOrderByClause(pCxt, yymsp[-3].minor.yy840, yymsp[-2].minor.yy56); - yylhsminor.yy840 = addSlimitClause(pCxt, yylhsminor.yy840, yymsp[-1].minor.yy840); - yylhsminor.yy840 = addLimitClause(pCxt, yylhsminor.yy840, yymsp[0].minor.yy840); + yylhsminor.yy952 = addOrderByClause(pCxt, yymsp[-3].minor.yy952, yymsp[-2].minor.yy824); + yylhsminor.yy952 = addSlimitClause(pCxt, yylhsminor.yy952, yymsp[-1].minor.yy952); + yylhsminor.yy952 = addLimitClause(pCxt, yylhsminor.yy952, yymsp[0].minor.yy952); } -#line 7288 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; - case 575: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ -#line 1129 "sql.y" -{ yylhsminor.yy840 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy840, yymsp[0].minor.yy840); } -#line 7294 "sql.c" - yymsp[-3].minor.yy840 = yylhsminor.yy840; + case 577: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ +{ yylhsminor.yy952 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy952, yymsp[0].minor.yy952); } + yymsp[-3].minor.yy952 = yylhsminor.yy952; break; - case 576: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ -#line 1131 "sql.y" -{ yylhsminor.yy840 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy840, yymsp[0].minor.yy840); } -#line 7300 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + case 578: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ +{ yylhsminor.yy952 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy952, yymsp[0].minor.yy952); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; - case 584: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 588: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==588); -#line 1145 "sql.y" -{ yymsp[-1].minor.yy840 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 7307 "sql.c" + case 586: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 590: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==590); +{ yymsp[-1].minor.yy952 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 585: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 589: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==589); -#line 1146 "sql.y" -{ yymsp[-3].minor.yy840 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } -#line 7313 "sql.c" + case 587: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 591: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==591); +{ yymsp[-3].minor.yy952 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 586: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 590: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==590); -#line 1147 "sql.y" -{ yymsp[-3].minor.yy840 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } -#line 7319 "sql.c" + case 588: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 592: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==592); +{ yymsp[-3].minor.yy952 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 591: /* subquery ::= NK_LP query_expression NK_RP */ -#line 1155 "sql.y" -{ yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy840); } -#line 7324 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + case 593: /* subquery ::= NK_LP query_expression NK_RP */ +{ yylhsminor.yy952 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy952); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; - case 596: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ -#line 1169 "sql.y" -{ yylhsminor.yy840 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), yymsp[-1].minor.yy82, yymsp[0].minor.yy521); } -#line 7330 "sql.c" - yymsp[-2].minor.yy840 = yylhsminor.yy840; + case 598: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ +{ yylhsminor.yy952 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy952), yymsp[-1].minor.yy498, yymsp[0].minor.yy977); } + yymsp[-2].minor.yy952 = yylhsminor.yy952; break; - case 597: /* ordering_specification_opt ::= */ -#line 1173 "sql.y" -{ yymsp[1].minor.yy82 = ORDER_ASC; } -#line 7336 "sql.c" + case 599: /* ordering_specification_opt ::= */ +{ yymsp[1].minor.yy498 = ORDER_ASC; } break; - case 598: /* ordering_specification_opt ::= ASC */ -#line 1174 "sql.y" -{ yymsp[0].minor.yy82 = ORDER_ASC; } -#line 7341 "sql.c" + case 600: /* ordering_specification_opt ::= ASC */ +{ yymsp[0].minor.yy498 = ORDER_ASC; } break; - case 599: /* ordering_specification_opt ::= DESC */ -#line 1175 "sql.y" -{ yymsp[0].minor.yy82 = ORDER_DESC; } -#line 7346 "sql.c" + case 601: /* ordering_specification_opt ::= DESC */ +{ yymsp[0].minor.yy498 = ORDER_DESC; } break; - case 600: /* null_ordering_opt ::= */ -#line 1179 "sql.y" -{ yymsp[1].minor.yy521 = NULL_ORDER_DEFAULT; } -#line 7351 "sql.c" + case 602: /* null_ordering_opt ::= */ +{ yymsp[1].minor.yy977 = NULL_ORDER_DEFAULT; } break; - case 601: /* null_ordering_opt ::= NULLS FIRST */ -#line 1180 "sql.y" -{ yymsp[-1].minor.yy521 = NULL_ORDER_FIRST; } -#line 7356 "sql.c" + case 603: /* null_ordering_opt ::= NULLS FIRST */ +{ yymsp[-1].minor.yy977 = NULL_ORDER_FIRST; } break; - case 602: /* null_ordering_opt ::= NULLS LAST */ -#line 1181 "sql.y" -{ yymsp[-1].minor.yy521 = NULL_ORDER_LAST; } -#line 7361 "sql.c" + case 604: /* null_ordering_opt ::= NULLS LAST */ +{ yymsp[-1].minor.yy977 = NULL_ORDER_LAST; } break; default: break; @@ -7420,7 +6290,6 @@ static void yy_syntax_error( ParseCTX_FETCH #define TOKEN yyminor /************ Begin %syntax_error code ****************************************/ -#line 29 "sql.y" if (TSDB_CODE_SUCCESS == pCxt->errCode) { if(TOKEN.z) { @@ -7431,7 +6300,6 @@ static void yy_syntax_error( } else if (TSDB_CODE_PAR_DB_NOT_SPECIFIED == pCxt->errCode && TK_NK_FLOAT == TOKEN.type) { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYNTAX_ERROR, TOKEN.z); } -#line 7434 "sql.c" /************ End %syntax_error code ******************************************/ ParseARG_STORE /* Suppress warning about unused %extra_argument variable */ ParseCTX_STORE @@ -7517,56 +6385,12 @@ void Parse( } #endif - while(1){ /* Exit by "break" */ - assert( yypParser->yytos>=yypParser->yystack ); + do{ assert( yyact==yypParser->yytos->stateno ); yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); if( yyact >= YY_MIN_REDUCE ){ - unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */ -#ifndef NDEBUG - assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); - if( yyTraceFILE ){ - int yysize = yyRuleInfoNRhs[yyruleno]; - if( yysize ){ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", - yyTracePrompt, - yyruleno, yyRuleName[yyruleno], - yyrulenoyytos[yysize].stateno); - }else{ - fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n", - yyTracePrompt, yyruleno, yyRuleName[yyruleno], - yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ - yypParser->yyhwm++; - assert( yypParser->yyhwm == - (int)(yypParser->yytos - yypParser->yystack)); - } -#endif -#if YYSTACKDEPTH>0 - if( yypParser->yytos>=yypParser->yystackEnd ){ - yyStackOverflow(yypParser); - break; - } -#else - if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ - if( yyGrowStack(yypParser) ){ - yyStackOverflow(yypParser); - break; - } - } -#endif - } - yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor ParseCTX_PARAM); + yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor, + yyminor ParseCTX_PARAM); }else if( yyact <= YY_MAX_SHIFTREDUCE ){ yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); #ifndef YYNOERRORRECOVERY @@ -7622,13 +6446,14 @@ void Parse( yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); yymajor = YYNOCODE; }else{ - while( yypParser->yytos > yypParser->yystack ){ - yyact = yy_find_reduce_action(yypParser->yytos->stateno, - YYERRORSYMBOL); - if( yyact<=YY_MAX_SHIFTREDUCE ) break; + while( yypParser->yytos >= yypParser->yystack + && (yyact = yy_find_reduce_action( + yypParser->yytos->stateno, + YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE + ){ yy_pop_parser_stack(yypParser); } - if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){ + if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); yy_parse_failed(yypParser); #ifndef YYNOERRORRECOVERY @@ -7678,7 +6503,7 @@ void Parse( break; #endif } - } + }while( yypParser->yytos>yypParser->yystack ); #ifndef NDEBUG if( yyTraceFILE ){ yyStackEntry *i; diff --git a/source/libs/planner/inc/planInt.h b/source/libs/planner/inc/planInt.h index 24d77cb9a4..d8fb0def5f 100644 --- a/source/libs/planner/inc/planInt.h +++ b/source/libs/planner/inc/planInt.h @@ -21,6 +21,7 @@ extern "C" { #endif #include "planner.h" +#include "tsimplehash.h" #include "taoserror.h" #define planFatal(param, ...) qFatal("PLAN: " param, ##__VA_ARGS__) @@ -43,6 +44,9 @@ int32_t splitLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan); int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan); int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList); +bool getBatchScanOptionFromHint(SNodeList* pList); +SLogicNode* getLogicNodeRootNode(SLogicNode* pCurr); +int32_t collectTableAliasFromNodes(SNode* pNode, SSHashObj** ppRes); bool isPartTableAgg(SAggLogicNode* pAgg); bool isPartTagAgg(SAggLogicNode* pAgg); bool isPartTableWinodw(SWindowLogicNode* pWindow); diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index a822c7f9fe..1c17db606c 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -44,6 +44,11 @@ static void setColumnInfo(SFunctionNode* pFunc, SColumnNode* pCol, bool isPartit switch (pFunc->funcType) { case FUNCTION_TYPE_TBNAME: pCol->colType = COLUMN_TYPE_TBNAME; + SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0); + if (pVal) { + strcpy(pCol->tableName, pVal->literal); + strcpy(pCol->tableAlias, pVal->literal); + } break; case FUNCTION_TYPE_WSTART: if (!isPartitionBy) { @@ -420,16 +425,26 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect } if (TSDB_CODE_SUCCESS == code) { - code = nodesCollectFuncs(pSelect, SQL_CLAUSE_FROM, fmIsScanPseudoColumnFunc, &pScan->pScanPseudoCols); - } - - // rewrite the expression in subsequent clauses - if (TSDB_CODE_SUCCESS == code) { - code = rewriteExprsForSelect(pScan->pScanPseudoCols, pSelect, SQL_CLAUSE_FROM, NULL); + code = nodesCollectFuncs(pSelect, SQL_CLAUSE_FROM, pRealTable->table.tableAlias, fmIsScanPseudoColumnFunc, &pScan->pScanPseudoCols); } pScan->scanType = getScanType(pCxt, pScan->pScanPseudoCols, pScan->pScanCols, pScan->tableType, pSelect->tagScan); + // rewrite the expression in subsequent clauses + if (TSDB_CODE_SUCCESS == code) { + SNodeList* pNewScanPseudoCols = NULL; + code = rewriteExprsForSelect(pScan->pScanPseudoCols, pSelect, SQL_CLAUSE_FROM, NULL); +/* + if (TSDB_CODE_SUCCESS == code && NULL != pScan->pScanPseudoCols) { + code = createColumnByRewriteExprs(pScan->pScanPseudoCols, &pNewScanPseudoCols); + if (TSDB_CODE_SUCCESS == code) { + nodesDestroyList(pScan->pScanPseudoCols); + pScan->pScanPseudoCols = pNewScanPseudoCols; + } + } +*/ + } + if (NULL != pScan->pScanCols) { pScan->hasNormalCols = true; } @@ -488,12 +503,15 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect } pJoin->joinType = pJoinTable->joinType; + pJoin->joinAlgo = JOIN_ALGO_UNKNOWN; pJoin->isSingleTableJoin = pJoinTable->table.singleTable; + pJoin->hasSubQuery = pJoinTable->hasSubQuery; pJoin->node.inputTsOrder = ORDER_ASC; pJoin->node.groupAction = GROUP_ACTION_CLEAR; pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_GLOBAL; - pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_GLOBAL; - + pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; + pJoin->isLowLevelJoin = pJoinTable->isLowLevelJoin; + int32_t code = TSDB_CODE_SUCCESS; // set left and right node @@ -520,21 +538,52 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect // set on conditions if (TSDB_CODE_SUCCESS == code && NULL != pJoinTable->pOnCond) { - pJoin->pOnConditions = nodesCloneNode(pJoinTable->pOnCond); - if (NULL == pJoin->pOnConditions) { + pJoin->pOtherOnCond = nodesCloneNode(pJoinTable->pOnCond); + if (NULL == pJoin->pOtherOnCond) { code = TSDB_CODE_OUT_OF_MEMORY; } } // set the output if (TSDB_CODE_SUCCESS == code) { + SNodeList* pColList = NULL; + if (QUERY_NODE_REAL_TABLE == nodeType(pJoinTable->pLeft) && !pJoin->isLowLevelJoin) { + code = nodesCollectColumns(pSelect, SQL_CLAUSE_WHERE, ((SRealTableNode*)pJoinTable->pLeft)->table.tableAlias, COLLECT_COL_TYPE_ALL, &pColList); + } else { + pJoin->node.pTargets = nodesCloneList(pLeft->pTargets); + if (NULL == pJoin->node.pTargets) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + if (TSDB_CODE_SUCCESS == code && NULL != pColList) { + code = createColumnByRewriteExprs(pColList, &pJoin->node.pTargets); + } + } + + if (TSDB_CODE_SUCCESS == code) { + SNodeList* pColList = NULL; + if (QUERY_NODE_REAL_TABLE == nodeType(pJoinTable->pRight) && !pJoin->isLowLevelJoin) { + code = nodesCollectColumns(pSelect, SQL_CLAUSE_WHERE, ((SRealTableNode*)pJoinTable->pRight)->table.tableAlias, COLLECT_COL_TYPE_ALL, &pColList); + } else { + if (pJoin->node.pTargets) { + nodesListStrictAppendList(pJoin->node.pTargets, nodesCloneList(pRight->pTargets)); + } else { + pJoin->node.pTargets = nodesCloneList(pRight->pTargets); + if (NULL == pJoin->node.pTargets) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + } + if (TSDB_CODE_SUCCESS == code && NULL != pColList) { + code = createColumnByRewriteExprs(pColList, &pJoin->node.pTargets); + } + } + + if (NULL == pJoin->node.pTargets) { pJoin->node.pTargets = nodesCloneList(pLeft->pTargets); if (NULL == pJoin->node.pTargets) { code = TSDB_CODE_OUT_OF_MEMORY; } - if (TSDB_CODE_SUCCESS == code) { - code = nodesListStrictAppendList(pJoin->node.pTargets, nodesCloneList(pRight->pTargets)); - } } if (TSDB_CODE_SUCCESS == code) { @@ -642,7 +691,7 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, // set grouyp keys, agg funcs and having conditions if (TSDB_CODE_SUCCESS == code) { - code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, fmIsAggFunc, &pAgg->pAggFuncs); + code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, NULL, fmIsAggFunc, &pAgg->pAggFuncs); } // rewrite the expression in subsequent clauses @@ -713,7 +762,7 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt pIdfRowsFunc->node.resultDataOrder = pIdfRowsFunc->node.requireDataOrder; // indefinite rows functions and _select_values functions - int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, fmIsVectorFunc, &pIdfRowsFunc->pFuncs); + int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, fmIsVectorFunc, &pIdfRowsFunc->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = rewriteExprsForSelect(pIdfRowsFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL); } @@ -751,7 +800,7 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p pInterpFunc->node.resultDataOrder = pInterpFunc->node.requireDataOrder; // interp functions and _group_key functions - int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, isInterpFunc, &pInterpFunc->pFuncs); + int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, isInterpFunc, &pInterpFunc->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = rewriteExprsForSelect(pInterpFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL); } @@ -797,7 +846,7 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm pWindow->node.inputTsOrder = ORDER_ASC; pWindow->node.outputTsOrder = ORDER_ASC; - int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_WINDOW, fmIsWindowClauseFunc, &pWindow->pFuncs); + int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_WINDOW, NULL, fmIsWindowClauseFunc, &pWindow->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = rewriteExprsForSelect(pWindow->pFuncs, pSelect, SQL_CLAUSE_WINDOW, NULL); } @@ -1328,11 +1377,17 @@ static int32_t createSelectFromLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p } static int32_t createSelectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) { + int32_t code = TSDB_CODE_SUCCESS; if (NULL == pSelect->pFromTable) { - return createSelectWithoutFromLogicNode(pCxt, pSelect, pLogicNode); + code = createSelectWithoutFromLogicNode(pCxt, pSelect, pLogicNode); } else { - return createSelectFromLogicNode(pCxt, pSelect, pLogicNode); + code = createSelectFromLogicNode(pCxt, pSelect, pLogicNode); } + if (TSDB_CODE_SUCCESS == code && NULL != *pLogicNode) { + (*pLogicNode)->stmtRoot = true; + TSWAP((*pLogicNode)->pHint, pSelect->pHint); + } + return code; } static int32_t createSetOpRootLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, FCreateSetOpLogicNode func, diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index 2d21359c62..2db0c8c54b 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -50,8 +50,8 @@ typedef struct SOsdInfo { } SOsdInfo; typedef struct SCpdIsMultiTableCondCxt { - SNodeList* pLeftCols; - SNodeList* pRightCols; + SSHashObj* pLeftTbls; + SSHashObj* pRightTbls; bool havaLeftCol; bool haveRightCol; } SCpdIsMultiTableCondCxt; @@ -505,12 +505,21 @@ static bool pushDownCondOptBelongThisTable(SNode* pCondCol, SNodeList* pTableCol return false; } +static bool pushDownCondOptColInTableList(SNode* pCondCol, SSHashObj* pTables) { + SColumnNode* pTableCol = (SColumnNode*)pCondCol; + if (NULL == tSimpleHashGet(pTables, pTableCol->tableAlias, strlen(pTableCol->tableAlias))) { + return false; + } + return true; +} + + static EDealRes pushDownCondOptIsCrossTableCond(SNode* pNode, void* pContext) { SCpdIsMultiTableCondCxt* pCxt = pContext; if (QUERY_NODE_COLUMN == nodeType(pNode)) { - if (pushDownCondOptBelongThisTable(pNode, pCxt->pLeftCols)) { + if (pushDownCondOptColInTableList(pNode, pCxt->pLeftTbls)) { pCxt->havaLeftCol = true; - } else if (pushDownCondOptBelongThisTable(pNode, pCxt->pRightCols)) { + } else if (pushDownCondOptColInTableList(pNode, pCxt->pRightTbls)) { pCxt->haveRightCol = true; } return pCxt->havaLeftCol && pCxt->haveRightCol ? DEAL_RES_END : DEAL_RES_CONTINUE; @@ -518,10 +527,10 @@ static EDealRes pushDownCondOptIsCrossTableCond(SNode* pNode, void* pContext) { return DEAL_RES_CONTINUE; } -static ECondAction pushDownCondOptGetCondAction(EJoinType joinType, SNodeList* pLeftCols, SNodeList* pRightCols, +static ECondAction pushDownCondOptGetCondAction(EJoinType joinType, SSHashObj* pLeftTbls, SSHashObj* pRightTbls, SNode* pNode) { SCpdIsMultiTableCondCxt cxt = { - .pLeftCols = pLeftCols, .pRightCols = pRightCols, .havaLeftCol = false, .haveRightCol = false}; + .pLeftTbls = pLeftTbls, .pRightTbls = pRightTbls, .havaLeftCol = false, .haveRightCol = false}; nodesWalkExpr(pNode, pushDownCondOptIsCrossTableCond, &cxt); return (JOIN_TYPE_INNER != joinType ? COND_ACTION_STAY @@ -534,12 +543,14 @@ static int32_t pushDownCondOptPartLogicCond(SJoinLogicNode* pJoin, SNode** pOnCo SNode** pRightChildCond) { SLogicConditionNode* pLogicCond = (SLogicConditionNode*)pJoin->node.pConditions; if (LOGIC_COND_TYPE_AND != pLogicCond->condType) { - return TSDB_CODE_SUCCESS; + return TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND; } - SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets; - SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets; int32_t code = TSDB_CODE_SUCCESS; + SSHashObj* pLeftTables = NULL; + SSHashObj* pRightTables = NULL; + collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); SNodeList* pOnConds = NULL; SNodeList* pLeftChildConds = NULL; @@ -547,7 +558,7 @@ static int32_t pushDownCondOptPartLogicCond(SJoinLogicNode* pJoin, SNode** pOnCo SNodeList* pRemainConds = NULL; SNode* pCond = NULL; FOREACH(pCond, pLogicCond->pParameterList) { - ECondAction condAction = pushDownCondOptGetCondAction(pJoin->joinType, pLeftCols, pRightCols, pCond); + ECondAction condAction = pushDownCondOptGetCondAction(pJoin->joinType, pLeftTables, pRightTables, pCond); if (COND_ACTION_PUSH_JOIN == condAction) { code = nodesListMakeAppend(&pOnConds, nodesCloneNode(pCond)); } else if (COND_ACTION_PUSH_LEFT_CHILD == condAction) { @@ -562,6 +573,9 @@ static int32_t pushDownCondOptPartLogicCond(SJoinLogicNode* pJoin, SNode** pOnCo } } + tSimpleHashCleanup(pLeftTables); + tSimpleHashCleanup(pRightTables); + SNode* pTempOnCond = NULL; SNode* pTempLeftChildCond = NULL; SNode* pTempRightChildCond = NULL; @@ -601,10 +615,17 @@ static int32_t pushDownCondOptPartLogicCond(SJoinLogicNode* pJoin, SNode** pOnCo static int32_t pushDownCondOptPartOpCond(SJoinLogicNode* pJoin, SNode** pOnCond, SNode** pLeftChildCond, SNode** pRightChildCond) { - SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets; - SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets; + SSHashObj* pLeftTables = NULL; + SSHashObj* pRightTables = NULL; + collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + ECondAction condAction = - pushDownCondOptGetCondAction(pJoin->joinType, pLeftCols, pRightCols, pJoin->node.pConditions); + pushDownCondOptGetCondAction(pJoin->joinType, pLeftTables, pRightTables, pJoin->node.pConditions); + + tSimpleHashCleanup(pLeftTables); + tSimpleHashCleanup(pRightTables); + if (COND_ACTION_STAY == condAction) { return TSDB_CODE_SUCCESS; } else if (COND_ACTION_PUSH_JOIN == condAction) { @@ -628,14 +649,14 @@ static int32_t pushDownCondOptPartCond(SJoinLogicNode* pJoin, SNode** pOnCond, S } static int32_t pushDownCondOptPushCondToOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin, SNode** pCond) { - return pushDownCondOptAppendCond(&pJoin->pOnConditions, pCond); + return pushDownCondOptAppendCond(&pJoin->pOtherOnCond, pCond); } static int32_t pushDownCondOptPushCondToChild(SOptimizeContext* pCxt, SLogicNode* pChild, SNode** pCond) { return pushDownCondOptAppendCond(&pChild->pConditions, pCond); } -static bool pushDownCondOptIsPriKey(SNode* pNode, SNodeList* pTableCols) { +static bool pushDownCondOptIsPriKey(SNode* pNode, SSHashObj* pTables) { if (QUERY_NODE_COLUMN != nodeType(pNode)) { return false; } @@ -643,7 +664,7 @@ static bool pushDownCondOptIsPriKey(SNode* pNode, SNodeList* pTableCols) { if (PRIMARYKEY_TIMESTAMP_COL_ID != pCol->colId || TSDB_SYSTEM_TABLE == pCol->tableType) { return false; } - return pushDownCondOptBelongThisTable(pNode, pTableCols); + return pushDownCondOptColInTableList(pNode, pTables); } static bool pushDownCondOptIsPriKeyEqualCond(SJoinLogicNode* pJoin, SNode* pCond) { @@ -656,26 +677,37 @@ static bool pushDownCondOptIsPriKeyEqualCond(SJoinLogicNode* pJoin, SNode* pCond return false; } - SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets; - SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets; - if (pushDownCondOptIsPriKey(pOper->pLeft, pLeftCols)) { - return pushDownCondOptIsPriKey(pOper->pRight, pRightCols); - } else if (pushDownCondOptIsPriKey(pOper->pLeft, pRightCols)) { - return pushDownCondOptIsPriKey(pOper->pRight, pLeftCols); + SSHashObj* pLeftTables = NULL; + SSHashObj* pRightTables = NULL; + collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + + bool res = false; + if (pushDownCondOptIsPriKey(pOper->pLeft, pLeftTables)) { + res = pushDownCondOptIsPriKey(pOper->pRight, pRightTables); + } else if (pushDownCondOptIsPriKey(pOper->pLeft, pRightTables)) { + res = pushDownCondOptIsPriKey(pOper->pRight, pLeftTables); } - return false; + + tSimpleHashCleanup(pLeftTables); + tSimpleHashCleanup(pRightTables); + + return res; } -static bool pushDownCondOptContainPriKeyEqualCond(SJoinLogicNode* pJoin, SNode* pCond) { +static bool pushDownCondOptContainPriKeyEqualCond(SJoinLogicNode* pJoin, SNode* pCond, bool* errCond) { if (QUERY_NODE_LOGIC_CONDITION == nodeType(pCond)) { SLogicConditionNode* pLogicCond = (SLogicConditionNode*)pCond; if (LOGIC_COND_TYPE_AND != pLogicCond->condType) { + if (errCond) { + *errCond = true; + } return false; } bool hasPrimaryKeyEqualCond = false; SNode* pCond = NULL; FOREACH(pCond, pLogicCond->pParameterList) { - if (pushDownCondOptContainPriKeyEqualCond(pJoin, pCond)) { + if (pushDownCondOptContainPriKeyEqualCond(pJoin, pCond, NULL)) { hasPrimaryKeyEqualCond = true; break; } @@ -687,26 +719,33 @@ static bool pushDownCondOptContainPriKeyEqualCond(SJoinLogicNode* pJoin, SNode* } static int32_t pushDownCondOptCheckJoinOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { - if (NULL == pJoin->pOnConditions) { + if (NULL == pJoin->pOtherOnCond) { return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN); } - if (!pushDownCondOptContainPriKeyEqualCond(pJoin, pJoin->pOnConditions)) { + bool errCond = false; + if (!pushDownCondOptContainPriKeyEqualCond(pJoin, pJoin->pOtherOnCond, &errCond)) { + if (errCond) { + return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND); + } return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_EXPECTED_TS_EQUAL); } return TSDB_CODE_SUCCESS; } -static int32_t pushDownCondOptPartJoinOnCondLogicCond(SJoinLogicNode* pJoin, SNode** ppMergeCond, SNode** ppOnCond) { - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(pJoin->pOnConditions); +static int32_t pushDownCondOptPartJoinOnCondLogicCond(SJoinLogicNode* pJoin, SNode** ppPrimKeyEqCond, SNode** ppOnCond) { + SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(pJoin->pOtherOnCond); int32_t code = TSDB_CODE_SUCCESS; SNodeList* pOnConds = NULL; SNode* pCond = NULL; - FOREACH(pCond, pLogicCond->pParameterList) { + WHERE_EACH(pCond, pLogicCond->pParameterList) { if (pushDownCondOptIsPriKeyEqualCond(pJoin, pCond)) { - *ppMergeCond = nodesCloneNode(pCond); + nodesDestroyNode(*ppPrimKeyEqCond); + *ppPrimKeyEqCond = nodesCloneNode(pCond); + ERASE_NODE(pLogicCond->pParameterList); } else { code = nodesListMakeAppend(&pOnConds, nodesCloneNode(pCond)); + WHERE_NEXT; } } @@ -715,10 +754,10 @@ static int32_t pushDownCondOptPartJoinOnCondLogicCond(SJoinLogicNode* pJoin, SNo code = nodesMergeConds(&pTempOnCond, &pOnConds); } - if (TSDB_CODE_SUCCESS == code && NULL != *ppMergeCond) { + if (TSDB_CODE_SUCCESS == code && NULL != *ppPrimKeyEqCond) { *ppOnCond = pTempOnCond; - nodesDestroyNode(pJoin->pOnConditions); - pJoin->pOnConditions = NULL; + nodesDestroyNode(pJoin->pOtherOnCond); + pJoin->pOtherOnCond = NULL; return TSDB_CODE_SUCCESS; } else { nodesDestroyList(pOnConds); @@ -727,35 +766,34 @@ static int32_t pushDownCondOptPartJoinOnCondLogicCond(SJoinLogicNode* pJoin, SNo } } -static int32_t pushDownCondOptPartJoinOnCond(SJoinLogicNode* pJoin, SNode** ppMergeCond, SNode** ppOnCond) { - if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pOnConditions) && - LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)(pJoin->pOnConditions))->condType) { - return pushDownCondOptPartJoinOnCondLogicCond(pJoin, ppMergeCond, ppOnCond); +static int32_t pushDownCondOptPartJoinOnCond(SJoinLogicNode* pJoin, SNode** ppPrimKeyEqCond, SNode** ppOnCond) { + if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pOtherOnCond) && + LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)(pJoin->pOtherOnCond))->condType) { + return pushDownCondOptPartJoinOnCondLogicCond(pJoin, ppPrimKeyEqCond, ppOnCond); } - if (pushDownCondOptIsPriKeyEqualCond(pJoin, pJoin->pOnConditions)) { - *ppMergeCond = nodesCloneNode(pJoin->pOnConditions); + if (pushDownCondOptIsPriKeyEqualCond(pJoin, pJoin->pOtherOnCond)) { + *ppPrimKeyEqCond = pJoin->pOtherOnCond; *ppOnCond = NULL; - nodesDestroyNode(pJoin->pOnConditions); - pJoin->pOnConditions = NULL; + pJoin->pOtherOnCond = NULL; return TSDB_CODE_SUCCESS; } else { return TSDB_CODE_PLAN_INTERNAL_ERROR; } } -static int32_t pushDownCondOptJoinExtractMergeCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { +static int32_t pushDownCondOptJoinExtractCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { int32_t code = pushDownCondOptCheckJoinOnCond(pCxt, pJoin); - SNode* pJoinMergeCond = NULL; + SNode* pPrimKeyEqCond = NULL; SNode* pJoinOnCond = NULL; if (TSDB_CODE_SUCCESS == code) { - code = pushDownCondOptPartJoinOnCond(pJoin, &pJoinMergeCond, &pJoinOnCond); + code = pushDownCondOptPartJoinOnCond(pJoin, &pPrimKeyEqCond, &pJoinOnCond); } if (TSDB_CODE_SUCCESS == code) { - pJoin->pMergeCondition = pJoinMergeCond; - pJoin->pOnConditions = pJoinOnCond; + pJoin->pPrimKeyEqCond = pPrimKeyEqCond; + pJoin->pOtherOnCond = pJoinOnCond; } else { - nodesDestroyNode(pJoinMergeCond); + nodesDestroyNode(pPrimKeyEqCond); nodesDestroyNode(pJoinOnCond); } return code; @@ -769,85 +807,168 @@ static bool pushDownCondOptIsTableColumn(SNode* pNode, SNodeList* pTableCols) { return pushDownCondOptBelongThisTable(pNode, pTableCols); } -static bool pushDownCondOptIsColEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond) { +static bool pushDownCondOptIsColEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* allTags) { if (QUERY_NODE_OPERATOR != nodeType(pCond)) { return false; } SOperatorNode* pOper = (SOperatorNode*)pCond; - if (OP_TYPE_EQUAL != pOper->opType) { - return false; - } if (QUERY_NODE_COLUMN != nodeType(pOper->pLeft) || QUERY_NODE_COLUMN != nodeType(pOper->pRight)) { return false; } SColumnNode* pLeft = (SColumnNode*)(pOper->pLeft); SColumnNode* pRight = (SColumnNode*)(pOper->pRight); - // TODO: add cast to operator and remove this restriction of optimization + + *allTags = (COLUMN_TYPE_TAG == pLeft->colType) && (COLUMN_TYPE_TAG == pRight->colType); + + if (OP_TYPE_EQUAL != pOper->opType) { + return false; + } + if (pLeft->node.resType.type != pRight->node.resType.type || pLeft->node.resType.bytes != pRight->node.resType.bytes) { return false; } SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets; SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets; + bool isEqual = false; if (pushDownCondOptIsTableColumn(pOper->pLeft, pLeftCols)) { - return pushDownCondOptIsTableColumn(pOper->pRight, pRightCols); + isEqual = pushDownCondOptIsTableColumn(pOper->pRight, pRightCols); } else if (pushDownCondOptIsTableColumn(pOper->pLeft, pRightCols)) { - return pushDownCondOptIsTableColumn(pOper->pRight, pLeftCols); + isEqual = pushDownCondOptIsTableColumn(pOper->pRight, pLeftCols); } - return false; + if (isEqual) { + } + return isEqual; } -static int32_t pushDownCondOptJoinExtractColEqualOnLogicCond(SJoinLogicNode* pJoin) { - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(pJoin->pOnConditions); +static int32_t pushDownCondOptJoinExtractEqualOnLogicCond(SJoinLogicNode* pJoin) { + SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(pJoin->pOtherOnCond); int32_t code = TSDB_CODE_SUCCESS; - SNodeList* pEqualOnConds = NULL; + SNodeList* pColEqOnConds = NULL; + SNodeList* pTagEqOnConds = NULL; + SNodeList* pTagOnConds = NULL; SNode* pCond = NULL; + bool allTags = false; FOREACH(pCond, pLogicCond->pParameterList) { - if (pushDownCondOptIsColEqualOnCond(pJoin, pCond)) { - code = nodesListMakeAppend(&pEqualOnConds, nodesCloneNode(pCond)); + allTags = false; + if (pushDownCondOptIsColEqualOnCond(pJoin, pCond, &allTags)) { + if (allTags) { + code = nodesListMakeAppend(&pTagEqOnConds, nodesCloneNode(pCond)); + } else { + code = nodesListMakeAppend(&pColEqOnConds, nodesCloneNode(pCond)); + } + } else if (allTags) { + code = nodesListMakeAppend(&pTagOnConds, nodesCloneNode(pCond)); + } + if (code) { + break; } } SNode* pTempTagEqCond = NULL; + SNode* pTempColEqCond = NULL; + SNode* pTempTagOnCond = NULL; if (TSDB_CODE_SUCCESS == code) { - code = nodesMergeConds(&pTempTagEqCond, &pEqualOnConds); + code = nodesMergeConds(&pTempColEqCond, &pColEqOnConds); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesMergeConds(&pTempTagEqCond, &pTagEqOnConds); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesMergeConds(&pTempTagOnCond, &pTagOnConds); } if (TSDB_CODE_SUCCESS == code) { - pJoin->pColEqualOnConditions = pTempTagEqCond; + pJoin->pColEqCond = pTempColEqCond; + pJoin->pTagEqCond = pTempTagEqCond; + pJoin->pTagOnCond = pTempTagOnCond; return TSDB_CODE_SUCCESS; } else { - nodesDestroyList(pEqualOnConds); + nodesDestroyList(pColEqOnConds); + nodesDestroyList(pTagEqOnConds); return TSDB_CODE_PLAN_INTERNAL_ERROR; } return TSDB_CODE_SUCCESS; } -static int32_t pushDownCondOptJoinExtractColEqualOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { - if (NULL == pJoin->pOnConditions) { - pJoin->pColEqualOnConditions = NULL; +static int32_t pushDownCondOptJoinExtractEqualOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { + if (NULL == pJoin->pOtherOnCond) { + pJoin->pColEqCond = NULL; + pJoin->pTagEqCond = NULL; return TSDB_CODE_SUCCESS; } - if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pOnConditions) && - LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)(pJoin->pOnConditions))->condType) { - return pushDownCondOptJoinExtractColEqualOnLogicCond(pJoin); + if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pOtherOnCond) && + LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)(pJoin->pOtherOnCond))->condType) { + return pushDownCondOptJoinExtractEqualOnLogicCond(pJoin); } - if (pushDownCondOptIsColEqualOnCond(pJoin, pJoin->pOnConditions)) { - pJoin->pColEqualOnConditions = nodesCloneNode(pJoin->pOnConditions); + bool allTags = false; + if (pushDownCondOptIsColEqualOnCond(pJoin, pJoin->pOtherOnCond, &allTags)) { + if (allTags) { + pJoin->pTagEqCond = nodesCloneNode(pJoin->pOtherOnCond); + } else { + pJoin->pColEqCond = nodesCloneNode(pJoin->pOtherOnCond); + } + } else if (allTags) { + pJoin->pTagOnCond = nodesCloneNode(pJoin->pOtherOnCond); } return TSDB_CODE_SUCCESS; } +static int32_t pushDownCondOptAppendFilterCol(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { + if (NULL == pJoin->pOtherOnCond) { + return TSDB_CODE_SUCCESS; + } + + int32_t code = TSDB_CODE_SUCCESS; + SNodeList* pCondCols = nodesMakeList(); + SNodeList* pTargets = NULL; + if (NULL == pCondCols) { + code = TSDB_CODE_OUT_OF_MEMORY; + } else { + code = nodesCollectColumnsFromNode(pJoin->pOtherOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); + } + if (TSDB_CODE_SUCCESS == code) { + code = createColumnByRewriteExprs(pCondCols, &pTargets); + } + + nodesDestroyList(pCondCols); + + if (TSDB_CODE_SUCCESS == code) { + SNode* pNode = NULL; + FOREACH(pNode, pTargets) { + SNode* pTmp = NULL; + bool found = false; + FOREACH(pTmp, pJoin->node.pTargets) { + if (nodesEqualNode(pTmp, pNode)) { + found = true; + break; + } + } + if (!found) { + nodesListStrictAppend(pJoin->node.pTargets, nodesCloneNode(pNode)); + } + } + } + + nodesDestroyList(pTargets); + + return code; +} + + static int32_t pushDownCondOptDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) { if (OPTIMIZE_FLAG_TEST_MASK(pJoin->node.optimizedFlag, OPTIMIZE_FLAG_PUSH_DOWN_CONDE)) { return TSDB_CODE_SUCCESS; } + if (pJoin->joinAlgo != JOIN_ALGO_UNKNOWN) { + return TSDB_CODE_SUCCESS; + } if (NULL == pJoin->node.pConditions) { - int32_t code = pushDownCondOptJoinExtractMergeCond(pCxt, pJoin); + int32_t code = pushDownCondOptJoinExtractCond(pCxt, pJoin); if (TSDB_CODE_SUCCESS == code) { OPTIMIZE_FLAG_SET_MASK(pJoin->node.optimizedFlag, OPTIMIZE_FLAG_PUSH_DOWN_CONDE); pCxt->optimized = true; @@ -872,11 +993,15 @@ static int32_t pushDownCondOptDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* p } if (TSDB_CODE_SUCCESS == code) { - code = pushDownCondOptJoinExtractMergeCond(pCxt, pJoin); + code = pushDownCondOptJoinExtractCond(pCxt, pJoin); } if (TSDB_CODE_SUCCESS == code) { - code = pushDownCondOptJoinExtractColEqualOnCond(pCxt, pJoin); + code = pushDownCondOptJoinExtractEqualOnCond(pCxt, pJoin); + } + + if (TSDB_CODE_SUCCESS == code) { + code = pushDownCondOptAppendFilterCol(pCxt, pJoin); } if (TSDB_CODE_SUCCESS == code) { @@ -1230,6 +1355,7 @@ static int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool group } case QUERY_NODE_LOGIC_PLAN_AGG: case QUERY_NODE_LOGIC_PLAN_PARTITION: + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: *pNotOptimize = true; return TSDB_CODE_SUCCESS; default: @@ -1848,10 +1974,13 @@ static bool eliminateProjOptCanChildConditionUseChildTargets(SLogicNode* pChild, nodesWalkExpr(pChild->pConditions, eliminateProjOptCanUseNewChildTargetsImpl, &cxt); if (!cxt.canUse) return false; } - if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild) && NULL != ((SJoinLogicNode*)pChild)->pOnConditions) { + if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild) && ((SJoinLogicNode*)pChild)->joinAlgo != JOIN_ALGO_UNKNOWN) { + return false; + } + if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild) && ((SJoinLogicNode*)pChild)->pOtherOnCond) { SJoinLogicNode* pJoinLogicNode = (SJoinLogicNode*)pChild; CheckNewChildTargetsCxt cxt = {.pNewChildTargets = pNewChildTargets, .canUse = false}; - nodesWalkExpr(pJoinLogicNode->pOnConditions, eliminateProjOptCanUseNewChildTargetsImpl, &cxt); + nodesWalkExpr(pJoinLogicNode->pOtherOnCond, eliminateProjOptCanUseNewChildTargetsImpl, &cxt); if (!cxt.canUse) return false; } return true; @@ -3057,23 +3186,413 @@ static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog return TSDB_CODE_SUCCESS; } +static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode) { + if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) { + return false; + } + + SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode; + if (pJoin->isSingleTableJoin || NULL == pJoin->pTagEqCond || pNode->pChildren->length != 2 + || pJoin->hasSubQuery || pJoin->joinAlgo != JOIN_ALGO_UNKNOWN || pJoin->isLowLevelJoin) { + if (pJoin->joinAlgo == JOIN_ALGO_UNKNOWN) { + pJoin->joinAlgo = JOIN_ALGO_MERGE; + } + return false; + } + + return true; +} + + +int32_t stbJoinOptAddFuncToScanNode(char* funcName, SScanLogicNode* pScan) { + SFunctionNode* pUidFunc = createFunction(funcName, NULL); + snprintf(pUidFunc->node.aliasName, sizeof(pUidFunc->node.aliasName), "%s.%p", + pUidFunc->functionName, pUidFunc); + nodesListStrictAppend(pScan->pScanPseudoCols, (SNode *)pUidFunc); + return createColumnByRewriteExpr((SNode*)pUidFunc, &pScan->node.pTargets); +} + + +int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) { + SScanLogicNode* pScan = (SScanLogicNode*)pNode; + SJoinLogicNode* pJoinNode = (SJoinLogicNode*)pJoin; + + pScan->scanType = SCAN_TYPE_TAG; + NODES_DESTORY_LIST(pScan->pScanCols); + NODES_DESTORY_NODE(pScan->node.pConditions); + pScan->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; + pScan->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; + pScan->onlyMetaCtbIdx = true; + + SNodeList* pTags = nodesMakeList(); + int32_t code = nodesCollectColumnsFromNode(pJoinNode->pTagEqCond, NULL, COLLECT_COL_TYPE_TAG, &pTags); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCollectColumnsFromNode(pJoinNode->pTagOnCond, NULL, COLLECT_COL_TYPE_TAG, &pTags); + } + if (TSDB_CODE_SUCCESS == code) { + SNode* pTarget = NULL; + SNode* pTag = NULL; + bool found = false; + WHERE_EACH(pTarget, pScan->node.pTargets) { + found = false; + FOREACH(pTag, pTags) { + if (nodesEqualNode(pTarget, pTag)) { + found = true; + break; + } + } + if (!found) { + ERASE_NODE(pScan->node.pTargets); + } else { + WHERE_NEXT; + } + } + } + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptAddFuncToScanNode("_tbuid", pScan); + } + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptAddFuncToScanNode("_vgid", pScan); + } + + if (code) { + nodesDestroyList(pTags); + } + + return code; +} + +static int32_t stbJoinOptCreateTagScanNode(SLogicNode* pJoin, SNodeList** ppList) { + SNodeList* pList = nodesCloneList(pJoin->pChildren); + if (NULL == pList) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + int32_t code = TSDB_CODE_SUCCESS; + SNode* pNode = NULL; + FOREACH(pNode, pList) { + code = stbJoinOptRewriteToTagScan(pJoin, pNode); + if (code) { + break; + } + } + + if (TSDB_CODE_SUCCESS == code) { + *ppList = pList; + } else { + nodesDestroyList(pList); + } + + return code; +} + +static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pChildren, SLogicNode** ppLogic) { + SJoinLogicNode* pOrigJoin = (SJoinLogicNode*)pOrig; + SJoinLogicNode* pJoin = (SJoinLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN); + if (NULL == pJoin) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pJoin->joinType = pOrigJoin->joinType; + pJoin->joinAlgo = JOIN_ALGO_HASH; + pJoin->isSingleTableJoin = pOrigJoin->isSingleTableJoin; + pJoin->hasSubQuery = pOrigJoin->hasSubQuery; + pJoin->node.inputTsOrder = pOrigJoin->node.inputTsOrder; + pJoin->node.groupAction = pOrigJoin->node.groupAction; + pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; + pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; + pJoin->pTagEqCond = nodesCloneNode(pOrigJoin->pTagEqCond); + pJoin->pOtherOnCond = nodesCloneNode(pOrigJoin->pTagOnCond); + + int32_t code = TSDB_CODE_SUCCESS; + pJoin->node.pChildren = pChildren; + + SNode* pNode = NULL; + FOREACH(pNode, pChildren) { + SScanLogicNode* pScan = (SScanLogicNode*)pNode; + SNode* pCol = NULL; + FOREACH(pCol, pScan->pScanPseudoCols) { + if (QUERY_NODE_FUNCTION == nodeType(pCol) && (((SFunctionNode*)pCol)->funcType == FUNCTION_TYPE_TBUID || ((SFunctionNode*)pCol)->funcType == FUNCTION_TYPE_VGID)) { + code = createColumnByRewriteExpr(pCol, &pJoin->node.pTargets); + if (code) { + break; + } + } + } + if (code) { + break; + } + pScan->node.pParent = (SLogicNode*)pJoin; + } + + if (TSDB_CODE_SUCCESS == code) { + *ppLogic = (SLogicNode*)pJoin; + } else { + nodesDestroyNode((SNode*)pJoin); + } + + return code; +} + +static int32_t stbJoinOptCreateTableScanNodes(SLogicNode* pJoin, SNodeList** ppList, bool* srcScan) { + SNodeList* pList = nodesCloneList(pJoin->pChildren); + if (NULL == pList) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + int32_t code = TSDB_CODE_SUCCESS; + int32_t i = 0; + SNode* pNode = NULL; + FOREACH(pNode, pList) { + SScanLogicNode* pScan = (SScanLogicNode*)pNode; + //code = stbJoinOptAddFuncToScanNode("_tbuid", pScan); + //if (code) { + // break; + //} + + pScan->node.dynamicOp = true; + *(srcScan + i++) = pScan->pVgroupList->numOfVgroups <= 1; + + pScan->scanType = SCAN_TYPE_TABLE; + } + + if (TSDB_CODE_SUCCESS == code) { + *ppList = pList; + } else { + nodesDestroyList(pList); + *ppList = NULL; + } + + return code; +} + +static int32_t stbJoinOptCreateGroupCacheNode(SLogicNode* pRoot, SNodeList* pChildren, SLogicNode** ppLogic) { + int32_t code = TSDB_CODE_SUCCESS; + SGroupCacheLogicNode* pGrpCache = (SGroupCacheLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_GROUP_CACHE); + if (NULL == pGrpCache) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + //pGrpCache->node.dynamicOp = true; + pGrpCache->grpColsMayBeNull = false; + pGrpCache->grpByUid = true; + pGrpCache->batchFetch = getBatchScanOptionFromHint(pRoot->pHint); + pGrpCache->node.pChildren = pChildren; + pGrpCache->node.pTargets = nodesMakeList(); + if (NULL == pGrpCache->node.pTargets) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + if (TSDB_CODE_SUCCESS == code) { + SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pChildren, 0); + code = nodesListStrictAppendList(pGrpCache->node.pTargets, nodesCloneList(pScan->node.pTargets)); + } + + SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pChildren, 0); + SNode* pCol = NULL; + FOREACH(pCol, pScan->pScanPseudoCols) { + if (QUERY_NODE_FUNCTION == nodeType(pCol) && (((SFunctionNode*)pCol)->funcType == FUNCTION_TYPE_TBUID || ((SFunctionNode*)pCol)->funcType == FUNCTION_TYPE_VGID)) { + code = createColumnByRewriteExpr(pCol, &pGrpCache->pGroupCols); + if (code) { + break; + } + } + } + + bool hasCond = false; + SNode* pNode = NULL; + FOREACH(pNode, pChildren) { + SScanLogicNode* pScan = (SScanLogicNode*)pNode; + if (pScan->node.pConditions) { + hasCond = true; + } + pScan->node.pParent = (SLogicNode*)pGrpCache; + } + pGrpCache->globalGrp = false; + + if (TSDB_CODE_SUCCESS == code) { + *ppLogic = (SLogicNode*)pGrpCache; + } else { + nodesDestroyNode((SNode*)pGrpCache); + } + + return code; +} + +static void stbJoinOptRemoveTagEqCond(SJoinLogicNode* pJoin) { + if (QUERY_NODE_OPERATOR == nodeType(pJoin->pOtherOnCond) && nodesEqualNode(pJoin->pOtherOnCond, pJoin->pTagEqCond)) { + NODES_DESTORY_NODE(pJoin->pOtherOnCond); + return; + } + if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pOtherOnCond)) { + SLogicConditionNode* pLogic = (SLogicConditionNode*)pJoin->pOtherOnCond; + SNode* pNode = NULL; + FOREACH(pNode, pLogic->pParameterList) { + if (nodesEqualNode(pNode, pJoin->pTagEqCond)) { + ERASE_NODE(pLogic->pParameterList); + break; + } else if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pTagEqCond)) { + SLogicConditionNode* pTags = (SLogicConditionNode*)pJoin->pTagEqCond; + SNode* pTag = NULL; + FOREACH(pTag, pTags->pParameterList) { + if (nodesEqualNode(pTag, pNode)) { + ERASE_NODE(pLogic->pParameterList); + break; + } + } + } + } + + if (pLogic->pParameterList->length <= 0) { + NODES_DESTORY_NODE(pJoin->pOtherOnCond); + } + } +} + +static int32_t stbJoinOptCreateMergeJoinNode(SLogicNode* pOrig, SLogicNode* pChild, SLogicNode** ppLogic) { + SJoinLogicNode* pOrigJoin = (SJoinLogicNode*)pOrig; + SJoinLogicNode* pJoin = (SJoinLogicNode*)nodesCloneNode((SNode*)pOrig); + if (NULL == pJoin) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pJoin->joinAlgo = JOIN_ALGO_MERGE; + //pJoin->node.dynamicOp = true; + + stbJoinOptRemoveTagEqCond(pJoin); + NODES_DESTORY_NODE(pJoin->pTagEqCond); + + SNode* pNode = NULL; + FOREACH(pNode, pJoin->node.pChildren) { + ERASE_NODE(pJoin->node.pChildren); + } + nodesListStrictAppend(pJoin->node.pChildren, (SNode *)pChild); + pChild->pParent = (SLogicNode*)pJoin; + + *ppLogic = (SLogicNode*)pJoin; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* pPrev, SLogicNode* pPost, bool* srcScan, SLogicNode** ppDynNode) { + int32_t code = TSDB_CODE_SUCCESS; + SDynQueryCtrlLogicNode* pDynCtrl = (SDynQueryCtrlLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL); + if (NULL == pDynCtrl) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pDynCtrl->qType = DYN_QTYPE_STB_HASH; + pDynCtrl->stbJoin.batchFetch = getBatchScanOptionFromHint(pRoot->pHint); + memcpy(pDynCtrl->stbJoin.srcScan, srcScan, sizeof(pDynCtrl->stbJoin.srcScan)); + + if (TSDB_CODE_SUCCESS == code) { + pDynCtrl->node.pChildren = nodesMakeList(); + if (NULL == pDynCtrl->node.pChildren) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + + if (TSDB_CODE_SUCCESS == code) { + pDynCtrl->stbJoin.pVgList = nodesMakeList(); + if (NULL == pDynCtrl->stbJoin.pVgList) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + + if (TSDB_CODE_SUCCESS == code) { + pDynCtrl->stbJoin.pUidList = nodesMakeList(); + if (NULL == pDynCtrl->stbJoin.pUidList) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + + SJoinLogicNode* pHJoin = (SJoinLogicNode*)pPrev; + nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 0)); + nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 2)); + nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 1)); + nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 3)); + + if (TSDB_CODE_SUCCESS == code) { + nodesListStrictAppend(pDynCtrl->node.pChildren, (SNode*)pPrev); + nodesListStrictAppend(pDynCtrl->node.pChildren, (SNode*)pPost); + pDynCtrl->node.pTargets = nodesCloneList(pPost->pTargets); + } + + if (TSDB_CODE_SUCCESS == code) { + pPrev->pParent = (SLogicNode*)pDynCtrl; + pPost->pParent = (SLogicNode*)pDynCtrl; + + *ppDynNode = (SLogicNode*)pDynCtrl; + } else { + nodesDestroyNode((SNode*)pDynCtrl); + *ppDynNode = NULL; + } + + return code; +} + +static int32_t stbJoinOptRewriteStableJoin(SOptimizeContext* pCxt, SLogicNode* pJoin, SLogicSubplan* pLogicSubplan) { + SNodeList* pTagScanNodes = NULL; + SNodeList* pTbScanNodes = NULL; + SLogicNode* pGrpCacheNode = NULL; + SLogicNode* pHJoinNode = NULL; + SLogicNode* pMJoinNode = NULL; + SLogicNode* pDynNode = NULL; + bool srcScan[2] = {0}; + + int32_t code = stbJoinOptCreateTagScanNode(pJoin, &pTagScanNodes); + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptCreateTagHashJoinNode(pJoin, pTagScanNodes, &pHJoinNode); + } + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptCreateTableScanNodes(pJoin, &pTbScanNodes, srcScan); + } + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptCreateGroupCacheNode(getLogicNodeRootNode(pJoin), pTbScanNodes, &pGrpCacheNode); + } + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptCreateMergeJoinNode(pJoin, pGrpCacheNode, &pMJoinNode); + } + if (TSDB_CODE_SUCCESS == code) { + code = stbJoinOptCreateDynQueryCtrlNode(getLogicNodeRootNode(pJoin), pHJoinNode, pMJoinNode, srcScan, &pDynNode); + } + if (TSDB_CODE_SUCCESS == code) { + code = replaceLogicNode(pLogicSubplan, pJoin, (SLogicNode*)pDynNode); + } + if (TSDB_CODE_SUCCESS == code) { + nodesDestroyNode((SNode*)pJoin); + pCxt->optimized = true; + } + return code; +} + +static int32_t stableJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { + SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, stbJoinOptShouldBeOptimized); + if (NULL == pNode) { + return TSDB_CODE_SUCCESS; + } + + return stbJoinOptRewriteStableJoin(pCxt, pNode, pLogicSubplan); +} + + // clang-format off static const SOptimizeRule optimizeRuleSet[] = { {.pName = "ScanPath", .optimizeFunc = scanPathOptimize}, {.pName = "PushDownCondition", .optimizeFunc = pushDownCondOptimize}, + {.pName = "StableJoin", .optimizeFunc = stableJoinOptimize}, {.pName = "sortNonPriKeyOptimize", .optimizeFunc = sortNonPriKeyOptimize}, {.pName = "SortPrimaryKey", .optimizeFunc = sortPrimaryKeyOptimize}, {.pName = "SmaIndex", .optimizeFunc = smaIndexOptimize}, {.pName = "PushDownLimit", .optimizeFunc = pushDownLimitOptimize}, {.pName = "PartitionTags", .optimizeFunc = partTagsOptimize}, {.pName = "MergeProjects", .optimizeFunc = mergeProjectsOptimize}, - {.pName = "EliminateProject", .optimizeFunc = eliminateProjOptimize}, - {.pName = "EliminateSetOperator", .optimizeFunc = eliminateSetOpOptimize}, {.pName = "RewriteTail", .optimizeFunc = rewriteTailOptimize}, {.pName = "RewriteUnique", .optimizeFunc = rewriteUniqueOptimize}, {.pName = "LastRowScan", .optimizeFunc = lastRowScanOptimize}, {.pName = "TagScan", .optimizeFunc = tagScanOptimize}, {.pName = "TableCountScan", .optimizeFunc = tableCountScanOptimize}, + {.pName = "EliminateProject", .optimizeFunc = eliminateProjOptimize}, + {.pName = "EliminateSetOperator", .optimizeFunc = eliminateSetOpOptimize}, }; // clang-format on @@ -3086,9 +3605,9 @@ static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) { char* pStr = NULL; nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL); if (NULL == pRuleName) { - qDebugL("before optimize: %s", pStr); + qDebugL("before optimize, JsonPlan: %s", pStr); } else { - qDebugL("apply optimize %s rule: %s", pRuleName, pStr); + qDebugL("apply optimize %s rule, JsonPlan: %s", pRuleName, pStr); } taosMemoryFree(pStr); } @@ -3108,6 +3627,7 @@ static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubpla if (cxt.optimized) { optimized = true; dumpLogicSubplan(optimizeRuleSet[i].pName, pLogicSubplan); + break; } } } while (optimized); diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index c180be173a..7e5a40ee0d 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/source/libs/planner/src/planPhysiCreater.c @@ -53,6 +53,17 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char* pKey) { return sprintf(pKey, "%s", pCol->colName); } return sprintf(pKey, "%s.%s", pCol->tableAlias, pCol->colName); + } else if (QUERY_NODE_FUNCTION == nodeType(pNode)) { + SFunctionNode* pFunc = (SFunctionNode*)pNode; + if (FUNCTION_TYPE_TBNAME == pFunc->funcType) { + SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0); + if (pVal) { + if (NULL != pStmtName && '\0' != pStmtName[0]) { + return sprintf(pKey, "%s.%s", pStmtName, ((SExprNode*)pNode)->aliasName); + } + return sprintf(pKey, "%s.%s", pVal->literal, ((SExprNode*)pNode)->aliasName); + } + } } if (NULL != pStmtName && '\0' != pStmtName[0]) { @@ -366,6 +377,7 @@ static SPhysiNode* makePhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode TSWAP(pPhysiNode->pLimit, pLogicNode->pLimit); TSWAP(pPhysiNode->pSlimit, pLogicNode->pSlimit); + pPhysiNode->dynamicOp = pLogicNode->dynamicOp; pPhysiNode->inputTsOrder = pLogicNode->inputTsOrder; pPhysiNode->outputTsOrder = pLogicNode->outputTsOrder; @@ -681,7 +693,64 @@ static int32_t createScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan, return TSDB_CODE_FAILED; } -static int32_t createJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SJoinLogicNode* pJoinLogicNode, +static int32_t mergeEqCond(SNode** ppDst, SNode** ppSrc) { + if (NULL == *ppSrc) { + return TSDB_CODE_SUCCESS; + } + if (NULL == *ppDst) { + *ppDst = *ppSrc; + *ppSrc = NULL; + return TSDB_CODE_SUCCESS; + } + if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc)) { + TSWAP(*ppDst, *ppSrc); + } + if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppDst)) { + SLogicConditionNode* pLogic = (SLogicConditionNode*)*ppDst; + if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc)) { + nodesListStrictAppendList(pLogic->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList); + ((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL; + } else { + nodesListStrictAppend(pLogic->pParameterList, *ppSrc); + *ppSrc = NULL; + } + nodesDestroyNode(*ppSrc); + *ppSrc = NULL; + return TSDB_CODE_SUCCESS; + } + + SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + if (NULL == pLogicCond) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; + pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; + pLogicCond->condType = LOGIC_COND_TYPE_AND; + pLogicCond->pParameterList = nodesMakeList(); + nodesListStrictAppend(pLogicCond->pParameterList, *ppSrc); + nodesListStrictAppend(pLogicCond->pParameterList, *ppDst); + + *ppDst = (SNode*)pLogicCond; + *ppSrc = NULL; + + return TSDB_CODE_SUCCESS; +} + +static int32_t getJoinDataBlockDescNode(SNodeList* pChildren, int32_t idx, SDataBlockDescNode** ppDesc) { + if (2 == pChildren->length) { + *ppDesc = ((SPhysiNode*)nodesListGetNode(pChildren, idx))->pOutputDataBlockDesc; + } else if (1 == pChildren->length && nodeType(nodesListGetNode(pChildren, 0)) == QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE) { + SGroupCachePhysiNode* pGrpCache = (SGroupCachePhysiNode*)nodesListGetNode(pChildren, 0); + *ppDesc = ((SPhysiNode*)nodesListGetNode(pGrpCache->node.pChildren, idx))->pOutputDataBlockDesc; + } else { + planError("Invalid join children num:%d or child type:%d", pChildren->length, nodeType(nodesListGetNode(pChildren, 0))); + return TSDB_CODE_PLAN_INTERNAL_ERROR; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t createMergeJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SJoinLogicNode* pJoinLogicNode, SPhysiNode** pPhyNode) { SSortMergeJoinPhysiNode* pJoin = (SSortMergeJoinPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pJoinLogicNode, QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN); @@ -689,46 +758,220 @@ static int32_t createJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren return TSDB_CODE_OUT_OF_MEMORY; } + pJoin->joinType = pJoinLogicNode->joinType; + pJoin->node.inputTsOrder = pJoinLogicNode->node.inputTsOrder; + + SDataBlockDescNode* pLeftDesc = NULL; + SDataBlockDescNode* pRightDesc = NULL; + int32_t code = getJoinDataBlockDescNode(pChildren, 0, &pLeftDesc); + if (TSDB_CODE_SUCCESS == code) { + code = getJoinDataBlockDescNode(pChildren, 1, &pRightDesc); + } + + if (TSDB_CODE_SUCCESS == code) { + code = setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pPrimKeyEqCond, + &pJoin->pPrimKeyCond); + } + + if (TSDB_CODE_SUCCESS == code) { + code = setListSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->node.pTargets, + &pJoin->pTargets); + } + + if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pOtherOnCond) { + code = setNodeSlotId(pCxt, ((SPhysiNode*)pJoin)->pOutputDataBlockDesc->dataBlockId, -1, + pJoinLogicNode->pOtherOnCond, &pJoin->pOtherOnCond); + } + + if (TSDB_CODE_SUCCESS == code && ((NULL != pJoinLogicNode->pColEqCond) || (NULL != pJoinLogicNode->pTagEqCond))) { + code = mergeEqCond(&pJoinLogicNode->pColEqCond, &pJoinLogicNode->pTagEqCond); + } + if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pColEqCond) { + code = setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pColEqCond, &pJoin->pColEqCond); + } + if (TSDB_CODE_SUCCESS == code) { + code = setConditionsSlotId(pCxt, (const SLogicNode*)pJoinLogicNode, (SPhysiNode*)pJoin); + } + + if (TSDB_CODE_SUCCESS == code) { + code = addDataBlockSlots(pCxt, pJoin->pTargets, pJoin->node.pOutputDataBlockDesc); + } + + if (TSDB_CODE_SUCCESS == code) { + *pPhyNode = (SPhysiNode*)pJoin; + } else { + nodesDestroyNode((SNode*)pJoin); + } + + return code; +} + +static int32_t extractHashJoinOpCols(int16_t lBlkId, int16_t rBlkId, SNode* pEq, SHashJoinPhysiNode* pJoin) { + if (QUERY_NODE_OPERATOR == nodeType(pEq)) { + SOperatorNode* pOp = (SOperatorNode*)pEq; + SColumnNode* pLeft = (SColumnNode*)pOp->pLeft; + SColumnNode* pRight = (SColumnNode*)pOp->pRight; + if (lBlkId == pLeft->dataBlockId && rBlkId == pRight->dataBlockId) { + nodesListStrictAppend(pJoin->pOnLeft, nodesCloneNode(pOp->pLeft)); + nodesListStrictAppend(pJoin->pOnRight, nodesCloneNode(pOp->pRight)); + } else if (rBlkId == pLeft->dataBlockId && lBlkId == pRight->dataBlockId) { + nodesListStrictAppend(pJoin->pOnLeft, nodesCloneNode(pOp->pRight)); + nodesListStrictAppend(pJoin->pOnRight, nodesCloneNode(pOp->pLeft)); + } else { + planError("Invalid join equal cond, lbid:%d, rbid:%d, oplid:%d, oprid:%d", lBlkId, rBlkId, pLeft->dataBlockId, pRight->dataBlockId); + return TSDB_CODE_PLAN_INTERNAL_ERROR; + } + + return TSDB_CODE_SUCCESS; + } + + planError("Invalid join equal node type:%d", nodeType(pEq)); + return TSDB_CODE_PLAN_INTERNAL_ERROR; +} + +static int32_t extractHashJoinOnCols(int16_t lBlkId, int16_t rBlkId, SNode* pEq, SHashJoinPhysiNode* pJoin) { + if (NULL == pEq) { + return TSDB_CODE_SUCCESS; + } + + int32_t code = TSDB_CODE_SUCCESS; + if (QUERY_NODE_OPERATOR == nodeType(pEq)) { + code = extractHashJoinOpCols(lBlkId, rBlkId, pEq, pJoin); + } else if (QUERY_NODE_LOGIC_CONDITION == nodeType(pEq)) { + SLogicConditionNode* pLogic = (SLogicConditionNode*)pEq; + SNode* pNode = NULL; + FOREACH(pNode, pLogic->pParameterList) { + code = extractHashJoinOpCols(lBlkId, rBlkId, pNode, pJoin); + if (code) { + break; + } + } + } else { + planError("Invalid join equal node type:%d", nodeType(pEq)); + return TSDB_CODE_PLAN_INTERNAL_ERROR; + } + + return code; +} + +static int32_t createHashJoinColList(int16_t lBlkId, int16_t rBlkId, SNode* pEq1, SNode* pEq2, SNode* pEq3, SHashJoinPhysiNode* pJoin) { + int32_t code = TSDB_CODE_SUCCESS; + pJoin->pOnLeft = nodesMakeList(); + pJoin->pOnRight = nodesMakeList(); + if (NULL == pJoin->pOnLeft || NULL == pJoin->pOnRight) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + code = extractHashJoinOnCols(lBlkId, rBlkId, pEq1, pJoin); + if (TSDB_CODE_SUCCESS == code) { + code = extractHashJoinOnCols(lBlkId, rBlkId, pEq2, pJoin); + } + if (TSDB_CODE_SUCCESS == code) { + code = extractHashJoinOnCols(lBlkId, rBlkId, pEq3, pJoin); + } + if (TSDB_CODE_SUCCESS == code && pJoin->pOnLeft->length <= 0) { + planError("Invalid join equal column num: %d", pJoin->pOnLeft->length); + code = TSDB_CODE_PLAN_INTERNAL_ERROR; + } + + return code; +} + +static int32_t sortHashJoinTargets(int16_t lBlkId, int16_t rBlkId, SHashJoinPhysiNode* pJoin) { + SNode* pNode = NULL; + char name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN]; + SSHashObj* pHash = tSimpleHashInit(pJoin->pTargets->length, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY)); + if (NULL == pHash) { + return TSDB_CODE_OUT_OF_MEMORY; + } + SNodeList* pNew = nodesMakeList(); + + FOREACH(pNode, pJoin->pTargets) { + SColumnNode* pCol = (SColumnNode*)pNode; + int32_t len = getSlotKey(pNode, NULL, name); + tSimpleHashPut(pHash, name, len, &pCol, POINTER_BYTES); + } + + nodesClearList(pJoin->pTargets); + pJoin->pTargets = pNew; + + FOREACH(pNode, pJoin->pOnLeft) { + SColumnNode* pCol = (SColumnNode*)pNode; + int32_t len = getSlotKey(pNode, NULL, name); + SNode** p = tSimpleHashGet(pHash, name, len); + if (p) { + nodesListStrictAppend(pJoin->pTargets, *p); + tSimpleHashRemove(pHash, name, len); + } + } + FOREACH(pNode, pJoin->pOnRight) { + SColumnNode* pCol = (SColumnNode*)pNode; + int32_t len = getSlotKey(pNode, NULL, name); + SNode** p = tSimpleHashGet(pHash, name, len); + if (p) { + nodesListStrictAppend(pJoin->pTargets, *p); + tSimpleHashRemove(pHash, name, len); + } + } + + if (tSimpleHashGetSize(pHash) > 0) { + SNode** p = NULL; + int32_t iter = 0; + while (1) { + p = tSimpleHashIterate(pHash, p, &iter); + if (p == NULL) { + break; + } + + nodesListStrictAppend(pJoin->pTargets, *p); + } + } + + tSimpleHashCleanup(pHash); + + return TSDB_CODE_SUCCESS; +} + +static int32_t createHashJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SJoinLogicNode* pJoinLogicNode, + SPhysiNode** pPhyNode) { + SHashJoinPhysiNode* pJoin = + (SHashJoinPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pJoinLogicNode, QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN); + if (NULL == pJoin) { + return TSDB_CODE_OUT_OF_MEMORY; + } + SDataBlockDescNode* pLeftDesc = ((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc; SDataBlockDescNode* pRightDesc = ((SPhysiNode*)nodesListGetNode(pChildren, 1))->pOutputDataBlockDesc; int32_t code = TSDB_CODE_SUCCESS; pJoin->joinType = pJoinLogicNode->joinType; pJoin->node.inputTsOrder = pJoinLogicNode->node.inputTsOrder; - setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pMergeCondition, - &pJoin->pMergeCondition); + + code = setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pPrimKeyEqCond, &pJoin->pPrimKeyCond); if (TSDB_CODE_SUCCESS == code) { - code = setListSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->node.pTargets, - &pJoin->pTargets); + code = setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pColEqCond, &pJoin->pColEqCond); + } + if (TSDB_CODE_SUCCESS == code) { + code = setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pTagEqCond, &pJoin->pTagEqCond); + } + if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pOtherOnCond) { + code = setNodeSlotId(pCxt, ((SPhysiNode*)pJoin)->pOutputDataBlockDesc->dataBlockId, -1, pJoinLogicNode->pOtherOnCond, &pJoin->pFilterConditions); } if (TSDB_CODE_SUCCESS == code) { - code = addDataBlockSlots(pCxt, pJoin->pTargets, pJoin->node.pOutputDataBlockDesc); - } - - if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pOnConditions) { - SNodeList* pCondCols = nodesMakeList(); - if (NULL == pCondCols) { - code = TSDB_CODE_OUT_OF_MEMORY; - } else { - code = nodesCollectColumnsFromNode(pJoinLogicNode->pOnConditions, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); - } - if (TSDB_CODE_SUCCESS == code) { - code = addDataBlockSlots(pCxt, pCondCols, pJoin->node.pOutputDataBlockDesc); - } - nodesDestroyList(pCondCols); - } - - if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pOnConditions) { - code = setNodeSlotId(pCxt, ((SPhysiNode*)pJoin)->pOutputDataBlockDesc->dataBlockId, -1, - pJoinLogicNode->pOnConditions, &pJoin->pOnConditions); - } - - if (TSDB_CODE_SUCCESS == code && NULL != pJoinLogicNode->pColEqualOnConditions) { - code = setNodeSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->pColEqualOnConditions, &pJoin->pColEqualOnConditions); + code = setListSlotId(pCxt, pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoinLogicNode->node.pTargets, &pJoin->pTargets); } if (TSDB_CODE_SUCCESS == code) { code = setConditionsSlotId(pCxt, (const SLogicNode*)pJoinLogicNode, (SPhysiNode*)pJoin); } + if (TSDB_CODE_SUCCESS == code) { + code = createHashJoinColList(pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoin->pPrimKeyCond, pJoin->pColEqCond, pJoin->pTagEqCond, pJoin); + } + if (TSDB_CODE_SUCCESS == code) { + code = sortHashJoinTargets(pLeftDesc->dataBlockId, pRightDesc->dataBlockId, pJoin); + } + if (TSDB_CODE_SUCCESS == code) { + code = addDataBlockSlots(pCxt, pJoin->pTargets, pJoin->node.pOutputDataBlockDesc); + } if (TSDB_CODE_SUCCESS == code) { *pPhyNode = (SPhysiNode*)pJoin; @@ -739,6 +982,105 @@ static int32_t createJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren return code; } +static int32_t createJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SJoinLogicNode* pJoinLogicNode, + SPhysiNode** pPhyNode) { + switch (pJoinLogicNode->joinAlgo) { + case JOIN_ALGO_MERGE: + return createMergeJoinPhysiNode(pCxt, pChildren, pJoinLogicNode, pPhyNode); + case JOIN_ALGO_HASH: + return createHashJoinPhysiNode(pCxt, pChildren, pJoinLogicNode, pPhyNode); + default: + planError("Invalid join algorithm:%d", pJoinLogicNode->joinAlgo); + break; + } + + return TSDB_CODE_FAILED; +} + +static int32_t createGroupCachePhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SGroupCacheLogicNode* pLogicNode, + SPhysiNode** pPhyNode) { + SGroupCachePhysiNode* pGrpCache = + (SGroupCachePhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pLogicNode, QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE); + if (NULL == pGrpCache) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pGrpCache->grpColsMayBeNull = pLogicNode->grpColsMayBeNull; + pGrpCache->grpByUid = pLogicNode->grpByUid; + pGrpCache->globalGrp = pLogicNode->globalGrp; + pGrpCache->batchFetch = pLogicNode->batchFetch; + SDataBlockDescNode* pChildDesc = ((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc; + int32_t code = TSDB_CODE_SUCCESS; +/* + if (TSDB_CODE_SUCCESS == code) { + code = setListSlotId(pCxt, pChildDesc->dataBlockId, -1, pLogicNode->pGroupCols, &pGrpCache->pGroupCols); + } +*/ + + if (TSDB_CODE_SUCCESS == code) { + *pPhyNode = (SPhysiNode*)pGrpCache; + } else { + nodesDestroyNode((SNode*)pGrpCache); + } + + return code; +} + +static int32_t updateDynQueryCtrlStbJoinInfo(SPhysiPlanContext* pCxt, SNodeList* pChildren, SDynQueryCtrlLogicNode* pLogicNode, + SDynQueryCtrlPhysiNode* pDynCtrl) { + SDataBlockDescNode* pPrevDesc = ((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc; + SNodeList* pVgList = NULL; + SNodeList* pUidList = NULL; + int32_t code = setListSlotId(pCxt, pPrevDesc->dataBlockId, -1, pLogicNode->stbJoin.pVgList, &pVgList); + if (TSDB_CODE_SUCCESS == code) { + code = setListSlotId(pCxt, pPrevDesc->dataBlockId, -1, pLogicNode->stbJoin.pUidList, &pUidList); + } + if (TSDB_CODE_SUCCESS == code) { + memcpy(pDynCtrl->stbJoin.srcScan, pLogicNode->stbJoin.srcScan, sizeof(pDynCtrl->stbJoin.srcScan)); + + SNode* pNode = NULL; + int32_t i = 0; + FOREACH(pNode, pVgList) { + pDynCtrl->stbJoin.vgSlot[i] = ((SColumnNode*)pNode)->slotId; + ++i; + } + i = 0; + FOREACH(pNode, pUidList) { + pDynCtrl->stbJoin.uidSlot[i] = ((SColumnNode*)pNode)->slotId; + ++i; + } + pDynCtrl->stbJoin.batchFetch = pLogicNode->stbJoin.batchFetch; + } + + return code; +} + +static int32_t createDynQueryCtrlPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SDynQueryCtrlLogicNode* pLogicNode, + SPhysiNode** pPhyNode) { + int32_t code = TSDB_CODE_SUCCESS; + SDynQueryCtrlPhysiNode* pDynCtrl = + (SDynQueryCtrlPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pLogicNode, QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL); + if (NULL == pDynCtrl) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + switch (pLogicNode->qType) { + case DYN_QTYPE_STB_HASH: + code = updateDynQueryCtrlStbJoinInfo(pCxt, pChildren, pLogicNode, pDynCtrl); + break; + default: + planError("Invalid dyn query ctrl type:%d", pLogicNode->qType); + return TSDB_CODE_PLAN_INTERNAL_ERROR; + } + + if (TSDB_CODE_SUCCESS == code) { + pDynCtrl->qType = pLogicNode->qType; + *pPhyNode = (SPhysiNode*)pDynCtrl; + } + + return code; +} + typedef struct SRewritePrecalcExprsCxt { int32_t errCode; int32_t planNodeId; @@ -1655,6 +1997,10 @@ static int32_t doCreatePhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode return createInterpFuncPhysiNode(pCxt, pChildren, (SInterpFuncLogicNode*)pLogicNode, pPhyNode); case QUERY_NODE_LOGIC_PLAN_MERGE: return createMergePhysiNode(pCxt, (SMergeLogicNode*)pLogicNode, pPhyNode); + case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: + return createGroupCachePhysiNode(pCxt, pChildren, (SGroupCacheLogicNode*)pLogicNode, pPhyNode); + case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: + return createDynQueryCtrlPhysiNode(pCxt, pChildren, (SDynQueryCtrlLogicNode*)pLogicNode, pPhyNode); default: break; } diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c index 868aee7147..b8cb72b7c9 100644 --- a/source/libs/planner/src/planSpliter.c +++ b/source/libs/planner/src/planSpliter.c @@ -108,6 +108,7 @@ static int32_t splCreateExchangeNode(SSplitContext* pCxt, SLogicNode* pChild, SE pExchange->srcStartGroupId = pCxt->groupId; pExchange->srcEndGroupId = pCxt->groupId; pExchange->node.precision = pChild->precision; + pExchange->node.dynamicOp = pChild->dynamicOp; pExchange->node.pTargets = nodesCloneList(pChild->pTargets); if (NULL == pExchange->node.pTargets) { return TSDB_CODE_OUT_OF_MEMORY; @@ -280,7 +281,7 @@ static bool stbSplNeedSplitWindow(bool streamQuery, SLogicNode* pNode) { } static bool stbSplNeedSplitJoin(bool streamQuery, SJoinLogicNode* pJoin) { - if (pJoin->isSingleTableJoin) { + if (pJoin->isSingleTableJoin || JOIN_ALGO_HASH == pJoin->joinAlgo) { return false; } SNode* pChild = NULL; @@ -1171,7 +1172,11 @@ static int32_t stbSplSplitJoinNodeImpl(SSplitContext* pCxt, SLogicSubplan* pSubp SNode* pChild = NULL; FOREACH(pChild, pJoin->node.pChildren) { if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pChild)) { - code = stbSplSplitMergeScanNode(pCxt, pSubplan, (SScanLogicNode*)pChild, false); + //if (pJoin->node.dynamicOp) { + // code = TSDB_CODE_SUCCESS; + //} else { + code = stbSplSplitMergeScanNode(pCxt, pSubplan, (SScanLogicNode*)pChild, false); + //} } else if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild)) { code = stbSplSplitJoinNodeImpl(pCxt, pSubplan, (SJoinLogicNode*)pChild); } else { @@ -1187,7 +1192,9 @@ static int32_t stbSplSplitJoinNodeImpl(SSplitContext* pCxt, SLogicSubplan* pSubp static int32_t stbSplSplitJoinNode(SSplitContext* pCxt, SStableSplitInfo* pInfo) { int32_t code = stbSplSplitJoinNodeImpl(pCxt, pInfo->pSubplan, (SJoinLogicNode*)pInfo->pSplitNode); if (TSDB_CODE_SUCCESS == code) { - pInfo->pSubplan->subplanType = SUBPLAN_TYPE_MERGE; + //if (!pInfo->pSplitNode->dynamicOp) { + pInfo->pSubplan->subplanType = SUBPLAN_TYPE_MERGE; + //} SPLIT_FLAG_SET_MASK(pInfo->pSubplan->splitFlag, SPLIT_FLAG_STABLE_SPLIT); } return code; @@ -1589,9 +1596,9 @@ static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) { char* pStr = NULL; nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL); if (NULL == pRuleName) { - qDebugL("before split: %s", pStr); + qDebugL("before split, JsonPlan: %s", pStr); } else { - qDebugL("apply split %s rule: %s", pRuleName, pStr); + qDebugL("apply split %s rule, JsonPlan: %s", pRuleName, pStr); } taosMemoryFree(pStr); } diff --git a/source/libs/planner/src/planUtil.c b/source/libs/planner/src/planUtil.c index 9febe102f6..dcdc402c8b 100644 --- a/source/libs/planner/src/planUtil.c +++ b/source/libs/planner/src/planUtil.c @@ -22,6 +22,8 @@ static char* getUsageErrFormat(int32_t errCode) { return "left.ts = right.ts is expected in join expression"; case TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN: return "not support cross join"; + case TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND: + return "Not supported join conditions"; default: break; } @@ -63,6 +65,16 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) { } pCol->node.resType = pExpr->resType; strcpy(pCol->colName, pExpr->aliasName); + if (QUERY_NODE_FUNCTION == nodeType(pNode)) { + SFunctionNode* pFunc = (SFunctionNode*)pNode; + if (pFunc->funcType == FUNCTION_TYPE_TBNAME) { + SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0); + if (NULL != pVal) { + strcpy(pCol->tableAlias, pVal->literal); + strcpy(pCol->tableName, pVal->literal); + } + } + } return (TSDB_CODE_SUCCESS == nodesListStrictAppend(pCxt->pList, (SNode*)pCol) ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR); } @@ -108,6 +120,7 @@ int32_t createColumnByRewriteExpr(SNode* pExpr, SNodeList** pList) { } int32_t replaceLogicNode(SLogicSubplan* pSubplan, SLogicNode* pOld, SLogicNode* pNew) { + pNew->stmtRoot = pOld->stmtRoot; if (NULL == pOld->pParent) { pSubplan->pNode = (SLogicNode*)pNew; pNew->pParent = NULL; @@ -125,6 +138,19 @@ int32_t replaceLogicNode(SLogicSubplan* pSubplan, SLogicNode* pOld, SLogicNode* return TSDB_CODE_PLAN_INTERNAL_ERROR; } +SLogicNode* getLogicNodeRootNode(SLogicNode* pCurr) { + while (pCurr) { + if (pCurr->stmtRoot || NULL == pCurr->pParent) { + return pCurr; + } + + pCurr = pCurr->pParent; + } + + return NULL; +} + + static int32_t adjustScanDataRequirement(SScanLogicNode* pScan, EDataOrderLevel requirement) { if ((SCAN_TYPE_TABLE != pScan->scanType && SCAN_TYPE_TABLE_MERGE != pScan->scanType) || DATA_ORDER_LEVEL_GLOBAL == pScan->node.requireDataOrder) { @@ -387,6 +413,48 @@ static bool stbHasPartTag(SNodeList* pPartKeys) { return false; } +bool getBatchScanOptionFromHint(SNodeList* pList) { + SNode* pNode = NULL; + bool batchScan = true; + FOREACH(pNode, pList) { + SHintNode* pHint = (SHintNode*)pNode; + if (pHint->option == HINT_BATCH_SCAN) { + batchScan = true; + break; + } else if (pHint->option == HINT_NO_BATCH_SCAN) { + batchScan = false; + break; + } + } + + return batchScan; +} + +int32_t collectTableAliasFromNodes(SNode* pNode, SSHashObj** ppRes) { + int32_t code = TSDB_CODE_SUCCESS; + SLogicNode* pCurr = (SLogicNode*)pNode; + FOREACH(pNode, pCurr->pTargets) { + SColumnNode* pCol = (SColumnNode*)pNode; + if (NULL == *ppRes) { + *ppRes = tSimpleHashInit(5, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY)); + if (NULL == *ppRes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + tSimpleHashPut(*ppRes, pCol->tableAlias, strlen(pCol->tableAlias), NULL, 0); + } + + FOREACH(pNode, pCurr->pChildren) { + code = collectTableAliasFromNodes(pNode, ppRes); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + + return TSDB_CODE_SUCCESS; +} + bool isPartTagAgg(SAggLogicNode* pAgg) { if (1 != LIST_LENGTH(pAgg->node.pChildren)) { return false; diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c index 2fcc8510d4..6dd9c544cc 100644 --- a/source/libs/planner/src/planner.c +++ b/source/libs/planner/src/planner.c @@ -33,7 +33,7 @@ static void dumpQueryPlan(SQueryPlan* pPlan) { } char* pStr = NULL; nodesNodeToString((SNode*)pPlan, false, &pStr, NULL); - planDebugL("QID:0x%" PRIx64 " Query Plan: %s", pPlan->queryId, pStr); + planDebugL("QID:0x%" PRIx64 " Query Plan, JsonPlan: %s", pPlan->queryId, pStr); taosMemoryFree(pStr); } diff --git a/source/libs/qworker/inc/qwInt.h b/source/libs/qworker/inc/qwInt.h index 4bc357d7dd..8797a8cf6b 100644 --- a/source/libs/qworker/inc/qwInt.h +++ b/source/libs/qworker/inc/qwInt.h @@ -120,9 +120,11 @@ typedef struct SQWTaskCtx { int8_t explain; int8_t needFetch; int8_t localExec; + int8_t dynamicTask; int32_t queryMsgType; int32_t fetchMsgType; int32_t level; + int32_t dynExecId; uint64_t sId; bool queryGotData; @@ -142,7 +144,7 @@ typedef struct SQWTaskCtx { SArray *explainRes; void *taskHandle; void *sinkHandle; - STbVerInfo tbInfo; + SArray *tbInfo; // STbVerInfo } SQWTaskCtx; typedef struct SQWSchStatus { @@ -385,7 +387,7 @@ int32_t qwGetTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx); int32_t qwAddAcquireTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx); void qwReleaseTaskCtx(SQWorker *mgmt, void *ctx); int32_t qwKillTaskHandle(SQWTaskCtx *ctx, int32_t rspCode); -int32_t qwUpdateTaskStatus(QW_FPARAMS_DEF, int8_t status); +int32_t qwUpdateTaskStatus(QW_FPARAMS_DEF, int8_t status, bool dynamicTask); int32_t qwDropTask(QW_FPARAMS_DEF); void qwSaveTbVersionInfo(qTaskInfo_t pTaskInfo, SQWTaskCtx *ctx); int32_t qwOpenRef(void); @@ -395,9 +397,10 @@ int64_t qwGetTimeInQueue(SQWorker *mgmt, EQueueType type); void qwClearExpiredSch(SQWorker *mgmt, SArray *pExpiredSch); int32_t qwAcquireScheduler(SQWorker *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch); void qwFreeTaskCtx(SQWTaskCtx *ctx); +int32_t qwHandleTaskComplete(QW_FPARAMS_DEF, SQWTaskCtx *ctx); void qwDbgDumpMgmtInfo(SQWorker *mgmt); -int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, bool *ignore); +int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, bool *ignore, bool dynamicTask); int32_t qwDbgBuildAndSendRedirectRsp(int32_t rspType, SRpcHandleInfo *pConn, int32_t code, SEpSet *pEpSet); int32_t qwAddTaskCtx(QW_FPARAMS_DEF); void qwDbgSimulateRedirect(SQWMsg *qwMsg, SQWTaskCtx *ctx, bool *rsped); diff --git a/source/libs/qworker/src/qwDbg.c b/source/libs/qworker/src/qwDbg.c index f2e48918ab..d28667d247 100644 --- a/source/libs/qworker/src/qwDbg.c +++ b/source/libs/qworker/src/qwDbg.c @@ -17,7 +17,7 @@ SQWDebug gQWDebug = {.lockEnable = false, .sleepSimulate = false, .forceStop = false}; -int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, bool *ignore) { +int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, bool *ignore, bool dynamicTask) { if (!gQWDebug.statusEnable) { return TSDB_CODE_SUCCESS; } @@ -25,7 +25,7 @@ int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, int32_t code = 0; if (oriStatus == newStatus) { - if (newStatus == JOB_TASK_STATUS_EXEC || newStatus == JOB_TASK_STATUS_FAIL) { + if (dynamicTask || newStatus == JOB_TASK_STATUS_EXEC || newStatus == JOB_TASK_STATUS_FAIL) { *ignore = true; return TSDB_CODE_SUCCESS; } @@ -128,11 +128,11 @@ void qwDbgDumpTasksInfo(SQWorker *mgmt) { QW_TASK_DLOG("%p lock:%x, phase:%d, type:%d, explain:%d, needFetch:%d, localExec:%d, queryMsgType:%d, " "sId:%" PRId64 ", level:%d, queryGotData:%d, queryRsped:%d, queryEnd:%d, queryContinue:%d, queryInQueue:%d, " - "rspCode:%x, affectedRows:%" PRId64 ", taskHandle:%p, sinkHandle:%p, tbFName:%s, sver:%d, tver:%d, events:%d,%d,%d,%d,%d", + "rspCode:%x, affectedRows:%" PRId64 ", taskHandle:%p, sinkHandle:%p, tbNum:%d, events:%d,%d,%d,%d,%d", ctx, ctx->lock, ctx->phase, ctx->taskType, ctx->explain, ctx->needFetch, ctx->localExec, ctx->queryMsgType, ctx->sId, ctx->level, ctx->queryGotData, ctx->queryRsped, ctx->queryEnd, ctx->queryContinue, - ctx->queryInQueue, ctx->rspCode, ctx->affectedRows, ctx->taskHandle, ctx->sinkHandle, ctx->tbInfo.tbFName, - ctx->tbInfo.sversion, ctx->tbInfo.tversion, ctx->events[QW_EVENT_CANCEL], ctx->events[QW_EVENT_READY], + ctx->queryInQueue, ctx->rspCode, ctx->affectedRows, ctx->taskHandle, ctx->sinkHandle, (int32_t)taosArrayGetSize(ctx->tbInfo), + ctx->events[QW_EVENT_CANCEL], ctx->events[QW_EVENT_READY], ctx->events[QW_EVENT_FETCH], ctx->events[QW_EVENT_DROP], ctx->events[QW_EVENT_CQUERY]); pIter = taosHashIterate(mgmt->ctxHash, pIter); diff --git a/source/libs/qworker/src/qwMsg.c b/source/libs/qworker/src/qwMsg.c index 508e957e26..0cbcf44ed4 100644 --- a/source/libs/qworker/src/qwMsg.c +++ b/source/libs/qworker/src/qwMsg.c @@ -63,17 +63,11 @@ int32_t qwBuildAndSendErrorRsp(int32_t rspType, SRpcHandleInfo *pConn, int32_t c } int32_t qwBuildAndSendQueryRsp(int32_t rspType, SRpcHandleInfo *pConn, int32_t code, SQWTaskCtx *ctx) { - STbVerInfo *tbInfo = ctx ? &ctx->tbInfo : NULL; int64_t affectedRows = ctx ? ctx->affectedRows : 0; SQueryTableRsp rsp = {0}; rsp.code = code; rsp.affectedRows = affectedRows; - - if (tbInfo) { - strcpy(rsp.tbFName, tbInfo->tbFName); - rsp.sversion = tbInfo->sversion; - rsp.tversion = tbInfo->tversion; - } + rsp.tbVerInfo = ctx->tbInfo; int32_t msgSize = tSerializeSQueryTableRsp(NULL, 0, &rsp); if (msgSize < 0) { @@ -512,7 +506,7 @@ int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int int64_t rId = 0; int32_t eId = req.execId; - SQWMsg qwMsg = {.node = node, .msg = NULL, .msgLen = 0, .connInfo = pMsg->info, .msgType = pMsg->msgType}; + SQWMsg qwMsg = {.node = node, .msg = req.pOpParam, .msgLen = 0, .connInfo = pMsg->info, .msgType = pMsg->msgType}; QW_SCH_TASK_DLOG("processFetch start, node:%p, handle:%p", node, pMsg->info.handle); diff --git a/source/libs/qworker/src/qwUtil.c b/source/libs/qworker/src/qwUtil.c index a342e48cc1..2ce920a9d2 100644 --- a/source/libs/qworker/src/qwUtil.c +++ b/source/libs/qworker/src/qwUtil.c @@ -45,7 +45,7 @@ char *qwBufStatusStr(int32_t bufStatus) { return "UNKNOWN"; } -int32_t qwSetTaskStatus(QW_FPARAMS_DEF, SQWTaskStatus *task, int8_t status) { +int32_t qwSetTaskStatus(QW_FPARAMS_DEF, SQWTaskStatus *task, int8_t status, bool dynamicTask) { int32_t code = 0; int8_t origStatus = 0; bool ignore = false; @@ -53,7 +53,7 @@ int32_t qwSetTaskStatus(QW_FPARAMS_DEF, SQWTaskStatus *task, int8_t status) { while (true) { origStatus = atomic_load_8(&task->status); - QW_ERR_RET(qwDbgValidateStatus(QW_FPARAMS(), origStatus, status, &ignore)); + QW_ERR_RET(qwDbgValidateStatus(QW_FPARAMS(), origStatus, status, &ignore, dynamicTask)); if (ignore) { break; } @@ -312,6 +312,9 @@ void qwFreeTaskCtx(SQWTaskCtx *ctx) { ctx->sinkHandle = NULL; qDebug("sink handle destroyed"); } + + taosArrayDestroy(ctx->tbInfo); + ctx->tbInfo = NULL; } int32_t qwDropTaskCtx(QW_FPARAMS_DEF) { @@ -381,7 +384,7 @@ _return: QW_RET(code); } -int32_t qwUpdateTaskStatus(QW_FPARAMS_DEF, int8_t status) { +int32_t qwUpdateTaskStatus(QW_FPARAMS_DEF, int8_t status, bool dynamicTask) { SQWSchStatus *sch = NULL; SQWTaskStatus *task = NULL; int32_t code = 0; @@ -389,7 +392,7 @@ int32_t qwUpdateTaskStatus(QW_FPARAMS_DEF, int8_t status) { QW_ERR_RET(qwAcquireScheduler(mgmt, sId, QW_READ, &sch)); QW_ERR_JRET(qwAcquireTaskStatus(QW_FPARAMS(), QW_READ, sch, &task)); - QW_ERR_JRET(qwSetTaskStatus(QW_FPARAMS(), task, status)); + QW_ERR_JRET(qwSetTaskStatus(QW_FPARAMS(), task, status, dynamicTask)); _return: @@ -401,7 +404,31 @@ _return: QW_RET(code); } + +int32_t qwHandleDynamicTaskEnd(QW_FPARAMS_DEF) { + char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0}; + QW_SET_QTID(id, qId, tId, eId); + SQWTaskCtx octx; + + SQWTaskCtx *ctx = taosHashGet(mgmt->ctxHash, id, sizeof(id)); + if (NULL == ctx) { + QW_TASK_DLOG_E("task ctx not exist, may be dropped"); + QW_ERR_RET(QW_CTX_NOT_EXISTS_ERR_CODE(mgmt)); + } + + if (!ctx->dynamicTask) { + return TSDB_CODE_SUCCESS; + } + + QW_ERR_RET(qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC, ctx->dynamicTask)); + + QW_ERR_RET(qwHandleTaskComplete(QW_FPARAMS(), ctx)); + + return TSDB_CODE_SUCCESS; +} + int32_t qwDropTask(QW_FPARAMS_DEF) { + QW_ERR_RET(qwHandleDynamicTaskEnd(QW_FPARAMS())); QW_ERR_RET(qwDropTaskStatus(QW_FPARAMS())); QW_ERR_RET(qwDropTaskCtx(QW_FPARAMS())); @@ -438,15 +465,29 @@ void qwSetHbParam(int64_t refId, SQWHbParam **pParam) { } void qwSaveTbVersionInfo(qTaskInfo_t pTaskInfo, SQWTaskCtx *ctx) { - char dbFName[TSDB_DB_FNAME_LEN] = {0}; - char tbName[TSDB_TABLE_NAME_LEN] = {0}; + char dbFName[TSDB_DB_FNAME_LEN]; + char tbName[TSDB_TABLE_NAME_LEN]; + STbVerInfo tbInfo; + int32_t i = 0; - qGetQueryTableSchemaVersion(pTaskInfo, dbFName, tbName, &ctx->tbInfo.sversion, &ctx->tbInfo.tversion); + while (true) { + if (qGetQueryTableSchemaVersion(pTaskInfo, dbFName, tbName, &tbInfo.sversion, &tbInfo.tversion, i) < 0) { + break; + } - if (dbFName[0] && tbName[0]) { - sprintf(ctx->tbInfo.tbFName, "%s.%s", dbFName, tbName); - } else { - ctx->tbInfo.tbFName[0] = 0; + if (dbFName[0] && tbName[0]) { + sprintf(tbInfo.tbFName, "%s.%s", dbFName, tbName); + } else { + tbInfo.tbFName[0] = 0; + } + + if (NULL == ctx->tbInfo) { + ctx->tbInfo = taosArrayInit(1, sizeof(tbInfo)); + } + + taosArrayPush(ctx->tbInfo, &tbInfo); + + i++; } } diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index 6f641e677a..1759cc89f5 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -95,6 +95,7 @@ static void freeItem(void *param) { taosMemoryFree(pInfo->verboseInfo); } + int32_t qwHandleTaskComplete(QW_FPARAMS_DEF, SQWTaskCtx *ctx) { qTaskInfo_t taskHandle = ctx->taskHandle; @@ -203,15 +204,26 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) { } if (numOfResBlock == 0 || (hasMore == false)) { - if (numOfResBlock == 0) { - QW_TASK_DLOG("qExecTask end with empty res, useconds:%" PRIu64, useconds); + if (!ctx->dynamicTask) { + if (numOfResBlock == 0) { + QW_TASK_DLOG("qExecTask end with empty res, useconds:%" PRIu64, useconds); + } else { + QW_TASK_DLOG("qExecTask done, useconds:%" PRIu64, useconds); + } + + QW_ERR_JRET(qwHandleTaskComplete(QW_FPARAMS(), ctx)); } else { - QW_TASK_DLOG("qExecTask done, useconds:%" PRIu64, useconds); + if (numOfResBlock == 0) { + QW_TASK_DLOG("dyn task qExecTask end with empty res, useconds:%" PRIu64, useconds); + } else { + QW_TASK_DLOG("dyn task qExecTask done, useconds:%" PRIu64, useconds); + } + + ctx->queryExecDone = true; } dsEndPut(sinkHandle, useconds); - QW_ERR_JRET(qwHandleTaskComplete(QW_FPARAMS(), ctx)); - + if (queryStop) { *queryStop = true; } @@ -332,7 +344,10 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen, QW_TASK_DLOG("no more data in sink and query end, fetched blocks %d rows %" PRId64, pOutput->numOfBlocks, pOutput->numOfRows); - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC); + if (!ctx->dynamicTask) { + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC, ctx->dynamicTask); + } + if (NULL == rsp) { QW_ERR_RET(qwMallocFetchRsp(!ctx->localExec, len, &rsp)); *pOutput = output; @@ -376,7 +391,7 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen, if (DS_BUF_EMPTY == pOutput->bufStatus && pOutput->queryEnd) { QW_TASK_DLOG("task all data fetched and done, fetched blocks %d rows %" PRId64, pOutput->numOfBlocks, pOutput->numOfRows); - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC); + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC, ctx->dynamicTask); break; } @@ -472,6 +487,40 @@ int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx * ctx, SQWMsg *qwMsg, i return TSDB_CODE_SUCCESS; } +int32_t qwStartDynamicTaskNewExec(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SQWMsg *qwMsg) { +#if 0 + if (!atomic_val_compare_exchange_8((int8_t*)&ctx->queryExecDone, true, false)) { + QW_TASK_ELOG("dynamic task prev exec not finished, execDone:%d", ctx->queryExecDone); + return TSDB_CODE_ACTION_IN_PROGRESS; + } + if (!atomic_val_compare_exchange_8((int8_t*)&ctx->queryEnd, true, false)) { + QW_TASK_ELOG("dynamic task prev exec not finished, queryEnd:%d", ctx->queryEnd); + return TSDB_CODE_ACTION_IN_PROGRESS; + } +#else + ctx->queryExecDone = false; + ctx->queryEnd = false; +#endif + + dsReset(ctx->sinkHandle); + + qUpdateOperatorParam(ctx->taskHandle, qwMsg->msg); + + QW_SET_EVENT_RECEIVED(ctx, QW_EVENT_FETCH); + + if (QW_QUERY_RUNNING(ctx)) { + atomic_store_8((int8_t *)&ctx->queryContinue, 1); + QW_TASK_DLOG("the %dth dynamic task exec started, continue running", ctx->dynExecId++); + } else if (0 == atomic_load_8((int8_t *)&ctx->queryInQueue)) { + atomic_store_8((int8_t *)&ctx->queryInQueue, 1); + QW_TASK_DLOG("the %dth dynamic task exec started", ctx->dynExecId++); + QW_ERR_RET(qwBuildAndSendCQueryMsg(QW_FPARAMS(), &qwMsg->connInfo)); + } + + return TSDB_CODE_SUCCESS; +} + + int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *input, SQWPhaseOutput *output) { int32_t code = 0; SQWTaskCtx *ctx = NULL; @@ -484,7 +533,7 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu QW_SET_PHASE(ctx, phase); - if (atomic_load_8((int8_t *)&ctx->queryEnd)) { + if (atomic_load_8((int8_t *)&ctx->queryEnd) && !ctx->dynamicTask) { QW_TASK_ELOG_E("query already end"); QW_ERR_JRET(TSDB_CODE_QW_MSG_ERROR); } @@ -505,7 +554,7 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu QW_ERR_JRET(ctx->rspCode); } - QW_ERR_JRET(qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXEC)); + QW_ERR_JRET(qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXEC, ctx->dynamicTask)); break; } case QW_PHASE_PRE_FETCH: { @@ -614,7 +663,7 @@ int32_t qwHandlePostPhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inp _return: if (TSDB_CODE_SUCCESS == code && QW_PHASE_POST_QUERY == phase) { - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_PART_SUCC); + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_PART_SUCC, ctx->dynamicTask); ctx->queryGotData = true; } @@ -635,14 +684,14 @@ _return: QW_SET_PHASE(ctx, phase); } + if (code) { + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAIL, ctx->dynamicTask); + } + QW_UNLOCK(QW_WRITE, &ctx->lock); qwReleaseTaskCtx(mgmt, ctx); } - if (code) { - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAIL); - } - QW_TASK_DLOG("end to handle event at phase %s, code:%x - %s", qwPhaseStr(phase), code, tstrerror(code)); QW_RET(code); @@ -725,12 +774,19 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char *sql) { //qwSendQueryRsp(QW_FPARAMS(), qwMsg->msgType + 1, ctx, code, true); ctx->level = plan->level; + ctx->dynamicTask = qIsDynamicExecTask(pTaskInfo); atomic_store_ptr(&ctx->taskHandle, pTaskInfo); atomic_store_ptr(&ctx->sinkHandle, sinkHandle); qwSaveTbVersionInfo(pTaskInfo, ctx); - QW_ERR_JRET(qwExecTask(QW_FPARAMS(), ctx, NULL)); + if (!ctx->dynamicTask) { + QW_ERR_JRET(qwExecTask(QW_FPARAMS(), ctx, NULL)); + } else { + ctx->queryExecDone = true; + ctx->queryEnd = true; + } + _return: taosMemoryFree(sql); @@ -849,6 +905,11 @@ int32_t qwProcessFetch(QW_FPARAMS_DEF, SQWMsg *qwMsg) { ctx->fetchMsgType = qwMsg->msgType; ctx->dataConnInfo = qwMsg->connInfo; + if (qwMsg->msg) { + code = qwStartDynamicTaskNewExec(QW_FPARAMS(), ctx, qwMsg); + goto _return; + } + SOutputData sOutput = {0}; QW_ERR_JRET(qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)); @@ -875,7 +936,7 @@ int32_t qwProcessFetch(QW_FPARAMS_DEF, SQWMsg *qwMsg) { } else if (QW_QUERY_RUNNING(ctx)) { atomic_store_8((int8_t *)&ctx->queryContinue, 1); } else if (0 == atomic_load_8((int8_t *)&ctx->queryInQueue)) { - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXEC); + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_EXEC, ctx->dynamicTask); atomic_store_8((int8_t *)&ctx->queryInQueue, 1); @@ -906,7 +967,7 @@ _return: } if (!rsped) { qwBuildAndSendFetchRsp(qwMsg->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code); - QW_TASK_DLOG("%s send, handle:%p, code:%x - %s, dataLen:%d", TMSG_INFO(qwMsg->msgType + 1), + QW_TASK_DLOG("fetch rsp send, msgType:%s, handle:%p, code:%x - %s, dataLen:%d", TMSG_INFO(qwMsg->msgType + 1), qwMsg->connInfo.handle, code, tstrerror(code), dataLen); } else { qwFreeFetchRsp(rsp); @@ -938,7 +999,7 @@ int32_t qwProcessDrop(QW_FPARAMS_DEF, SQWMsg *qwMsg) { if (QW_QUERY_RUNNING(ctx)) { QW_ERR_JRET(qwKillTaskHandle(ctx, TSDB_CODE_TSC_QUERY_CANCELLED)); - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_DROP); + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_DROP, ctx->dynamicTask); } else { QW_ERR_JRET(qwDropTask(QW_FPARAMS())); dropped = true; @@ -954,9 +1015,8 @@ _return: if (code) { if (ctx) { QW_UPDATE_RSP_CODE(ctx, code); + qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAIL, ctx->dynamicTask); } - - qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_FAIL); } if (locked) { diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index b9af716929..821967dfa4 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -1706,6 +1706,31 @@ int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO return TSDB_CODE_SUCCESS; } +int32_t qTbUidFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + char* p = colDataGetNumData(pInput->columnData, 0); + + int32_t code = colDataSetNItems(pOutput->columnData, pOutput->numOfRows, p, pInput->numOfRows, true); + if (code) { + return code; + } + + pOutput->numOfRows += pInput->numOfRows; + return TSDB_CODE_SUCCESS; +} + +int32_t qVgIdFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + char* p = colDataGetNumData(pInput->columnData, 0); + + int32_t code = colDataSetNItems(pOutput->columnData, pOutput->numOfRows, p, pInput->numOfRows, true); + if (code) { + return code; + } + + pOutput->numOfRows += pInput->numOfRows; + return TSDB_CODE_SUCCESS; +} + + /** Aggregation functions **/ int32_t countScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { SColumnInfoData *pInputData = pInput->columnData; diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c index 78e0807775..d2ed26d405 100644 --- a/source/libs/scheduler/src/schJob.c +++ b/source/libs/scheduler/src/schJob.c @@ -588,7 +588,7 @@ int32_t schLaunchJobLowerLevel(SSchJob *pJob, SSchTask *pTask) { } int32_t schSaveJobExecRes(SSchJob *pJob, SQueryTableRsp *rsp) { - if (rsp->tbFName[0]) { + if (rsp->tbVerInfo) { SCH_LOCK(SCH_WRITE, &pJob->resLock); if (NULL == pJob->execRes.res) { @@ -599,12 +599,9 @@ int32_t schSaveJobExecRes(SSchJob *pJob, SQueryTableRsp *rsp) { } } - STbVerInfo tbInfo; - strcpy(tbInfo.tbFName, rsp->tbFName); - tbInfo.sversion = rsp->sversion; - tbInfo.tversion = rsp->tversion; - - taosArrayPush((SArray *)pJob->execRes.res, &tbInfo); + taosArrayAddBatch((SArray *)pJob->execRes.res, taosArrayGet(rsp->tbVerInfo, 0), taosArrayGetSize(rsp->tbVerInfo)); + taosArrayDestroy(rsp->tbVerInfo); + pJob->execRes.msgType = TDMT_SCH_QUERY; SCH_UNLOCK(SCH_WRITE, &pJob->resLock); diff --git a/source/libs/scheduler/src/schUtil.c b/source/libs/scheduler/src/schUtil.c index 0582184730..df9cde6b7a 100644 --- a/source/libs/scheduler/src/schUtil.c +++ b/source/libs/scheduler/src/schUtil.c @@ -234,7 +234,7 @@ int32_t schUpdateHbConnection(SQueryNodeEpId *epId, SSchTrans *trans) { hb = taosHashGet(schMgmt.hbConnections, epId, sizeof(SQueryNodeEpId)); if (NULL == hb) { SCH_UNLOCK(SCH_READ, &schMgmt.hbLock); - qError("taosHashGet hb connection failed, nodeId:%d, fqdn:%s, port:%d", epId->nodeId, epId->ep.fqdn, epId->ep.port); + qInfo("taosHashGet hb connection not exists, nodeId:%d, fqdn:%s, port:%d", epId->nodeId, epId->ep.fqdn, epId->ep.port); SCH_ERR_RET(TSDB_CODE_APP_ERROR); } diff --git a/source/libs/tdb/src/db/tdbBtree.c b/source/libs/tdb/src/db/tdbBtree.c index 612179b205..a48bae002e 100644 --- a/source/libs/tdb/src/db/tdbBtree.c +++ b/source/libs/tdb/src/db/tdbBtree.c @@ -2198,6 +2198,20 @@ int tdbBtcDelete(SBTC *pBtc) { return -1; } tdbOsFree(pCell); + + if (pPage->nOverflow > 0) { + tdbDebug("tdb/btc-delete: btree balance after update cell, pPage/nOverflow: %p/%d.", pPage, + pPage->nOverflow); + + pBtc->iPage = iPage; + pBtc->pPage = pPage; + ret = tdbBtreeBalance(pBtc); + if (ret < 0) { + tdbError("tdb/btc-delete: btree balance failed with ret: %d.", ret); + return -1; + } + } + break; } else { pgno = TDB_PAGE_PGNO(pPage); diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 466b9985e7..0dc6f1d777 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -408,6 +408,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_IN_GROUP_ERROR, "Json not support in g TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JOB_NOT_EXIST, "Job not exist") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_QWORKER_QUIT, "Vnode/Qnode is quitting") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR, "Geometry not support in this operator") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR, "Executor internal error") // grant TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED, "License expired") @@ -577,6 +578,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR, "Parser internal err TAOS_DEFINE_ERROR(TSDB_CODE_PLAN_INTERNAL_ERROR, "Planner internal error") TAOS_DEFINE_ERROR(TSDB_CODE_PLAN_EXPECTED_TS_EQUAL, "Expect ts equal") TAOS_DEFINE_ERROR(TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN, "Cross join not support") +TAOS_DEFINE_ERROR(TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND, "Not supported join conditions") //function TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_FUNTION_ERROR, "Function internal error") diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task index ac6d3f32da..2a744f4d8e 100644 --- a/tests/parallel_test/cases.task +++ b/tests/parallel_test/cases.task @@ -6,6 +6,10 @@ ,,y,unit-test,bash test.sh #system test +,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stbJoin.py +,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stbJoin.py -Q 2 +,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stbJoin.py -Q 3 +,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stbJoin.py -Q 4 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/nestedQuery.py ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/nestedQuery_str.py ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/nestedQuery_math.py diff --git a/tests/script/tsim/parser/join_multitables.sim b/tests/script/tsim/parser/join_multitables.sim index 6817d2325d..d2f8ea4a88 100644 --- a/tests/script/tsim/parser/join_multitables.sim +++ b/tests/script/tsim/parser/join_multitables.sim @@ -406,7 +406,7 @@ sql insert into tbb_5 values('2021-03-03 05:00:00.000', 99115,99115.0,'b5'); sql insert into tbb_5 values('2021-03-04 05:00:00.000', 99115,99115.0,'b5'); sql insert into tbb_5 values('2021-03-05 05:00:00.000', 99115,99115.0,'b5'); -sql select * from st0, st1 where st0.ts=st1.ts and st0.id1=st1.id1; +sql select * from st0, st1 where st0.ts=st1.ts and st0.id1=st1.id1 order by st0.ts; if $rows != 25 then return -1 endi @@ -442,7 +442,7 @@ if $data09 != @21-03-01 01:00:00.000@ then return -1 endi -sql select * from st0, st1 where st0.ts=st1.ts and st0.id2=st1.id2; +sql select * from st0, st1 where st0.ts=st1.ts and st0.id2=st1.id2 order by st0.ts; if $rows != 25 then return -1 endi @@ -478,7 +478,7 @@ if $data09 != @21-03-01 01:00:00.000@ then return -1 endi -sql select * from st0, st1 where st0.id3=st1.id3 and st1.ts=st0.ts; +sql select * from st0, st1 where st0.id3=st1.id3 and st1.ts=st0.ts order by st0.ts; if $rows != 25 then return -1 endi @@ -514,7 +514,7 @@ if $data09 != @21-03-01 01:00:00.000@ then return -1 endi -sql select * from st0, st1 where st1.id5=st0.id5 and st0.ts=st1.ts; +sql select * from st0, st1 where st1.id5=st0.id5 and st0.ts=st1.ts order by st0.ts; if $rows != 25 then return -1 endi @@ -550,7 +550,7 @@ if $data09 != @21-03-01 01:00:00.000@ then return -1 endi -sql select st0.* from st0, st1 where st0.ts=st1.ts and st0.id1=st1.id1; +sql select st0.* from st0, st1 where st0.ts=st1.ts and st0.id1=st1.id1 order by st0.ts; if $rows != 25 then return -1 endi @@ -583,7 +583,7 @@ if $data08 != 3 then return -1 endi -sql select st0.* from st0, st1 where st0.ts=st1.ts and st1.id2=st0.id2; +sql select st0.* from st0, st1 where st0.ts=st1.ts and st1.id2=st0.id2 order by st0.ts; if $rows != 25 then return -1 endi @@ -616,7 +616,7 @@ if $data08 != 3 then return -1 endi -sql select st0.* from st0, st1 where st0.id3=st1.id3 and st1.ts=st0.ts; +sql select st0.* from st0, st1 where st0.id3=st1.id3 and st1.ts=st0.ts order by st0.ts; if $rows != 25 then return -1 endi @@ -649,7 +649,7 @@ if $data08 != 3 then return -1 endi -sql select st1.* from st0, st1 where st1.id5=st0.id5 and st0.ts=st1.ts; +sql select st1.* from st0, st1 where st1.id5=st0.id5 and st0.ts=st1.ts order by st1.ts; if $rows != 25 then return -1 endi @@ -711,7 +711,7 @@ if $data31 != 9911 then return -1 endi -sql select st0.ts,st1.ts from st0, st1 where st0.ts=st1.ts and st1.id2=st0.id2; +sql select st0.ts,st1.ts from st0, st1 where st0.ts=st1.ts and st1.id2=st0.id2 order by st1.ts; if $rows != 25 then return -1 endi @@ -728,7 +728,7 @@ if $data51 != @21-03-02 01:00:00.000@ then return -1 endi -sql select st1.ts,st0.ts,st0.id3,st1.id3,st0.f3,st1.f3 from st0, st1 where st0.id3=st1.id3 and st1.ts=st0.ts; +sql select st1.ts,st0.ts,st0.id3,st1.id3,st0.f3,st1.f3 from st0, st1 where st0.id3=st1.id3 and st1.ts=st0.ts order by st1.ts; if $rows != 25 then return -1 endi @@ -751,7 +751,7 @@ if $data05 != 11 then return -1 endi -sql select st0.ts,st0.f2,st1.f3,st1.f2,st0.f3 from st0, st1 where st1.id5=st0.id5 and st0.ts=st1.ts; +sql select st0.ts,st0.f2,st1.f3,st1.f2,st0.f3 from st0, st1 where st1.id5=st0.id5 and st0.ts=st1.ts order by st1.ts; if $rows != 25 then return -1 endi @@ -850,7 +850,7 @@ if $data08 != 15 then return -1 endi -sql select st0.*,st1.* from st0, st1 where st1.id1=st0.id1 and st0.ts=st1.ts and st1.ts=st0.ts and st0.id1=st1.id1; +sql select st0.*,st1.* from st0, st1 where st1.id1=st0.id1 and st0.ts=st1.ts and st1.ts=st0.ts and st0.id1=st1.id1 order by st0.ts; if $rows != 25 then return -1 endi @@ -1085,7 +1085,7 @@ endi # return -1 #endi -sql select st0.*,st1.*,st2.*,st3.*,st4.*,st5.*,st6.*,st7.*,st8.*,st9.* from st0,st1,st2,st3,st4,st5,st6,st7,st8,st9 where st0.ts=st2.ts and st0.ts=st4.ts and st0.ts=st6.ts and st0.ts=st8.ts and st1.ts=st3.ts and st3.ts=st5.ts and st5.ts=st7.ts and st7.ts=st9.ts and st0.ts=st1.ts and st0.id1=st2.id1 and st0.id1=st4.id1 and st0.id1=st6.id1 and st0.id1=st8.id1 and st1.id1=st3.id1 and st3.id1=st5.id1 and st5.id1=st7.id1 and st7.id1=st9.id1 and st0.id1=st1.id1; +sql select st0.*,st1.*,st2.*,st3.*,st4.*,st5.*,st6.*,st7.*,st8.*,st9.* from st0,st1,st2,st3,st4,st5,st6,st7,st8,st9 where st0.ts=st2.ts and st0.ts=st4.ts and st0.ts=st6.ts and st0.ts=st8.ts and st1.ts=st3.ts and st3.ts=st5.ts and st5.ts=st7.ts and st7.ts=st9.ts and st0.ts=st1.ts and st0.id1=st2.id1 and st0.id1=st4.id1 and st0.id1=st6.id1 and st0.id1=st8.id1 and st1.id1=st3.id1 and st3.id1=st5.id1 and st5.id1=st7.id1 and st7.id1=st9.id1 and st0.id1=st1.id1 order by st1.ts; if $rows != 25 then return -1 endi diff --git a/tests/system-test/2-query/stbJoin.py b/tests/system-test/2-query/stbJoin.py new file mode 100644 index 0000000000..ce6da6eb1c --- /dev/null +++ b/tests/system-test/2-query/stbJoin.py @@ -0,0 +1,118 @@ +from wsgiref.headers import tspecials +from util.log import * +from util.cases import * +from util.sql import * +import numpy as np + + +class TDTestCase: + def init(self, conn, logSql, replicaVar=1): + self.replicaVar = int(replicaVar) + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + self.rowNum = 10 + self.batchNum = 5 + self.ts = 1537146000000 + + def run(self): + dbname = "db" + tdSql.prepare() + + tdSql.execute(f'''create table sta(ts timestamp, col1 int, col2 bigint) tags(tg1 int, tg2 binary(20))''') + tdSql.execute(f"create table sta1 using sta tags(1, 'a')") + tdSql.execute(f"create table sta2 using sta tags(2, 'b')") + tdSql.execute(f"create table sta3 using sta tags(3, 'c')") + tdSql.execute(f"create table sta4 using sta tags(4, 'a')") + tdSql.execute(f"insert into sta1 values(1537146000001, 11, 110)") + tdSql.execute(f"insert into sta1 values(1537146000002, 12, 120)") + tdSql.execute(f"insert into sta1 values(1537146000003, 13, 130)") + tdSql.execute(f"insert into sta2 values(1537146000001, 21, 210)") + tdSql.execute(f"insert into sta2 values(1537146000002, 22, 220)") + tdSql.execute(f"insert into sta2 values(1537146000003, 23, 230)") + tdSql.execute(f"insert into sta3 values(1537146000001, 31, 310)") + tdSql.execute(f"insert into sta3 values(1537146000002, 32, 320)") + tdSql.execute(f"insert into sta3 values(1537146000003, 33, 330)") + tdSql.execute(f"insert into sta4 values(1537146000001, 41, 410)") + tdSql.execute(f"insert into sta4 values(1537146000002, 42, 420)") + tdSql.execute(f"insert into sta4 values(1537146000003, 43, 430)") + + tdSql.execute(f'''create table stb(ts timestamp, col1 int, col2 bigint) tags(tg1 int, tg2 binary(20))''') + tdSql.execute(f"create table stb1 using stb tags(1, 'a')") + tdSql.execute(f"create table stb2 using stb tags(2, 'b')") + tdSql.execute(f"create table stb3 using stb tags(3, 'c')") + tdSql.execute(f"create table stb4 using stb tags(4, 'a')") + tdSql.execute(f"insert into stb1 values(1537146000001, 911, 9110)") + tdSql.execute(f"insert into stb1 values(1537146000002, 912, 9120)") + tdSql.execute(f"insert into stb1 values(1537146000003, 913, 9130)") + tdSql.execute(f"insert into stb2 values(1537146000001, 921, 9210)") + tdSql.execute(f"insert into stb2 values(1537146000002, 922, 9220)") + tdSql.execute(f"insert into stb2 values(1537146000003, 923, 9230)") + tdSql.execute(f"insert into stb3 values(1537146000001, 931, 9310)") + tdSql.execute(f"insert into stb3 values(1537146000002, 932, 9320)") + tdSql.execute(f"insert into stb3 values(1537146000003, 933, 9330)") + tdSql.execute(f"insert into stb4 values(1537146000001, 941, 9410)") + tdSql.execute(f"insert into stb4 values(1537146000002, 942, 9420)") + tdSql.execute(f"insert into stb4 values(1537146000003, 943, 9430)") + + tdSql.query(f"select * from sta a, stb b where a.ts=b.ts") + tdSql.checkRows(48) + + tdSql.query(f"select * from sta a join stb b on a.tg1=b.tg1 where a.ts=b.ts;") + tdSql.checkRows(12) + + tdSql.query(f"select a.* from sta a join stb b on a.tg1=b.tg1 where a.ts=b.ts;") + tdSql.checkRows(12) + + tdSql.query(f"select b.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts;") + tdSql.checkRows(12) + + tdSql.query(f"select b.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts order by a.ts;") + tdSql.checkRows(12) + + tdSql.query(f"select b.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts order by a.ts, a.tg1;") + tdSql.checkRows(12) + + tdSql.query(f"select b.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts order by a.tg1, a.ts;") + tdSql.checkRows(12) + + tdSql.query(f"select b.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts order by b.tg1, a.ts;") + tdSql.checkRows(12) + + tdSql.query(f"select b.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts order by b.ts, b.tg1;") + tdSql.checkRows(12) + + tdSql.query(f"select a.tg1,a.tg2,b.* from sta a, stb b where (a.tg1=b.tg1 or a.tg2=b.tg2) and a.ts=b.ts;") + tdSql.checkRows(18) + + tdSql.query(f"select a.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts and a.tg2=b.tg2;") + tdSql.checkRows(12) + + tdSql.query(f"select a.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts and a.tg2 > 'a';") + tdSql.checkRows(6) + + tdSql.query(f"select a.* from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts and b.tg2 > 'a';") + tdSql.checkRows(6) + + tdSql.query(f"select count(*) from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts and b.tg2 > 'a' interval(1a);") + tdSql.checkRows(3) + + tdSql.query(f"select /*+ batch_scan() */ count(*) from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts and b.tg2 > 'a' interval(1a);") + tdSql.checkRows(3) + + tdSql.query(f"select /*+ no_batch_scan() */ count(*) from sta a, stb b where a.tg1=b.tg1 and a.ts=b.ts and b.tg2 > 'a' interval(1a);") + tdSql.checkRows(3) + + +# tdSql.checkData(0,1,10) + + tdSql.error(f"select a.* from sta a join stb b on a.tg1=b.tg1 where a.ts=b.ts or a.tg2=b.tg2;") + tdSql.error(f"select b.* from sta a, stb b where a.tg1=b.tg1 or a.ts=b.ts;") + tdSql.error(f"select a.* from sta a join stb b on a.ts=b.ts where a.tg1=b.tg1 or a.tg2=b.tg2;"); #!!!!make it work + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase())